Merge branch 'development' into feat/newInputCapture

Author: jorgesg82

.changesets/gpio-af-bitmaps-patch.md

@@ -0,0 +1,5 @@
+release: patch
+summary: Fix incorrect GPIO alternate-function availability bitmaps
+
+Correct the STM32H723 pin alternate-function masks in `Pin.hpp` so GPIO
+configuration reflects the actual AF support per pin.

.claude/commands/new-driver.md

@@ -0,0 +1,79 @@
+Create a new ST-LIB hardware driver for: $ARGUMENTS
+
+Use ADC as the reference implementation:
+- `Inc/HALAL/Services/ADC/ADC.hpp` — service header pattern
+- `Tests/adc_test.cpp` — test pattern with mocked drivers
+
+### Step 1 — Service header `Inc/HALAL/Services/[Module]/[Module].hpp`
+
+- Define `[Module]Domain` struct (wraps everything)
+- Define `Entry` struct: compile-time config per peripheral instance (pin, mode, output pointer, etc.)
+- Define `Config` struct: fully resolved config after `build()` (all AUTO fields resolved)
+- Define enums for peripheral IDs, operating modes, resolutions, etc.
+- Implement `consteval build<N>(std::span<const Entry, N>) -> std::array<Config, N>`
+  - Resolve AUTO fields (pin → peripheral/channel lookup tables)
+  - Validate constraints at compile time — use `compile_error()` for violations
+- Guard hardware-specific declarations with `#ifdef HAL_[MODULE]_MODULE_ENABLED`
+- Include `hal_wrapper.h` at the top
+
+### Step 2 — Service implementation `Src/HALAL/Services/[Module]/[Module].cpp`
+
+- HAL handle declarations (`extern [MODULE]_HandleTypeDef h[module]N`)
+- `start(const Config& cfg)` function: initialize HAL, configure DMA if needed
+- Runtime operations: `read()`, `write()`, `get_value()`, etc.
+- Use `#ifdef SIM_ON` to call mocked functions instead of real HAL
+
+### Step 3 — MockedDriver `Inc/MockedDrivers/mocked_hal_[module].hpp`
+
+- In-memory state arrays replacing HAL registers
+- Init function called instead of HAL init in `SIM_ON` mode
+- Control functions for tests: `[module]_set_*(idx, value)`, `[module]_get_*(idx)`
+- Time simulation if the peripheral has timing behavior: `[module]_advance_time_ns(ns)`
+- Callback/interrupt simulation if needed
+
+### Step 4 — Tests `Tests/[module]_test.cpp`
+
+```cpp
+#include <gtest/gtest.h>
+#include "HALAL/Services/[Module]/[Module].hpp"
+#include "MockedDrivers/mocked_hal_[module].hpp"
+
+namespace ST_LIB::TestErrorHandler { void reset(); void set_fail_on_error(bool); }
+
+namespace {
+// Declare test configs at namespace scope (constexpr can't be local)
+inline float test_output = 0.0f;
+constexpr std::array<[Module]Domain::Entry, 1> test_entry{{ ... }};
+constexpr auto test_cfg = [Module]Domain::build<1>(std::span{test_entry});
+static_assert(test_cfg[0].peripheral == ...);  // verify compile-time resolution
+}
+
+TEST(ModuleTest, CompileTimeConfig) { ... }
+TEST(ModuleTest, BasicReadWrite) { ... }
+TEST(ModuleTest, ErrorOnInvalidConfig) {
+    ST_LIB::TestErrorHandler::set_fail_on_error(true);
+    // trigger invalid config...
+    ST_LIB::TestErrorHandler::reset();
+}
+```
+
+Add to `Tests/CMakeLists.txt`:
+```cmake
+add_executable([module]_test [module]_test.cpp)
+target_link_libraries([module]_test PRIVATE stlib GTest::gtest_main)
+add_test(NAME [Module]Test COMMAND [module]_test)
+```
+
+### Step 5 — Register in HALAL
+
+- Add `#include "HALAL/Services/[Module]/[Module].hpp"` to `Inc/HALAL/HALAL.hpp`
+- Add `[Module]Domain::start()` call in `Src/HALAL/HALAL.cpp` inside `common_start()`
+  - Check initialization order: DMA must be started before services that use it
+
+### Verification
+
+```bash
+cmake --preset simulator
+cmake --build --preset simulator
+ctest --preset simulator-all
+```

.claude/commands/new-test.md

