Firmware simulation, Unity project, and sim-verified robot fixes

Simulation
- sim/: the unchanged robot firmware compiled into hexapod_sim.dll
  against PC stand-ins (Arduino, Servo, Wire + register-level MPU6050,
  RF24 with matching-config radio), a kinematic body model (support
  plane + planted-foot odometry) that also drives the simulated IMU,
  and a headless smoke test (sim_smoke). build.ps1 builds and tests.
- Hexapod_Simulation_Unity/ folded in (history kept in a bundle
  outside the repo). Assets/HexapodSim loads the DLL, drives the
  existing leg rig, and offers joystick / keyboard / robot-serial
  input plus a test panel.

Robot (all found or confirmed in the simulation)
- Config.h geometry taken from the Unity model.
- IK femur elevation sign, gait stance direction, body pose
  rotation direction, yaw lever arm.
- Stance feet integrated from the current command; gait restarts at
  mid-stance; heading integrates the applied turn rate, only while
  walking.
- Leg clearance and reach checks (Limits::feetFeasible); walk command
  and body pose scaled as a whole, pose scale rate-limited, planted
  feet guarded so the body never snaps or legs collide.
- Robot-gyro self-leveling as an integrator.
- Heading mode: steering relative to the body; S walks backward.
- Standing height from the remote (STANCE_HEIGHT_RANGE_MM).

Protocol v3 (reflash both boards)
- CmdPacket gains body_height (22 bytes).

Remote
- Height slider (Nextion hHeight/nHeight, serial [ ]).
- Fixed unspecified I2C read order in RemoteIMU.

LEGACY/: owner's old Nextion HMI and remote hardware assets.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

2026-current/sim/shim/Arduino.h

@@ -0,0 +1,56 @@
+#pragma once
+// PC stand-in for the Arduino core, just enough for robot/ to compile
+// unchanged into the simulation DLL. Only on the sim's include path - the
+// Teensy build never sees this file.
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <type_traits>
+
+#ifndef PI
+#define PI 3.1415926535897932384626433832795
+#endif
+
+// Arduino defines these as macros; templates behave the same for every use
+// in robot/ without the double-evaluation surprises.
+template <class T, class L, class H>
+constexpr T constrain(T amt, L low, H high) {
+  return amt < low ? (T)low : (amt > high ? (T)high : amt);
+}
+template <class A, class B>
+constexpr typename std::common_type<A, B>::type min(A a, B b) { return a < b ? a : b; }
+template <class A, class B>
+constexpr typename std::common_type<A, B>::type max(A a, B b) { return a > b ? a : b; }
+
+inline double radians(double deg) { return deg * (PI / 180.0); }
+inline double degrees(double rad) { return rad * (180.0 / PI); }
+
+// Simulated clock, advanced by the simulation (see SimHardware.cpp).
+uint32_t millis();
+uint32_t micros();
+void delay(uint32_t ms);
+void delayMicroseconds(uint32_t us);
+
+// USB serial: output is captured for Unity, input is fed from Unity.
+class SimSerial {
+public:
+  void begin(unsigned long) {}
+  int available();
+  int read();
+  size_t write(uint8_t c);
+  size_t print(const char* s);
+  size_t print(char c)          { return write((uint8_t)c); }
+  size_t print(int v)           { return printf("%d", v); }
+  size_t print(unsigned v)      { return printf("%u", v); }
+  size_t print(long v)          { return printf("%ld", v); }
+  size_t print(unsigned long v) { return printf("%lu", v); }
+  size_t print(double v)        { return printf("%.2f", v); }
+  template <class T> size_t println(T v) { size_t n = print(v); return n + print("\n"); }
+  size_t println()              { return print("\n"); }
+  size_t printf(const char* fmt, ...);
+  operator bool() const { return true; }
+};
+extern SimSerial Serial;

2026-current/sim/shim/EEPROM.h

