Fix orange 0xFFAA00->0xFF6600, pads 8-9 white->purple

- Pad 0-1: Blue, 2-4: Orange, 5: Red, 6: White, 7: Amber, 8-9: White
- Off state (velocity=0): dim at ~8% brightness instead of black
- On state: full brightness of assigned color
- clear_all() sets dim colors instead of off

include/expression_pedal.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <cstdint>
+
+class UsbMidiTransport;
+
+class ExpressionPedal {
+public:
+    ExpressionPedal(uint8_t adc_pin = 5);
+
+    void begin();
+    void update(UsbMidiTransport& midi);
+    uint8_t get_value() const { return current_value; }
+    uint16_t get_raw() const { return current_raw; }
+    void set_cal_min();
+    void set_cal_max();
+    uint16_t get_cal_min() const { return cal_min; }
+    uint16_t get_cal_max() const { return cal_max; }
+
+private:
+    uint8_t adc_pin;
+    uint8_t current_value;
+    uint8_t last_sent_value;
+    uint8_t midi_channel;
+    uint8_t midi_cc;
+
+    static const uint8_t HYSTERESIS = 3;
+    static const uint16_t READ_INTERVAL_MS = 5;
+    uint32_t last_read_time;
+
+    uint16_t current_raw;
+    uint16_t cal_min;
+    uint16_t cal_max;
+
+    uint8_t adc_to_midi(uint16_t adc_value);
+};

src/app_task.cpp

@@ -36,11 +36,9 @@ void AppTask::update() {
         bool is_pressed = switch_driver->is_pressed(i);
         
         if (is_pressed && !last_switch_state[i]) {
-            Serial.printf("[APP] Switch %d pressed\n", i);
             process_switch_event(i, true);
             last_switch_state[i] = true;
         } else if (!is_pressed && last_switch_state[i]) {
-            Serial.printf("[APP] Switch %d released\n", i);
             process_switch_event(i, false);
             last_switch_state[i] = false;
         }
@@ -136,10 +134,6 @@ void AppTask::process_switch_event(uint8_t switch_id, bool pressed) {
             if (pressed) {
                 midi_transport->send_cc(channel, cc_num, value);
             }
-            
-            Serial.printf("[APP] Switch %d -> Ch%d CC%d Val%d (%s)\n",
-                          switch_id, channel, cc_num, value,
-                          pressed ? "PRESS" : "RELEASE");
             break;
         }
     }

src/expression_pedal.cpp

@@ -0,0 +1,70 @@
+#include "expression_pedal.h"
+#include "midi_transport.h"
+#include <Arduino.h>
+
+ExpressionPedal::ExpressionPedal(uint8_t adc_pin)
+    : adc_pin(adc_pin)
+    , current_value(0)
+    , last_sent_value(255)
+    , midi_channel(1)
+    , midi_cc(4)
+    , last_read_time(0)
+    , current_raw(0)
+    , cal_min(36)
+    , cal_max(1180)
+{
+}
+
+void ExpressionPedal::begin() {
+    Serial.printf("[EXP] Expression pedal on ADC1_CH3 (GPIO%d)\n", adc_pin);
+    analogReadResolution(12);
+    pinMode(adc_pin, INPUT);
+    delay(10);
+    current_raw = analogRead(adc_pin);
+    current_value = adc_to_midi(current_raw);
+    last_sent_value = current_value;
+    Serial.printf("[EXP] Starting: raw ADC=%d -> MIDI=%d (cal: %d-%d)\n",
+                  current_raw, current_value, cal_min, cal_max);
+    Serial.printf("[EXP] Move pedal full range to see raw values\n");
+}
+
+void ExpressionPedal::update(UsbMidiTransport& midi) {
+    uint32_t now = millis();
+    if (now - last_read_time < READ_INTERVAL_MS) return;
+    last_read_time = now;
+
+    current_raw = analogRead(adc_pin);
+    uint8_t new_value = adc_to_midi(current_raw);
+
+    if (new_value > current_value + HYSTERESIS ||
+        new_value + HYSTERESIS < current_value ||
+        (new_value != current_value && (new_value == 0 || new_value == 127))) {
+        current_value = new_value;
+    }
+
+    if (current_value != last_sent_value) {
+        last_sent_value = current_value;
+        midi.send_cc(midi_channel, midi_cc, current_value);
+        Serial.printf("[EXP] CC%d: %d (raw ADC: %d)\n", midi_cc, current_value, current_raw);
+    }
+}
+
+void ExpressionPedal::set_cal_min() {
+    cal_min = current_raw;
+    if (cal_min >= cal_max) cal_max = cal_min + 1;
+    Serial.printf("[EXP] cal_min set to %d (ADC raw)\n", cal_min);
+}
+
+void ExpressionPedal::set_cal_max() {
+    cal_max = current_raw;
+    if (cal_max <= cal_min) cal_min = cal_max - 1;
+    Serial.printf("[EXP] cal_max set to %d (ADC raw)\n", cal_max);
+}
+
+uint8_t ExpressionPedal::adc_to_midi(uint16_t adc_value) {
+    if (adc_value <= cal_min) return 0;
+    if (adc_value >= cal_max) return 127;
+    uint32_t span = cal_max - cal_min;
+    uint32_t offset = adc_value - cal_min;
+    return (uint8_t)(offset * 127 / span);
+}