@@ -0,0 +1,51 @@
+Write a new GTest test for ST-LIB module: $ARGUMENTS
+
+1. Read the most relevant existing test first to understand the exact patterns:
+   - `Tests/adc_test.cpp` — for ADC-like services (compile-time config + DMA)
+   - `Tests/dma2_test.cpp` — for DMA-focused tests
+   - `Tests/spi2_test.cpp` — for SPI/communication tests
+   - `Tests/adc_sensor_test.cpp` — for higher-level sensor abstractions
+
+2. Read the service header (`Inc/HALAL/Services/[Module]/[Module].hpp`) to understand the API
+
+3. Read the MockedDriver header (`Inc/MockedDrivers/mocked_hal_[module].hpp`) to understand what control/injection functions are available
+
+4. Write the test file `Tests/[module]_test.cpp`:
+
+   **Required structure:**
+   - All `constexpr` test configs at **namespace scope**, not inside TEST bodies (constexpr variables cannot be local)
+   - `inline float` output variables at namespace scope
+   - For DMA-based services: use `merge_dma_entries<TotalN>(base_span, extra_array...)` pattern from `adc_test.cpp` when combining multiple peripheral DMA configs
+
+   **Recommended test cases:**
+   - `CompileTimeConfig`: verify `build()` resolves AUTO fields correctly via `static_assert` + `EXPECT_EQ`
+   - `BasicOperation`: inject a value via mocked driver, call the service, verify output
+   - `MultiInstance`: test two simultaneous instances don't interfere
+   - `ErrorOnInvalidConfig`: set `TestErrorHandler::set_fail_on_error(true)`, trigger invalid config, verify error was called
+
+   **Error handler pattern:**
+   ```cpp
+   namespace ST_LIB::TestErrorHandler {
+   void reset();
+   void set_fail_on_error(bool enabled);
+   extern int call_count;
+   }
+   // In test:
+   ST_LIB::TestErrorHandler::set_fail_on_error(true);
+   // ... code that should trigger error ...
+   EXPECT_GT(ST_LIB::TestErrorHandler::call_count, 0);
+   ST_LIB::TestErrorHandler::reset();
+   ```
+
+5. Register in `Tests/CMakeLists.txt`:
+   ```cmake
+   add_executable([module]_test [module]_test.cpp)
+   target_link_libraries([module]_test PRIVATE stlib GTest::gtest_main)
+   add_test(NAME [Module]Test COMMAND [module]_test)
+   ```
+
+6. Run and verify:
+   ```bash
+   cmake --build --preset simulator
+   ctest --preset simulator-all --output-on-failure
+   ```

.claude/commands/pin-mapping.md

@@ -0,0 +1,38 @@
+Show the ADC peripheral and channel mapping for GPIO pin: $ARGUMENTS
+
+1. Read `Inc/HALAL/Services/ADC/ADC.hpp` and find the `pin_map` constexpr lookup table
+
+2. Look up the requested pin and report:
+   - Which ADC peripheral it maps to: `ADC_1`, `ADC_2`, or `ADC_3`
+   - Which channel number (e.g. `CH16`)
+   - Whether this pin is shared with another function (PWM, SPI, etc.) that could conflict
+
+3. Check `Tests/adc_test.cpp` for any existing `static_assert` that already validates this mapping
+
+4. Explain the implications for multi-channel use:
+   - Pins on the **same ADC peripheral** → share one DMA stream, conversion is sequential (scan mode)
+   - Pins on **different ADC peripherals** → separate DMA streams, conversions run in parallel
+   - Maximum 16 channels per peripheral on STM32H723
+
+5. Show the exact `ADCDomain::Entry` snippet to use this pin correctly:
+   ```cpp
+   inline float my_output = 0.0f;
+
+   constexpr std::array<ADCDomain::Entry, 1> entry{{
+       {.gpio_idx   = 0,
+        .pin        = ST_LIB::[PIN],
+        .peripheral = ADCDomain::Peripheral::AUTO,
+        .channel    = ADCDomain::Channel::AUTO,
+        .resolution = ADCDomain::Resolution::BITS_12,
+        .sample_time = ADCDomain::SampleTime::CYCLES_8_5,
+        .prescaler  = ADCDomain::ClockPrescaler::DIV1,
+        .sample_rate_hz = 0,
+        .output     = &my_output}
+   }};
+   constexpr auto cfg = ADCDomain::build<1>(std::span{entry});
+   // Confirm the resolved mapping:
+   static_assert(cfg[0].peripheral == ADCDomain::Peripheral::[RESOLVED]);
+   static_assert(cfg[0].channel    == ADCDomain::Channel::[RESOLVED]);
+   ```
+
+6. If the pin is **not in the pin_map** (not ADC-capable on STM32H723), say so clearly and suggest the nearest ADC-capable pins.

.github/workflows/claude-code-review.yml

@@ -0,0 +1,30 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize, ready_for_review, reopened]
+
+jobs:
+  claude-review:
+    if: github.event.pull_request.user.login == 'jsaegar'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          plugin_marketplaces: 'https://github.com/anthropics/claude-code.git'
+          plugins: 'code-review@claude-code-plugins'
+          prompt: '/code-review:code-review ${{ github.repository }}/pull/${{ github.event.pull_request.number }}'

.github/workflows/claude.yml

@@ -0,0 +1,43 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      github.actor == 'jsaegar' && (
+        (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+        (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+        (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+        (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+      )
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read