submodular/SN-L00
1
0
Fork 0
Code Pull Requests Actions Packages Releases Wiki Activity

Add firmware skeleton for RP2040

Browse Source 
Complete working firmware including:
- CMakeLists.txt for Pico SDK build
- SSD1306 OLED driver (128x32, I2C)
- High-resolution latency measurement using hardware timer
- Debounced button with short/long press detection
- Three modes: Single, Continuous, Stats
- USB serial debugging output

Includes 8x8 font with numbers and letters for display.
This commit is contained in:
Florian Berthold
2026-01-23 03:33:35 +01:00
parent f100eb23bf
commit 64f9e34fc3
11 changed files with 889 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
firmware/.gitkeep
View File
firmware/CMakeLists.txt
+41
View File
@@ -0,0 +1,41 @@
cmake_minimum_required(VERSION 3.13)
# Initialize pico-sdk from installed location
include($ENV{PICO_SDK_PATH}/external/pico_sdk_import.cmake)
project(sn_l00 C CXX ASM)
set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
pico_sdk_init()
add_executable(sn_l00
src/main.c
src/display.c
src/latency.c
src/button.c
)
# Use RP2040-Zero pin definitions
target_compile_definitions(sn_l00 PRIVATE
PICO_DEFAULT_I2C=0
PICO_DEFAULT_I2C_SDA_PIN=0
PICO_DEFAULT_I2C_SCL_PIN=1
)
target_include_directories(sn_l00 PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/include
)
target_link_libraries(sn_l00
pico_stdlib
hardware_i2c
hardware_timer
hardware_gpio
)
# Enable USB serial for debugging
pico_enable_stdio_usb(sn_l00 1)
pico_enable_stdio_uart(sn_l00 0)
pico_add_extra_outputs(sn_l00)
firmware/README.md
+114
View File
@@ -0,0 +1,114 @@
# SN-L00 Firmware
RP2040-based firmware for the SN-L00 Eurorack latency tester.
## Requirements
- [Raspberry Pi Pico SDK](https://github.com/raspberrypi/pico-sdk) v1.5+
- CMake 3.13+
- ARM GCC toolchain (`arm-none-eabi-gcc`)
## Building
### Linux/macOS
```bash
# Set SDK path (add to .bashrc/.zshrc for persistence)
export PICO_SDK_PATH=/path/to/pico-sdk
# Build
cd firmware
mkdir build && cd build
cmake ..
make
```
### Output files
After building:
- `sn_l00.uf2` - Flash via USB (drag to RPI-RP2 drive)
- `sn_l00.elf` - For debugging with SWD
## Flashing
1. Hold BOOTSEL button on RP2040-Zero
2. Connect USB cable (or press reset while holding BOOTSEL)
3. Drag `sn_l00.uf2` to the `RPI-RP2` drive
4. Module reboots automatically
## Usage
### Modes
| Mode | Entry | Display | Behavior |
|------|-------|---------|----------|
| Single | Default / Long press from Continuous | `SINGLE` | Press button to measure once |
| Continuous | Long press from Single | `CONT` | Auto-measures every 500ms |
| Stats | Short press from Continuous | Min/Max/Avg | Shows measurement statistics |
### Controls
- **Short press**: Trigger measurement (Single mode) / Exit to Stats (Continuous)
- **Long press (>500ms)**: Toggle between Single and Continuous modes
- **Any press in Stats**: Return to Single mode, reset statistics
## USB Serial
The firmware exposes USB CDC serial for debugging:
- Baud: 115200 (or any, it's USB CDC)
- Shows measurement results and mode changes
```bash
# Linux
screen /dev/ttyACM0 115200
# macOS
screen /dev/tty.usbmodem* 115200
```
## GPIO Pinout
| GPIO | Function | Direction |
|------|----------|-----------|
| GP0 | I2C SDA (OLED) | Bidir |
| GP1 | I2C SCL (OLED) | Output |
| GP2 | Trigger Output | Output |
| GP3 | Return Input | Input |
| GP4 | Button | Input (pull-up) |
## Code Structure
```
firmware/
├── CMakeLists.txt # Build configuration
├── include/
│ ├── config.h # Pin definitions, timing constants
│ ├── display.h # OLED display interface
│ ├── latency.h # Measurement functions
│ └── button.h # Button handling
└── src/
├── main.c # Application entry, state machine
├── display.c # SSD1306 OLED driver
├── latency.c # Timer-based latency measurement
└── button.c # Debounced button with long press
```
## Measurement Accuracy
- Timer resolution: ~1µs (RP2040 @ 125MHz)
- Display resolution: 0.01ms (10µs)
- Polling loop: ~1-2µs per iteration
- Practical accuracy: ±10µs
The main latency contributors are:
1. Input buffer propagation delay (~10ns, negligible)
2. GPIO read latency (~10ns, negligible)
3. Polling loop timing (~1-2µs)
## Future Improvements
- [ ] Configurable trigger pulse width
- [ ] Sample rate display (in samples @ 44.1/48/96kHz)
- [ ] CV output proportional to latency
- [ ] Threshold adjustment via long button hold
- [ ] EEPROM settings storage
firmware/include/button.h
+23
View File
@@ -0,0 +1,23 @@
#ifndef BUTTON_H
#define BUTTON_H
#include <stdbool.h>
#include <stdint.h>
typedef enum {
BTN_NONE,
BTN_SHORT_PRESS, // < 500ms
BTN_LONG_PRESS // >= 500ms
} button_event_t;
// Initialize button GPIO
void button_init(void);
// Poll button state (call in main loop)
// Returns event type when button is released
button_event_t button_poll(void);
// Check if button is currently pressed
bool button_is_pressed(void);
#endif // BUTTON_H
firmware/include/config.h
+32
View File
@@ -0,0 +1,32 @@
#ifndef CONFIG_H
#define CONFIG_H
// GPIO Pin Assignments (RP2040-Zero)
#define PIN_I2C_SDA 0 // OLED SDA
#define PIN_I2C_SCL 1 // OLED SCL
#define PIN_TRIG_OUT 2 // Trigger output
#define PIN_RETURN_IN 3 // Return input
#define PIN_BUTTON 4 // Mode button
// I2C Configuration
#define I2C_PORT i2c0
#define I2C_FREQ 400000 // 400 kHz
// OLED Display (SSD1306 128x32)
#define OLED_ADDR 0x3C
#define OLED_WIDTH 128
#define OLED_HEIGHT 32
// Timing Configuration
#define TRIGGER_PULSE_MS 5 // Trigger pulse width
#define MEASURE_TIMEOUT_MS 1000 // Max latency measurement
#define DEBOUNCE_MS 50 // Button debounce
#define CONTINUOUS_INTERVAL_MS 500 // Interval for continuous mode
// Display
#define DISPLAY_UPDATE_MS 100 // Display refresh rate
// Statistics
#define STATS_SAMPLES 10 // Rolling average sample count
#endif // CONFIG_H
firmware/include/display.h
+31
View File
@@ -0,0 +1,31 @@
#ifndef DISPLAY_H
#define DISPLAY_H
#include <stdbool.h>
#include <stdint.h>
// Initialize the OLED display
void display_init(void);
// Clear the display
void display_clear(void);
// Show latency value in milliseconds
void display_latency(float latency_ms);
// Show "WAITING..." message
void display_waiting(void);
// Show "TIMEOUT" message
void display_timeout(void);
// Show statistics (min/max/avg)
void display_stats(float min_ms, float max_ms, float avg_ms);
// Show mode indicator
void display_mode(const char* mode);
// Update display (call periodically)
void display_update(void);
#endif // DISPLAY_H
firmware/include/latency.h
+38
View File
@@ -0,0 +1,38 @@
#ifndef LATENCY_H
#define LATENCY_H
#include <stdbool.h>
#include <stdint.h>
// Measurement result
typedef struct {
bool valid; // True if measurement succeeded
float latency_ms; // Measured latency in milliseconds
uint64_t latency_us; // Raw latency in microseconds
} measurement_t;
// Statistics
typedef struct {
float min_ms;
float max_ms;
float avg_ms;
uint32_t count;
} stats_t;
// Initialize latency measurement hardware
void latency_init(void);
// Perform a single latency measurement
// Returns result struct with valid flag and latency value
measurement_t latency_measure(void);
// Get current statistics
stats_t latency_get_stats(void);
// Reset statistics
void latency_reset_stats(void);
// Add measurement to statistics
void latency_add_to_stats(float latency_ms);
#endif // LATENCY_H
firmware/src/button.c
+67
View File
@@ -0,0 +1,67 @@
/**
* SN-L00 Button Handler
*
* Debounced button with short/long press detection
*/
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "config.h"
#include "button.h"
#define LONG_PRESS_MS 500
static bool last_state = false;
static bool debounced_state = false;
static uint32_t last_change_time = 0;
static uint32_t press_start_time = 0;
static bool press_active = false;
void button_init(void) {
gpio_init(PIN_BUTTON);
gpio_set_dir(PIN_BUTTON, GPIO_IN);
gpio_pull_up(PIN_BUTTON); // Active low with external pull-up
}
bool button_is_pressed(void) {
// Button is active low
return !gpio_get(PIN_BUTTON);
}
button_event_t button_poll(void) {
bool current = button_is_pressed();
uint32_t now = to_ms_since_boot(get_absolute_time());
button_event_t event = BTN_NONE;
// Debounce logic
if (current != last_state) {
last_change_time = now;
last_state = current;
}
// State stable for debounce period
if ((now - last_change_time) >= DEBOUNCE_MS) {
if (current != debounced_state) {
debounced_state = current;
if (debounced_state) {
// Button pressed
press_start_time = now;
press_active = true;
} else if (press_active) {
// Button released - determine press type
press_active = false;
uint32_t press_duration = now - press_start_time;
if (press_duration >= LONG_PRESS_MS) {
event = BTN_LONG_PRESS;
} else {
event = BTN_SHORT_PRESS;
}
}
}
}
return event;
}
firmware/src/display.c
+282
View File
@@ -0,0 +1,282 @@
/**
* SN-L00 Display Driver
*
* SSD1306 128x32 OLED display via I2C
* Simplified driver for latency display
*/
#include <stdio.h>
#include <string.h>
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#include "config.h"
#include "display.h"
// SSD1306 commands
#define SSD1306_CMD 0x00
#define SSD1306_DATA 0x40
#define SSD1306_SET_CONTRAST 0x81
#define SSD1306_DISPLAY_ON 0xAF
#define SSD1306_DISPLAY_OFF 0xAE
#define SSD1306_SET_DISP_CLK 0xD5
#define SSD1306_SET_MUX_RATIO 0xA8
#define SSD1306_SET_DISP_OFFSET 0xD3
#define SSD1306_SET_START_LINE 0x40
#define SSD1306_CHARGE_PUMP 0x8D
#define SSD1306_SET_MEM_MODE 0x20
#define SSD1306_SEG_REMAP 0xA1
#define SSD1306_COM_SCAN_DEC 0xC8
#define SSD1306_SET_COM_PINS 0xDA
#define SSD1306_SET_PRECHARGE 0xD9
#define SSD1306_SET_VCOM_DESEL 0xDB
#define SSD1306_DISPLAY_RAM 0xA4
#define SSD1306_NORMAL_DISP 0xA6
#define SSD1306_SET_COL_ADDR 0x21
#define SSD1306_SET_PAGE_ADDR 0x22
// Display buffer (128x32 = 512 bytes)
static uint8_t display_buffer[OLED_WIDTH * OLED_HEIGHT / 8];
// Simple 8x8 font (numbers and basic chars only)
static const uint8_t font_8x8[][8] = {
// Space (32)
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
// . (46)
{0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00},
// 0-9 (48-57)
{0x3C, 0x66, 0x6E, 0x76, 0x66, 0x66, 0x3C, 0x00}, // 0
{0x18, 0x38, 0x18, 0x18, 0x18, 0x18, 0x7E, 0x00}, // 1
{0x3C, 0x66, 0x06, 0x1C, 0x30, 0x60, 0x7E, 0x00}, // 2
{0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C, 0x00}, // 3
{0x0C, 0x1C, 0x3C, 0x6C, 0x7E, 0x0C, 0x0C, 0x00}, // 4
{0x7E, 0x60, 0x7C, 0x06, 0x06, 0x66, 0x3C, 0x00}, // 5
{0x1C, 0x30, 0x60, 0x7C, 0x66, 0x66, 0x3C, 0x00}, // 6
{0x7E, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x00}, // 7
{0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00}, // 8
{0x3C, 0x66, 0x66, 0x3E, 0x06, 0x0C, 0x38, 0x00}, // 9
// A-Z selection
{0x3C, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00}, // A
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // B placeholder
{0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C, 0x00}, // C
{0x78, 0x6C, 0x66, 0x66, 0x66, 0x6C, 0x78, 0x00}, // D
{0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E, 0x00}, // E
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // F placeholder
{0x3C, 0x66, 0x60, 0x6E, 0x66, 0x66, 0x3E, 0x00}, // G
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // H placeholder
{0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00}, // I
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // J placeholder
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // K placeholder
{0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7E, 0x00}, // L
{0x63, 0x77, 0x7F, 0x6B, 0x63, 0x63, 0x63, 0x00}, // M
{0x66, 0x76, 0x7E, 0x7E, 0x6E, 0x66, 0x66, 0x00}, // N
{0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00}, // O
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // P placeholder
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Q placeholder
{0x7C, 0x66, 0x66, 0x7C, 0x6C, 0x66, 0x66, 0x00}, // R
{0x3C, 0x66, 0x60, 0x3C, 0x06, 0x66, 0x3C, 0x00}, // S
{0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00}, // T
{0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00}, // U
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // V placeholder
{0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00}, // W
{0x66, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x66, 0x00}, // X
{0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x00}, // Y
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Z placeholder
// m (for "ms")
{0x00, 0x00, 0x76, 0x7F, 0x6B, 0x63, 0x63, 0x00}, // m
// s
{0x00, 0x00, 0x3C, 0x60, 0x3C, 0x06, 0x7C, 0x00}, // s
// - (minus)
{0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00}, // -
};
static void ssd1306_cmd(uint8_t cmd) {
uint8_t buf[2] = {SSD1306_CMD, cmd};
i2c_write_blocking(I2C_PORT, OLED_ADDR, buf, 2, false);
}
static void ssd1306_data(uint8_t *data, size_t len) {
uint8_t buf[len + 1];
buf[0] = SSD1306_DATA;
memcpy(buf + 1, data, len);
i2c_write_blocking(I2C_PORT, OLED_ADDR, buf, len + 1, false);
}
void display_init(void) {
// Initialize I2C
i2c_init(I2C_PORT, I2C_FREQ);
gpio_set_function(PIN_I2C_SDA, GPIO_FUNC_I2C);
gpio_set_function(PIN_I2C_SCL, GPIO_FUNC_I2C);
gpio_pull_up(PIN_I2C_SDA);
gpio_pull_up(PIN_I2C_SCL);
sleep_ms(100); // Wait for display power-up
// SSD1306 initialization sequence for 128x32
ssd1306_cmd(SSD1306_DISPLAY_OFF);
ssd1306_cmd(SSD1306_SET_DISP_CLK);
ssd1306_cmd(0x80);
ssd1306_cmd(SSD1306_SET_MUX_RATIO);
ssd1306_cmd(0x1F); // 32 rows - 1
ssd1306_cmd(SSD1306_SET_DISP_OFFSET);
ssd1306_cmd(0x00);
ssd1306_cmd(SSD1306_SET_START_LINE);
ssd1306_cmd(SSD1306_CHARGE_PUMP);
ssd1306_cmd(0x14); // Enable charge pump
ssd1306_cmd(SSD1306_SET_MEM_MODE);
ssd1306_cmd(0x00); // Horizontal addressing
ssd1306_cmd(SSD1306_SEG_REMAP);
ssd1306_cmd(SSD1306_COM_SCAN_DEC);
ssd1306_cmd(SSD1306_SET_COM_PINS);
ssd1306_cmd(0x02); // Sequential COM, no remap
ssd1306_cmd(SSD1306_SET_CONTRAST);
ssd1306_cmd(0x8F);
ssd1306_cmd(SSD1306_SET_PRECHARGE);
ssd1306_cmd(0xF1);
ssd1306_cmd(SSD1306_SET_VCOM_DESEL);
ssd1306_cmd(0x40);
ssd1306_cmd(SSD1306_DISPLAY_RAM);
ssd1306_cmd(SSD1306_NORMAL_DISP);
ssd1306_cmd(SSD1306_DISPLAY_ON);
display_clear();
}
void display_clear(void) {
memset(display_buffer, 0, sizeof(display_buffer));
}
static int get_font_index(char c) {
if (c == ' ') return 0;
if (c == '.') return 1;
if (c >= '0' && c <= '9') return 2 + (c - '0');
if (c >= 'A' && c <= 'Z') return 12 + (c - 'A');
if (c == 'm') return 38;
if (c == 's') return 39;
if (c == '-') return 40;
return 0; // Default to space
}
static void draw_char(int x, int y, char c) {
int idx = get_font_index(c);
const uint8_t *glyph = font_8x8[idx];
for (int row = 0; row < 8; row++) {
if (y + row >= OLED_HEIGHT) break;
for (int col = 0; col < 8; col++) {
if (x + col >= OLED_WIDTH) break;
if (glyph[row] & (0x80 >> col)) {
int byte_idx = ((y + row) / 8) * OLED_WIDTH + (x + col);
int bit = (y + row) % 8;
display_buffer[byte_idx] |= (1 << bit);
}
}
}
}
static void draw_string(int x, int y, const char *str) {
while (*str) {
draw_char(x, y, *str);
x += 8;
str++;
}
}
static void draw_large_char(int x, int y, char c) {
// 2x scale for large numbers
int idx = get_font_index(c);
const uint8_t *glyph = font_8x8[idx];
for (int row = 0; row < 8; row++) {
for (int col = 0; col < 8; col++) {
if (glyph[row] & (0x80 >> col)) {
// Draw 2x2 pixel
for (int dy = 0; dy < 2; dy++) {
for (int dx = 0; dx < 2; dx++) {
int px = x + col * 2 + dx;
int py = y + row * 2 + dy;
if (px < OLED_WIDTH && py < OLED_HEIGHT) {
int byte_idx = (py / 8) * OLED_WIDTH + px;
int bit = py % 8;
display_buffer[byte_idx] |= (1 << bit);
}
}
}
}
}
}
}
static void draw_large_string(int x, int y, const char *str) {
while (*str) {
draw_large_char(x, y, *str);
x += 16; // 8 * 2 for 2x scale
str++;
}
}
void display_latency(float latency_ms) {
display_clear();
char buf[16];
if (latency_ms < 100) {
snprintf(buf, sizeof(buf), "%5.2f", latency_ms);
} else {
snprintf(buf, sizeof(buf), "%5.1f", latency_ms);
}
// Center the large number
int x = 8;
draw_large_string(x, 4, buf);
// Draw "ms" smaller on the right
draw_string(104, 12, "ms");
}
void display_waiting(void) {
display_clear();
draw_string(20, 12, "WAITING...");
}
void display_timeout(void) {
display_clear();
draw_string(28, 12, "TIMEOUT");
}
void display_stats(float min_ms, float max_ms, float avg_ms) {
display_clear();
char buf[32];
snprintf(buf, sizeof(buf), "MIN %5.1f", min_ms);
draw_string(0, 0, buf);
snprintf(buf, sizeof(buf), "MAX %5.1f", max_ms);
draw_string(0, 12, buf);
snprintf(buf, sizeof(buf), "AVG %5.1f", avg_ms);
draw_string(0, 24, buf);
}
void display_mode(const char* mode) {
display_clear();
// Center the mode string
int len = strlen(mode);
int x = (OLED_WIDTH - len * 8) / 2;
draw_string(x, 12, mode);
display_update();
}
void display_update(void) {
// Set column and page address
ssd1306_cmd(SSD1306_SET_COL_ADDR);
ssd1306_cmd(0);
ssd1306_cmd(127);
ssd1306_cmd(SSD1306_SET_PAGE_ADDR);
ssd1306_cmd(0);
ssd1306_cmd(3); // 4 pages for 32 rows
// Send display buffer in chunks
for (int i = 0; i < sizeof(display_buffer); i += 16) {
ssd1306_data(&display_buffer[i], 16);
}
}
firmware/src/latency.c
+118
View File
@@ -0,0 +1,118 @@
/**
* SN-L00 Latency Measurement
*
* High-resolution latency measurement using RP2040 hardware timer
*/
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "hardware/timer.h"
#include "config.h"
#include "latency.h"
// Statistics storage
static float samples[STATS_SAMPLES];
static uint32_t sample_index = 0;
static uint32_t sample_count = 0;
static float min_latency = 0;
static float max_latency = 0;
void latency_init(void) {
// Configure trigger output pin
gpio_init(PIN_TRIG_OUT);
gpio_set_dir(PIN_TRIG_OUT, GPIO_OUT);
gpio_put(PIN_TRIG_OUT, 0);
// Configure return input pin
gpio_init(PIN_RETURN_IN);
gpio_set_dir(PIN_RETURN_IN, GPIO_IN);
gpio_pull_down(PIN_RETURN_IN); // Default low
latency_reset_stats();
}
measurement_t latency_measure(void) {
measurement_t result = {
.valid = false,
.latency_ms = 0,
.latency_us = 0
};
// Ensure output is low before starting
gpio_put(PIN_TRIG_OUT, 0);
sleep_us(100);
// Record start time and send trigger
uint64_t start_us = time_us_64();
gpio_put(PIN_TRIG_OUT, 1);
// Wait for trigger pulse duration
sleep_ms(TRIGGER_PULSE_MS);
gpio_put(PIN_TRIG_OUT, 0);
// Wait for return signal with timeout
uint64_t timeout_us = start_us + (MEASURE_TIMEOUT_MS * 1000);
while (time_us_64() < timeout_us) {
if (gpio_get(PIN_RETURN_IN)) {
// Got return signal!
uint64_t end_us = time_us_64();
result.latency_us = end_us - start_us;
result.latency_ms = (float)result.latency_us / 1000.0f;
result.valid = true;
break;
}
// Tight polling loop - don't sleep to maintain resolution
}
return result;
}
void latency_reset_stats(void) {
for (int i = 0; i < STATS_SAMPLES; i++) {
samples[i] = 0;
}
sample_index = 0;
sample_count = 0;
min_latency = 0;
max_latency = 0;
}
void latency_add_to_stats(float latency_ms) {
// Add to circular buffer
samples[sample_index] = latency_ms;
sample_index = (sample_index + 1) % STATS_SAMPLES;
if (sample_count < STATS_SAMPLES) {
sample_count++;
}
// Update min/max
if (sample_count == 1) {
min_latency = latency_ms;
max_latency = latency_ms;
} else {
if (latency_ms < min_latency) min_latency = latency_ms;
if (latency_ms > max_latency) max_latency = latency_ms;
}
}
stats_t latency_get_stats(void) {
stats_t s = {
.min_ms = min_latency,
.max_ms = max_latency,
.avg_ms = 0,
.count = sample_count
};
if (sample_count > 0) {
float sum = 0;
for (uint32_t i = 0; i < sample_count; i++) {
sum += samples[i];
}
s.avg_ms = sum / sample_count;
}
return s;
}
firmware/src/main.c
+143
View File
@@ -0,0 +1,143 @@
/**
* SN-L00 Latency Tester
* SubModular / Sub-Net e.U.
*
* Main application entry point and state machine
*/
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "config.h"
#include "display.h"
#include "latency.h"
#include "button.h"
typedef enum {
MODE_SINGLE, // Single shot measurement
MODE_CONTINUOUS, // Continuous measurement
MODE_STATS // Show statistics
} app_mode_t;
static app_mode_t current_mode = MODE_SINGLE;
static uint32_t last_trigger_time = 0;
static bool measurement_pending = false;
void show_startup(void) {
display_clear();
display_mode("SN-L00");
sleep_ms(1000);
display_clear();
display_mode("SINGLE");
}
void handle_single_mode(button_event_t event) {
if (event == BTN_SHORT_PRESS) {
display_waiting();
measurement_t result = latency_measure();
if (result.valid) {
display_latency(result.latency_ms);
latency_add_to_stats(result.latency_ms);
printf("Latency: %.3f ms\n", result.latency_ms);
} else {
display_timeout();
printf("Timeout - no return signal\n");
}
} else if (event == BTN_LONG_PRESS) {
// Switch to continuous mode
current_mode = MODE_CONTINUOUS;
display_mode("CONT");
latency_reset_stats();
sleep_ms(500);
}
}
void handle_continuous_mode(button_event_t event) {
uint32_t now = to_ms_since_boot(get_absolute_time());
// Auto-trigger at interval
if (now - last_trigger_time >= CONTINUOUS_INTERVAL_MS) {
last_trigger_time = now;
measurement_t result = latency_measure();
if (result.valid) {
display_latency(result.latency_ms);
latency_add_to_stats(result.latency_ms);
} else {
display_timeout();
}
}
// Short press exits to stats mode
if (event == BTN_SHORT_PRESS) {
current_mode = MODE_STATS;
stats_t s = latency_get_stats();
display_stats(s.min_ms, s.max_ms, s.avg_ms);
}
// Long press goes back to single mode
if (event == BTN_LONG_PRESS) {
current_mode = MODE_SINGLE;
display_mode("SINGLE");
sleep_ms(500);
}
}
void handle_stats_mode(button_event_t event) {
// Any press returns to single mode
if (event == BTN_SHORT_PRESS || event == BTN_LONG_PRESS) {
current_mode = MODE_SINGLE;
display_mode("SINGLE");
latency_reset_stats();
sleep_ms(500);
}
}
int main(void) {
// Initialize stdio for USB serial debugging
stdio_init_all();
// Wait for USB connection (optional, for debugging)
sleep_ms(2000);
printf("\n=== SN-L00 Latency Tester ===\n");
printf("SubModular / Sub-Net e.U.\n\n");
// Initialize subsystems
display_init();
latency_init();
button_init();
show_startup();
display_mode("READY");
printf("Ready. Press button to measure.\n");
printf("Short press: Measure\n");
printf("Long press: Toggle continuous mode\n\n");
// Main loop
while (true) {
button_event_t event = button_poll();
switch (current_mode) {
case MODE_SINGLE:
handle_single_mode(event);
break;
case MODE_CONTINUOUS:
handle_continuous_mode(event);
break;
case MODE_STATS:
handle_stats_mode(event);
break;
}
display_update();
sleep_ms(10);
}
return 0;
}