@@ -0,0 +1,17 @@
+#pragma once
+// Not used by robot/ today; here so a future robot-side EEPROM use doesn't
+// break the simulation build silently. Backed by RAM, starts erased (0xFF).
+#include <Arduino.h>
+
+class SimEEPROM {
+public:
+  template <class T> T& get(int addr, T& t) { memcpy(&t, mem_ + addr, sizeof(T)); return t; }
+  template <class T> const T& put(int addr, const T& t) { memcpy(mem_ + addr, &t, sizeof(T)); return t; }
+  uint8_t read(int addr) { return mem_[addr]; }
+  void write(int addr, uint8_t v) { mem_[addr] = v; }
+  SimEEPROM() { memset(mem_, 0xFF, sizeof(mem_)); }
+
+private:
+  uint8_t mem_[4284];
+};
+extern SimEEPROM EEPROM;

2026-current/sim/shim/RF24.h

@@ -0,0 +1,38 @@
+#pragma once
+#include <Arduino.h>
+
+// Stand-in for the TMRh20 RF24 library. Enum values match RF24 1.x so the
+// static_asserts in Comms.cpp still check HexapodProtocol.h.
+enum rf24_pa_dbm_e { RF24_PA_MIN = 0, RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX, RF24_PA_ERROR };
+enum rf24_datarate_e { RF24_1MBPS = 0, RF24_2MBPS, RF24_250KBPS };
+
+// A simulated radio. Packets the simulation puts "on air" (hxsim_radio_send)
+// are only received if this radio's channel, data rate, address and static
+// payload size match the sender's, just like the real nRF24L01. The RX FIFO
+// holds 3 packets; extra packets are dropped.
+class RF24 {
+public:
+  RF24(uint16_t ce_pin, uint16_t csn_pin) { (void)ce_pin; (void)csn_pin; }
+  bool begin();
+  bool isChipConnected();
+  void setPayloadSize(uint8_t size) { payload_size_ = size > 32 ? 32 : size; }
+  void openReadingPipe(uint8_t pipe, const uint8_t* address);
+  void openWritingPipe(const uint8_t*) {}
+  void setPALevel(rf24_pa_dbm_e, bool = true) {}
+  bool setDataRate(rf24_datarate_e rate) { data_rate_ = rate; return true; }
+  void setChannel(uint8_t ch) { channel_ = ch > 125 ? 125 : ch; }
+  void setRetries(uint8_t, uint8_t) {}
+  void startListening() { listening_ = true; }
+  void stopListening() { listening_ = false; }
+  bool available();
+  void read(void* buf, uint8_t len);
+  bool write(const void*, uint8_t) { return false; }   // the robot never transmits
+
+private:
+  uint8_t payload_size_ = 32;
+  uint8_t channel_ = 76;
+  rf24_datarate_e data_rate_ = RF24_1MBPS;
+  uint8_t address_[5] = {};
+  bool pipe_open_ = false;
+  bool listening_ = false;
+};

2026-current/sim/shim/SPI.h

@@ -0,0 +1,2 @@
+#pragma once
+// Nothing needed: the simulated RF24 doesn't talk SPI.

2026-current/sim/shim/Servo.h

@@ -0,0 +1,16 @@
+#pragma once
+#include <Arduino.h>
+
+// Stand-in for the Teensy Servo library. Every pulse the robot code writes is
+// recorded per pin, so the simulation sees exactly what real servos would.
+class Servo {
+public:
+  uint8_t attach(int pin);
+  void detach();
+  void writeMicroseconds(int us);
+  void write(int deg) { writeMicroseconds(544 + deg * (2400 - 544) / 180); }
+  bool attached() const { return pin_ >= 0; }
+
+private:
+  int pin_ = -1;
+};

2026-current/sim/shim/Wire.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <Arduino.h>
+
+// Stand-in for the I2C bus with one simulated MPU6050 on it (address 0x68).
+// The simulation fills its accel/gyro registers from the simulated body
+// motion, so robot/RobotIMU.cpp runs unchanged, register map and all.
+class TwoWire {
+public:
+  void begin() {}
+  void setClock(uint32_t) {}
+  void beginTransmission(int address);
+  size_t write(uint8_t b);
+  uint8_t endTransmission(bool stop = true);
+  uint8_t requestFrom(int address, int quantity);
+  int available();
+  int read();
+};
+extern TwoWire Wire;