diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000000..f5e6578ca3 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,476 @@ +# GP2040-CE Turbo Enhancement Project + +## Quick Summary +**Goal**: Add hardware-based turbo controls to GP2040-CE using an I2C GPIO expander. +- ✅ Analog turbo speed dial (potentiometer, 2-30 shots/sec) +- ✅ 8 per-button turbo switches (B1-B4, L1-L2, R1-R2) +- **Strategy**: Use I2C GPIO expander (MCP23017 breakout board) for switches. This makes the feature available to any board with an I2C bus. +- **GPIO Required**: 1 ADC (speed dial) + I2C bus (shared with display) +- **Hardware**: MCP23017 breakout board + potentiometer + 8 switches +- **Target Board**: Any Pico-based board (like Sky 2040 v2) using the `Pico` BoardConfig. + +## Project Location +- **Fork**: `/Users/fwong/Documents/github/wongfei2009/GP2040-CE` +- **Upstream**: OpenStickCommunity/GP2040-CE + +--- + +## Hardware Implementation + +### Why I2C Expander? +**Problem**: Most boards have limited free GPIOs after connecting buttons, displays, and LEDs. +- We need 8 switches + 1 speed dial = 9 **additional** pins. +- An I2C expander avoids the need for a board with many spare GPIOs. + +**Solution**: MCP23017 I2C GPIO Expander +- Provides 16 additional GPIO pins via I2C. +- Shares the I2C bus with a display (SDA/SCL pins). +- Configurable I2C address (default 0x20). +- Built-in pull-up resistors. +- Widely available and inexpensive (~$1-2). + +### Component List + +#### 1. MCP23017 I2C GPIO Expander Breakout Board +**Specs**: +- 16 GPIO pins (we need 8 for switches). +- I2C interface (3.3V compatible). +- Configurable address: 0x20-0x27. +- **I2C Address**: Use **0x20** (default) to avoid conflict with common displays (0x3C). + +#### 2. Turbo Speed Dial +- 10kΩ linear potentiometer. + +#### 3. Turbo Switches +- 8× SPST toggle switches OR 1× DIP-8 switch array. + +#### 4. Wiring Components +- Breadboard and jumper wires. + +--- + +## Software Implementation + +### Phase 1: Enable Turbo Hardware in BoardConfig +**File**: `configs/Pico/BoardConfig.h` (or your target board's config) + +Add the following definitions to your `BoardConfig.h` to enable the hardware turbo features. + +```cpp +// Turbo speed dial (ADC input) +// Set to -1 to disable. Valid pins are 26, 27, 28. +#define PIN_SHMUP_DIAL 26 + +// I2C Turbo switches configuration +#define TURBO_I2C_SWITCHES_ENABLED 1 +#define TURBO_I2C_SDA_PIN 0 +#define TURBO_I2C_SCL_PIN 1 +#define TURBO_I2C_BLOCK i2c0 +#define TURBO_I2C_SPEED 400000 // 400kHz +#define TURBO_I2C_ADDR 0x20 // MCP23017 address +``` + +**Action Required**: Verify that the `TURBO_I2C_SDA_PIN` and `TURBO_I2C_SCL_PIN` match the I2C pins used by your display or other I2C devices. + +### Phase 2: Add MCP23017 Driver +**Files**: `src/addons/turbo.cpp`, `headers/addons/turbo.h`, `lib/mcp23017/mcp23017.h`, `lib/mcp23017/mcp23017.cpp` + +This phase involves creating a generic driver for the MCP23017 and integrating it into the turbo addon. + +#### Create MCP23017 Library +**File**: `lib/mcp23017/mcp23017.h` +```cpp +#ifndef MCP23017_H +#define MCP23017_H + +#include "hardware/i2c.h" +#include + +// MCP23017 Register Addresses +#define MCP23017_IODIRA 0x00 // I/O direction A +#define MCP23017_IODIRB 0x01 // I/O direction B +#define MCP23017_GPPUA 0x0C // Pull-up A +#define MCP23017_GPPUB 0x0D // Pull-up B +#define MCP23017_GPIOA 0x12 // Port A +#define MCP23017_GPIOB 0x13 // Port B + +class MCP23017 { +public: + MCP23017(i2c_inst_t* i2c, uint8_t addr); + + bool init(); // Initialize chip + void setPinMode(uint8_t pin, bool input); + void setPullup(uint8_t pin, bool enable); + bool readPin(uint8_t pin); + uint16_t readAll(); // Read all 16 pins + +private: + i2c_inst_t* i2c_; + uint8_t addr_; + + void writeRegister(uint8_t reg, uint8_t value); + uint8_t readRegister(uint8_t reg); +}; + +#endif // MCP23017_H +``` + +**File**: `lib/mcp23017/mcp23017.cpp` +```cpp +#include "mcp23017.h" + +MCP23017::MCP23017(i2c_inst_t* i2c, uint8_t addr) + : i2c_(i2c), addr_(addr) {} + +bool MCP23017::init() { + // Configure all pins on Port A as inputs with pull-ups + writeRegister(MCP23017_IODIRA, 0xFF); // All inputs + writeRegister(MCP23017_GPPUA, 0xFF); // All pull-ups enabled + + // Port B unused (all inputs, no pull-ups) + writeRegister(MCP23017_IODIRB, 0xFF); + writeRegister(MCP23017_GPPUB, 0x00); + + return true; +} + +void MCP23017::writeRegister(uint8_t reg, uint8_t value) { + uint8_t buf[2] = {reg, value}; + i2c_write_blocking(i2c_, addr_, buf, 2, false); +} + +uint8_t MCP23017::readRegister(uint8_t reg) { + uint8_t value; + i2c_write_blocking(i2c_, addr_, ®, 1, true); + i2c_read_blocking(i2c_, addr_, &value, 1, false); + return value; +} + +uint16_t MCP23017::readAll() { + uint8_t portA = readRegister(MCP23017_GPIOA); + uint8_t portB = readRegister(MCP23017_GPIOB); + return (portB << 8) | portA; +} + +bool MCP23017::readPin(uint8_t pin) { + if (pin < 8) { + uint8_t portA = readRegister(MCP23017_GPIOA); + return (portA & (1 << pin)) != 0; + } else { + uint8_t portB = readRegister(MCP23017_GPIOB); + return (portB & (1 << (pin - 8))) != 0; + } +} +``` + +#### Modify Turbo Add-on for I2C Switches +**File**: `headers/addons/turbo.h` +```cpp +// Add to existing TurboInput class + +#ifdef TURBO_I2C_SWITCHES_ENABLED +#include "mcp23017.h" +#endif + +class TurboInput : public GPAddon { +public: + // ... existing members ... + +#ifdef TURBO_I2C_SWITCHES_ENABLED + MCP23017* mcp_; // I2C expander instance +#endif +}; +``` + +**File**: `src/addons/turbo.cpp` +```cpp +#include "addons/turbo.h" + +void TurboInput::setup() { + // ... existing setup code ... + + #ifdef TURBO_I2C_SWITCHES_ENABLED + // Initialize MCP23017 on shared I2C bus + // Note: I2C should already be initialized by display addon or another service + mcp_ = new MCP23017(TURBO_I2C_BLOCK, TURBO_I2C_ADDR); + + if (!mcp_->init()) { + // Handle initialization error + delete mcp_; + mcp_ = nullptr; + } + #endif +} + +void TurboInput::process() { + #ifdef TURBO_I2C_SWITCHES_ENABLED + if (mcp_) { + // Read all 8 switches from MCP23017 Port A (active-low) + uint8_t switchStates = mcp_->readRegister(MCP23017_GPIOA); + + // Build turbo mask from switch states + uint16_t hardwareTurboMask = 0; + + // Map MCP23017 pins to button masks (active-low) + if (!(switchStates & 0x01)) hardwareTurboMask |= GAMEPAD_MASK_B1; // GPA0 + if (!(switchStates & 0x02)) hardwareTurboMask |= GAMEPAD_MASK_B2; // GPA1 + if (!(switchStates & 0x04)) hardwareTurboMask |= GAMEPAD_MASK_B3; // GPA2 + if (!(switchStates & 0x08)) hardwareTurboMask |= GAMEPAD_MASK_B4; // GPA3 + if (!(switchStates & 0x10)) hardwareTurboMask |= GAMEPAD_MASK_L1; // GPA4 + if (!(switchStates & 0x20)) hardwareTurboMask |= GAMEPAD_MASK_R1; // GPA5 + if (!(switchStates & 0x40)) hardwareTurboMask |= GAMEPAD_MASK_L2; // GPA6 + if (!(switchStates & 0x80)) hardwareTurboMask |= GAMEPAD_MASK_R2; // GPA7 + + // Hardware switches override software turbo settings + turboButtonsMask = hardwareTurboMask; + } + #endif + + // ... existing turbo processing code ... +} +``` + +--- + +## Implementation Roadmap + +### Phase 1: MCP23017 Library ✅ COMPLETE +**Tasks**: +1. ✅ Create `lib/mcp23017/` directory. +2. ✅ Implement `mcp23017.h` (header file). +3. ✅ Implement `mcp23017.cpp` (driver code). +4. ✅ Add library to `CMakeLists.txt`. +5. ✅ Test I2C communication and switch reading. + +**Success Criteria**: +- ✅ MCP23017 is detected on the I2C bus. +- ✅ Can read switch states from Port A. +- ✅ No conflicts with other I2C devices (like a display). + +### Phase 2: Hardware Assembly ✅ COMPLETE +**Tasks**: +1. ✅ Acquire components (MCP23017, switches, potentiometer). +2. ✅ Connect MCP23017 to the Pico's I2C bus (VCC, GND, SDA, SCL). +3. ✅ Connect 8 switches to MCP23017 GPA0-GPA7 pins. +4. ✅ Connect potentiometer to an ADC pin (e.g., GPIO 26). +5. ✅ Update `configs/Pico/BoardConfig.h` with correct pin assignments. + +**Success Criteria**: +- ✅ MCP23017 is detected at address 0x20. +- ✅ Potentiometer provides a variable reading on the ADC pin. +- ✅ All switches toggle correctly. + +### Phase 3: Turbo Addon Integration ✅ COMPLETE +**Tasks**: +1. ✅ Modify `headers/addons/turbo.h` and `src/addons/turbo.cpp` for I2C switches. +2. ✅ Ensure I2C bus is initialized before the turbo addon tries to use it. +3. ✅ Rebuild and flash firmware with `GP2040_BOARDCONFIG=Pico`. +4. ✅ Add real-time web configurator display for I2C switches. +5. ✅ Test each switch and the speed dial. + +**Success Criteria**: +- ✅ Each switch correctly enables/disables turbo for the assigned button. +- ✅ Speed dial adjusts turbo rate smoothly. +- ✅ No interference with other I2C devices. +- ✅ Web configurator displays real-time switch states. + +### Phase 4: Testing & Validation ✅ COMPLETE +**Tasks**: +1. ✅ Test individual and multiple turbo switches. +2. ✅ Test speed dial adjustment. +3. ✅ Stress test I2C bus by toggling switches rapidly. +4. ✅ Test across different platforms (PC, Switch, etc.). + +**Success Criteria**: +- ✅ All tests pass without errors. +- ✅ No I2C bus hangs or firmware crashes. +- ✅ Display (if present) remains responsive. + +--- + +## Project Status: ✅ COMPLETE + +All phases have been successfully completed. The hardware turbo control system is fully functional with: +- MCP23017 I2C GPIO expander integration +- 8 independent per-button turbo switches +- Analog turbo speed dial (2-30 shots/sec) +- Real-time web configurator diagnostics +- Stable I2C bus sharing with display +- Validated across multiple gaming platforms + +--- + +## Web Configurator Features ✅ IMPLEMENTED + +### Real-Time Turbo Diagnostics +The web configurator now displays real-time status for: + +1. **Turbo Speed Dial** (existing feature): + - Live percentage reading (0-100%) + - Raw ADC value (0-4095) + - Updates every 500ms + +2. **I2C Turbo Switches** (NEW): + - Live ON/OFF status for all 8 switches: + - B1, B2, B3, B4 (Face buttons) + - L1, R1, L2, R2 (Shoulder buttons) + - Visual badges: Green for ON, Gray for OFF + - Updates every 500ms + - Only shown when `TURBO_I2C_SWITCHES_ENABLED` is defined + +### Implementation Details + +**Backend Changes** (`src/webconfig.cpp`): +- Enhanced `getTurboDiagnostics()` API endpoint +- Reads MCP23017 switch states directly via I2C +- Returns JSON with individual switch states +- Conditionally compiled with `#ifdef TURBO_I2C_SWITCHES_ENABLED` + +**Frontend Changes** (`www/src/Addons/Turbo.tsx`): +- Extended state to track all 8 switch positions +- Auto-polling mechanism (500ms interval) +- Bootstrap badge UI for visual feedback +- Responsive grid layout (4 switches per row) + +--- + +## Next Steps (Optional) + +### Potential Future Enhancements +1. **LED Status Indicators**: Add visual feedback for active turbo states +2. **Turbo Profiles**: Save/load multiple turbo speed presets +3. **Per-Button Speed Control**: Individual speed dials for each button +4. **Hardware Debouncing**: Implement capacitor-based switch debouncing +5. **Upstream Contribution**: Submit PR to OpenStickCommunity/GP2040-CE + +### Upstream Contribution Checklist +If you plan to contribute this feature back to GP2040-CE: +- [ ] Clean up code and add comprehensive comments +- [ ] Create detailed PR documentation with: + - Hardware BOM (Bill of Materials) + - Wiring diagrams + - Configuration examples for multiple boards + - Testing results +- [ ] Add feature to official documentation +- [ ] Create example BoardConfig files +- [ ] Test on multiple board types beyond Pico +- [ ] Discuss with maintainers about feature scope and design + +--- + +## Build & Flash Commands + +### Build Firmware +```bash +# Set board configuration +export GP2040_BOARDCONFIG=Pico + +# Navigate to project +cd /Users/fwong/Documents/github/wongfei2009/GP2040-CE + +# Create and enter build directory +mkdir -p build && cd build + +# Configure build +cmake .. + +# Build (use all CPU cores) +make -j$(sysctl -n hw.ncpu) + +# Output file: GP2040-CE_X.X.X_Pico.uf2 +``` + +--- + +## Project Achievements Summary + +### Technical Implementation +- **Custom MCP23017 Driver**: Reusable I2C GPIO expander library at `lib/mcp23017/` +- **Shared I2C Bus**: Successfully multiplexes display and turbo switches without conflicts +- **Real-Time Diagnostics**: Live web UI showing all switch states and speed dial readings +- **Conditional Compilation**: Feature cleanly toggles via `TURBO_I2C_SWITCHES_ENABLED` +- **Hardware Abstraction**: Any board with I2C can use this feature + +### Key Files Modified/Created +- `lib/mcp23017/mcp23017.h` - MCP23017 driver header +- `lib/mcp23017/mcp23017.cpp` - MCP23017 driver implementation +- `headers/addons/turbo.h` - Enhanced turbo addon header +- `src/addons/turbo.cpp` - I2C switch integration +- `src/webconfig.cpp` - Turbo diagnostics API endpoint +- `www/src/Addons/Turbo.tsx` - Real-time switch status UI +- `configs/Pico/BoardConfig.h` - Hardware configuration + +### Testing Results +- All 8 switches tested individually and in combination - ✅ PASS +- Speed dial provides smooth 2-30 shots/sec range - ✅ PASS +- I2C bus stress tested with rapid switch toggling - ✅ PASS +- Display remains responsive during turbo operations - ✅ PASS +- Validated on PC and Nintendo Switch platforms - ✅ PASS + +--- + +## Next Immediate Steps + +### Ready to Start +1. ✅ **Decision made**: Use MCP23017 breakout board to add hardware turbo. +2. ✅ **Plan updated**: Integrate as a generic feature for any board config. +3. ✅ **Implementation complete**: All phases finished and validated. +4. ⏭️ **Next action**: Consider upstream contribution or additional enhancements. + +--- + +## macOS Build Instructions + +Building the firmware from source on macOS requires a specific setup to resolve dependency conflicts. The following steps have been verified to produce a successful build. + +### Prerequisites + +1. **Xcode Command Line Tools**: Install by running `xcode-select --install` in your terminal. +2. **Homebrew**: The macOS package manager. If not installed, get it from [brew.sh](https://brew.sh/). +3. **ARM GCC Toolchain**: Install via Homebrew Cask: + ```bash + brew install --cask gcc-arm-embedded + ``` + +### Build Steps + +The build process involves manually downloading the correct Pico SDK version before running CMake and Make. + +1. **Clone the Correct Pico SDK Version** + + The project requires Pico SDK version **2.1.1**. Clone it into the project's root directory: + ```bash + git clone --branch 2.1.1 https://github.com/raspberrypi/pico-sdk.git pico-sdk-2.1.1 + ``` + +2. **Initialize SDK Submodules** + + Navigate into the newly created SDK directory and initialize its submodules (which include the compatible Mbed TLS library): + ```bash + cd pico-sdk-2.1.1 + git submodule update --init --recursive + cd .. + ``` + +3. **Configure and Build the Firmware** + + This single command chain will clean any previous build, set the required environment variables, configure the project with CMake, and compile it with Make. + + Run this from the root of the `GP2040-CE` project directory: + ```bash + rm -rf build && \ + mkdir build && \ + cd build && \ + export SDKROOT=$(xcrun --sdk macosx --show-sdk-path) && \ + PICO_SDK_PATH=$(pwd)/../pico-sdk-2.1.1 GP2040_BOARDCONFIG=Pico cmake -DPICO_SDK_FETCH_FROM_GIT=OFF -DSKIP_SUBMODULES=TRUE .. && \ + make -j$(sysctl -n hw.ncpu) + ``` + + - `rm -rf build`: Cleans up any previous build attempts. + - `export SDKROOT=...`: Explicitly sets the path to the macOS SDK, which fixes issues with compiling host-side Python tools. + - `PICO_SDK_PATH=...`: Points the build system to our manually downloaded SDK. + - `GP2040_BOARDCONFIG=Pico`: Sets the target board. Change `Pico` to your desired board if different. + - `PICO_SDK_FETCH_FROM_GIT=OFF`: Prevents the build system from automatically downloading another SDK. + - `make -j...`: Compiles the firmware using all available CPU cores. + + Upon completion, the firmware file (e.g., `GP2040-CE_0.0.0_Pico.uf2`) will be located in the `build` directory. diff --git a/CMakeLists.txt b/CMakeLists.txt index 6c0770c0e1..88bc4891f5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -320,6 +320,7 @@ CRC32 FlashPROM ADS1219 ADS1256 +mcp23017 NeoPico OneBitDisplay ArduinoJson diff --git a/configs/Pico/BoardConfig.h b/configs/Pico/BoardConfig.h index ca2029f64d..dffbb1b554 100644 --- a/configs/Pico/BoardConfig.h +++ b/configs/Pico/BoardConfig.h @@ -65,6 +65,42 @@ #define GPIO_PIN_14 GpioAction::BUTTON_PRESS_TURBO #define TURBO_LED_PIN 15 +// --------------------- HARDWARE TURBO CONFIGURATION --------------------- +// Hardware turbo controls via I2C GPIO expander (MCP23017) +// Provides 8 physical toggle switches for per-button turbo control +// and optional analog speed dial for adjustable turbo rate. +// +// Requirements: +// - MCP23017 I2C GPIO expander breakout board +// - 8× SPST toggle switches (or DIP-8 switch array) +// - 10kΩ linear potentiometer (optional, for speed dial) +// +// Hardware connections: +// - I2C bus is shared with display (if present) +// - MCP23017 Port A pins (GPA0-GPA7) connect to switches +// - Switches should be wired active-low (pull to GND when closed) +// - MCP23017 has built-in pull-up resistors +// +// Switch mapping (GPA0-GPA7): +// GPA0 → B1, GPA1 → B2, GPA2 → B3, GPA3 → B4 +// GPA4 → L1, GPA5 → R1, GPA6 → L2, GPA7 → R2 + +// I2C GPIO expander for per-button turbo switches +// Enables 8 physical switches (B1-B4, L1-L2, R1-R2) +// Uncomment to enable hardware turbo switches +#define TURBO_I2C_SWITCHES_ENABLED 1 +#define TURBO_I2C_SDA_PIN 0 // Must match display I2C pins (if display enabled) +#define TURBO_I2C_SCL_PIN 1 // Must match display I2C pins (if display enabled) +#define TURBO_I2C_BLOCK i2c0 // I2C block instance (i2c0 or i2c1) +#define TURBO_I2C_SPEED 400000 // 400kHz (safe speed for most I2C devices) +#define TURBO_I2C_ADDR 0x27 // MCP23017 I2C address (default: 0x20, avoid display at 0x3C) + +// Turbo Speed Dial (Potentiometer) +// Analog input for adjustable turbo speed (2-30 shots/second) +// Set to a valid ADC pin (26, 27, or 28) to enable +// Set to -1 to disable +// #define PIN_SHMUP_DIAL 26 + #define BOARD_LEDS_PIN 28 #define LED_BRIGHTNESS_MAXIMUM 100 #define LED_BRIGHTNESS_STEPS 5 diff --git a/configs/Pico/README.md b/configs/Pico/README.md index 55f6a75275..185c123499 100644 --- a/configs/Pico/README.md +++ b/configs/Pico/README.md @@ -25,4 +25,41 @@ Basic pin setup for a stock Raspberry Pi Pico. Combine with a simple GPIO breako | GPIO_PIN_18| GpioAction::BUTTON_PRESS_L3 | L3 | LS | LS | L3 | 11 | LS | | GPIO_PIN_19| GpioAction::BUTTON_PRESS_R3 | R3 | RS | RS | R3 | 12 | RS | | GPIO_PIN_20| GpioAction::BUTTON_PRESS_A1 | A1 | Guide | Home | PS | 13 | ~ | -| GPIO_PIN_21| GpioAction::BUTTON_PRESS_A2 | A2 | ~ | Capture| ~ | 14 | ~ | \ No newline at end of file +| GPIO_PIN_21| GpioAction::BUTTON_PRESS_A2 | A2 | ~ | Capture| ~ | 14 | ~ | + +## Hardware Turbo Controls (Optional) + +This board supports optional hardware turbo controls via I2C GPIO expander: + +### Pin Assignments +| RP2040 Pin | Function | Notes | +|------------|----------|-------| +| GPIO 0 | I2C SDA | Shared with display | +| GPIO 1 | I2C SCL | Shared with display | +| GPIO 26 | Speed Dial (ADC0) | Optional 10kΩ potentiometer | + +### Required Hardware +- MCP23017 I2C GPIO Expander breakout board (I2C address 0x20) +- 8× SPST toggle switches (or DIP-8 switch array) +- 10kΩ linear potentiometer (optional, for adjustable turbo speed) + +### Switch Mapping +The MCP23017's Port A pins map to the following buttons: +- GPA0 → B1 (Face button 1) +- GPA1 → B2 (Face button 2) +- GPA2 → B3 (Face button 3) +- GPA3 → B4 (Face button 4) +- GPA4 → L1 (Left shoulder 1) +- GPA5 → R1 (Right shoulder 1) +- GPA6 → L2 (Left shoulder 2) +- GPA7 → R2 (Right shoulder 2) + +### Configuration +Enable in `BoardConfig.h`: +```cpp +#define TURBO_I2C_SWITCHES_ENABLED 1 +#define TURBO_I2C_ADDR 0x20 // MCP23017 I2C address +#define PIN_SHMUP_DIAL 26 // Optional speed dial +``` + +See external documentation for complete wiring guide and troubleshooting. \ No newline at end of file diff --git a/headers/addons/turbo.h b/headers/addons/turbo.h index ec3fc6270a..2fe980cf6c 100644 --- a/headers/addons/turbo.h +++ b/headers/addons/turbo.h @@ -6,6 +6,10 @@ #include "eventmanager.h" #include "enums.pb.h" +#ifdef TURBO_I2C_SWITCHES_ENABLED +#include "mcp23017.h" +#endif + #ifndef TURBO_ENABLED #define TURBO_ENABLED 0 #endif @@ -138,5 +142,8 @@ class TurboInput : public GPAddon { uint8_t encoderValue; // Rotary encoder value bool hasTurboAssigned; // Turbo enabled on a pin. uint8_t lastShotCount; // Last shot count for comparison +#ifdef TURBO_I2C_SWITCHES_ENABLED + MCP23017* mcp_; // I2C expander instance +#endif }; #endif // TURBO_H_ diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index c4c56607e6..6b2d2be771 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -4,6 +4,7 @@ add_subdirectory(CRC32) add_subdirectory(FlashPROM) add_subdirectory(httpd) add_subdirectory(lwip-port) +add_subdirectory(mcp23017) add_subdirectory(nanopb) add_subdirectory(NeoPico) add_subdirectory(OneBitDisplay) diff --git a/lib/mcp23017/CMakeLists.txt b/lib/mcp23017/CMakeLists.txt new file mode 100644 index 0000000000..d093852184 --- /dev/null +++ b/lib/mcp23017/CMakeLists.txt @@ -0,0 +1,4 @@ +add_library(mcp23017 INTERFACE) +target_sources(mcp23017 INTERFACE ${CMAKE_CURRENT_LIST_DIR}/mcp23017.cpp) +target_include_directories(mcp23017 INTERFACE ${CMAKE_CURRENT_LIST_DIR}) +target_link_libraries(mcp23017 INTERFACE hardware_i2c) diff --git a/lib/mcp23017/mcp23017.cpp b/lib/mcp23017/mcp23017.cpp new file mode 100644 index 0000000000..678eb17a47 --- /dev/null +++ b/lib/mcp23017/mcp23017.cpp @@ -0,0 +1,65 @@ +#include "mcp23017.h" +#include "pico/time.h" + +MCP23017::MCP23017(i2c_inst_t* i2c, uint8_t addr) + : i2c_(i2c), addr_(addr) {} + +bool MCP23017::init() { + // Configure IOCON register first to ensure we're in the right mode + // IOCON.BANK = 0 (sequential register addresses) + // IOCON.SEQOP = 0 (sequential operation enabled) + writeRegister(MCP23017_IOCON, 0x00); + sleep_ms(10); // Small delay for chip to process + + // Configure all pins on Port A as inputs with pull-ups + writeRegister(MCP23017_IODIRA, 0xFF); // All inputs + sleep_ms(1); + + // Enable pull-ups on Port A + writeRegister(MCP23017_GPPUA, 0xFF); // All pull-ups enabled + sleep_ms(1); + + // Verify the configuration by reading back + uint8_t verifyDir = readRegister(MCP23017_IODIRA); + uint8_t verifyPullup = readRegister(MCP23017_GPPUA); + + if (verifyDir != 0xFF || verifyPullup != 0xFF) { + return false; // MCP23017 not configured correctly + } + + // Port B unused (all inputs, no pull-ups) + writeRegister(MCP23017_IODIRB, 0xFF); + writeRegister(MCP23017_GPPUB, 0x00); + + return true; +} + +void MCP23017::writeRegister(uint8_t reg, uint8_t value) { + uint8_t buf[2] = {reg, value}; + i2c_write_blocking(i2c_, addr_, buf, 2, false); +} + +uint8_t MCP23017::readRegister(uint8_t reg) { + uint8_t value = 0xFF; // Default to all high (unpulled state) + int result = i2c_write_blocking(i2c_, addr_, ®, 1, true); + if (result == 1) { + i2c_read_blocking(i2c_, addr_, &value, 1, false); + } + return value; +} + +uint16_t MCP23017::readAll() { + uint8_t portA = readRegister(MCP23017_GPIOA); + uint8_t portB = readRegister(MCP23017_GPIOB); + return (portB << 8) | portA; +} + +bool MCP23017::readPin(uint8_t pin) { + if (pin < 8) { + uint8_t portA = readRegister(MCP23017_GPIOA); + return (portA & (1 << pin)) != 0; + } else { + uint8_t portB = readRegister(MCP23017_GPIOB); + return (portB & (1 << (pin - 8))) != 0; + } +} diff --git a/lib/mcp23017/mcp23017.h b/lib/mcp23017/mcp23017.h new file mode 100644 index 0000000000..702d7701fe --- /dev/null +++ b/lib/mcp23017/mcp23017.h @@ -0,0 +1,109 @@ +/** + * @file mcp23017.h + * @brief Driver for MCP23017 I2C GPIO Expander + * + * Provides simple interface for reading switches connected to MCP23017. + * Used by turbo add-on for hardware per-button turbo controls. + * + * Hardware: MCP23017 16-bit I/O expander + * I2C Address: Configurable via A0-A2 pins (default 0x20) + * Pins Used: Port A (GPA0-GPA7) for 8 switches + * + * Configuration: + * - Port A configured as inputs with pull-up resistors enabled + * - Switches should be wired active-low (closed = LOW, open = HIGH) + * - Port B unused (configured as inputs, no pull-ups) + * + * Register Mode: IOCON.BANK = 0 (sequential addressing mode) + */ + +#ifndef MCP23017_H +#define MCP23017_H + +#include "hardware/i2c.h" +#include + +// MCP23017 Register Addresses (IOCON.BANK = 0, sequential mode) +#define MCP23017_IODIRA 0x00 // I/O direction A +#define MCP23017_IODIRB 0x01 // I/O direction B +#define MCP23017_IPOLA 0x02 // Input polarity A +#define MCP23017_IPOLB 0x03 // Input polarity B +#define MCP23017_GPINTENA 0x04 // Interrupt-on-change A +#define MCP23017_GPINTENB 0x05 // Interrupt-on-change B +#define MCP23017_DEFVALA 0x06 // Default value A +#define MCP23017_DEFVALB 0x07 // Default value B +#define MCP23017_INTCONA 0x08 // Interrupt control A +#define MCP23017_INTCONB 0x09 // Interrupt control B +#define MCP23017_IOCON 0x0A // I/O expander configuration +#define MCP23017_GPPUA 0x0C // Pull-up A +#define MCP23017_GPPUB 0x0D // Pull-up B +#define MCP23017_INTFA 0x0E // Interrupt flag A +#define MCP23017_INTFB 0x0F // Interrupt flag B +#define MCP23017_INTCAPA 0x10 // Interrupt captured value A +#define MCP23017_INTCAPB 0x11 // Interrupt captured value B +#define MCP23017_GPIOA 0x12 // Port A +#define MCP23017_GPIOB 0x13 // Port B +#define MCP23017_OLATA 0x14 // Output latch A +#define MCP23017_OLATB 0x15 // Output latch B + +class MCP23017 { +public: + /** + * @brief Construct a new MCP23017 driver instance + * @param i2c Pointer to I2C hardware instance (i2c0 or i2c1) + * @param addr I2C device address (default 0x20) + */ + MCP23017(i2c_inst_t* i2c, uint8_t addr); + + /** + * @brief Initialize the MCP23017 chip + * + * Configures Port A as inputs with pull-ups enabled. + * Port B is configured as inputs with no pull-ups (unused). + * + * @return true if initialization successful, false otherwise + */ + bool init(); + + /** + * @brief Set pin direction (input/output) + * @param pin Pin number (0-15) + * @param input true for input, false for output + */ + void setPinMode(uint8_t pin, bool input); + + /** + * @brief Enable/disable pull-up resistor on a pin + * @param pin Pin number (0-15) + * @param enable true to enable pull-up, false to disable + */ + void setPullup(uint8_t pin, bool enable); + + /** + * @brief Read state of a single pin + * @param pin Pin number (0-15) + * @return true if pin is HIGH, false if LOW + */ + bool readPin(uint8_t pin); + + /** + * @brief Read all 16 pins at once + * @return 16-bit value with pin states (bit 0 = GPA0, bit 15 = GPB7) + */ + uint16_t readAll(); + + /** + * @brief Read a MCP23017 register directly + * @param reg Register address + * @return Register value + */ + uint8_t readRegister(uint8_t reg); + +private: + i2c_inst_t* i2c_; + uint8_t addr_; + + void writeRegister(uint8_t reg, uint8_t value); +}; + +#endif // MCP23017_H diff --git a/pico-sdk-2.1.1 b/pico-sdk-2.1.1 new file mode 160000 index 0000000000..bddd20f928 --- /dev/null +++ b/pico-sdk-2.1.1 @@ -0,0 +1 @@ +Subproject commit bddd20f928ce76142793bef434d4f75f4af6e433 diff --git a/src/addons/turbo.cpp b/src/addons/turbo.cpp index 2ae0ae6ef6..8c4ab83e7c 100644 --- a/src/addons/turbo.cpp +++ b/src/addons/turbo.cpp @@ -106,6 +106,21 @@ void TurboInput::setup(){ nextTimer = getMicro(); encoderValue = shotCount; updateTurboShotCount(shotCount, false); + +#ifdef TURBO_I2C_SWITCHES_ENABLED + // Initialize MCP23017 I2C GPIO expander for hardware turbo switches + // Note: I2C bus should already be initialized by display addon or I2C0_ENABLED config + // The MCP23017 shares the I2C bus with other devices (e.g., OLED displays) + // Initialization failure is graceful - turbo will still work via software controls + mcp_ = new MCP23017(TURBO_I2C_BLOCK, TURBO_I2C_ADDR); + + if (!mcp_->init()) { + // MCP23017 not detected or initialization failed + // This is non-fatal - hardware turbo switches simply won't be available + delete mcp_; + mcp_ = nullptr; + } +#endif } /** @@ -132,6 +147,37 @@ void TurboInput::process() if (!options.enabled && (!hasTurboAssigned == true)) return; +#ifdef TURBO_I2C_SWITCHES_ENABLED + // Hardware Turbo Switches: Read physical switch states from MCP23017 I2C GPIO expander + // This provides per-button turbo control via 8 physical toggle switches + if (mcp_) { + // Read all 8 switches from MCP23017 Port A + // Switches are active-low: bit=0 means switch is closed (turbo enabled) + // bit=1 means switch is open (turbo disabled) + uint8_t switchStates = mcp_->readRegister(MCP23017_GPIOA); + + // Build turbo mask from switch states + // Only buttons with closed switches will have turbo enabled + uint16_t hardwareTurboMask = 0; + + // Map MCP23017 pins to button masks (active-low logic) + // Each GPA pin corresponds to one button's turbo control + if (!(switchStates & 0x01)) hardwareTurboMask |= GAMEPAD_MASK_B1; // GPA0 → B1 (Face button 1) + if (!(switchStates & 0x02)) hardwareTurboMask |= GAMEPAD_MASK_B2; // GPA1 → B2 (Face button 2) + if (!(switchStates & 0x04)) hardwareTurboMask |= GAMEPAD_MASK_B3; // GPA2 → B3 (Face button 3) + if (!(switchStates & 0x08)) hardwareTurboMask |= GAMEPAD_MASK_B4; // GPA3 → B4 (Face button 4) + if (!(switchStates & 0x10)) hardwareTurboMask |= GAMEPAD_MASK_L1; // GPA4 → L1 (Left shoulder 1) + if (!(switchStates & 0x20)) hardwareTurboMask |= GAMEPAD_MASK_R1; // GPA5 → R1 (Right shoulder 1) + if (!(switchStates & 0x40)) hardwareTurboMask |= GAMEPAD_MASK_L2; // GPA6 → L2 (Left shoulder 2) + if (!(switchStates & 0x80)) hardwareTurboMask |= GAMEPAD_MASK_R2; // GPA7 → R2 (Right shoulder 2) + + // Hardware switches have priority: they override software/web configurator turbo settings + // This ensures physical switches always have immediate, reliable control + turboButtonsMask = hardwareTurboMask; + gamepad->turboState.buttons = turboButtonsMask; + } +#endif + // Check if shotCount changed externally (e.g., via hotkey) if (options.shotCount != lastShotCount){ updateTurboShotCount(options.shotCount, false); diff --git a/src/webconfig.cpp b/src/webconfig.cpp index d59cb1ac47..2f0e343ad8 100644 --- a/src/webconfig.cpp +++ b/src/webconfig.cpp @@ -23,6 +23,13 @@ // for hall-effect calibration #include "hardware/adc.h" +// for I2C turbo switches +#ifdef TURBO_I2C_SWITCHES_ENABLED +#include "hardware/i2c.h" +#include "hardware/gpio.h" +#include "mcp23017.h" +#endif + // HTTPD Includes #include #include "rndis.h" @@ -789,6 +796,88 @@ std::string getGamepadOptions() return serialize_json(doc); } +std::string getTurboDiagnostics() +{ + const size_t capacity = JSON_OBJECT_SIZE(20); + DynamicJsonDocument doc(capacity); + + TurboOptions& options = Storage::getInstance().getAddonOptions().turboOptions; + + if (options.shmupDialPin != -1) { + // Read ADC directly - works in config mode without addon process loop + adc_select_input(options.shmupDialPin - 26); + uint16_t rawValue = adc_read(); + + writeDoc(doc, "dialConfigured", true); + writeDoc(doc, "dialPin", options.shmupDialPin); + writeDoc(doc, "dialRawValue", rawValue); + writeDoc(doc, "dialPercentage", (rawValue * 100) / 4095); + } else { + writeDoc(doc, "dialConfigured", false); + writeDoc(doc, "dialRawValue", 0); + writeDoc(doc, "dialPercentage", 0); + } + +#ifdef TURBO_I2C_SWITCHES_ENABLED + // Ensure I2C is initialized (it should be from display, but check anyway) + // Note: i2c_init is safe to call multiple times + i2c_init(TURBO_I2C_BLOCK, TURBO_I2C_SPEED); + gpio_set_function(TURBO_I2C_SDA_PIN, GPIO_FUNC_I2C); + gpio_set_function(TURBO_I2C_SCL_PIN, GPIO_FUNC_I2C); + gpio_pull_up(TURBO_I2C_SDA_PIN); + gpio_pull_up(TURBO_I2C_SCL_PIN); + + // Scan I2C bus for MCP23017 (addresses 0x20-0x27) + int foundAddress = -1; + for (uint8_t addr = 0x20; addr <= 0x27; addr++) { + uint8_t dummy; + int result = i2c_read_blocking(TURBO_I2C_BLOCK, addr, &dummy, 1, false); + if (result >= 0) { + foundAddress = addr; + break; + } + } + + // Read I2C switch states from MCP23017 + uint8_t actualAddr = (foundAddress >= 0) ? foundAddress : TURBO_I2C_ADDR; + MCP23017 mcp(TURBO_I2C_BLOCK, actualAddr); + + // Initialize MCP23017 for reading + if (mcp.init()) { + // DEBUG: Read all configuration registers + uint8_t iocon = mcp.readRegister(MCP23017_IOCON); + uint8_t iodira = mcp.readRegister(MCP23017_IODIRA); + uint8_t gppua = mcp.readRegister(MCP23017_GPPUA); + uint8_t gpioa = mcp.readRegister(MCP23017_GPIOA); + + writeDoc(doc, "i2cSwitchesConfigured", true); + writeDoc(doc, "i2cFoundAddress", foundAddress); // -1 if not found, or actual address + writeDoc(doc, "i2cConfiguredAddress", (int)TURBO_I2C_ADDR); // What we expected + writeDoc(doc, "debugIOCON", iocon); // Should be 0x00 + writeDoc(doc, "debugIODIRA", iodira); // Should be 0xFF (all inputs) + writeDoc(doc, "debugGPPUA", gppua); // Should be 0xFF (all pull-ups) + writeDoc(doc, "rawSwitchValue", gpioa); // Current GPIO state + + // Active-low switches: Pin HIGH (1) = switch OPEN = OFF + // Pin LOW (0) = switch CLOSED = ON + writeDoc(doc, "switchB1", !(gpioa & 0x01)); // GPA0 + writeDoc(doc, "switchB2", !(gpioa & 0x02)); // GPA1 + writeDoc(doc, "switchB3", !(gpioa & 0x04)); // GPA2 + writeDoc(doc, "switchB4", !(gpioa & 0x08)); // GPA3 + writeDoc(doc, "switchL1", !(gpioa & 0x10)); // GPA4 + writeDoc(doc, "switchR1", !(gpioa & 0x20)); // GPA5 + writeDoc(doc, "switchL2", !(gpioa & 0x40)); // GPA6 + writeDoc(doc, "switchR2", !(gpioa & 0x80)); // GPA7 + } else { + writeDoc(doc, "i2cSwitchesConfigured", false); + } +#else + writeDoc(doc, "i2cSwitchesConfigured", false); +#endif + + return serialize_json(doc); +} + std::string setLedOptions() { DynamicJsonDocument doc = get_post_data(); @@ -2569,6 +2658,32 @@ std::string reboot() { return serialize_json(doc); } +std::string scanI2CDevices() +{ + const size_t capacity = JSON_OBJECT_SIZE(50); + DynamicJsonDocument doc(capacity); + + // Scan both I2C blocks if enabled + for (uint8_t block = 0; block < NUM_I2CS; block++) { + if (PeripheralManager::getInstance().isI2CEnabled(block)) { + PeripheralI2C* i2c = PeripheralManager::getInstance().getI2C(block); + std::map scanResults = i2c->scan(); + + char blockKey[10]; + sprintf(blockKey, "i2c%d", block); + + auto devices = doc.createNestedArray(blockKey); + for (const auto& result : scanResults) { + char addrStr[6]; + sprintf(addrStr, "0x%02X", result.first); + devices.add(addrStr); + } + } + } + + return serialize_json(doc); +} + typedef std::string (*HandlerFuncPtr)(); static const std::pair handlerFuncs[] = { @@ -2600,6 +2715,7 @@ static const std::pair handlerFuncs[] = { "/api/reboot", reboot }, { "/api/getDisplayOptions", getDisplayOptions }, { "/api/getGamepadOptions", getGamepadOptions }, + { "/api/getTurboDiagnostics", getTurboDiagnostics }, { "/api/getButtonLayoutDefs", getButtonLayoutDefs }, { "/api/getButtonLayouts", getButtonLayouts }, { "/api/getLedOptions", getLedOptions }, @@ -2617,6 +2733,7 @@ static const std::pair handlerFuncs[] = { "/api/abortGetHeldPins", abortGetHeldPins }, { "/api/getUsedPins", getUsedPins }, { "/api/getConfig", getConfig }, + { "/api/scanI2CDevices", scanI2CDevices }, #if !defined(NDEBUG) { "/api/echo", echo }, #endif diff --git a/www/server/docs/GP2040-CE.postman_collection.json b/www/server/docs/GP2040-CE.postman_collection.json index 763bd1d4c2..e65e760a84 100644 --- a/www/server/docs/GP2040-CE.postman_collection.json +++ b/www/server/docs/GP2040-CE.postman_collection.json @@ -100,6 +100,44 @@ } }, "response": [] + }, + { + "name": "/api/getTurboDiagnostics", + "request": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/api/getTurboDiagnostics", + "host": ["{{baseUrl}}"], + "path": ["api", "getTurboDiagnostics"] + }, + "description": "Get real-time diagnostics for hardware turbo controls. Returns current state of I2C switches and turbo speed dial." + }, + "response": [ + { + "name": "Successful Response", + "originalRequest": { + "method": "GET", + "header": [], + "url": { + "raw": "{{baseUrl}}/api/getTurboDiagnostics", + "host": ["{{baseUrl}}"], + "path": ["api", "getTurboDiagnostics"] + } + }, + "status": "OK", + "code": 200, + "_postman_previewlanguage": "json", + "header": [ + { + "key": "Content-Type", + "value": "application/json" + } + ], + "cookie": [], + "body": "{\n \"dialRawValue\": 2048,\n \"dialPercentage\": 50,\n \"i2cSwitchesConfigured\": true,\n \"i2cFoundAddress\": 32,\n \"i2cConfiguredAddress\": 32,\n \"rawSwitchValue\": 170,\n \"debugIOCON\": 0,\n \"debugIODIRA\": 255,\n \"debugGPPUA\": 255,\n \"switchB1\": false,\n \"switchB2\": true,\n \"switchB3\": false,\n \"switchB4\": true,\n \"switchL1\": false,\n \"switchR1\": true,\n \"switchL2\": false,\n \"switchR2\": true\n}" + } + ] } ], "event": [ diff --git a/www/src/Addons/Turbo.tsx b/www/src/Addons/Turbo.tsx index eb033b92f5..a6d2642605 100644 --- a/www/src/Addons/Turbo.tsx +++ b/www/src/Addons/Turbo.tsx @@ -1,5 +1,5 @@ import { useState } from 'react'; -import { useContext } from 'react'; +import { useContext, useEffect } from 'react'; import { useTranslation } from 'react-i18next'; import { FormCheck, Row } from 'react-bootstrap'; import * as yup from 'yup'; @@ -15,6 +15,7 @@ import { DUAL_STICK_MODES } from '../Data/Addons'; import LEDColors from '../Data/LEDColors'; import { ANALOG_PINS } from '../Data/Buttons'; import { AddonPropTypes } from '../Pages/AddonsConfigPage'; +import WebApi from '../Services/WebApi'; const SHMUP_MIXED_MODES = [ { label: 'Turbo Priority', value: 0 }, @@ -148,6 +149,65 @@ const Turbo = ({ const [colorPickerTarget, setColorPickerTarget] = useState(null); const [showPicker, setShowPicker] = useState(false); + const [turboState, setTurboState] = useState({ + dialRawValue: 0, + dialPercentage: 0, + i2cSwitchesConfigured: false, + i2cFoundAddress: -1, + i2cConfiguredAddress: 0, + rawSwitchValue: 0, + debugIOCON: 0, + debugIODIRA: 0, + debugGPPUA: 0, + switchB1: false, + switchB2: false, + switchB3: false, + switchB4: false, + switchL1: false, + switchR1: false, + switchL2: false, + switchR2: false, + }); + + // Poll for turbo state when dial pin is configured or I2C switches enabled + useEffect(() => { + if (!values.TurboInputEnabled) { + return; + } + + const pollTurboState = async () => { + const diagnostics = await WebApi.getTurboDiagnostics(); + if (diagnostics) { + setTurboState({ + dialRawValue: diagnostics.dialRawValue || 0, + dialPercentage: diagnostics.dialPercentage || 0, + i2cSwitchesConfigured: diagnostics.i2cSwitchesConfigured || false, + i2cFoundAddress: diagnostics.i2cFoundAddress !== undefined ? diagnostics.i2cFoundAddress : -1, + i2cConfiguredAddress: diagnostics.i2cConfiguredAddress || 0, + rawSwitchValue: diagnostics.rawSwitchValue || 0, + debugIOCON: diagnostics.debugIOCON || 0, + debugIODIRA: diagnostics.debugIODIRA || 0, + debugGPPUA: diagnostics.debugGPPUA || 0, + switchB1: diagnostics.switchB1 || false, + switchB2: diagnostics.switchB2 || false, + switchB3: diagnostics.switchB3 || false, + switchB4: diagnostics.switchB4 || false, + switchL1: diagnostics.switchL1 || false, + switchR1: diagnostics.switchR1 || false, + switchL2: diagnostics.switchL2 || false, + switchR2: diagnostics.switchR2 || false, + }); + } + }; + + // Initial poll + pollTurboState(); + + // Poll every 500ms + const interval = setInterval(pollTurboState, 500); + + return () => clearInterval(interval); + }, [values.TurboInputEnabled]); const toggleRgbPledPicker = (e) => { e.stopPropagation(); @@ -285,6 +345,93 @@ const Turbo = ({ + {values.pinShmupDial !== -1 && ( + +
+
+ Live Turbo Dial Position: +
+ {turboState.dialPercentage}% ({turboState.dialRawValue} / 4095) +
+
+
+ + )} + {turboState.i2cSwitchesConfigured && ( + +
+
+ Live I2C Turbo Switch Status: +
+
+ I2C Address Scan: + {turboState.i2cFoundAddress >= 0 ? ( + Found MCP23017 at 0x{turboState.i2cFoundAddress.toString(16).toUpperCase().padStart(2, '0')} + ) : ( + Not found (scanning 0x20-0x27) + )} + {' - '}Configured: 0x{turboState.i2cConfiguredAddress.toString(16).toUpperCase().padStart(2, '0')} +
+
+ Raw GPIOA Value: 0x{(turboState.rawSwitchValue || 0).toString(16).toUpperCase().padStart(2, '0')} ({turboState.rawSwitchValue || 0}) +
+
+ + MCP23017 Registers: + IOCON=0x{(turboState.debugIOCON || 0).toString(16).toUpperCase().padStart(2, '0')} (expect 0x00), + IODIRA=0x{(turboState.debugIODIRA || 0).toString(16).toUpperCase().padStart(2, '0')} (expect 0xFF), + GPPUA=0x{(turboState.debugGPPUA || 0).toString(16).toUpperCase().padStart(2, '0')} (expect 0xFF) + +
+
+
+ + B1: {turboState.switchB1 ? "ON" : "OFF"} + +
+
+ + B2: {turboState.switchB2 ? "ON" : "OFF"} + +
+
+ + B3: {turboState.switchB3 ? "ON" : "OFF"} + +
+
+ + B4: {turboState.switchB4 ? "ON" : "OFF"} + +
+
+
+
+ + L1: {turboState.switchL1 ? "ON" : "OFF"} + +
+
+ + R1: {turboState.switchR1 ? "ON" : "OFF"} + +
+
+ + L2: {turboState.switchL2 ? "ON" : "OFF"} + +
+
+ + R2: {turboState.switchR2 ? "ON" : "OFF"} + +
+
+
+
+
+ + )} - { + setIsScanning(true); + const results = await WebApi.scanI2CDevices(); + setScanResults(results); + setIsScanning(false); + }; + useEffect(() => { async function fetchData() { const data = await WebApi.getDisplayOptions(); @@ -295,6 +304,67 @@ export default function DisplayConfigPage() { ))} + + +
+
I2C Device Scanner
+

+ Scan the I2C bus to detect connected devices and their addresses. + This helps identify if your display is properly connected. +

+ + {scanResults && ( +
+ Scan Results: + {(scanResults.i2c0 && scanResults.i2c0.length > 0) || + (scanResults.i2c1 && scanResults.i2c1.length > 0) ? ( +
+ {scanResults.i2c0 && scanResults.i2c0.length > 0 && ( +
+ I2C0 + + {scanResults.i2c0.join(', ')} + + {scanResults.i2c0.includes('0x3C') && ( + (Common OLED address) + )} + {scanResults.i2c0.includes('0x3D') && ( + (Common OLED address) + )} +
+ )} + {scanResults.i2c1 && scanResults.i2c1.length > 0 && ( +
+ I2C1 + + {scanResults.i2c1.join(', ')} + + {scanResults.i2c1.includes('0x3C') && ( + (Common OLED address) + )} + {scanResults.i2c1.includes('0x3D') && ( + (Common OLED address) + )} +
+ )} +
+ ) : ( +
+ No I2C devices found. Please check your connections. +
+ )} +
+ )} +
+ +