# AvocAudio Bring-Up Source Bundle ## `CMakeLists.txt` ```cmake cmake_minimum_required(VERSION 3.13) include(${CMAKE_CURRENT_LIST_DIR}/pico_sdk_import.cmake) project(avocaudio_bringup C CXX ASM) set(CMAKE_C_STANDARD 11) set(CMAKE_CXX_STANDARD 17) pico_sdk_init() add_executable(avocaudio_bringup src/main.c) target_include_directories(avocaudio_bringup PRIVATE src) pico_generate_pio_header(avocaudio_bringup ${CMAKE_CURRENT_LIST_DIR}/src/lora_uart.pio) target_link_libraries(avocaudio_bringup PRIVATE pico_stdlib hardware_flash hardware_pio hardware_watchdog pico_unique_id) pico_enable_stdio_usb(avocaudio_bringup 1) pico_enable_stdio_uart(avocaudio_bringup 0) pico_add_extra_outputs(avocaudio_bringup) ``` ## `pico_sdk_import.cmake` ```cmake # Minimal local Pico SDK importer. Set PICO_SDK_PATH in the environment or CMake cache. if (DEFINED ENV{PICO_SDK_PATH} AND (NOT PICO_SDK_PATH)) set(PICO_SDK_PATH $ENV{PICO_SDK_PATH}) endif() if (NOT PICO_SDK_PATH) message(FATAL_ERROR "PICO_SDK_PATH is not set. Point it at a current Raspberry Pi pico-sdk checkout.") endif() get_filename_component(PICO_SDK_PATH "${PICO_SDK_PATH}" REALPATH BASE_DIR "${CMAKE_BINARY_DIR}") if (NOT EXISTS "${PICO_SDK_PATH}/external/pico_sdk_import.cmake") message(FATAL_ERROR "No Pico SDK importer found under ${PICO_SDK_PATH}/external") endif() include("${PICO_SDK_PATH}/external/pico_sdk_import.cmake") ``` ## `README.md` ````markdown # AvocAudio RP2040 Bring-Up Firmware First milestone firmware for the bare RP2040 on AvocAudio v3 Rev 2. It provides USB CDC startup diagnostics, LED blink, bounded DHT probing, read-only boot-flash identification, a low-speed bit-banged SD SPI-mode/OCR diagnostic, and a PIO UART LoRa-E5 AT probe. ## Build Install a current Raspberry Pi Pico SDK and ARM GNU toolchain. Make `pico_sdk_import.cmake` available beside `CMakeLists.txt` (copy it from `pico-sdk/external/`) or set `PICO_SDK_PATH`. ```sh mkdir build && cd build cmake -DPICO_BOARD=pico .. cmake --build . -j ``` Outputs include `avocaudio_bringup.uf2`, `.elf`, `.bin`, and `.hex`. ## Flash and test 1. Hold BOOTSEL while connecting USB, then copy `build/avocaudio_bringup.uf2` to the RPI-RP2 drive. 2. Open the USB CDC serial port at any terminal baud (USB CDC ignores baud). 3. The program waits only for the configured USB grace period, prints the startup table, then continues scheduled tests. 4. Verify continuous LED blinking, flash ID, SD initialization result, DHT reports every 2.5 s, and bounded LoRa `AT` retries. ## Important limits - The PCB currently has 0 routed traces; this firmware is based on verified schematic connectivity only. - SW2 drives RUN and is not readable. SW1/BOOTSEL shares QSPI flash CS and is deliberately not sampled while XIP executes. No safe firmware-readable user button is validated. - LoRa reset active level/timing and 9600 8N1 defaults are configurable in `src/avocaudio_board.h` and require hardware confirmation. - The SD diagnostic enters SPI mode and reads OCR only; it does not mount FAT. - Periodic SD reinitialization is disabled by default. Enabling `AVO_SD_PERIODIC_RETRY` introduces a bounded approximately 1 second worst-case cooperative pause from ACMD41 retries. - DHT11/DHT22 is inferred from the received payload and must be confirmed against the fitted sensor. - LED active-high is inferred and configurable. - Microphone functions are intentionally outside this milestone. - Full Pico SDK compilation remains unverified. ```` ## `src/avocaudio_board.h` ```c #pragma once /* AvocAudio v3 Rev 2 schematic-grounded pin/configuration map. */ #define AVO_LED_GPIO 25 #define AVO_LED_ACTIVE_HIGH 1 #define AVO_LED_BLINK_MS 500u #define AVO_DHT_GPIO 16 #define AVO_DHT_PERIOD_MS 2500u #define AVO_DHT_EDGE_TIMEOUT_US 120u #define AVO_DHT_START_LOW_MS 20u #define AVO_SD_CLK_GPIO 17 #define AVO_SD_CMD_MOSI_GPIO 18 #define AVO_SD_DAT0_MISO_GPIO 19 #define AVO_SD_DAT1_GPIO 20 #define AVO_SD_DAT2_GPIO 21 #define AVO_SD_DAT3_CS_GPIO 22 #define AVO_SD_SPI_HALF_PERIOD_US 5u #define AVO_SD_COMMAND_TIMEOUT_BYTES 16u #define AVO_SD_ACMD41_TRIES 100u #define AVO_SD_RETRY_MS 30000u #define AVO_SD_PERIODIC_RETRY 0 #define AVO_LORA_RX_GPIO 0 #define AVO_LORA_TX_GPIO 1 #define AVO_LORA_NRST_GPIO 12 #define AVO_LORA_BAUD 9600u #define AVO_LORA_RESET_ACTIVE_LOW 1 #define AVO_LORA_RESET_PULSE_MS 20u #define AVO_LORA_RESET_SETTLE_MS 250u #define AVO_LORA_RESPONSE_TIMEOUT_MS 1500u #define AVO_LORA_RETRY_MS 15000u #define AVO_LORA_RESPONSE_MAX 96u #define AVO_USB_GRACE_MS 1500u #define AVO_USER_INPUT_GPIO (-1) #define AVO_ENABLE_DHT 1 #define AVO_ENABLE_SD_DIAGNOSTIC 1 #define AVO_ENABLE_LORA 1 #define AVO_ENABLE_FLASH_DIAGNOSTIC 1 ``` ## `src/lora_uart.pio` ```pio .program lora_uart_tx .side_set 1 opt pull side 1 [7] set x, 7 side 0 [7] bitloop_tx: out pins, 1 jmp x-- bitloop_tx [6] .program lora_uart_rx wait 0 pin 0 set x, 7 [10] bitloop_rx: in pins, 1 jmp x-- bitloop_rx [6] push block % c-sdk { static inline void lora_uart_tx_program_init(PIO pio, uint sm, uint offset, uint pin, uint baud) { pio_sm_config c = lora_uart_tx_program_get_default_config(offset); sm_config_set_out_pins(&c, pin, 1); sm_config_set_sideset_pins(&c, pin); sm_config_set_out_shift(&c, true, false, 32); sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_TX); float div = (float)clock_get_hz(clk_sys) / (8.0f * (float)baud); sm_config_set_clkdiv(&c, div); pio_gpio_init(pio, pin); pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true); pio_sm_init(pio, sm, offset, &c); pio_sm_set_enabled(pio, sm, true); } static inline void lora_uart_rx_program_init(PIO pio, uint sm, uint offset, uint pin, uint baud) { pio_sm_config c = lora_uart_rx_program_get_default_config(offset); sm_config_set_in_pins(&c, pin); sm_config_set_jmp_pin(&c, pin); sm_config_set_in_shift(&c, true, false, 32); sm_config_set_fifo_join(&c, PIO_FIFO_JOIN_RX); float div = (float)clock_get_hz(clk_sys) / (8.0f * (float)baud); sm_config_set_clkdiv(&c, div); pio_gpio_init(pio, pin); gpio_pull_up(pin); pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, false); pio_sm_init(pio, sm, offset, &c); pio_sm_set_enabled(pio, sm, true); } %} ``` ## `src/main.c` ```c #include #include #include "pico/stdlib.h" #include "pico/stdio_usb.h" #include "pico/unique_id.h" #include "hardware/clocks.h" #include "hardware/flash.h" #include "hardware/pio.h" #include "hardware/sync.h" #include "hardware/watchdog.h" #include "avocaudio_board.h" #include "lora_uart.pio.h" static absolute_time_t led_due, dht_due; #if AVO_SD_PERIODIC_RETRY static absolute_time_t sd_due; #endif static bool led_on; static void led_write(bool on) { gpio_put(AVO_LED_GPIO, AVO_LED_ACTIVE_HIGH ? on : !on); } static bool wait_level(uint pin, bool level, uint32_t timeout_us, uint32_t *elapsed) { absolute_time_t start = get_absolute_time(); while (gpio_get(pin) != level) { if (absolute_time_diff_us(start, get_absolute_time()) >= timeout_us) return false; tight_loop_contents(); } if (elapsed) *elapsed = (uint32_t)absolute_time_diff_us(start, get_absolute_time()); return true; } static void dht_probe(void) { #if AVO_ENABLE_DHT uint32_t high_us[40] = {0}; uint8_t b[5] = {0}; gpio_set_dir(AVO_DHT_GPIO, GPIO_OUT); gpio_put(AVO_DHT_GPIO, 0); sleep_ms(AVO_DHT_START_LOW_MS); gpio_put(AVO_DHT_GPIO, 1); sleep_us(30); gpio_set_dir(AVO_DHT_GPIO, GPIO_IN); gpio_pull_up(AVO_DHT_GPIO); if (!wait_level(AVO_DHT_GPIO, false, AVO_DHT_EDGE_TIMEOUT_US, NULL) || !wait_level(AVO_DHT_GPIO, true, AVO_DHT_EDGE_TIMEOUT_US, NULL) || !wait_level(AVO_DHT_GPIO, false, AVO_DHT_EDGE_TIMEOUT_US, NULL)) { printf("DHT FAIL no response\n"); return; } for (int i = 0; i < 40; ++i) { uint32_t width = 0; if (!wait_level(AVO_DHT_GPIO, true, AVO_DHT_EDGE_TIMEOUT_US, NULL) || !wait_level(AVO_DHT_GPIO, false, AVO_DHT_EDGE_TIMEOUT_US, &width)) { printf("DHT FAIL edge timeout bit=%d\n", i); return; } high_us[i] = width; b[i / 8] = (uint8_t)((b[i / 8] << 1) | (width > 50u)); } if ((uint8_t)(b[0] + b[1] + b[2] + b[3]) != b[4]) { printf("DHT FAIL checksum raw=%02x %02x %02x %02x %02x\n", b[0],b[1],b[2],b[3],b[4]); return; } if (b[1] == 0 && b[3] == 0 && b[0] <= 100 && b[2] <= 80) { printf("DHT PASS DHT11 interpretation humidity=%u%% temp=%uC (confirm fitted type)\n", b[0], b[2]); } else { uint16_t rh = ((uint16_t)b[0] << 8) | b[1]; uint16_t tr = ((uint16_t)b[2] << 8) | b[3]; bool neg = (tr & 0x8000u) != 0; tr &= 0x7fffu; printf("DHT PASS DHT22 interpretation humidity=%u.%u%% temp=%s%u.%uC (confirm fitted type)\n", rh/10, rh%10, neg?"-":"", tr/10, tr%10); } #endif } static inline uint8_t sd_xfer(uint8_t out) { uint8_t in = 0; for (int i = 7; i >= 0; --i) { gpio_put(AVO_SD_CMD_MOSI_GPIO, (out >> i) & 1u); sleep_us(AVO_SD_SPI_HALF_PERIOD_US); gpio_put(AVO_SD_CLK_GPIO, 1); in = (uint8_t)((in << 1) | gpio_get(AVO_SD_DAT0_MISO_GPIO)); sleep_us(AVO_SD_SPI_HALF_PERIOD_US); gpio_put(AVO_SD_CLK_GPIO, 0); } return in; } static uint8_t sd_cmd(uint8_t cmd, uint32_t arg, uint8_t crc, uint8_t *tail, size_t tail_n) { gpio_put(AVO_SD_DAT3_CS_GPIO, 0); sd_xfer(0xff); sd_xfer((uint8_t)(0x40u | cmd)); sd_xfer((uint8_t)(arg >> 24)); sd_xfer((uint8_t)(arg >> 16)); sd_xfer((uint8_t)(arg >> 8)); sd_xfer((uint8_t)arg); sd_xfer(crc); uint8_t r = 0xff; for (uint i = 0; i < AVO_SD_COMMAND_TIMEOUT_BYTES; ++i) { r = sd_xfer(0xff); if (!(r & 0x80u)) break; } for (size_t i = 0; i < tail_n; ++i) tail[i] = sd_xfer(0xff); gpio_put(AVO_SD_DAT3_CS_GPIO, 1); sd_xfer(0xff); return r; } static bool sd_init_diag(void) { #if !AVO_ENABLE_SD_DIAGNOSTIC return false; #else gpio_init(AVO_SD_CLK_GPIO); gpio_set_dir(AVO_SD_CLK_GPIO, GPIO_OUT); gpio_put(AVO_SD_CLK_GPIO, 0); gpio_init(AVO_SD_CMD_MOSI_GPIO); gpio_set_dir(AVO_SD_CMD_MOSI_GPIO, GPIO_OUT); gpio_put(AVO_SD_CMD_MOSI_GPIO, 1); gpio_init(AVO_SD_DAT0_MISO_GPIO); gpio_set_dir(AVO_SD_DAT0_MISO_GPIO, GPIO_IN); gpio_pull_up(AVO_SD_DAT0_MISO_GPIO); gpio_init(AVO_SD_DAT1_GPIO); gpio_set_dir(AVO_SD_DAT1_GPIO, GPIO_IN); gpio_pull_up(AVO_SD_DAT1_GPIO); gpio_init(AVO_SD_DAT2_GPIO); gpio_set_dir(AVO_SD_DAT2_GPIO, GPIO_IN); gpio_pull_up(AVO_SD_DAT2_GPIO); gpio_init(AVO_SD_DAT3_CS_GPIO); gpio_set_dir(AVO_SD_DAT3_CS_GPIO, GPIO_OUT); gpio_put(AVO_SD_DAT3_CS_GPIO, 1); for (int i = 0; i < 10; ++i) sd_xfer(0xff); uint8_t r = sd_cmd(0, 0, 0x95, NULL, 0); if (r != 0x01) { printf("SD FAIL CMD0 R1=%02x\n", r); return false; } uint8_t r7[4]; r = sd_cmd(8, 0x1aa, 0x87, r7, 4); bool v2 = (r == 0x01 && r7[2] == 0x01 && r7[3] == 0xaa); if (!(v2 || (r & 0x04u))) { printf("SD FAIL CMD8 R1=%02x R7=%02x%02x%02x%02x\n",r,r7[0],r7[1],r7[2],r7[3]); return false; } bool ready = false; for (uint i = 0; i < AVO_SD_ACMD41_TRIES; ++i) { uint8_t r55 = sd_cmd(55, 0, 0x01, NULL, 0); if (r55 > 1) break; r = sd_cmd(41, v2 ? 0x40000000u : 0, 0x01, NULL, 0); if (r == 0) { ready = true; break; } sleep_ms(10); } if (!ready) { printf("SD FAIL ACMD41 R1=%02x\n", r); return false; } uint8_t ocr[4]; r = sd_cmd(58, 0, 0x01, ocr, 4); if (r != 0) { printf("SD FAIL CMD58 R1=%02x\n", r); return false; } uint32_t o = ((uint32_t)ocr[0]<<24)|((uint32_t)ocr[1]<<16)|((uint32_t)ocr[2]<<8)|ocr[3]; printf("SD PASS SPI init type=%s OCR=%08lx (no filesystem mount)\n", v2 ? ((o&0x40000000u)?"SDHC/SDXC":"SDSC v2") : "SDSC v1", (unsigned long)o); return true; #endif } static void __no_inline_not_in_flash_func(read_flash_ids)(uint8_t jedec[3]) { uint8_t tx[4] = {0x9f, 0, 0, 0}, rx[4] = {0}; uint32_t ints = save_and_disable_interrupts(); flash_do_cmd(tx, rx, sizeof(tx)); restore_interrupts(ints); memcpy(jedec, &rx[1], 3); } static void flash_diag(void) { #if AVO_ENABLE_FLASH_DIAGNOSTIC uint8_t id[3]; pico_unique_board_id_t uid; read_flash_ids(id); pico_get_unique_board_id(&uid); printf("FLASH %s JEDEC=%02x %02x %02x expected=ef 40 18 UID=", (id[0]==0xef&&id[1]==0x40&&id[2]==0x18)?"PASS":"WARN", id[0],id[1],id[2]); for (size_t i=0;i>24); if (llen+1"); lst=LORA_RETRY_WAIT; lora_due=make_timeout_time_ms(AVO_LORA_RETRY_MS); break; case LORA_RETRY_WAIT: lora_reset_level(true); lst=LORA_RESET_ASSERT; lora_due=make_timeout_time_ms(AVO_LORA_RESET_PULSE_MS); break; default: break; } #endif } int main(void) { stdio_init_all(); gpio_init(AVO_LED_GPIO); gpio_set_dir(AVO_LED_GPIO, GPIO_OUT); led_write(false); gpio_init(AVO_DHT_GPIO); gpio_set_dir(AVO_DHT_GPIO, GPIO_IN); gpio_pull_up(AVO_DHT_GPIO); absolute_time_t grace=make_timeout_time_ms(AVO_USB_GRACE_MS); while (!stdio_usb_connected() && !time_reached(grace)) sleep_ms(10); printf("\nAvocAudio v3 Rev 2 RP2040 bring-up\n====================================\n"); printf("RESET watchdog=%s watchdog-enable=%s\n",watchdog_caused_reboot()?"yes":"no",watchdog_enable_caused_reboot()?"yes":"no"); printf("INPUTS SW2=RUN unreadable; SW1=BOOTSEL/flash-CS not sampled; user GPIO=%d\n",AVO_USER_INPUT_GPIO); printf("LED GPIO%d active-%s\nDHT GPIO%d auto-interpret DHT11/DHT22\n",AVO_LED_GPIO,AVO_LED_ACTIVE_HIGH?"high":"low",AVO_DHT_GPIO); printf("SD CLK=%d CMD/MOSI=%d DAT0/MISO=%d DAT3/CS=%d bit-banged diagnostic\n",AVO_SD_CLK_GPIO,AVO_SD_CMD_MOSI_GPIO,AVO_SD_DAT0_MISO_GPIO,AVO_SD_DAT3_CS_GPIO); printf("LORA PIO UART RX=%d TX=%d NRST=%d %u 8N1 (defaults require confirmation)\n",AVO_LORA_RX_GPIO,AVO_LORA_TX_GPIO,AVO_LORA_NRST_GPIO,AVO_LORA_BAUD); flash_diag(); bool sd_ok=sd_init_diag(); (void)sd_ok; lora_init(); led_due=make_timeout_time_ms(AVO_LED_BLINK_MS); dht_due=make_timeout_time_ms(500); #if AVO_SD_PERIODIC_RETRY sd_due=make_timeout_time_ms(AVO_SD_RETRY_MS); #endif for (;;) { if (time_reached(led_due)) { led_on=!led_on; led_write(led_on); led_due=delayed_by_ms(led_due,AVO_LED_BLINK_MS); } if (time_reached(dht_due)) { dht_probe(); dht_due=make_timeout_time_ms(AVO_DHT_PERIOD_MS); } #if AVO_SD_PERIODIC_RETRY if (time_reached(sd_due)) { sd_init_diag(); sd_due=make_timeout_time_ms(AVO_SD_RETRY_MS); } #endif lora_task(); sleep_ms(1); } } ```