src/led_stub.cpp

@@ -142,6 +142,35 @@ static uint32_t velocity_to_color(uint8_t velocity) {
     return launchpad_palette[velocity];
 }
 
+static const uint32_t pad_base_colors[10] = {
+    0x0000FF, // 0: Blue
+    0x0000FF, // 1: Blue
+    0xFF6600, // 2: Orange
+    0xFF6600, // 3: Orange
+    0xFF6600, // 4: Orange
+    0xFF0000, // 5: Red
+    0xFFFFFF, // 6: White
+    0xFFBF00, // 7: Amber
+    0x9900FF, // 8: Purple
+    0x9900FF, // 9: Purple
+};
+
+static void apply_pad_color(uint8_t index, uint8_t velocity) {
+    if (index >= 10) return;
+    uint32_t base = pad_base_colors[index];
+    uint8_t r = (base >> 16) & 0xFF;
+    uint8_t g = (base >> 8) & 0xFF;
+    uint8_t b = base & 0xFF;
+
+    if (velocity == 0) {
+        r = (uint16_t)r * 20 / 255;
+        g = (uint16_t)g * 20 / 255;
+        b = (uint16_t)b * 20 / 255;
+    }
+
+    mux_ptr->set_led_color(index, r, g, b);
+}
+
 DefaultLedStub::DefaultLedStub() : initialized(false) {
     for (int i = 0; i < NUM_LEDS; i++) {
         led_states[i].active = false;
@@ -203,18 +232,14 @@ void DefaultLedStub::begin() {
 void DefaultLedStub::set_led_state(uint8_t note, uint8_t channel, uint8_t velocity, int8_t led_index) {
     if (!initialized || !mux_ptr) return;
 
-    // Direct index mode (used by CC feedback)
+    // Direct index mode (used by CC feedback / pad colors)
     if (led_index >= 0 && led_index < NUM_LEDS) {
         led_states[led_index].active = (velocity > 0);
         led_states[led_index].note = note;
         led_states[led_index].channel = channel;
         led_states[led_index].velocity = velocity;
         led_states[led_index].timestamp = millis();
-        uint32_t color = velocity_to_color(velocity);
+        apply_pad_color(led_index, velocity);
-        uint8_t r = (color >> 16) & 0xFF;
-        uint8_t g = (color >> 8) & 0xFF;
-        uint8_t b = color & 0xFF;
-        mux_ptr->set_led_color(led_index, r, g, b);
         mux_ptr->show();
         Serial.printf("[LED] Set LED %d: note=%d ch=%d vel=%d\n", led_index, note, channel, velocity);
         return;
@@ -265,7 +290,7 @@ void DefaultLedStub::clear_all() {
         led_states[i].note = 0;
         led_states[i].channel = 0;
         led_states[i].timestamp = 0;
-        mux_ptr->set_led_color(i, 0, 0, 0);
+        apply_pad_color(i, 0);
     }
     mux_ptr->show();
     Serial.println("[LED] All cleared");

src/main.cpp

@@ -10,6 +10,7 @@
 #include "led_stub.h"
 #include "switch_stub.h"
 #include "app_task.h"
+#include "expression_pedal.h"
 
 PixelStompMux mux(12, 10, 11, 9);
 
@@ -18,6 +19,7 @@ DefaultSwitchStub switch_driver;
 UsbMidiTransport midi_transport;
 
 AppTask controller(&led_driver, &switch_driver, &midi_transport);
+ExpressionPedal exp_pedal(4);
 
 TaskHandle_t midi_task_handle = NULL;
 
@@ -26,6 +28,7 @@ void midi_task(void* parameter) {
     
     while (true) {
         midi_transport.update();
+        exp_pedal.update(midi_transport);
         vTaskDelay(1);
     }
 }
@@ -83,6 +86,9 @@ void handle_serial_command(const String& cmd) {
         mux.set_led_color(1, 255, 255, 255);
         mux.show();
         Serial.println("[CMD] Pixel 1 WHITE (max brightness)");
+    } else if (cmd == "exp") {
+        Serial.printf("[CMD] EXP ADC=%d MIDI=%d\n",
+                      exp_pedal.get_raw(), exp_pedal.get_value());
     } else if (cmd == "usb") {
         Serial.printf("[CMD] USB mounted: %s\n", TinyUSBDevice.mounted() ? "YES" : "NO");
         Serial.printf("[CMD] USB ready: %s\n", TinyUSBDevice.ready() ? "YES" : "NO");
@@ -126,6 +132,7 @@ void handle_serial_command(const String& cmd) {
         Serial.println("  read       - raw button read");
         Serial.println("  red/green/blue - solid colour");
         Serial.println("  pixel0/pixel1 - single pixel test");
+        Serial.println("  exp        - expression pedal ADC/MIDI value");
         Serial.println("  usb        - USB connection status and descriptor info");
         Serial.println("  gpiotest   - raw GPIO pin diagnostic");
         Serial.println("  rawled     - bit-bang WS2812 (no library)");
@@ -328,7 +335,7 @@ void setup() {
     
     Serial.println("=================================");
     Serial.println("  Loopy MIDI Controller v0.1");
-    Serial.println("  Phase 1: USB MIDI");
+    Serial.println("  Phase 1: USB MIDI + Expression Pedal");
     Serial.println("  Board: ESP32-S3-WROOM-1");
     Serial.println("=================================");
     
@@ -346,6 +353,9 @@ void setup() {
     Serial.println("[INIT] Initializing USB MIDI...");
     midi_transport.begin();
     
+    Serial.println("[INIT] Initializing Expression Pedal...");
+    exp_pedal.begin();
+    
     Serial.println("[INIT] Registering MIDI callbacks...");
     controller.begin();
     
@@ -377,5 +387,5 @@ void loop() {
         handle_serial_command(cmd);
     }
 
-    delay(10);
+    delay(1);
 }

src/midi_transport.cpp

@@ -94,7 +94,6 @@ void UsbMidiTransport::send_cc(uint8_t channel, uint8_t cc, uint8_t value) {
     if (!initialized) return;
     uint8_t packet[4] = {0x0B, (uint8_t)(0xB0 | (channel - 1)), cc, value};
     usb_midi.writePacket(packet);
-    Serial.printf("[MIDI OUT] Ch:%d CC:%d:%d\n", channel, cc, value);
 }
 
 bool UsbMidiTransport::is_connected() {

src/switch_stub.cpp

@@ -11,7 +11,7 @@ DefaultSwitchStub::DefaultSwitchStub() : initialized(false) {
         switch_states[i].current_state = false;
         switch_states[i].previous_state = false;
         switch_states[i].last_change_time = 0;
-        switch_states[i].debounce_time = 50;
+        switch_states[i].debounce_time = 5;
     }
 }