Files
hexapod-robot/2026-current/sim/shim/RF24.h
T
mangavalkandClaude Opus 5.5 0b836af8de 2026 remote: tabbed Nextion UI, robot telemetry, servo centre calibration
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>
2026-11-17 14:42:37 +01:00

48 lines
2.0 KiB
C++

#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 (with dynamic
// payloads - enableAckPayload() - any length up to 32 is received). The RX
// FIFO holds 3 packets; extra packets are dropped. An ack payload queued with
// writeAckPayload() goes back with the next packet received, like the chip's
// auto-ack (hxsim_get_ack_payload shows it).
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
void enableDynamicPayloads() { dynamic_ = true; }
void enableAckPayload() { dynamic_ = true; }
uint8_t getDynamicPayloadSize();
bool writeAckPayload(uint8_t pipe, const void* buf, uint8_t len);
uint8_t flush_tx();
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;
bool dynamic_ = false;
};