// A test harness for 16 pin UART TX on a single PIO State Machine
// Test project https://wokwi.com/projects/344345628967436882
// uart_tx.h source 
#include "pico/stdlib.h"
#include "hardware/pio.h"
#include "uart_tx16.h"

// start at pin 2, so if we want we have UART0 on GP0 and GP1
const uint pin = 2;

// NOTE the simulator doesn't seem to hit this exactly (on my 2015 macbook)
// It ends up being slow by about 6% YMMV
const uint baud = 31250;
const PIO pio = pio0;

uint sm;

void setup() {
  uint offset = pio_add_program(pio, &uart_tx_program);
  sm = pio_claim_unused_sm(pio, true);
  uart_tx_program_init(pio, sm, offset, pin, baud);
}

// Some test messages
uint8_t messages[12] = {
  0x80, 0x3C, 0x00, // Note Off Channel 1, Middle C, Velocity 0
  0x90, 0x3C, 0x7F, // Note On Channel 1, Middle C, Velocity 127
  0x80, 0x3D, 0x00, // Note Off Channel 1, Middle C, Velocity 0
  0x90, 0x3D, 0x7F  // Note On Channel 1, Middle C, Velocity 127
};
uint counter = 0;

void loop() {
  // pull 3 message bytes off
  sendByte(counter++);
  sendByte(counter++);
  sendByte(counter++);
  counter %= 12;
  // delay(1);
  // delayMicroseconds(100);
}

void sendByte(uint idx) {
  uint8_t m = messages[idx];
  uart_tx_program_putc(pio, sm, (uint32_t)m);
}

uart_tx16.ino

diagram.json

// -------------------------------------------------- //
// This file is autogenerated by pioasm; do not edit! //
// -------------------------------------------------- //

#pragma once

#if !PICO_NO_HARDWARE
#include "hardware/pio.h"
#endif

// ------- //
// uart_tx //
// ------- //

#define uart_tx_wrap_target 0
#define uart_tx_wrap 12

static const uint16_t uart_tx_program_instructions[] = {
            //     .wrap_target
    0x82a0, //  0: pull   block                  [2] 
    0xa003, //  1: mov    pins, null                 
    0xe047, //  2: set    y, 7                       
    0x6021, //  3: out    x, 1                       
    0x0028, //  4: jmp    !x, 8                      
    0xa00b, //  5: mov    pins, !null                
    0x0083, //  6: jmp    y--, 3                     
    0x000b, //  7: jmp    11                         
    0xa003, //  8: mov    pins, null                 
    0x0083, //  9: jmp    y--, 3                     
    0xa042, // 10: nop                               
    0xa042, // 11: nop                               
    0xa00b, // 12: mov    pins, !null                
            //     .wrap
};

#if !PICO_NO_HARDWARE
static const struct pio_program uart_tx_program = {
    .instructions = uart_tx_program_instructions,
    .length = 13,
    .origin = -1,
};

static inline pio_sm_config uart_tx_program_get_default_config(uint offset) {
    pio_sm_config c = pio_get_default_sm_config();
    sm_config_set_wrap(&c, offset + uart_tx_wrap_target, offset + uart_tx_wrap);
    return c;
}

static inline void uart_tx_program_init(PIO pio, uint sm, uint offset, uint pin, uint baud) {
    const int PIN_COUNT = 16;
    const uint32_t PIN_MASK = 0xFFFF;
    // the number of PIO cycles that it takes to output a single bit
    const uint cycles_per_bit = 4;
    // the clock divider (number of CPU cycles that each PIO cycle takes)
    float div = (float)clock_get_hz(clk_sys) / (baud * cycles_per_bit);
    // initialize the pins to high indicating the stop bit
    pio_sm_set_set_pins(pio, sm, pin, PIN_COUNT);
    pio_sm_set_pindirs_with_mask(pio, sm, 0xFFFFFFFF, PIN_MASK << pin);
    pio_sm_set_pins_with_mask(pio, sm, 0xFFFFFFFF, PIN_MASK << pin);
    for (int i = 0; i < PIN_COUNT; i++) {
        pio_gpio_init(pio, pin + i);
    }
    pio_sm_config c = uart_tx_program_get_default_config(offset);
    sm_config_set_out_shift(&c, true, false, 32); // shift to right, no autopull
    sm_config_set_out_pins(&c, pin, PIN_COUNT); // Set 8 pins starting at `pin`
    sm_config_set_set_pins(&c, pin, PIN_COUNT); // Set 8 pins starting at `pin`
    sm_config_set_clkdiv(&c, div);
    pio_sm_init(pio, sm, offset, &c); // Load config
    pio_sm_set_enabled(pio, sm, true); // Start state machine
}
static inline void uart_tx_program_putc(PIO pio, uint sm, uint32_t b1) {
    pio_sm_put_blocking(pio, sm, b1);
}

#endif
