Protocol v4: CmdPacket grows to 26 bytes (cal_cmd, cal_servo, cal_value); new 30-byte Telemetry rides back on the nRF24 ack payload (robot state, IMU, battery, 18 joint angles, packets/s, servo-cal echo). Each end drops wrong-length packets, so version mismatches still fail closed. Robot (owner-approved): SERVO_CAL state while disarmed, per-servo centre trims (+-200 us) in EEPROM, telemetry, battery reading; the IMU estimate now always runs (leveling still gated by ROBOT GYRO). Remote: generated HMI (scripts/make_remote_hmi.py) with pages splash, drive, status, servos, cal, setup, upload; page-aware NextionUI that only writes the showing page and only what changed; servo calibration and UPDATE DISPLAY on the touchscreen and serial console; battery module. The display is on Serial2 (pins 7/8), found on the real remote; the old sketch's Serial1 was never connected to it. Sim: RF24 shim supports ack payloads, API version 8 (hxsim_get_ack_payload); sim_smoke checks telemetry and every CAL command. Unity CmdPacket mirror updated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
70 lines
2.6 KiB
C++
70 lines
2.6 KiB
C++
#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); }
|
|
|
|
// Pins and hardware PWM. analogWrite() pulses are recorded per pin, so the
|
|
// simulation sees servo pulses exactly as the PWM hardware would make them.
|
|
#define INPUT 0
|
|
#define OUTPUT 1
|
|
#define LOW 0
|
|
#define HIGH 1
|
|
void pinMode(uint8_t pin, uint8_t mode);
|
|
void digitalWrite(uint8_t pin, uint8_t value);
|
|
void analogWrite(uint8_t pin, int value);
|
|
inline int analogRead(uint8_t) { return 0; } // nothing analog is simulated
|
|
uint32_t analogWriteResolution(uint32_t bits); // returns the previous resolution, like Teensyduino
|
|
void analogWriteFrequency(uint8_t pin, float hz);
|
|
|
|
// 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;
|