Add MCU firmware test harness with 8 bug-confirming tests

Complete test infrastructure for the observe-before-fix methodology:

- stm32_hal_mock: HAL stub types + spy/recording ring buffer (512 entries)
- ad_driver_mock: ADF4382/AD9523 mock drivers with configurable returns
- 9 shim headers redirecting real #includes to mock types
- Makefile with individual (test_bug1..8) and aggregate (test) targets

All 8 tests pass, confirming:
  #1 Timed sync init ordering (SetupTimedSync before initialized=true)
  #2 AD9523 double setup (first call before reset release)
  #3 TriggerTimedSync no-op (prints messages, no HW action)
  #4 Phase shift before init error check
  #5 SetFinePhaseShift GPIO-only placeholder (no PWM)
  #6 Timer variable collision (last_check vs last_check1)
  #7 GPIO pin mapping conflict (manager.h vs CubeMX main.h)
  #8 uart_print/uart_println commented out

9_Firmware/9_1_Microcontroller/tests/ad_driver_mock.c

@@ -0,0 +1,142 @@
+/*******************************************************************************
+ * ad_driver_mock.c -- Mock implementations for ADF4382 and AD9523 drivers
+ ******************************************************************************/
+#include "ad_driver_mock.h"
+#include <stdlib.h>
+#include <string.h>
+
+/* Configurable return values */
+int mock_adf4382_init_retval = 0;
+int mock_ad9523_setup_retval = 0;
+
+/* Internal device stubs (allocated on the heap by mock init) */
+static struct adf4382_dev  adf4382_stub_devs[4];
+static int                 adf4382_stub_idx = 0;
+
+static struct ad9523_dev   ad9523_stub_devs[2];
+static int                 ad9523_stub_idx = 0;
+
+/* Helper to push spy record (references the extern in stm32_hal_mock) */
+extern SpyRecord spy_log[];
+extern int       spy_count;
+
+static void spy_push_drv(SpyCallType type, void *extra, uint32_t val)
+{
+    if (spy_count < SPY_MAX_RECORDS) {
+        spy_log[spy_count++] = (SpyRecord){
+            .type  = type,
+            .port  = NULL,
+            .pin   = 0,
+            .value = val,
+            .extra = extra
+        };
+    }
+}
+
+/* ========================= ADF4382 mock =========================== */
+
+int adf4382_init(struct adf4382_dev **device, struct adf4382_init_param *init_param)
+{
+    spy_push_drv(SPY_ADF4382_INIT, (void*)init_param, 0);
+    if (mock_adf4382_init_retval != 0) {
+        *device = NULL;
+        return mock_adf4382_init_retval;
+    }
+    /* Return a stub device */
+    int idx = adf4382_stub_idx % 4;
+    memset(&adf4382_stub_devs[idx], 0, sizeof(struct adf4382_dev));
+    adf4382_stub_devs[idx].freq = init_param->freq;
+    adf4382_stub_devs[idx].ref_freq_hz = init_param->ref_freq_hz;
+    *device = &adf4382_stub_devs[idx];
+    adf4382_stub_idx++;
+    return 0;
+}
+
+int adf4382_remove(struct adf4382_dev *dev)
+{
+    spy_push_drv(SPY_ADF4382_REMOVE, dev, 0);
+    return 0;
+}
+
+int adf4382_set_out_power(struct adf4382_dev *dev, uint8_t ch, int32_t pwr)
+{
+    spy_push_drv(SPY_ADF4382_SET_OUT_POWER, dev, (uint32_t)((ch << 16) | (pwr & 0xFFFF)));
+    return 0;
+}
+
+int adf4382_set_en_chan(struct adf4382_dev *dev, uint8_t ch, bool en)
+{
+    spy_push_drv(SPY_ADF4382_SET_EN_CHAN, dev, (uint32_t)((ch << 16) | en));
+    return 0;
+}
+
+int adf4382_set_timed_sync_setup(struct adf4382_dev *dev, bool sync)
+{
+    spy_push_drv(SPY_ADF4382_SET_TIMED_SYNC, dev, (uint32_t)sync);
+    return 0;
+}
+
+int adf4382_set_ezsync_setup(struct adf4382_dev *dev, bool sync)
+{
+    spy_push_drv(SPY_ADF4382_SET_EZSYNC, dev, (uint32_t)sync);
+    return 0;
+}
+
+int adf4382_set_sw_sync(struct adf4382_dev *dev, bool sw_sync)
+{
+    spy_push_drv(SPY_ADF4382_SET_SW_SYNC, dev, (uint32_t)sw_sync);
+    return 0;
+}
+
+int adf4382_spi_read(struct adf4382_dev *dev, uint16_t reg_addr, uint8_t *data)
+{
+    spy_push_drv(SPY_ADF4382_SPI_READ, dev, (uint32_t)reg_addr);
+    if (data) {
+        /* By default, return "locked" status for reg 0x58 */
+        if (reg_addr == 0x58) {
+            *data = ADF4382_LOCKED_MSK; /* locked */
+        } else {
+            *data = 0;
+        }
+    }
+    return 0;
+}
+
+/* ========================= AD9523 mock ============================ */
+
+int32_t ad9523_init(struct ad9523_init_param *init_param)
+{
+    spy_push_drv(SPY_AD9523_INIT, init_param, 0);
+    return 0;
+}
+
+int32_t ad9523_setup(struct ad9523_dev **device, const struct ad9523_init_param *init_param)
+{
+    spy_push_drv(SPY_AD9523_SETUP, (void*)init_param, 0);
+    if (mock_ad9523_setup_retval != 0) {
+        return mock_ad9523_setup_retval;
+    }
+    int idx = ad9523_stub_idx % 2;
+    memset(&ad9523_stub_devs[idx], 0, sizeof(struct ad9523_dev));
+    *device = &ad9523_stub_devs[idx];
+    ad9523_stub_idx++;
+    return 0;
+}
+
+int32_t ad9523_status(struct ad9523_dev *dev)
+{
+    spy_push_drv(SPY_AD9523_STATUS, dev, 0);
+    return 0;
+}
+
+int32_t ad9523_sync(struct ad9523_dev *dev)
+{
+    spy_push_drv(SPY_AD9523_SYNC, dev, 0);
+    return 0;
+}
+
+int32_t ad9523_remove(struct ad9523_dev *dev)
+{
+    spy_push_drv(SPY_AD9523_REMOVE, dev, 0);
+    return 0;
+}