rich/MeshCore
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
keymindCascade
MeshCore/test/fixtures/rak_gps_power.cpp
T

445 lines
22 KiB
C++
Raw Permalink Blame History

#include <helpers/sensors/EnvironmentSensorManager.h>
#include <helpers/sensors/I2CAddressClaimPolicy.h>
#include <helpers/sensors/NmeaSentenceProbe.h>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <initializer_list>
#define WB_IO2 21
#define PIN_GPS_TX 15
#define PIN_GPS_RX 16
#define TELEM_RAK12500_ADDRESS 0x42
#define RAK_UART_GPS_PROBE_TIMEOUT_MS 1200UL
#define TELEM_WIRE (&Wire)
#define MESH_DEBUG_PRINTLN(...) ((void)0)
#define POWERSAVING_DEBUG_PRINTLN(...) ((void)0)
#define COM_TYPE_UBX 1
#define SFE_UBLOX_GNSS_ID_GPS 0
#define SFE_UBLOX_GNSS_ID_GALILEO 1
#define SFE_UBLOX_GNSS_ID_GLONASS 2
#define SFE_UBLOX_GNSS_ID_SBAS 3
#define SFE_UBLOX_GNSS_ID_BEIDOU 4
#define SFE_UBLOX_GNSS_ID_IMES 5
#define SFE_UBLOX_GNSS_ID_QZSS 6
#define VAL_CFG_SUBSEC_IOPORT 1
void LocationProvider::sendSentence(const char*) {}
static uint32_t gpsResetPin = static_cast<uint32_t>(-1);
static bool i2cGPSFlag = false, serialGPSFlag = false;
static const char meshcore_capability_rak_wisblock_gps[] = "linked-provider";
struct SerialMock : Stream {
unsigned begins=0, ends=0, polls=0;
bool installed=false;
std::deque<uint8_t> incoming;
void setPins(int tx,int rx) { event("uartPins",tx,rx); }
void begin(unsigned baud) { installed=true; ++begins; event("uartBegin",baud); }
void end() { assert(installed&&"pinned UARTE end must not be called twice"); installed=false; ++ends; event("uartEnd"); }
int available() override { ++polls; return installed ? int(incoming.size()) : 0; }
int read() override { if(incoming.empty()) return -1; int c=incoming.front(); incoming.pop_front(); return c; }
void nmea() {
const char* body="GPRMC,valid";
uint8_t checksum=0;
for(const char* c=body;*c;++c) checksum^=uint8_t(*c);
char sentence[64]; std::snprintf(sentence,sizeof(sentence),"$%s*%02X\r\n",body,checksum);
for(const char* c=sentence;*c;++c) incoming.push_back(uint8_t(*c));
}
} Serial1;
namespace mesh { namespace ota {
struct OtaStoreQspiNrf52 {
inline static uint8_t selected=0;
inline static uint32_t rak_id=0,w25_id=0;
inline static bool header_present=false;
inline static bool cached=false;
inline static unsigned probes=0;
static bool headerW25Detected() { autoDetect(); event("headerProbe"); return header_present; }
static uint8_t autoDetect() { if(!cached) { cached=true; ++probes; event("norProbe"); assert(digitalRead(WB_IO2)==HIGH); } return selected; }
static void autoProbeIds(uint32_t& rak,uint32_t& w25) { autoDetect(); rak=rak_id; w25=w25_id; }
};
}}
static bool bus_available=true;
static bool ensureI2cBusReleased(TwoWire*) { event("i2cBus"); return bus_available; }
struct GnssMock {
bool present=false, begin_ok=true, output_ok=true, rate_ok=true, psm_ok=true, valid=false;
unsigned begins=0, polls=0, flushes=0, output_calls=0, rate_calls=0, nv_writes=0;
std::vector<bool> psm;
bool begin(TwoWire&,uint8_t address) { ++begins; event("gnssBegin",address); return present&&begin_ok; }
bool powerSaveMode(bool enabled) { psm.push_back(enabled); event("gnssPsm",enabled); return psm_ok; }
bool setI2COutput(unsigned output) { ++output_calls; event("gnssOutput",output); return output_ok; }
void enableGNSS(bool,unsigned) {}
bool setMeasurementRate(unsigned rate) { ++rate_calls; event("gnssRate",rate); return rate_ok; }
void saveConfigSelective(unsigned) { ++nv_writes; }
void flushPVT() { ++flushes; }
bool getPVT(unsigned) { ++polls; return valid; }
bool getGnssFixOk(unsigned) { ++polls; return valid; }
long getLatitude(unsigned) { return 476100000; }
long getLongitude(unsigned) { return -1223300000; }
long getAltitude(unsigned) { return 125000; }
int getSIV(unsigned) { return valid?8:0; }
bool getDateValid(unsigned) { return valid; }
bool getTimeValid(unsigned) { return valid; }
long getUnixEpoch(unsigned) { return 1790942400; }
} ublox_GNSS;
@HELPERS@
@PROVIDER@
static RAK12500LocationProvider RAK12500_provider;
struct SensorDef {
uint32_t address;
const char* name;
uint8_t (*init)(TwoWire*,uint8_t);
void (*query)(uint8_t,uint8_t,CayenneLPP&);
bool (*query_voltage)(uint8_t,float&);
};
static const SensorDef SENSOR_TABLE[1] = {};
static const size_t SENSOR_TABLE_SIZE=0;
bool EnvironmentSensorManager::i2c_probe(TwoWire&,uint8_t) { return false; }
@METHODS@
struct TestLocation : LocationProvider {
unsigned loops=0,resets=0,clears=0;
int pin=-1;
mesh::RTCClock clock;
bool valid=false;
void reset() override { ++resets; valid=false; }
void begin() override {}
void stop() override {}
void loop() override { ++loops; }
bool isEnabled() override { return pin<0 || digitalRead(pin)==HIGH; }
bool clearPositionFix() override { valid=false; ++clears; return true; }
void setPinEn(int value) override { pin=value; }
int getPinEn() override { return pin; }
mesh::RTCClock* getRTCClock() override { return &clock; }
long getLatitude() override { return 47610000; }
long getLongitude() override { return -122330000; }
long getAltitude() override { return 125000; }
long satellitesCount() override { return valid?8:0; }
bool isValid() override { return valid; }
long getTimestamp() override { return 1790942400; }
void acceptedClock() { markTimeSyncApplied(); stopTimeSync(); }
};
struct TestEnvironment : EnvironmentSensorManager {
explicit TestEnvironment(TestLocation& location):EnvironmentSensorManager(location) {}
bool active() const { return gps_active; }
bool userEnabled() const { return isGpsTelemetryUserEnabled(); }
bool transportAvailable() const { return isGpsTelemetryTransportAvailable(); }
using EnvironmentSensorManager::start_gps;
using EnvironmentSensorManager::stop_gps;
using EnvironmentSensorManager::rakGPSInit;
using EnvironmentSensorManager::_wisblock_power;
};
static constexpr bool compile_held = mesh::gps::wisBlockCompileRailHolds()!=0;
static void fresh() {
now_ms=100; delay_count=0; hardware_events.clear();
std::memset(pin_values,0,sizeof(pin_values)); pin_values[WB_IO2]=HIGH;
Serial1=SerialMock{}; ublox_GNSS=GnssMock{}; RAK12500_provider=RAK12500LocationProvider{};
mesh::ota::OtaStoreQspiNrf52::selected=0;
mesh::ota::OtaStoreQspiNrf52::rak_id=mesh::ota::OtaStoreQspiNrf52::w25_id=0;
mesh::ota::OtaStoreQspiNrf52::header_present=false;
mesh::ota::OtaStoreQspiNrf52::cached=false;
mesh::ota::OtaStoreQspiNrf52::probes=0;
i2cGPSFlag=serialGPSFlag=false; gpsResetPin=uint32_t(-1); bus_available=true;
}
static size_t firstEvent(const char* name,int a=-999,int b=-999,size_t after=0) {
for(size_t i=after;i<hardware_events.size();++i) {
const auto& e=hardware_events[i];
if(e.name==name&&(a==-999||e.a==a)&&(b==-999||e.b==b)) return i;
}
return hardware_events.size();
}
static void bootUart(TestEnvironment& sensors,TestLocation& location,bool shared=false) {
Serial1.nmea(); assert(sensors.begin());
assert(sensors.isGPSDetected()&&sensors.active()&&!sensors.userEnabled());
assert(location.pin<0 && sensors.isGpsPowered());
assert(digitalRead(WB_IO2)==HIGH);
sensors.configureSharedPeripheralMode(shared);
assert(sensors._wisblock_power.isConfigured()&&!sensors._wisblock_power.discoveryActive());
assert(sensors.setSettingValue("gps","0"));
assert(!sensors.active()&&!sensors.userEnabled()&&!Serial1.installed);
}
static void requireNoLow() {
for(const auto& e:hardware_events) assert(!(e.name=="write"&&e.a==WB_IO2&&e.b==LOW));
}
static void requireUartReleasedBeforePowerOff(int pin=WB_IO2,int value=LOW) {
const size_t end=firstEvent("uartEnd");
const size_t tx=firstEvent("pinMode",PIN_GPS_TX,INPUT,end);
const size_t rx=firstEvent("pinMode",PIN_GPS_RX,INPUT,end);
const size_t off=firstEvent("write",pin,value,end);
assert(off<hardware_events.size());
assert(end<tx&&tx<off&&end<rx&&rx<off);
}
static void uart(bool shared) {
fresh(); TestLocation location; TestEnvironment sensors(location); bootUart(sensors,location,shared);
const bool held=shared||compile_held;
assert(sensors.isGpsPowered()==held && digitalRead(WB_IO2)==int(held));
if(!held) requireUartReleasedBeforePowerOff();
else requireNoLow();
assert(sensors.gpsUsesSerialUart(1)&&sensors.gpsSerialTransportMayConflict(1));
assert(!sensors.gpsSerialTransportCanYield(1));
assert(!sensors.gpsUsesSerialUart(2)&&!sensors.gpsSerialTransportMayConflict(2));
const unsigned begins=Serial1.begins,ends=Serial1.ends,loops=location.loops;
assert(!sensors.setGpsSerialTransportBlocked(1,true));
assert(!sensors.setGpsSerialTransportBlocked(2,true));
assert(sensors.transportAvailable()&&Serial1.begins==begins&&Serial1.ends==ends);
now_ms+=1000; sensors.loop(); assert(location.loops==loops&&!sensors.active());
hardware_events.clear(); const uint32_t started=millis();
assert(sensors.setSettingValue("gps","1"));
assert(sensors.active()&&sensors.userEnabled()&&Serial1.installed&&sensors.isGpsPowered());
const size_t high=firstEvent("write",WB_IO2,HIGH),opened=firstEvent("uartBegin");
assert(high<opened);
assert(hardware_events[opened].time>=started+(held?0:500));
assert(location.clears==1&&location.pin<0);
sensors.setPowerSavingEnabled(false); now_ms+=600001; sensors.loop();
assert(sensors.active()); // Manual on plus power-saving off is continuous.
hardware_events.clear(); assert(sensors.setSettingValue("gps","0"));
assert(!sensors.active()&&!Serial1.installed&&sensors.isGpsPowered()==held);
if(!held) requireUartReleasedBeforePowerOff();
else requireNoLow();
sensors.setPowerSavingEnabled(true); now_ms+=1000; sensors.loop();
sensors.setPowerSavingEnabled(false); assert(!sensors.active());
const unsigned saved_begins=Serial1.begins;
sensors.configureSharedPeripheralMode(!shared); // Boot-only mode cannot revoke/reconfigure owners.
assert(sensors.isGpsPowered()==held&&Serial1.begins==saved_begins);
}
static void hourly() {
fresh(); TestLocation location; TestEnvironment sensors(location); bootUart(sensors,location);
sensors.applyGpsTimeSyncInterval(1); sensors.setPowerSavingEnabled(true);
assert(sensors.setSettingValue("gps","1"));
assert(sensors.active()&&location.getGPSPowerSaving());
assert(location.getNextGPSOff()!=0);
now_ms+=100; location.acceptedClock(); sensors.loop();
assert(!sensors.active()&&!sensors.isGpsPowered());
const uint32_t deadline=uint32_t(location.getNextGPSOn());
assert(deadline==millis()+3600000U);
now_ms=deadline-1; sensors.loop(); assert(!sensors.active());
now_ms=deadline; hardware_events.clear(); sensors.loop();
assert(sensors.active()&&Serial1.installed);
assert(firstEvent("write",WB_IO2,HIGH)<firstEvent("uartBegin"));
// Explicit off cancels both clock/duty deadlines and must not be undone by them.
assert(sensors.setSettingValue("gps","0"));
assert(!location.getGPSPowerSaving()&&location.getNextGPSOn()==0&&location.getNextGPSOff()==0);
const unsigned begins=Serial1.begins; now_ms+=3600100; sensors.loop();
assert(!sensors.active()&&!sensors.isGpsPowered()&&Serial1.begins==begins);
}
static void repeatedDiscovery() {
fresh(); TestLocation location; TestEnvironment sensors(location); bootUart(sensors,location);
hardware_events.clear(); Serial1.nmea();
assert(sensors.begin());
assert(!sensors.active()&&!sensors.userEnabled()&&!sensors.isGpsPowered());
assert(!Serial1.installed&&!sensors._wisblock_power.discoveryActive());
assert(firstEvent("write",WB_IO2,HIGH)<firstEvent("uartBegin"));
requireUartReleasedBeforePowerOff();
assert(sensors.setSettingValue("gps","1"));
hardware_events.clear(); Serial1.nmea(); assert(sensors.begin());
assert(sensors.active()&&sensors.userEnabled()&&sensors.isGpsPowered()&&Serial1.installed);
requireNoLow();
}
static void preferenceBeforeDiscovery() {
for(bool shared:{false,true}) {
for(bool enabled:{false,true}) {
fresh(); TestLocation location; TestEnvironment sensors(location);
sensors.configureSharedPeripheralMode(shared);
// Companion loads mode before sensors.begin(): saved GPS-only must not
// cut supply until the first discovery pass has actually completed.
assert(sensors._wisblock_power.isConfigured());
assert(sensors._wisblock_power.discoveryActive());
assert(sensors.isGpsPowered()&&digitalRead(WB_IO2)==HIGH); requireNoLow();
Serial1.nmea(); assert(sensors.begin());
assert(sensors.isGPSDetected()&&sensors.active()&&!sensors.userEnabled());
assert(sensors.isGpsPowered()&&Serial1.installed); requireNoLow();
assert(!sensors._wisblock_power.discoveryActive());
assert(sensors.setSettingValue("gps",enabled?"1":"0"));
assert(sensors.active()==enabled&&sensors.userEnabled()==enabled);
const bool powered=enabled||shared||compile_held;
assert(sensors.isGpsPowered()==powered&&digitalRead(WB_IO2)==int(powered));
if(!powered) requireUartReleasedBeforePowerOff();
else requireNoLow();
}
}
}
static void actualPoweredStatus() {
fresh(); TestLocation location; TestEnvironment sensors(location); bootUart(sensors,location);
assert(!sensors.isGpsPowered());
// Status must read the applied GPIO, not a provider whose absent enable pin
// means 'always powered', and not merely the desired policy state.
assert(location.isEnabled());
pin_values[WB_IO2]=HIGH; assert(sensors.isGpsPowered());
pin_values[WB_IO2]=LOW; assert(!sensors.isGpsPowered());
}
static void absent() {
fresh(); TestLocation location; TestEnvironment sensors(location);
assert(sensors.begin()); assert(!sensors.isGPSDetected()&&!sensors.active());
assert(digitalRead(WB_IO2)==HIGH&&!sensors._wisblock_power.isConfigured());
requireNoLow(); sensors.configureSharedPeripheralMode(false);
assert(digitalRead(WB_IO2)==int(compile_held));
const unsigned polls=Serial1.polls,begins=Serial1.begins;
now_ms+=1000; sensors.loop(); assert(Serial1.polls==polls&&Serial1.begins==begins);
assert(!sensors.setSettingValue("gps","1"));
assert(!sensors.gpsSerialTransportCanYield(1)&&sensors.gpsSerialTransportMayConflict(1));
}
static void storage() {
fresh(); TestLocation location; TestEnvironment sensors(location);
mesh::ota::OtaStoreQspiNrf52::header_present=true;
mesh::ota::OtaStoreQspiNrf52::selected=2;
mesh::ota::OtaStoreQspiNrf52::w25_id=0xef4015;
assert(sensors.begin()); assert(!sensors.isGPSDetected()&&Serial1.begins==0);
sensors.configureSharedPeripheralMode(false);
assert(sensors._wisblock_power.holds()&mesh::gps::ExternalStorage);
assert(digitalRead(WB_IO2)==HIGH); requireNoLow();
sensors.configureSharedPeripheralMode(true);
assert(digitalRead(WB_IO2)==HIGH); requireNoLow();
}
static void fixedStorage() {
fresh(); TestLocation location; TestEnvironment sensors(location); bootUart(sensors,location);
assert(sensors._wisblock_power.holds()&mesh::gps::ExternalStorage);
assert(sensors.isGpsPowered()&&digitalRead(WB_IO2)==HIGH);
assert(!sensors.active()&&!Serial1.installed); requireNoLow();
assert(mesh::ota::OtaStoreQspiNrf52::probes==0);
assert(sensors.setSettingValue("gps","1"));
assert(sensors.active()&&sensors.isGpsPowered());
assert(sensors.setSettingValue("gps","0"));
assert(!sensors.active()&&sensors.isGpsPowered()); requireNoLow();
}
static void storageIds() {
for(uint8_t selected: {uint8_t(0),uint8_t(1),uint8_t(2),uint8_t(3)}) {
for(uint32_t id: {0U,0xffffffU,0x123456U,0xef4015U}) {
for(bool header: {false,true}) {
fresh(); TestLocation location; TestEnvironment sensors(location);
mesh::ota::OtaStoreQspiNrf52::selected=selected;
if(header) mesh::ota::OtaStoreQspiNrf52::w25_id=id;
else mesh::ota::OtaStoreQspiNrf52::rak_id=id;
// Supply is protected while the read-only probe identifies a physical owner.
assert(sensors.begin()); requireNoLow();
sensors.configureSharedPeripheralMode(false);
const bool storage_held=selected!=0||(id!=0&&id!=0xffffffU);
assert(bool(sensors._wisblock_power.holds()&mesh::gps::ExternalStorage)==storage_held);
assert(digitalRead(WB_IO2)==int(storage_held||compile_held));
assert(mesh::ota::OtaStoreQspiNrf52::probes>0);
}
}
}
}
static void i2c(bool shared,unsigned wake_failure=0) {
fresh(); TestLocation location; TestEnvironment sensors(location); ublox_GNSS.present=true;
assert(sensors.begin()); assert(sensors.isGPSDetected()&&sensors.active()&&!sensors.userEnabled());
assert(i2cGPSFlag&&!serialGPSFlag&&sensors.getLocationProvider()==&RAK12500_provider);
assert(RAK12500_provider.getPinEn()<0);
sensors.configureSharedPeripheralMode(shared);
assert(sensors.setSettingValue("gps","0"));
const bool held=shared||compile_held;
assert(!sensors.active()&&sensors.isGpsPowered()==held);
if(held) { requireNoLow(); assert(ublox_GNSS.psm.back()); }
else assert(ublox_GNSS.psm.empty());
const unsigned begins=ublox_GNSS.begins,polls=ublox_GNSS.polls;
now_ms+=1000; sensors.loop(); assert(ublox_GNSS.polls==polls);
hardware_events.clear(); const uint32_t started=millis();
const unsigned writes=ublox_GNSS.nv_writes;
if(wake_failure==1) ublox_GNSS.begin_ok=false;
if(wake_failure==2) ublox_GNSS.output_ok=false;
if(wake_failure==3) ublox_GNSS.rate_ok=false;
if(wake_failure==4) bus_available=false;
assert(sensors.setSettingValue("gps","1"));
if(wake_failure) {
assert(!held&&!sensors.active()&&!sensors.isGPSDetected()&&!sensors.isGpsPowered());
assert(sensors.userEnabled()); // Persisted intent is not silently rewritten after failure.
const unsigned failed_begins=ublox_GNSS.begins;
for(unsigned i=0;i<10;++i) { now_ms+=1000; sensors.loop(); }
assert(ublox_GNSS.begins==failed_begins&&ublox_GNSS.polls==polls);
assert(!sensors.setSettingValue("gps","1"));
return;
}
assert(ublox_GNSS.nv_writes==writes); // Cold duty wake must not write receiver flash/BBR again.
assert(sensors.active()&&sensors.isGpsPowered());
if(held) {
assert(ublox_GNSS.begins==begins&&!ublox_GNSS.psm.back()); requireNoLow();
} else {
assert(ublox_GNSS.begins==begins+1);
assert(firstEvent("write",WB_IO2,HIGH)<firstEvent("gnssBegin"));
assert(hardware_events[firstEvent("gnssBegin")].time>=started+500);
}
assert(ublox_GNSS.flushes>0); // A cold wake never reuses a previous position as fresh.
assert(sensors.setSettingValue("gps","0"));
assert(!sensors.active()&&sensors.isGpsPowered()==held);
}
static void initialConfigFailure() {
for(unsigned failed_step:{1U,2U}) {
fresh(); TestLocation location; TestEnvironment sensors(location); ublox_GNSS.present=true;
if(failed_step==1) ublox_GNSS.output_ok=false;
else ublox_GNSS.rate_ok=false;
assert(sensors.begin());
assert(!sensors.isGPSDetected()&&!sensors.active()&&!i2cGPSFlag&&!serialGPSFlag);
assert(sensors.getLocationProvider()==&location&&!Serial1.installed);
assert(ublox_GNSS.output_calls==1&&ublox_GNSS.rate_calls==(failed_step==1?0U:1U));
assert(ublox_GNSS.nv_writes==0&&!sensors.userEnabled());
requireNoLow(); sensors.configureSharedPeripheralMode(false);
assert(!sensors.isGpsPowered()&&digitalRead(WB_IO2)==LOW);
const unsigned begins=ublox_GNSS.begins,polls=ublox_GNSS.polls;
for(unsigned i=0;i<10;++i) { now_ms+=1000; sensors.loop(); }
assert(ublox_GNSS.begins==begins&&ublox_GNSS.polls==polls);
assert(!sensors.setSettingValue("gps","1"));
}
}
static void dedicated() {
#ifdef PIN_GPS_EN
fresh(); TestLocation location; TestEnvironment sensors(location); Serial1.nmea();
assert(sensors.begin()&&sensors.isGPSDetected()&&location.pin==PIN_GPS_EN);
sensors.configureSharedPeripheralMode(true);
assert(sensors.setSettingValue("gps","0"));
requireUartReleasedBeforePowerOff(PIN_GPS_EN,!PIN_GPS_EN_ACTIVE);
assert(!sensors.active()&&!sensors.isGpsPowered());
assert(digitalRead(PIN_GPS_EN)==!PIN_GPS_EN_ACTIVE);
assert(digitalRead(WB_IO2)==HIGH); requireNoLow();
assert(sensors.gpsSerialTransportCanYield(1));
const unsigned off_ends=Serial1.ends;
assert(sensors.setGpsSerialTransportBlocked(1,true));
assert(Serial1.ends==off_ends); // Already-off GPS must not close UARTE twice.
assert(!sensors.transportAvailable()&&!sensors.isGpsPowered());
assert(sensors.setSettingValue("gps","1"));
assert(sensors.userEnabled()&&!sensors.active()&&!sensors.isGpsPowered());
hardware_events.clear(); assert(sensors.setGpsSerialTransportBlocked(1,false));
assert(sensors.active()&&Serial1.installed&&sensors.isGpsPowered());
assert(firstEvent("write",PIN_GPS_EN,PIN_GPS_EN_ACTIVE)<firstEvent("uartBegin"));
assert(digitalRead(WB_IO2)==HIGH); requireNoLow();
const unsigned on_ends=Serial1.ends;
hardware_events.clear(); assert(sensors.setGpsSerialTransportBlocked(1,true));
assert(!sensors.active()&&!Serial1.installed&&Serial1.ends==on_ends+1);
requireUartReleasedBeforePowerOff(PIN_GPS_EN,!PIN_GPS_EN_ACTIVE);
assert(!sensors.isGpsPowered()&&sensors.userEnabled()); requireNoLow();
assert(sensors.setGpsSerialTransportBlocked(1,false));
assert(sensors.active()&&sensors.isGpsPowered()&&Serial1.installed);
#else
assert(false&&"dedicated scenario requires a separate enable pin");
#endif
}
int main(int argc,char** argv) {
assert(argc==2);
if(!std::strcmp(argv[1],"uart")) uart(false);
else if(!std::strcmp(argv[1],"shared_uart")) uart(true);
else if(!std::strcmp(argv[1],"held_uart")) uart(false);
else if(!std::strcmp(argv[1],"hourly")) hourly();
else if(!std::strcmp(argv[1],"repeat")) repeatedDiscovery();
else if(!std::strcmp(argv[1],"prefs_before")) preferenceBeforeDiscovery();
else if(!std::strcmp(argv[1],"powered_status")) actualPoweredStatus();
else if(!std::strcmp(argv[1],"absent")) absent();
else if(!std::strcmp(argv[1],"storage")) storage();
else if(!std::strcmp(argv[1],"fixed_storage")) fixedStorage();
else if(!std::strcmp(argv[1],"storage_ids")) storageIds();
else if(!std::strcmp(argv[1],"i2c")) i2c(false);
else if(!std::strcmp(argv[1],"shared_i2c")) i2c(true);
else if(!std::strcmp(argv[1],"held_i2c")) i2c(false);
else if(!std::strcmp(argv[1],"wake_failure")) i2c(false,1);
else if(!std::strcmp(argv[1],"wake_output_failure")) i2c(false,2);
else if(!std::strcmp(argv[1],"wake_rate_failure")) i2c(false,3);
else if(!std::strcmp(argv[1],"wake_bus_failure")) i2c(false,4);
else if(!std::strcmp(argv[1],"initial_config_failure")) initialConfigFailure();
else if(!std::strcmp(argv[1],"dedicated")) dedicated();
else assert(false&&"unknown scenario");
}
Reference in new issue View Git Blame Copy Permalink