Add native SolarXiao MPPT and battery telemetry and controls

This commit is contained in:
mikecarper committed 2026-10-21 15:25:53 -07:00
1 parent e5c8d28d5e
commit 2dcc1caccb
15 files changed
+1357 -2

No files matched your search

+305
View File
@@ -0,0 +1,305 @@
"""Exercise the shipping charger core with fault-injected I2C and persistence."""
from pathlib import Path
import os
import shutil
import subprocess
import tempfile
import unittest
from test_replay_reset_integration import extract_braced
ROOT = Path(__file__).resolve().parents[1]
HARNESS = r'''
#include "SolarXiaoPowerCore.h"
#include <cassert>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
using namespace mesh::solar;
struct FakeBus : Bus {
uint16_t r[256]={}, ina[256]={};
bool online=true, fail_write=false, ignore_write=false;
int read_fail=-1;
struct Write {unsigned reg, value;};
std::vector<Write> writes;
FakeBus() {
r[0x43]=0x46b4; r[0x14]=2; r[0x29]=1;
r[16]=16019; r[17]=17414; r[0x1a]=31; r[0x1b]=15;
r[0x4a]=1; r[0x39]=7; r[0x34]=256;
r[0x3a]=17152; r[0x3b]=8000; r[0x3c]=7985;
r[0x3d]=uint16_t(-100); r[0x3e]=200; r[0x3f]=14000;
r[0x40]=10914; r[0x41]=10;
ina[0xfe]=0x5449; ina[0xff]=0x2270;
ina[2]=10560; ina[1]=uint16_t(-8); ina[3]=13;
}
bool read(uint8_t addr,uint8_t reg,uint16_t& word) override {
assert(addr==0x68 || addr==0x40);
if (!online || int(reg)==read_fail) return false;
word=(addr==0x68?r:ina)[reg]; return true;
}
bool write(uint8_t addr,uint8_t reg,uint16_t word) override {
assert(addr==0x68); writes.push_back({reg,word});
if (fail_write) return false;
if (ignore_write) return true;
if(reg>=0x36 && reg<=0x38) r[reg]&=word;
else r[reg]=word;
return true;
}
};
struct FakeStore : Store {
std::vector<uint8_t> bytes;
bool writable=true, failed=false;
int saves=0;
bool available() const override {return writable;}
bool exists() const override {return !bytes.empty();}
bool load(uint8_t* data,size_t n) override {
if(bytes.size()!=n) return false;
memcpy(data,bytes.data(),n);return true;
}
bool save(const uint8_t* data,size_t n) override {
++saves; if(failed)return false;
bytes.assign(data,data+n);return true;
}
};
std::string cli(Controller& c,const char* cmd,bool local=true) {
struct Guard {char a[3]; char reply[157]; char z[3];} g;
memset(&g,0x5a,sizeof(g));
assert(c.handle(cmd,g.reply,sizeof(g.reply),local));
assert(g.a[0]==0x5a && g.a[2]==0x5a && g.z[0]==0x5a && g.z[2]==0x5a);
assert(memchr(g.reply,0,sizeof(g.reply)));
return g.reply;
}
void has(const std::string& s,const char* part) {assert(s.find(part)!=std::string::npos);}
void close(double got,double expected) {assert(fabs(got-expected)<0.0002);}
int main(int argc,char** argv) {
assert(argc==2); std::string test=argv[1];
FakeBus bus;FakeStore store;Controller c(bus,store);c.begin();
if(test=="readings") {
Snapshot s;assert(c.snapshot(s)); assert(s.charger && s.monitor && s.adc_active);
close(s.battery_v,13.2);close(s.battery_a,-0.01);close(s.battery_w,0.13);
close(s.vin_v,13.192);close(s.charger_vbat_v,13.2001792);
close(s.ibat_a,-0.01466);close(s.iin_a,0.02932);close(s.die_c,36.6);
assert(fabs(s.ntc_c-25)<0.02);close(s.bsr_ohm,0.0008);
bus.r[0x4a]=3;c.snapshot(s);assert(std::isnan(s.bsr_ohm));
bus.r[0x43]=0x06b0;c.snapshot(s);assert(s.cells==0 && c.lastCellCount()==4);
assert(std::isnan(s.charger_vbat_v));has(cli(c,"get mppt battery.mv"),"unknown cells");
bus.r[0x39]=0;c.snapshot(s);assert(!s.adc_active && std::isnan(s.vin_v));
has(cli(c,"get mppt input.mv"),"ADC inactive");
bus.r[0x14]|=4;c.snapshot(s);assert(s.adc_active);
bus.r[0x40]=21684;c.snapshot(s);assert(std::isnan(s.ntc_c));
bus.ina[0xff]=0x227f;c.snapshot(s);assert(s.monitor);
bus.ina[0xff]=0x2260;c.snapshot(s);assert(!s.monitor);
assert(bus.writes.empty() && store.saves==0);
} else if(test=="defaults-identity") {
c.service(0);c.service(5000);assert(bus.writes.empty());
for(unsigned id: {0x0101u,0x0404u,0x0603u,0x0704u,0x0f04u}) {
bus.r[0x43]=id;has(cli(c,"set mppt telemetry.fast on"),"Err -");
c.service(10000+id);assert(bus.writes.empty());
}
bus.r[0x43]=0x06b0;has(cli(c,"set mppt telemetry.fast on"),"OK -");
assert(bus.r[0x14]==10);
bus.online=false;has(cli(c,"set mppt telemetry.fast off"),"unavailable");
} else if(test=="locks-ranges") {
for(const char* cmd: {"set mppt cells 3","set mppt chemistry 4",
"set mppt jeita.t1_raw 123","set mppt jeita.voltages_432 123",
"set mppt absorb.seconds 500","set mppt recharge.mv 13000",
"set mppt input.limit_ma nan","set mppt input.limit_ma inf",
"set mppt input.limit_ma -1","set mppt input.limit_ma 10",
"set mppt input.limit_ma 3201","set mppt charge.cell_mv 3650",
"set mppt charge.current_ma 2000","set mppt charge.cell_mv 3550",
"set mppt input.minimum_mv 14000","set mppt telemetry.fast 1",
"set mppt thermal.start_c 126","set mppt thermal.start_c 120",
"set mppt thermal.end_c 70","set mppt termination.current_ma -1",
"set mppt alert.limits_mask 0x1000","set mppt state 0",
"set mppt telemetry.fast on extra"}) {
has(cli(c,cmd),"Err -");assert(bus.writes.empty());
}
bus.r[0x43]=0x0600;
has(cli(c,"set mppt alert.battery_low_mv 12000"),"unknown");assert(bus.writes.empty());
assert(store.saves==0);
} else if(test=="rounding-rmw") {
bus.r[0x14]=0x8052;
has(cli(c,"set mppt telemetry.fast on"),"readback verified");
assert(bus.r[0x14]==0x804a); // preserve other bits; never replay run_bsr.
has(cli(c,"set mppt input.limit_ma 1234"),"1200");assert(bus.r[0x15]==23);
has(cli(c,"set mppt mppt.enabled off"),"OK -");
has(cli(c,"set mppt input.minimum_mv 13000"),"13078.1");assert(bus.r[0x16]==92);
has(cli(c,"set mppt jeita.enabled off"),"OK -");
has(cli(c,"set mppt charge.current_ma 1540"),"1500");assert(bus.r[0x1a]==14);
has(cli(c,"set mppt charge.cell_mv 3558"),"3550");assert(bus.r[0x1b]==11);
has(cli(c,"set mppt thermal.start_c 80"),"OK -");
has(cli(c,"set mppt thermal.end_c 115"),"OK -");
has(cli(c,"set mppt termination.current_ma 200"),"OK -");
} else if(test=="persistence-order") {
has(cli(c,"set mppt telemetry.force on"),"OK -");
has(cli(c,"set mppt jeita.enabled off"),"OK -");
has(cli(c,"set mppt charge.current_ma 1000"),"OK -");
has(cli(c,"set mppt thermal.end_c 125"),"OK -");
has(cli(c,"set mppt thermal.start_c 115"),"OK -");
has(cli(c,"set mppt charge.enabled off"),"OK -");
bus.r[0x14]=2;bus.r[0x29]=1;bus.r[0x1a]=31;bus.r[16]=16019;bus.r[17]=17414;
bus.writes.clear();Controller fresh(bus,store);fresh.begin();fresh.service(0xfffffff0);
assert(bus.writes[0].reg==0x14 && (bus.writes[0].value&0x20));
assert(bus.writes[1].reg==17 && bus.writes[2].reg==16);
assert(bus.r[0x29]==0 && bus.r[0x1a]==9 && bus.r[0x14]==38);
assert(fresh.settingsApplied());size_t count=bus.writes.size();fresh.service(20);
assert(bus.writes.size()==count);fresh.service(5000);assert(bus.writes.size()==count);
has(cli(fresh,"set mppt jeita.enabled on"),"OK -");
bus.r[0x1a]=31;count=bus.writes.size();fresh.service(10000);assert(bus.writes.size()==count);
has(cli(fresh,"mppt forget"),"live charger unchanged");
bus.r[0x14]=2;fresh.service(15000);assert(bus.r[0x14]==2);
} else if(test=="faults") {
bus.ignore_write=true;has(cli(c,"set mppt telemetry.fast on"),"write/readback failed");
assert(store.saves==0 && bus.r[0x14]==2);
bus.ignore_write=false;store.failed=true;
has(cli(c,"set mppt telemetry.fast on"),"rollback=verified");
assert(bus.r[0x14]==2 && !c.settingsHealthy());
size_t count=bus.writes.size();c.service(0);assert(bus.writes.size()==count);
has(cli(c,"set mppt telemetry.fast on"),"storage unavailable");
store.failed=false;has(cli(c,"mppt reload"),"OK -");
has(cli(c,"set mppt telemetry.fast on"),"OK -");
bus.read_fail=0x14;has(cli(c,"set mppt telemetry.fast off"),"read failed");
bus.read_fail=-1;bus.fail_write=true;
has(cli(c,"set mppt telemetry.fast off"),"rollback=verified");
} else if(test=="record-validation") {
Settings s;s.defaults();uint8_t image[Settings::IMAGE_SIZE];s.encode(image);
Settings got;assert(got.decode(image));image[23]^=1;assert(!got.decode(image));
for(int type=0;type<6;++type) {
s.defaults();
if(type==0){s.masks[0x43%Settings::REG_COUNT]=1;} // reserved/non-writable
if(type==1){s.masks[0x14]=16;s.values[0x14]=16;}
if(type==2){s.masks[16]=0xffff;s.values[16]=1;}
if(type==3){s.rsnsb_mohm=NAN;}
if(type==4){s.masks[0x1c]=0xffff;s.values[0x1c]=0xffff;}
if(type==5){s.masks[0x1b]=31;s.values[0x1b]=31;}
s.encode(image);assert(!got.decode(image));
}
store.bytes.assign(10,0);Controller bad(bus,store);bad.begin();bad.service(0);
assert(!bad.settingsHealthy() && bus.writes.empty());
has(cli(bad,"set mppt telemetry.force on"),"storage unavailable");
has(cli(bad,"mppt reset",false),"local USB");
has(cli(bad,"mppt reset"),"OK -");assert(bad.settingsHealthy());
has(cli(bad,"set mppt cal.rsnsb_mohm 20"),"saved");
has(cli(bad,"get mppt cal.rsnsb_mohm"),"source=user");
Controller after(bus,store);after.begin();close(after.configuration().rsnsb_mohm,20);
} else if(test=="actions-parser") {
assert(!c.handle("get mpptish",nullptr,0,true));
for(int i=0;i<40;++i) {std::string cmd="get mppt fields "+std::to_string(i);cli(c,cmd.c_str());}
has(cli(c,"get mppt fields -1"),"Err -");
has(cli(c,"get mppt raw 0x43"),"46B4");has(cli(c,"get mppt raw 0x12"),"Err -");
has(cli(c,"mppt ship arm",false),"local USB");assert(bus.writes.empty());
has(cli(c,"mppt bsr run"),"not saved");assert(bus.writes.back().value==18);
has(cli(c,"mppt ship arm"),"not saved");assert(bus.writes.back().value==21325);
has(cli(c,"mppt ship disarm"),"not saved");assert(bus.writes.back().value==0);
bus.r[0x36]=0xcfff;has(cli(c,"mppt alerts clear limits 0x20"),"OK -");
assert(bus.writes.back().value==0xffdf && bus.r[0x36]==0xcfdf);
has(cli(c,"mppt alerts clear limits 0x1000"),"Err -");assert(store.saves==0);
} else return 2;
}
'''
class SolarXiaoPowerTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.temp = tempfile.TemporaryDirectory(prefix="solarxiao-power-test-")
cls.addClassCleanup(cls.temp.cleanup)
directory = Path(cls.temp.name)
cpp = directory / "test.cpp"
cpp.write_text(HARNESS, encoding="ascii")
cls.binary = directory / "test"
compiler = os.environ.get("CXX") or shutil.which("g++")
assert compiler, "host C++11 compiler required"
subprocess.run([compiler, "-std=c++11", "-Wall", "-Wextra", "-Werror",
"-fsanitize=address,undefined", "-fno-sanitize-recover=all", "-fno-pie", "-no-pie",
"-DMESH_SOLARXIAO_POWER=1", "-I" + str(ROOT / "src/helpers/sensors"),
str(cpp), str(ROOT / "src/helpers/sensors/SolarXiaoPowerCore.cpp"),
"-o", str(cls.binary)], check=True, capture_output=True, text=True, timeout=30)
def test_shipping_core(self):
for scenario in ("readings", "defaults-identity", "locks-ranges", "rounding-rmw",
"persistence-order", "faults", "record-validation", "actions-parser"):
with self.subTest(scenario=scenario):
result = subprocess.run([str(self.binary), scenario], capture_output=True,
text=True, timeout=10)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
class SolarXiaoTelemetryIntegrationTests(unittest.TestCase):
def test_permissions_and_stable_voltage_channels(self):
source = (ROOT / "src/helpers/sensors/EnvironmentSensorManager.cpp").read_text()
methods = "\n".join(extract_braced(source, prefix) for prefix in (
"bool EnvironmentSensorManager::querySensors(",
"uint8_t EnvironmentSensorManager::getVoltageSensorChannels(",
"uint8_t EnvironmentSensorManager::queryVoltageSensors("))
harness = r'''#include <cassert>
#include <cstdint>
#include <cmath>
using std::isfinite;
#define TELEM_CHANNEL_SELF 1
#define TELEM_PERM_ENVIRONMENT 4
struct CayenneLPP {};
struct SensorManager { struct VoltageSensorReading {uint8_t channel;float voltage;bool valid;}; };
int native_queries=0, optional_queries=0;
namespace mesh { namespace solar {
constexpr uint8_t FIRST_OPTIONAL_CHANNEL=14;
void addTelemetry(CayenneLPP&) {++native_queries;}
uint8_t voltageChannels(uint8_t* ch,uint8_t cap) {
const uint8_t n=cap<4?cap:4;for(uint8_t i=0;ch && i<n;++i)ch[i]=2+i;return n;
}
uint8_t queryVoltages(SensorManager::VoltageSensorReading* r,uint8_t cap) {
const uint8_t n=cap<4?cap:4;
for(uint8_t i=0;i<n;++i)r[i]={uint8_t(2+i),13.2f,i==0};return n;
}
}}
void optional(uint8_t ch,uint8_t,CayenneLPP&) {
++optional_queries;assert(ch==(MESH_SOLARXIAO_POWER?14:2));
}
bool optional_voltage(uint8_t,float& voltage) {voltage=5;return true;}
class EnvironmentSensorManager:public SensorManager {
struct ActiveSensor {void(*query)(uint8_t,uint8_t,CayenneLPP&);bool(*query_voltage)(uint8_t,float&);uint8_t sub_channel;};
ActiveSensor _active_sensors[1]={{optional,optional_voltage,0}};
int _active_sensor_count=1;uint8_t next_available_channel=2;
public:
bool querySensors(uint8_t,CayenneLPP&);
uint8_t getVoltageSensorChannels(uint8_t*,uint8_t) const;
uint8_t queryVoltageSensors(VoltageSensorReading*,uint8_t);
};
@METHODS@
int main() {
EnvironmentSensorManager env;CayenneLPP lpp;
env.querySensors(0,lpp);assert(!native_queries && !optional_queries);
env.querySensors(4,lpp);assert(native_queries==MESH_SOLARXIAO_POWER && optional_queries==1);
const int all=MESH_SOLARXIAO_POWER?5:1;
for(int cap=0;cap<7;++cap) {
uint8_t ch[8];for(auto& c:ch)c=255;
SensorManager::VoltageSensorReading r[8];for(auto& item:r)item.channel=255;
int n=cap<all?cap:all;
assert(env.getVoltageSensorChannels(ch,cap)==n);
assert(env.queryVoltageSensors(r,cap)==n);
for(int i=0;i<n;++i) {
int expected=MESH_SOLARXIAO_POWER && i<4?2+i:MESH_SOLARXIAO_POWER?14:2;
assert(ch[i]==expected && r[i].channel==expected);
assert(r[i].valid==(MESH_SOLARXIAO_POWER?i==0 || i==4:true));
}
assert(ch[n]==255 && r[n].channel==255);
}
}
'''.replace("@METHODS@", methods)
with tempfile.TemporaryDirectory(prefix="solarxiao-telemetry-test-") as temp:
cpp = Path(temp) / "test.cpp"
binary = Path(temp) / "test"
cpp.write_text(harness, encoding="ascii")
for enabled in (0, 1):
build = subprocess.run([shutil.which("g++"), "-std=c++11",
"-DMESH_SOLARXIAO_POWER=" + str(enabled), "-fsanitize=address,undefined",
"-fno-pie", "-no-pie", str(cpp), "-o", str(binary)],
capture_output=True, text=True, timeout=30)
self.assertEqual(build.returncode, 0, build.stdout + build.stderr)
run = subprocess.run([str(binary)], capture_output=True, text=True, timeout=10)
self.assertEqual(run.returncode, 0, run.stdout + run.stderr)
if __name__ == "__main__":
unittest.main()