Exergie/TransparentBox-V1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor names to follow new convention

Browse Source
This commit is contained in:
Hector van der Aa
2026-03-29 15:04:28 +02:00
parent fedbdd2739
commit 3b2abd3f71
32 changed files with 1073 additions and 1063 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/base/module_base.h
View File

@@ -4,8 +4,7 @@
#pragma once #pragma once
#include "base/task.h" #include "base/task.h"
class module_base class ModuleBase {
{
public: public:
virtual int push(const Task& task) = 0; virtual int push(const Task& task) = 0;
}; };

2
src/base/modules.cpp
View File

@@ -3,4 +3,4 @@
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later
#include "base/modules.h" #include "base/modules.h"
module_base* modules[MOD_COUNT] = {nullptr}; ModuleBase* module_registry[module::Count] = {nullptr};

2
src/base/modules.h
View File

@@ -6,4 +6,4 @@
#include "base/module_base.h" #include "base/module_base.h"
#include "base/task.h" #include "base/task.h"
extern module_base* modules[MOD_COUNT]; extern ModuleBase* module_registry[module::Count];

32
src/base/ring_buffer.h
View File

@@ -5,34 +5,34 @@
#include <inttypes.h> #include <inttypes.h>
template<typename T, uint8_t SIZE> template<typename T, uint8_t SIZE>
class ring_buffer { class RingBuffer {
private: private:
T _buffer[SIZE]; T buffer_[SIZE];
volatile uint8_t _head = 0; volatile uint8_t head_ = 0;
volatile uint8_t _tail = 0; volatile uint8_t tail_ = 0;
volatile uint8_t _count = 0; volatile uint8_t count_ = 0;
public: public:
int push(const T& item) { int push(const T& item) {
if (_count == SIZE) { if (count_ == SIZE) {
return 1; return 1;
} }
_buffer[_head] = item; buffer_[head_] = item;
_head = (_head++) % SIZE; head_ = (head_++) % SIZE;
_count++; count_++;
return 0; return 0;
} }
int pop(T& item) { int pop(T& item) {
if (_count == 0) { if (count_ == 0) {
return 1; return 1;
} }
item = _buffer[_tail]; item = buffer_[tail_];
_tail = (_tail++) % SIZE; tail_ = (tail_++) % SIZE;
_count--; count_--;
return 0; return 0;
} }
bool is_empty() const { return _count == 0;} bool isEmpty() const { return count_ == 0; }
bool is_full() const { return _count == SIZE;} bool isFull() const { return count_ == SIZE; }
uint8_t size() const { return _count;} uint8_t size() const { return count_; }
}; };

24
src/base/router.cpp
View File

@@ -6,37 +6,37 @@
namespace router { namespace router {
int send(const Task &task) { int send(const Task &task) {
if (task.target == MOD_ALL) { if (task.target_ == module::All) {
int ret = 0; int ret = 0;
for (size_t i = 0; i < MOD_COUNT; i++) { for (size_t index = 0; index < module::Count; index++) {
module_base *mod = modules[i]; ModuleBase *module_ptr = module_registry[index];
if (mod == nullptr) { if (module_ptr == nullptr) {
continue; continue;
} }
if (mod->push(task) != 0) { if (module_ptr->push(task) != 0) {
ret = 1; ret = 1;
} }
} }
return ret; return ret;
} }
if (task.target >= MOD_COUNT) { if (task.target_ >= module::Count) {
return 1; return 1;
} }
module_base *mod = modules[task.target]; ModuleBase *module_ptr = module_registry[task.target_];
if (mod == nullptr) { if (module_ptr == nullptr) {
return 1; return 1;
} }
return mod->push(task); return module_ptr->push(task);
} }
int send(module_id target, task_type type, uint32_t data) { int send(module::Id target, task::Type type, uint32_t data) {
Task t{target, type, data}; Task task{target, type, data};
return send(t); return send(task);
} }
} // namespace router } // namespace router

2
src/base/router.h
View File

@@ -9,5 +9,5 @@
namespace router { namespace router {
int send(const Task& task); int send(const Task& task);
int send(module_id target, task_type type, uint32_t data = 0); int send(module::Id target, task::Type type, uint32_t data = 0);
} }

81
src/base/task.h
View File

@@ -5,46 +5,53 @@
#include <inttypes.h> #include <inttypes.h>
#include <Arduino.h> #include <Arduino.h>
enum module_id : uint8_t { namespace module {
// modules/cmd
MOD_CMD, enum Id : uint8_t {
// modules/config Cmd,
MOD_CFG, Config,
// modules/gps Gps,
MOD_GPS, Lcd,
// modules/lcd Battery,
MOD_LCD, Thermocouple,
// modules/battery Count,
MOD_BAT, Null,
// modules/thermocouple All,
MOD_THC,
MOD_COUNT,
MOD_NULL,
MOD_ALL,
}; };
enum task_type : uint8_t { } // namespace module
TASK_NULL,
TASK_DISPLAY_GPS_DEBUG, namespace task {
TASK_DISPLAY_DRIVER_PRIMARY,
TASK_DISPLAY_MSG_GPS_FIX, enum Type : uint8_t {
TASK_DISPLAY_MSG_TRACK_DETECT_OK, Null,
TASK_DISPLAY_MSG_CONFIG_NO_TRACKS, DisplayGpsDebug,
TASK_DISPLAY_MSG_BAT_LOW, DisplayDriverPrimary,
TASK_CONFIG_TRACK_DETECT, DisplayMsgGpsFix,
TASK_CONFIG_WRITE_TEMP_TRACK, DisplayMsgTrackDetectOk,
TASK_CONFIG_TRACK_DELETE, DisplayMsgConfigNoTracks,
TASK_CONFIG_CFG_RESET, DisplayMsgBatteryLow,
TASK_CONFIG_VBAT_CAL_SET, ConfigTrackDetect,
TASK_CONFIG_VBAT_SET_LOW, ConfigWriteTempTrack,
TASK_CONFIG_TENG_SET_LOW, ConfigTrackDelete,
TASK_CONFIG_TENG_SET_HIGH, ConfigReset,
TASK_BATTERY_CAL, ConfigVbatCalSet,
TASK_ALL_CONFIG_UPDATED, ConfigVbatSetLow,
ConfigTengSetLow,
ConfigTengSetHigh,
BatteryCal,
AllConfigUpdated,
}; };
} // namespace task
struct Task { struct Task {
module_id target; Task(module::Id target = module::Null,
task_type type; task::Type type = task::Null,
uint32_t data; uint32_t data = 0)
: target_(target), type_(type), data_(data) {}
module::Id target_;
task::Type type_;
uint32_t data_;
}; };

63
src/custom_types.h
View File

@@ -6,51 +6,52 @@
#include <string.h> #include <string.h>
#define CONFIG_MAGIC 0xBEEF #define CONFIG_MAGIC 0xBEEF
struct vehicle_config{
uint16_t magic = CONFIG_MAGIC; struct VehicleConfig {
bool auto_detect_track = true; uint16_t magic_ = CONFIG_MAGIC;
uint8_t track_fallback = 0; bool auto_detect_track_ = true;
bool track_slot_occupied[8] = {false}; uint8_t track_fallback_ = 0;
double vbat_calibration = 0; bool track_slot_occupied_[8] = {false};
double vbat_low = 0; double vbat_calibration_ = 0;
double teng_low = 0; double vbat_low_ = 0;
double teng_high = 0; double teng_low_ = 0;
double teng_high_ = 0;
}; };
struct lat_lng { struct LatLng {
double lat; double lat_;
double lng; double lng_;
}; };
struct track_data { struct TrackData {
uint16_t magic = CONFIG_MAGIC; uint16_t magic_ = CONFIG_MAGIC;
unsigned short id; unsigned short id_;
char name[21]; char name_[21];
lat_lng pt_a; LatLng point_a_;
lat_lng pt_b; LatLng point_b_;
}; };
struct gps_sub_data { struct GpsSubData {
uint32_t age; uint32_t age_;
bool valid; bool valid_;
double value; double value_;
}; };
struct gps_data { struct GpsData {
gps_sub_data altitude; GpsSubData altitude_;
gps_sub_data lat; GpsSubData lat_;
gps_sub_data lng; GpsSubData lng_;
gps_sub_data speed; GpsSubData speed_;
gps_sub_data course; GpsSubData course_;
uint32_t num_fix; uint32_t num_fix_;
}; };
template<typename T> template<typename T>
inline void copy_from_volatile(T& dst, const volatile T& src) { inline void copyFromVolatile(T& dst, const volatile T& src) {
memcpy(&dst, (const void*)&src, sizeof(T)); memcpy(&dst, (const void*)&src, sizeof(T));
} }
template<typename T> template<typename T>
inline void copy_to_volatile(volatile T& dst, const T& src) { inline void copyToVolatile(volatile T& dst, const T& src) {
memcpy((void*)&dst, &src, sizeof(T)); memcpy((void*)&dst, &src, sizeof(T));
} }

10
src/data/config_store.cpp
View File

@@ -3,12 +3,12 @@
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later
#include "data/config_store.h" #include "data/config_store.h"
volatile vehicle_config config_global = {}; volatile VehicleConfig config_global = {};
void config_global_read(vehicle_config& out) { void configGlobalRead(VehicleConfig& out) {
copy_from_volatile(out, config_global); copyFromVolatile(out, config_global);
} }
void config_global_write(const vehicle_config& in) { void configGlobalWrite(const VehicleConfig& in) {
copy_to_volatile(config_global, in); copyToVolatile(config_global, in);
} }

6
src/data/config_store.h
View File

@@ -6,7 +6,7 @@
#include "custom_types.h" #include "custom_types.h"
#include <EEPROM.h> #include <EEPROM.h>
extern volatile vehicle_config config_global; extern volatile VehicleConfig config_global;
void config_global_read(vehicle_config& out); void configGlobalRead(VehicleConfig& out);
void config_global_write(const vehicle_config& in); void configGlobalWrite(const VehicleConfig& in);

22
src/data/eeprom_layout.h
View File

@@ -7,19 +7,19 @@
namespace eeprom_layout { namespace eeprom_layout {
static const uint16_t total_bytes = 4096; static const uint16_t TOTAL_BYTES = 4096;
static const uint16_t config_addr = 0; static const uint16_t CONFIG_ADDR = 0;
static const uint16_t config_reserved_bytes = 256; static const uint16_t CONFIG_RESERVED_BYTES = 256;
static const uint16_t track_slots = 8; static const uint16_t TRACK_SLOTS = 8;
static const uint16_t track_slot_bytes = 128; static const uint16_t TRACK_SLOT_BYTES = 128;
static const uint16_t track_base_addr = config_addr + config_reserved_bytes; static const uint16_t TRACK_BASE_ADDR = CONFIG_ADDR + CONFIG_RESERVED_BYTES;
static const uint16_t track_end_addr = track_base_addr + (track_slots * track_slot_bytes); static const uint16_t TRACK_END_ADDR = TRACK_BASE_ADDR + (TRACK_SLOTS * TRACK_SLOT_BYTES);
static const uint16_t free_after_tracks = total_bytes - track_end_addr; static const uint16_t FREE_AFTER_TRACKS = TOTAL_BYTES - TRACK_END_ADDR;
static_assert(track_end_addr <= total_bytes, "EEPROM layout exceeds physical storage"); static_assert(TRACK_END_ADDR <= TOTAL_BYTES, "EEPROM layout exceeds physical storage");
inline uint16_t track_slot_addr(uint8_t idx) { inline uint16_t trackSlotAddr(uint8_t idx) {
return track_base_addr + ((idx - 1) * track_slot_bytes); return TRACK_BASE_ADDR + ((idx - 1) * TRACK_SLOT_BYTES);
} }
} // namespace eeprom_layout } // namespace eeprom_layout

8
src/data/general_store.cpp
View File

@@ -6,18 +6,18 @@
volatile double vbat_global = 0; volatile double vbat_global = 0;
volatile double teng_global = 0; volatile double teng_global = 0;
void vbat_global_read(double& out) { void vbatGlobalRead(double& out) {
out = vbat_global; out = vbat_global;
} }
void vbat_global_write(const double& in) { void vbatGlobalWrite(const double& in) {
vbat_global = in; vbat_global = in;
} }
void teng_global_read(double& out) { void tengGlobalRead(double& out) {
out = vbat_global; out = vbat_global;
} }
void teng_global_write(const double& in) { void tengGlobalWrite(const double& in) {
vbat_global = in; vbat_global = in;
} }

8
src/data/general_store.h
View File

@@ -6,8 +6,8 @@
extern volatile double vbat_global; extern volatile double vbat_global;
extern volatile double teng_global; extern volatile double teng_global;
void vbat_global_read(double& out); void vbatGlobalRead(double& out);
void vbat_global_write(const double& in); void vbatGlobalWrite(const double& in);
void teng_global_read(double& out); void tengGlobalRead(double& out);
void teng_global_write(const double& in); void tengGlobalWrite(const double& in);

10
src/data/gps_store.cpp
View File

@@ -3,12 +3,12 @@
// SPDX-License-Identifier: GPL-3.0-or-later // SPDX-License-Identifier: GPL-3.0-or-later
#include "gps_store.h" #include "gps_store.h"
volatile gps_data gps_data_global = {}; volatile GpsData gps_data_global = {};
void gps_global_read(gps_data& out) { void gpsGlobalRead(GpsData& out) {
copy_from_volatile(out, gps_data_global); copyFromVolatile(out, gps_data_global);
} }
void gps_global_write(const gps_data& in) { void gpsGlobalWrite(const GpsData& in) {
copy_to_volatile(gps_data_global, in); copyToVolatile(gps_data_global, in);
} }

6
src/data/gps_store.h
View File

@@ -5,7 +5,7 @@
#include "custom_types.h" #include "custom_types.h"
extern volatile gps_data gps_data_global; extern volatile GpsData gps_data_global;
void gps_global_read(gps_data& out); void gpsGlobalRead(GpsData& out);
void gps_global_write(const gps_data& in); void gpsGlobalWrite(const GpsData& in);

30
src/data/track_store.cpp
View File

@@ -4,34 +4,34 @@
#include "data/track_store.h" #include "data/track_store.h"
#include "data/eeprom_layout.h" #include "data/eeprom_layout.h"
volatile track_data track_data_global = {}; volatile TrackData track_data_global = {};
volatile track_data track_data_temp_global = {}; volatile TrackData track_data_temp_global = {};
void track_global_read(track_data& out) { void trackGlobalRead(TrackData& out) {
copy_from_volatile(out, track_data_global); copyFromVolatile(out, track_data_global);
} }
int track_global_read(unsigned short idx, track_data& out) { int trackGlobalRead(unsigned short idx, TrackData& out) {
if (idx < 1 || idx > 8) { if (idx < 1 || idx > 8) {
return 1; return 1;
} }
track_data temp; TrackData track_data;
EEPROM.get(eeprom_layout::track_slot_addr(idx), temp); EEPROM.get(eeprom_layout::trackSlotAddr(idx), track_data);
if (temp.magic != CONFIG_MAGIC) { if (track_data.magic_ != CONFIG_MAGIC) {
return 1; return 1;
} }
out = temp; out = track_data;
return 0; return 0;
} }
void track_global_write(const track_data& in) { void trackGlobalWrite(const TrackData& in) {
copy_to_volatile(track_data_global, in); copyToVolatile(track_data_global, in);
} }
void track_temp_global_read(track_data& out) { void trackTempGlobalRead(TrackData& out) {
copy_from_volatile(out, track_data_temp_global); copyFromVolatile(out, track_data_temp_global);
} }
void track_temp_global_write(const track_data& in) { void trackTempGlobalWrite(const TrackData& in) {
copy_to_volatile(track_data_temp_global, in); copyToVolatile(track_data_temp_global, in);
} }

14
src/data/track_store.h
View File

@@ -6,12 +6,12 @@
#include "custom_types.h" #include "custom_types.h"
#include <EEPROM.h> #include <EEPROM.h>
extern volatile track_data track_data_global; extern volatile TrackData track_data_global;
extern volatile track_data track_data_temp_global; extern volatile TrackData track_data_temp_global;
void track_global_read(track_data& out); void trackGlobalRead(TrackData& out);
int track_global_read(unsigned short idx, track_data& out); int trackGlobalRead(unsigned short idx, TrackData& out);
void track_global_write(const track_data& in); void trackGlobalWrite(const TrackData& in);
void track_temp_global_read(track_data& out); void trackTempGlobalRead(TrackData& out);
void track_temp_global_write(const track_data& in); void trackTempGlobalWrite(const TrackData& in);

57
src/main.cpp
View File

@@ -16,63 +16,62 @@
#include "modules/battery/battery.h" #include "modules/battery/battery.h"
SystemLogger *logger = new SystemLogger(&Serial);
system_logger *logger_output = new system_logger(&Serial); Lcd *display = new Lcd(logger);
Gps *gps_module = new Gps(&Serial2, logger);
lcd *driver_display = new lcd(logger_output); Config *system_config = new Config(logger);
gps *gps_module = new gps(&Serial2, logger_output); Cmd *command_handler = new Cmd(&Serial, logger);
config *system_config = new config(logger_output); Battery *battery_module = new Battery(logger);
cmd *command_handler = new cmd(&Serial, logger_output);
battery *battery_handler = new battery(logger_output);
void setup() { void setup() {
wdt_disable(); wdt_disable();
modules[MOD_LCD] = driver_display; module_registry[module::Lcd] = display;
modules[MOD_GPS] = gps_module; module_registry[module::Gps] = gps_module;
modules[MOD_CFG] = system_config; module_registry[module::Config] = system_config;
modules[MOD_CMD] = command_handler; module_registry[module::Cmd] = command_handler;
modules[MOD_BAT] = battery_handler; module_registry[module::Battery] = battery_module;
driver_display->init(); display->init();
driver_display->print_message("Starting Initialization"); display->printMessage("Starting Initialization");
delay(1000); delay(1000);
driver_display->print_message("Cmd Init..."); display->printMessage("Cmd Init...");
command_handler->init(); command_handler->init();
delay(1000); delay(1000);
driver_display->print_message("Cmd Init Complete"); display->printMessage("Cmd Init Complete");
delay(1000); delay(1000);
driver_display->print_message("Config Init..."); display->printMessage("Config Init...");
int result = system_config->auto_init(); int result = system_config->autoInit();
delay(1000); delay(1000);
if (result != 0) { if (result != 0) {
driver_display->print_message("Configuration Read Failed"); display->printMessage("Configuration Read Failed");
} else { } else {
driver_display->print_message("Config Init Complete"); display->printMessage("Config Init Complete");
} }
delay(1000); delay(1000);
driver_display->print_message("GPS Init..."); display->printMessage("GPS Init...");
gps_module->init(); gps_module->init();
delay(1000); delay(1000);
driver_display->print_message("GPS Init Complete"); display->printMessage("GPS Init Complete");
delay(1000); delay(1000);
driver_display->print_message("Sensors Init..."); display->printMessage("Sensors Init...");
battery_handler->init(); battery_module->init();
delay(1000); delay(1000);
driver_display->print_message("Sensors Init Complete"); display->printMessage("Sensors Init Complete");
delay(1000); delay(1000);
router::send(MOD_LCD, TASK_DISPLAY_DRIVER_PRIMARY); router::send(module::Lcd, task::DisplayDriverPrimary);
} }
void loop() { void loop() {
gps_module->loop(); gps_module->loop();
driver_display->loop(); display->loop();
command_handler->parse_task(); command_handler->parseTask();
system_config->loop(); system_config->loop();
battery_handler->loop(); battery_module->loop();
} }

67
src/modules/battery/battery.cpp
View File

@@ -7,67 +7,72 @@
#include "data/config_store.h" #include "data/config_store.h"
#include "data/general_store.h" #include "data/general_store.h"
int battery::calibrate(const Task &task) { int Battery::calibrate(const Task &task) {
double actual_voltage; double actual_voltage;
memcpy(&actual_voltage, &task.data, sizeof(double)); memcpy(&actual_voltage, &task.data_, sizeof(double));
int adc_read = analogRead(VBAT_PIN); int adc_read = analogRead(VBAT_PIN);
double cal_factor = actual_voltage / adc_read; double cal_factor = actual_voltage / adc_read;
uint32_t output_val; uint32_t output_val;
memcpy(&output_val, &cal_factor, sizeof(uint32_t)); memcpy(&output_val, &cal_factor, sizeof(uint32_t));
router::send(MOD_CFG, TASK_CONFIG_VBAT_CAL_SET, output_val); router::send(module::Config, task::ConfigVbatCalSet, output_val);
return 0; return 0;
} }
int battery::push(const Task &task) { return _queue.push(task); } int Battery::push(const Task &task) { return queue_.push(task); }
battery::battery() : _logger(nullptr) {} Battery::Battery() : logger_(nullptr) {}
battery::battery(system_logger *logger) : _logger(logger) {} Battery::Battery(SystemLogger *logger) : logger_(logger) {}
battery::~battery() {} Battery::~Battery() {}
int battery::init() { int Battery::init() {
pinMode(VBAT_PIN, INPUT); pinMode(VBAT_PIN, INPUT);
vehicle_config config; VehicleConfig config;
config_global_read(config); configGlobalRead(config);
_cal = config.vbat_calibration; calibration_ = config.vbat_calibration_;
_low = config.vbat_low; low_threshold_ = config.vbat_low_;
return 0;
} }
int battery::loop(unsigned long timeout_ms) { int Battery::loop(unsigned long timeout_ms) {
if (millis() > _last_read + _update_interval) { (void)timeout_ms;
if (millis() > last_read_at_ + update_interval_) {
int adc_read = analogRead(VBAT_PIN); int adc_read = analogRead(VBAT_PIN);
_vbat = _cal * adc_read; vbat_ = calibration_ * adc_read;
vbat_global_write(_vbat); vbatGlobalWrite(vbat_);
if (_vbat < _low) { if (vbat_ < low_threshold_) {
if (_warning_sent == 0 || millis() > _warning_sent + _warning_timeout) { if (warning_sent_at_ == 0 || millis() > warning_sent_at_ + warning_timeout_) {
router::send(MOD_LCD, TASK_DISPLAY_MSG_BAT_LOW, 2000); router::send(module::Lcd, task::DisplayMsgBatteryLow, 2000);
_warning_sent = millis(); warning_sent_at_ = millis();
} }
} }
last_read_at_ = millis();
} }
Task active_task; Task active_task;
int res = _queue.pop(active_task); int res = queue_.pop(active_task);
if (res == 0) { if (res == 0) {
if (active_task.target == MOD_BAT) { if (active_task.target_ == module::Battery) {
switch (active_task.type) { switch (active_task.type_) {
case TASK_BATTERY_CAL: case task::BatteryCal:
this->calibrate(active_task); this->calibrate(active_task);
break; break;
default: default:
break; break;
} }
} else if (active_task.target == MOD_ALL) { } else if (active_task.target_ == module::All) {
switch (active_task.type) switch (active_task.type_)
{ {
case TASK_ALL_CONFIG_UPDATED: { case task::AllConfigUpdated: {
vehicle_config config; VehicleConfig config;
config_global_read(config); configGlobalRead(config);
_cal = config.vbat_calibration; calibration_ = config.vbat_calibration_;
_low = config.vbat_low; low_threshold_ = config.vbat_low_;
break; break;
} }

26
src/modules/battery/battery.h
View File

@@ -9,25 +9,25 @@
#include "modules/logger/system_logger.h" #include "modules/logger/system_logger.h"
#include <Arduino.h> #include <Arduino.h>
class battery : public module_base { class Battery : public ModuleBase {
private: private:
system_logger *_logger; SystemLogger *logger_;
ring_buffer<Task, 16> _queue; RingBuffer<Task, 16> queue_;
double _vbat = 0; double vbat_ = 0;
double _cal = 0; double calibration_ = 0;
double _low = 0; double low_threshold_ = 0;
unsigned long _warning_sent = 0; unsigned long warning_sent_at_ = 0;
unsigned long _warning_timeout = 10000; unsigned long warning_timeout_ = 10000;
unsigned long _update_interval = 1000; unsigned long update_interval_ = 1000;
unsigned long _last_read = 0; unsigned long last_read_at_ = 0;
int calibrate(const Task& task); int calibrate(const Task& task);
public: public:
int push(const Task &task) override; int push(const Task &task) override;
battery(); Battery();
battery(system_logger *logger); Battery(SystemLogger *logger);
~battery(); ~Battery();
int init(); int init();
int loop(unsigned long timeout_ms = 500); int loop(unsigned long timeout_ms = 500);
}; };

431
src/modules/cmd/cmd.cpp
View File

@@ -10,7 +10,7 @@
#include "data/general_store.h" #include "data/general_store.h"
#include "base/router.h" #include "base/router.h"
char *cmd::trim_arg(char *input) { char *Cmd::trimArg(char *input) {
if (input == nullptr) { if (input == nullptr) {
return nullptr; return nullptr;
} }
@@ -33,7 +33,7 @@ char *cmd::trim_arg(char *input) {
return input; return input;
} }
unsigned short cmd::split_args(char *input, char *argv[], unsigned short max_args) { unsigned short Cmd::splitArgs(char *input, char *argv[], unsigned short max_args) {
unsigned short argc = 0; unsigned short argc = 0;
char *p = input; char *p = input;
char *token_start = input; char *token_start = input;
@@ -51,7 +51,7 @@ unsigned short cmd::split_args(char *input, char *argv[], unsigned short max_arg
char separator = *p; char separator = *p;
*p = '\0'; *p = '\0';
argv[argc] = trim_arg(token_start); argv[argc] = trimArg(token_start);
argc++; argc++;
if (separator == '\0') { if (separator == '\0') {
@@ -67,71 +67,71 @@ unsigned short cmd::split_args(char *input, char *argv[], unsigned short max_arg
return argc; return argc;
} }
cmd::command_id cmd::parse_command_name(const char *input) { Cmd::CommandId Cmd::parseCommandName(const char *input) {
if (input == nullptr) { if (input == nullptr) {
return CMD_UNKNOWN; return Unknown;
} }
if (strcmp(input, "REBOOT") == 0) { if (strcmp(input, "REBOOT") == 0) {
return CMD_REBOOT; return Reboot;
} }
if (strcmp(input, "CFG_DUMP") == 0) { if (strcmp(input, "CFG_DUMP") == 0) {
return CMD_CFG_DUMP; return ConfigDump;
} }
if (strcmp(input, "TRACK_PUT") == 0) { if (strcmp(input, "TRACK_PUT") == 0) {
return CMD_PUT_TRACK; return PutTrack;
} }
if (strcmp(input, "TRACK_DELETE") == 0) { if (strcmp(input, "TRACK_DELETE") == 0) {
return CMD_DELETE_TRACK; return DeleteTrack;
} }
if (strcmp(input, "TRACK_DUMP") == 0) { if (strcmp(input, "TRACK_DUMP") == 0) {
return CMD_DUMP_TRACK; return DumpTrack;
} }
if (strcmp(input, "CFG_RESET") == 0) { if (strcmp(input, "CFG_RESET") == 0) {
return CMD_CFG_RESET; return ConfigReset;
} }
if (strcmp(input, "TRACK_AUTODETECT") == 0) { if (strcmp(input, "TRACK_AUTODETECT") == 0) {
return CMD_TRACK_AUTODETECT; return TrackAutodetect;
} }
if (strcmp(input, "DISPLAY_GPS_DEBUG") == 0) { if (strcmp(input, "DISPLAY_GPS_DEBUG") == 0) {
return CMD_DISPLAY_GPS_DEBUG; return DisplayGpsDebug;
} }
if (strcmp(input, "DISPLAY_DRIVER_PRIMARY") == 0) { if (strcmp(input, "DISPLAY_DRIVER_PRIMARY") == 0) {
return CMD_DISPLAY_DRIVER_PRIMARY; return DisplayDriverPrimary;
} }
if (strcmp(input, "BATTERY_CAL") == 0) { if (strcmp(input, "BATTERY_CAL") == 0) {
return CMD_BATTERY_CAL; return BatteryCal;
} }
if (strcmp(input, "BATTERY_PRINT_VBAT") == 0) { if (strcmp(input, "BATTERY_PRINT_VBAT") == 0) {
return CMD_BATTERY_PRINT_VBAT; return BatteryPrintVbat;
} }
if (strcmp(input, "BATTERY_SET_LOW") == 0) { if (strcmp(input, "BATTERY_SET_LOW") == 0) {
return CMD_BATTERY_SET_LOW; return BatterySetLow;
} }
if (strcmp(input, "THERMO_SET_LOW") == 0) { if (strcmp(input, "THERMO_SET_LOW") == 0) {
return CMD_THERMO_SET_LOW; return ThermoSetLow;
} }
if (strcmp(input, "THERMO_SET_HIGH") == 0) { if (strcmp(input, "THERMO_SET_HIGH") == 0) {
return CMD_THERMO_SET_HIGH; return ThermoSetHigh;
} }
return CMD_UNKNOWN; return Unknown;
} }
int cmd::parse_track_slot_id(const char *id_str, unsigned short &id_out) { int Cmd::parseTrackSlotId(const char *id_str, unsigned short &id_out) {
if (id_str == nullptr || id_str[0] == '\0') { if (id_str == nullptr || id_str[0] == '\0') {
return 1; return 1;
} }
@@ -144,51 +144,51 @@ int cmd::parse_track_slot_id(const char *id_str, unsigned short &id_out) {
return 0; return 0;
} }
int cmd::dump_track_slot(unsigned short id) { int Cmd::dumpTrackSlot(unsigned short id) {
vehicle_config cfg; VehicleConfig config;
config_global_read(cfg); configGlobalRead(config);
bool occupied = cfg.track_slot_occupied[id - 1]; bool occupied = config.track_slot_occupied_[id - 1];
track_data track; TrackData track_data;
int res = track_global_read(id, track); int result = trackGlobalRead(id, track_data);
if (res != 0) { if (result != 0) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("Track slot " + String(id) + " has no valid track data"); logger_->error("Track slot " + String(id) + " has no valid track data");
} }
#endif #endif
return 1; return 1;
} }
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Track dump for slot " + String(id)); logger_->info("Track dump for slot " + String(id));
_logger->info(String("\tOccupied flag: ") + String(occupied)); logger_->info(String("\tOccupied flag: ") + String(occupied));
_logger->info(String("\tID: ") + String(track.id)); logger_->info(String("\tID: ") + String(track_data.id_));
_logger->info(String("\tName: ") + String(track.name)); logger_->info(String("\tName: ") + String(track_data.name_));
_logger->info(String("\tPoint A lat: ") + String(track.pt_a.lat, 6)); logger_->info(String("\tPoint A lat: ") + String(track_data.point_a_.lat_, 6));
_logger->info(String("\tPoint A lng: ") + String(track.pt_a.lng, 6)); logger_->info(String("\tPoint A lng: ") + String(track_data.point_a_.lng_, 6));
_logger->info(String("\tPoint B lat: ") + String(track.pt_b.lat, 6)); logger_->info(String("\tPoint B lat: ") + String(track_data.point_b_.lat_, 6));
_logger->info(String("\tPoint B lng: ") + String(track.pt_b.lng, 6)); logger_->info(String("\tPoint B lng: ") + String(track_data.point_b_.lng_, 6));
} }
#endif #endif
return 0; return 0;
} }
int cmd::handle_reboot_command(unsigned short argc) { int Cmd::handleRebootCommand(unsigned short argc) {
if (argc != 1) { if (argc != 1) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("REBOOT expects no arguments"); logger_->error("REBOOT expects no arguments");
} }
#endif #endif
return 1; return 1;
} }
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Rebooting"); logger_->info("Rebooting");
} }
#endif #endif
delay(200); delay(200);
@@ -198,196 +198,196 @@ int cmd::handle_reboot_command(unsigned short argc) {
return 0; return 0;
} }
int cmd::handle_dumpcfg_command(unsigned short argc) { int Cmd::handleDumpConfigCommand(unsigned short argc) {
if (argc != 1) { if (argc != 1) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("DUMPCFG expects no arguments"); logger_->error("DUMPCFG expects no arguments");
} }
#endif #endif
return 1; return 1;
} }
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->dump_config(); logger_->dumpConfig();
} }
#endif #endif
return 0; return 0;
} }
int cmd::handle_track_put_command(unsigned short argc, char *argv[]) { int Cmd::handleTrackPutCommand(unsigned short argc, char *argv[]) {
if (argc != 7) { if (argc != 7) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("TRACK_PUT expects 6 arguments"); logger_->error("TRACK_PUT expects 6 arguments");
} }
#endif #endif
return 1; return 1;
} }
track_data new_track; TrackData new_track;
if (parse_track_slot_id(argv[1], new_track.id) != 0) { if (parseTrackSlotId(argv[1], new_track.id_) != 0) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error(String("ID out of range: ") + String(argv[1])); logger_->error(String("ID out of range: ") + String(argv[1]));
} }
#endif #endif
return 1; return 1;
} }
strncpy(new_track.name, argv[2], sizeof(new_track.name) - 1); strncpy(new_track.name_, argv[2], sizeof(new_track.name_) - 1);
new_track.name[sizeof(new_track.name) - 1] = '\0'; new_track.name_[sizeof(new_track.name_) - 1] = '\0';
lat_lng pt_a; LatLng point_a;
pt_a.lat = strtod(argv[3], nullptr); point_a.lat_ = strtod(argv[3], nullptr);
pt_a.lng = strtod(argv[4], nullptr); point_a.lng_ = strtod(argv[4], nullptr);
new_track.pt_a = pt_a; new_track.point_a_ = point_a;
lat_lng pt_b; LatLng point_b;
pt_b.lat = strtod(argv[5], nullptr); point_b.lat_ = strtod(argv[5], nullptr);
pt_b.lng = strtod(argv[6], nullptr); point_b.lng_ = strtod(argv[6], nullptr);
new_track.pt_b = pt_b; new_track.point_b_ = point_b;
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Loading new track"); logger_->info("Loading new track");
_logger->info(String("ID: ") + String(new_track.id)); logger_->info(String("ID: ") + String(new_track.id_));
_logger->info(String("Name: ") + new_track.name); logger_->info(String("Name: ") + new_track.name_);
_logger->info(String("Point A lat: ") + String(new_track.pt_a.lat)); logger_->info(String("Point A lat: ") + String(new_track.point_a_.lat_));
_logger->info(String("Point A lng: ") + String(new_track.pt_a.lng)); logger_->info(String("Point A lng: ") + String(new_track.point_a_.lng_));
_logger->info(String("Point B lat: ") + String(new_track.pt_b.lat)); logger_->info(String("Point B lat: ") + String(new_track.point_b_.lat_));
_logger->info(String("Point B lng: ") + String(new_track.pt_b.lng)); logger_->info(String("Point B lng: ") + String(new_track.point_b_.lng_));
} }
#endif #endif
track_temp_global_write(new_track); trackTempGlobalWrite(new_track);
return router::send(MOD_CFG, TASK_CONFIG_WRITE_TEMP_TRACK); return router::send(module::Config, task::ConfigWriteTempTrack);
} }
int cmd::handle_track_delete_command(unsigned short argc, char *argv[]) { int Cmd::handleTrackDeleteCommand(unsigned short argc, char *argv[]) {
if (argc != 2) { if (argc != 2) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("TRACK_DELETE expects 1 argument"); logger_->error("TRACK_DELETE expects 1 argument");
} }
#endif #endif
return 1; return 1;
} }
unsigned short id; unsigned short id;
if (parse_track_slot_id(argv[1], id) != 0) { if (parseTrackSlotId(argv[1], id) != 0) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error(String("ID out of range: ") + String(argv[1])); logger_->error(String("ID out of range: ") + String(argv[1]));
} }
#endif #endif
return 1; return 1;
} }
return router::send(MOD_CFG, TASK_CONFIG_TRACK_DELETE, id); return router::send(module::Config, task::ConfigTrackDelete, id);
} }
int cmd::handle_track_dump_command(unsigned short argc, char *argv[]) { int Cmd::handleTrackDumpCommand(unsigned short argc, char *argv[]) {
if (argc != 2) { if (argc != 2) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("TRACK_DUMP expects 1 argument"); logger_->error("TRACK_DUMP expects 1 argument");
} }
#endif #endif
return 1; return 1;
} }
unsigned short id; unsigned short id;
if (parse_track_slot_id(argv[1], id) != 0) { if (parseTrackSlotId(argv[1], id) != 0) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error(String("ID out of range: ") + String(argv[1])); logger_->error(String("ID out of range: ") + String(argv[1]));
} }
#endif #endif
return 1; return 1;
} }
return this->dump_track_slot(id); return this->dumpTrackSlot(id);
} }
int cmd::handle_cfg_reset_command(unsigned short argc) { int Cmd::handleConfigResetCommand(unsigned short argc) {
if (argc != 1) { if (argc != 1) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("CFG_RESET expects no arguments"); logger_->error("CFG_RESET expects no arguments");
} }
#endif #endif
return 1; return 1;
} }
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Resetting config"); logger_->info("Resetting config");
} }
#endif #endif
return router::send(MOD_CFG, TASK_CONFIG_CFG_RESET); return router::send(module::Config, task::ConfigReset);
} }
int cmd::handle_track_autodetect_command(unsigned short argc) { int Cmd::handleTrackAutodetectCommand(unsigned short argc) {
if (argc != 1) { if (argc != 1) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("TRACK_AUTODETECT expects no arguments"); logger_->error("TRACK_AUTODETECT expects no arguments");
} }
#endif #endif
return 1; return 1;
} }
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Detecting track"); logger_->info("Detecting track");
} }
#endif #endif
return router::send(MOD_CFG, TASK_CONFIG_TRACK_DETECT, 1); return router::send(module::Config, task::ConfigTrackDetect, 1);
} }
int cmd::handle_display_gps_debug(unsigned short argc) { int Cmd::handleDisplayGpsDebug(unsigned short argc) {
if (argc != 1) { if (argc != 1) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("DISPLAY_GPS_DEBUG expects no arguments"); logger_->error("DISPLAY_GPS_DEBUG expects no arguments");
} }
#endif #endif
return 1; return 1;
} }
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Switching to GPS_DEBUG display"); logger_->info("Switching to GPS_DEBUG display");
} }
#endif #endif
return router::send(MOD_LCD, TASK_DISPLAY_GPS_DEBUG); return router::send(module::Lcd, task::DisplayGpsDebug);
} }
int cmd::handle_display_driver_primary(unsigned short argc) { int Cmd::handleDisplayDriverPrimary(unsigned short argc) {
if (argc != 1) { if (argc != 1) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("DISPLAY_DRIVER_PRIMARY expects no arguments"); logger_->error("DISPLAY_DRIVER_PRIMARY expects no arguments");
} }
#endif #endif
return 1; return 1;
} }
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Switching to DRIVER_PRIMARY display"); logger_->info("Switching to DRIVER_PRIMARY display");
} }
#endif #endif
return router::send(MOD_LCD, TASK_DISPLAY_DRIVER_PRIMARY); return router::send(module::Lcd, task::DisplayDriverPrimary);
} }
int cmd::handle_battery_cal(unsigned short argc, char *argv[]) { int Cmd::handleBatteryCal(unsigned short argc, char *argv[]) {
if (argc != 2) { if (argc != 2) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("BATTERY_CAL expects 1 argument"); logger_->error("BATTERY_CAL expects 1 argument");
} }
#endif #endif
return 1; return 1;
@@ -396,19 +396,19 @@ int cmd::handle_battery_cal(unsigned short argc, char *argv[]) {
uint32_t task_data; uint32_t task_data;
memcpy(&task_data, &vbat, sizeof(uint32_t)); memcpy(&task_data, &vbat, sizeof(uint32_t));
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Calibrating VBAT"); logger_->info("Calibrating VBAT");
} }
#endif #endif
router::send(MOD_BAT, TASK_BATTERY_CAL, task_data); router::send(module::Battery, task::BatteryCal, task_data);
return 0; return 0;
} }
int cmd::handle_battery_print_vbat(unsigned short argc) { int Cmd::handleBatteryPrintVbat(unsigned short argc) {
if (argc != 1) { if (argc != 1) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("BATTERY_PRINT_VBAT expects no arguments"); logger_->error("BATTERY_PRINT_VBAT expects no arguments");
} }
#endif #endif
return 1; return 1;
@@ -416,18 +416,19 @@ int cmd::handle_battery_print_vbat(unsigned short argc) {
#ifdef INFO #ifdef INFO
double vbat; double vbat;
vbat_global_read(vbat); vbatGlobalRead(vbat);
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("VBAT: " + String(vbat)); logger_->info("VBAT: " + String(vbat));
} }
#endif #endif
return 0;
} }
int cmd::handle_battery_set_low(unsigned short argc, char* argv[]) { int Cmd::handleBatterySetLow(unsigned short argc, char* argv[]) {
if (argc != 2) { if (argc != 2) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("BATTERY_SET_LOW expects 1 argument"); logger_->error("BATTERY_SET_LOW expects 1 argument");
} }
#endif #endif
return 1; return 1;
@@ -436,19 +437,19 @@ int cmd::handle_battery_set_low(unsigned short argc, char* argv[]) {
uint32_t task_data; uint32_t task_data;
memcpy(&task_data, &low, sizeof(uint32_t)); memcpy(&task_data, &low, sizeof(uint32_t));
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Setting warning level for VBAT"); logger_->info("Setting warning level for VBAT");
} }
#endif #endif
router::send(MOD_CFG, TASK_CONFIG_VBAT_SET_LOW, task_data); router::send(module::Config, task::ConfigVbatSetLow, task_data);
return 0; return 0;
} }
int cmd::handle_thermo_set_low(unsigned short argc, char* argv[]) { int Cmd::handleThermoSetLow(unsigned short argc, char* argv[]) {
if (argc != 2) { if (argc != 2) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("THERMO_SET_LOW expects 1 argument"); logger_->error("THERMO_SET_LOW expects 1 argument");
} }
#endif #endif
return 1; return 1;
@@ -457,19 +458,19 @@ int cmd::handle_thermo_set_low(unsigned short argc, char* argv[]) {
uint32_t task_data; uint32_t task_data;
memcpy(&task_data, &low, sizeof(uint32_t)); memcpy(&task_data, &low, sizeof(uint32_t));
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Setting low level for TENG"); logger_->info("Setting low level for TENG");
} }
#endif #endif
router::send(MOD_CFG, TASK_CONFIG_TENG_SET_LOW, task_data); router::send(module::Config, task::ConfigTengSetLow, task_data);
return 0; return 0;
} }
int cmd::handle_thermo_set_high(unsigned short argc, char* argv[]) { int Cmd::handleThermoSetHigh(unsigned short argc, char* argv[]) {
if (argc != 2) { if (argc != 2) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("THERMO_SET_HIGH expects 1 argument"); logger_->error("THERMO_SET_HIGH expects 1 argument");
} }
#endif #endif
return 1; return 1;
@@ -478,156 +479,156 @@ int cmd::handle_thermo_set_high(unsigned short argc, char* argv[]) {
uint32_t task_data; uint32_t task_data;
memcpy(&task_data, &low, sizeof(uint32_t)); memcpy(&task_data, &low, sizeof(uint32_t));
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Setting high level for TENG"); logger_->info("Setting high level for TENG");
} }
#endif #endif
router::send(MOD_CFG, TASK_CONFIG_TENG_SET_LOW, task_data); router::send(module::Config, task::ConfigTengSetLow, task_data);
return 0; return 0;
} }
int cmd::handle_unknown_command(unsigned short argc, char *argv[]) { int Cmd::handleUnknownCommand(unsigned short argc, char *argv[]) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
if (argc > 0 && argv != nullptr && argv[0] != nullptr && argv[0][0] != '\0') { if (argc > 0 && argv != nullptr && argv[0] != nullptr && argv[0][0] != '\0') {
_logger->error(String("Unknown command: ") + String(argv[0])); logger_->error(String("Unknown command: ") + String(argv[0]));
} else { } else {
_logger->error("Unknown command"); logger_->error("Unknown command");
} }
} }
#endif #endif
return 1; return 1;
} }
int cmd::dispatch_command(command_id command, unsigned short argc, char *argv[]) { int Cmd::dispatchCommand(CommandId command, unsigned short argc, char *argv[]) {
switch (command) { switch (command) {
case CMD_REBOOT: case Reboot:
return this->handle_reboot_command(argc); return this->handleRebootCommand(argc);
case CMD_CFG_DUMP: case ConfigDump:
return this->handle_dumpcfg_command(argc); return this->handleDumpConfigCommand(argc);
case CMD_PUT_TRACK: case PutTrack:
return this->handle_track_put_command(argc, argv); return this->handleTrackPutCommand(argc, argv);
case CMD_DELETE_TRACK: case DeleteTrack:
return this->handle_track_delete_command(argc, argv); return this->handleTrackDeleteCommand(argc, argv);
case CMD_DUMP_TRACK: case DumpTrack:
return this->handle_track_dump_command(argc, argv); return this->handleTrackDumpCommand(argc, argv);
case CMD_CFG_RESET: case ConfigReset:
return this->handle_cfg_reset_command(argc); return this->handleConfigResetCommand(argc);
case CMD_TRACK_AUTODETECT: case TrackAutodetect:
return this->handle_track_autodetect_command(argc); return this->handleTrackAutodetectCommand(argc);
case CMD_DISPLAY_GPS_DEBUG: case DisplayGpsDebug:
return this->handle_display_gps_debug(argc); return this->handleDisplayGpsDebug(argc);
case CMD_DISPLAY_DRIVER_PRIMARY: case DisplayDriverPrimary:
return this->handle_display_driver_primary(argc); return this->handleDisplayDriverPrimary(argc);
case CMD_BATTERY_CAL: case BatteryCal:
return this->handle_battery_cal(argc, argv); return this->handleBatteryCal(argc, argv);
case CMD_BATTERY_PRINT_VBAT: case BatteryPrintVbat:
return this->handle_battery_print_vbat(argc); return this->handleBatteryPrintVbat(argc);
case CMD_BATTERY_SET_LOW: case BatterySetLow:
return this->handle_battery_set_low(argc, argv); return this->handleBatterySetLow(argc, argv);
case CMD_THERMO_SET_LOW: case ThermoSetLow:
return this->handle_thermo_set_low(argc, argv); return this->handleThermoSetLow(argc, argv);
case CMD_THERMO_SET_HIGH: case ThermoSetHigh:
return this->handle_thermo_set_high(argc, argv); return this->handleThermoSetHigh(argc, argv);
case CMD_UNKNOWN: case Unknown:
default: default:
return this->handle_unknown_command(argc, argv); return this->handleUnknownCommand(argc, argv);
} }
} }
int cmd::try_parse() { int Cmd::tryParse() {
#ifdef DEBUG #ifdef DEBUG
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->debug("Attempting to parse command"); logger_->debug("Attempting to parse command");
} }
#endif #endif
char *argvp[_max_args]; char *argvp[MAX_ARGS];
unsigned short argc = split_args(_buffer, argvp, _max_args); unsigned short argc = splitArgs(buffer_, argvp, MAX_ARGS);
if (argc == 0 || argvp[0] == nullptr || argvp[0][0] == '\0') { if (argc == 0 || argvp[0] == nullptr || argvp[0][0] == '\0') {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("Empty command"); logger_->error("Empty command");
} }
#endif #endif
return 1; return 1;
} }
command_id command = parse_command_name(argvp[0]); CommandId command = parseCommandName(argvp[0]);
return dispatch_command(command, argc, argvp); return dispatchCommand(command, argc, argvp);
} }
int cmd::push(const Task &task) { int Cmd::push(const Task &task) {
return _queue.push(task); return queue_.push(task);
} }
cmd::cmd(HardwareSerial *data_stream) Cmd::Cmd(HardwareSerial *data_stream)
: _data_stream(data_stream), _logger(nullptr) {} : data_stream_(data_stream), logger_(nullptr) {}
cmd::cmd(HardwareSerial *data_stream, system_logger *logger) Cmd::Cmd(HardwareSerial *data_stream, SystemLogger *logger)
: _data_stream(data_stream), _logger(logger) {} : data_stream_(data_stream), logger_(logger) {}
cmd::~cmd() {} Cmd::~Cmd() {}
int cmd::init() { int Cmd::init() {
_data_stream->begin(_baud_rate); data_stream_->begin(baud_rate_);
return 0; return 0;
} }
int cmd::parse_task(unsigned long timeout_ms) { int Cmd::parseTask(unsigned long timeout_ms) {
unsigned long start = millis(); unsigned long start = millis();
while (_data_stream->available()) { while (data_stream_->available()) {
if ((unsigned long)(millis() - start) >= timeout_ms) { if ((unsigned long)(millis() - start) >= timeout_ms) {
return 1; return 1;
} }
char c = _data_stream->read(); char current_char = data_stream_->read();
if (c == '<') { if (current_char == '<') {
_buf_open = true; buffer_open_ = true;
_idx = 0; index_ = 0;
continue; continue;
} }
if (!_buf_open) { if (!buffer_open_) {
continue; continue;
} }
if (c == '>') { if (current_char == '>') {
_buffer[_idx] = '\0'; buffer_[index_] = '\0';
_buf_open = false; buffer_open_ = false;
return this->try_parse(); return this->tryParse();
} }
if (_idx >= sizeof(_buffer) - 1) { if (index_ >= sizeof(buffer_) - 1) {
_buf_open = false; buffer_open_ = false;
_idx = 0; index_ = 0;
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("Command parser buffer overflow"); logger_->error("Command parser buffer overflow");
} }
#endif #endif
return 1; return 1;
} }
_buffer[_idx] = c; buffer_[index_] = current_char;
_idx++; index_++;
} }
return 0; return 0;

102
src/modules/cmd/cmd.h
View File

@@ -12,64 +12,64 @@
#include "custom_types.h" #include "custom_types.h"
#include "modules/logger/system_logger.h" #include "modules/logger/system_logger.h"
class cmd : public module_base { class Cmd : public ModuleBase {
private: private:
enum command_id { enum CommandId {
CMD_UNKNOWN = 0, Unknown = 0,
CMD_REBOOT, Reboot,
CMD_PUT_TRACK, PutTrack,
CMD_DELETE_TRACK, DeleteTrack,
CMD_DUMP_TRACK, DumpTrack,
CMD_CFG_RESET, ConfigReset,
CMD_CFG_DUMP, ConfigDump,
CMD_TRACK_AUTODETECT, TrackAutodetect,
CMD_DISPLAY_GPS_DEBUG, DisplayGpsDebug,
CMD_DISPLAY_DRIVER_PRIMARY, DisplayDriverPrimary,
CMD_BATTERY_CAL, BatteryCal,
CMD_BATTERY_PRINT_VBAT, BatteryPrintVbat,
CMD_BATTERY_SET_LOW, BatterySetLow,
CMD_THERMO_SET_LOW, ThermoSetLow,
CMD_THERMO_SET_HIGH, ThermoSetHigh,
}; };
HardwareSerial *_data_stream; HardwareSerial *data_stream_;
unsigned long _baud_rate = 115200; unsigned long baud_rate_ = 115200;
system_logger *_logger; SystemLogger *logger_;
char _buffer[256]; char buffer_[256];
unsigned int _idx = 0; unsigned int index_ = 0;
bool _buf_open = false; bool buffer_open_ = false;
ring_buffer<Task, 16> _queue; RingBuffer<Task, 16> queue_;
static const unsigned short _max_args = 10; static const unsigned short MAX_ARGS = 10;
int try_parse(); int tryParse();
unsigned short split_args(char *input, char *argv[], unsigned short max_args); unsigned short splitArgs(char *input, char *argv[], unsigned short max_args);
char *trim_arg(char *input); char *trimArg(char *input);
command_id parse_command_name(const char *input); CommandId parseCommandName(const char *input);
int dispatch_command(command_id command, unsigned short argc, char *argv[]); int dispatchCommand(CommandId command, unsigned short argc, char *argv[]);
int parse_track_slot_id(const char *id_str, unsigned short &id_out); int parseTrackSlotId(const char *id_str, unsigned short &id_out);
int dump_track_slot(unsigned short id); int dumpTrackSlot(unsigned short id);
int handle_reboot_command(unsigned short argc); int handleRebootCommand(unsigned short argc);
int handle_dumpcfg_command(unsigned short argc); int handleDumpConfigCommand(unsigned short argc);
int handle_track_put_command(unsigned short argc, char *argv[]); int handleTrackPutCommand(unsigned short argc, char *argv[]);
int handle_track_delete_command(unsigned short argc, char *argv[]); int handleTrackDeleteCommand(unsigned short argc, char *argv[]);
int handle_track_dump_command(unsigned short argc, char *argv[]); int handleTrackDumpCommand(unsigned short argc, char *argv[]);
int handle_cfg_reset_command(unsigned short argc); int handleConfigResetCommand(unsigned short argc);
int handle_track_autodetect_command(unsigned short argc); int handleTrackAutodetectCommand(unsigned short argc);
int handle_display_gps_debug(unsigned short argc); int handleDisplayGpsDebug(unsigned short argc);
int handle_display_driver_primary(unsigned short argc); int handleDisplayDriverPrimary(unsigned short argc);
int handle_battery_cal(unsigned short argc, char *argv[]); int handleBatteryCal(unsigned short argc, char *argv[]);
int handle_battery_print_vbat(unsigned short argc); int handleBatteryPrintVbat(unsigned short argc);
int handle_battery_set_low(unsigned short argc, char *argv[]); int handleBatterySetLow(unsigned short argc, char *argv[]);
int handle_thermo_set_low(unsigned short argc, char *argv[]); int handleThermoSetLow(unsigned short argc, char *argv[]);
int handle_thermo_set_high(unsigned short argc, char *argv[]); int handleThermoSetHigh(unsigned short argc, char *argv[]);
int handle_unknown_command(unsigned short argc, char *argv[]); int handleUnknownCommand(unsigned short argc, char *argv[]);
public: public:
int push(const Task &task) override; int push(const Task &task) override;
cmd(HardwareSerial *data_stream); Cmd(HardwareSerial *data_stream);
cmd(HardwareSerial *data_stream, system_logger *logger); Cmd(HardwareSerial *data_stream, SystemLogger *logger);
~cmd(); ~Cmd();
int init(); int init();
int parse_task(unsigned long timeout_ms = 500); int parseTask(unsigned long timeout_ms = 500);
}; };

360
src/modules/config/config.cpp
View File

@@ -8,282 +8,282 @@
#include <math.h> #include <math.h>
#include <string.h> #include <string.h>
int config::push(const Task &task) { return _queue.push(task); } int Config::push(const Task &task) { return queue_.push(task); }
int config::task_complete() { int Config::taskComplete() {
_task_memory_stale = true; task_memory_stale_ = true;
_active_task = {MOD_NULL, TASK_NULL, 0}; active_task_ = Task(module::Null, task::Null, 0);
return 0; return 0;
} }
int config::write_track(const track_data &in) { int Config::writeTrack(const TrackData &track_data) {
track_data copy = in; TrackData track_copy = track_data;
copy.magic = CONFIG_MAGIC; track_copy.magic_ = CONFIG_MAGIC;
if (copy.id < 1 || copy.id > 8) { if (track_copy.id_ < 1 || track_copy.id_ > 8) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("Cannot write track data with out of range id, aborting"); logger_->error("Cannot write track data with out of range id, aborting");
} }
#endif #endif
return 1; return 1;
} }
EEPROM.put(eeprom_layout::track_slot_addr(copy.id), copy); EEPROM.put(eeprom_layout::trackSlotAddr(track_copy.id_), track_copy);
_config.track_slot_occupied[copy.id - 1] = true; config_.track_slot_occupied_[track_copy.id_ - 1] = true;
this->write_cfg(); this->writeConfig();
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Succesfully wrote new track into slot " + String(copy.id)); logger_->info("Succesfully wrote new track into slot " + String(track_copy.id_));
} }
#endif #endif
return 0; return 0;
} }
int config::write_track_from_temp() { int Config::writeTrackFromTemp() {
track_data new_track; TrackData track_data;
track_temp_global_read(new_track); trackTempGlobalRead(track_data);
return this->write_track(new_track); return this->writeTrack(track_data);
} }
int config::delete_track(unsigned short idx) { int Config::deleteTrack(unsigned short idx) {
if (idx < 1 || idx > 8) { if (idx < 1 || idx > 8) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("Cannot delete track with out of range id, aborting"); logger_->error("Cannot delete track with out of range id, aborting");
} }
#endif #endif
return 1; return 1;
} }
if (_config.track_slot_occupied[idx - 1] == false) { if (config_.track_slot_occupied_[idx - 1] == false) {
#ifdef WARN #ifdef WARN
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->warn("Requested delete on empty track slot " + String(idx)); logger_->warn("Requested delete on empty track slot " + String(idx));
} }
#endif #endif
return 0; return 0;
} }
_config.track_slot_occupied[idx - 1] = false; config_.track_slot_occupied_[idx - 1] = false;
if (_is_track_loaded && _loaded_track.id == idx) { if (is_track_loaded_ && loaded_track_.id_ == idx) {
_is_track_loaded = false; is_track_loaded_ = false;
_loaded_track = {}; loaded_track_ = {};
track_global_write(_loaded_track); trackGlobalWrite(loaded_track_);
} }
int write_res = this->write_cfg(); int write_result = this->writeConfig();
#ifdef INFO #ifdef INFO
if (_logger != nullptr && write_res == 0) { if (logger_ != nullptr && write_result == 0) {
_logger->info("Succesfully deleted track slot " + String(idx)); logger_->info("Succesfully deleted track slot " + String(idx));
} }
#endif #endif
return write_res; return write_result;
} }
int config::reset_cfg() { int Config::resetConfig() {
vehicle_config clean_config; VehicleConfig clean_config;
_config = clean_config; config_ = clean_config;
_is_track_loaded = false; is_track_loaded_ = false;
_loaded_track = {}; loaded_track_ = {};
_task_memory_stale = true; task_memory_stale_ = true;
_no_tracks_notice_shown = false; no_tracks_notice_shown_ = false;
track_global_write(_loaded_track); trackGlobalWrite(loaded_track_);
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Resetting configuration to factory defaults"); logger_->info("Resetting configuration to factory defaults");
} }
#endif #endif
return this->write_cfg(); return this->writeConfig();
} }
int config::write_vbat_cal(double val) { int Config::writeVbatCal(double value) {
_config.vbat_calibration = val; config_.vbat_calibration_ = value;
return this->write_cfg(); return this->writeConfig();
} }
int config::write_vbat_low(double val) { int Config::writeVbatLow(double value) {
_config.vbat_low = val; config_.vbat_low_ = value;
return this->write_cfg(); return this->writeConfig();
} }
int config::write_teng_low(double val) { int Config::writeTengLow(double value) {
_config.teng_low = val; config_.teng_low_ = value;
return this->write_cfg(); return this->writeConfig();
} }
int config::write_teng_high(double val) { int Config::writeTengHigh(double value) {
_config.teng_high = val; config_.teng_high_ = value;
return this->write_cfg(); return this->writeConfig();
} }
config::config() : _logger(nullptr), _valid_config(true) {} Config::Config() : logger_(nullptr), valid_config_(true) {}
config::config(system_logger *logger) : _logger(logger), _valid_config(true) {} Config::Config(SystemLogger *logger) : logger_(logger), valid_config_(true) {}
config::~config() {} Config::~Config() {}
int config::read_cfg() { int Config::readConfig() {
EEPROM.get(eeprom_layout::config_addr, _config); EEPROM.get(eeprom_layout::CONFIG_ADDR, config_);
config_global_write(_config); configGlobalWrite(config_);
return 0; return 0;
} }
int config::write_cfg() { int Config::writeConfig() {
EEPROM.put(eeprom_layout::config_addr, _config); EEPROM.put(eeprom_layout::CONFIG_ADDR, config_);
config_global_write(_config); configGlobalWrite(config_);
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info("Config updated and saved to EEPROM"); logger_->info("Config updated and saved to EEPROM");
} }
#endif #endif
router::send(MOD_ALL, TASK_ALL_CONFIG_UPDATED); router::send(module::All, task::AllConfigUpdated);
return 0; return 0;
} }
int config::write_cfg(const vehicle_config &new_config) { int Config::writeConfig(const VehicleConfig &new_config) {
_config = new_config; config_ = new_config;
EEPROM.put(eeprom_layout::config_addr, new_config); EEPROM.put(eeprom_layout::CONFIG_ADDR, new_config);
config_global_write(new_config); configGlobalWrite(new_config);
return 0; return 0;
} }
int config::task_config_detect_track(unsigned long timeout_ms) { int Config::taskConfigDetectTrack(unsigned long timeout_ms) {
unsigned long start = millis(); unsigned long start = millis();
bool min_one = false; bool has_at_least_one_track = false;
for (size_t i = 0; i < 8; i++) { for (size_t i = 0; i < 8; i++) {
if (_config.track_slot_occupied[i] == true) { if (config_.track_slot_occupied_[i] == true) {
min_one = true; has_at_least_one_track = true;
break; break;
} }
} }
if (!min_one) { if (!has_at_least_one_track) {
if (!_no_tracks_notice_shown) { if (!no_tracks_notice_shown_) {
router::send(MOD_LCD, TASK_DISPLAY_MSG_CONFIG_NO_TRACKS, 3000); router::send(module::Lcd, task::DisplayMsgConfigNoTracks, 3000);
_no_tracks_notice_shown = true; no_tracks_notice_shown_ = true;
} }
this->task_complete(); this->taskComplete();
return 1; return 1;
} }
task_config_track_detect_data task_data; TaskConfigTrackDetectData task_data;
if (!_task_memory_stale) { if (!task_memory_stale_) {
memcpy(&task_data, _task_memory, sizeof(task_data)); memcpy(&task_data, task_memory_, sizeof(task_data));
} else { } else {
gps_data current_gps; GpsData current_gps;
gps_global_read(current_gps); gpsGlobalRead(current_gps);
task_data.gps_lat = current_gps.lat.value; task_data.gps_lat_ = current_gps.lat_.value_;
task_data.gps_lng = current_gps.lng.value; task_data.gps_lng_ = current_gps.lng_.value_;
task_data.cos = cos(task_data.gps_lat * M_PI / 180); task_data.cos_ = cos(task_data.gps_lat_ * M_PI / 180);
} }
while (true) { while (true) {
task_data.last_checked++; task_data.last_checked_++;
track_data temp; TrackData track_data;
int res = this->get_track(task_data.last_checked, temp); int result = this->getTrack(task_data.last_checked_, track_data);
if (res == 0) { if (result == 0) {
double delta_lat = temp.pt_a.lat - task_data.gps_lat; double delta_lat = track_data.point_a_.lat_ - task_data.gps_lat_;
double delta_lng = (temp.pt_a.lng - task_data.gps_lng) * task_data.cos; double delta_lng = (track_data.point_a_.lng_ - task_data.gps_lng_) * task_data.cos_;
double dist2 = delta_lat * delta_lat + delta_lng * delta_lng; double dist2 = delta_lat * delta_lat + delta_lng * delta_lng;
if (dist2 < task_data.sqdiff || task_data.smallest_idx == 0) { if (dist2 < task_data.sqdiff_ || task_data.smallest_idx_ == 0) {
task_data.smallest_idx = task_data.last_checked; task_data.smallest_idx_ = task_data.last_checked_;
task_data.sqdiff = dist2; task_data.sqdiff_ = dist2;
} }
} }
if (task_data.last_checked >= 8) { if (task_data.last_checked_ >= 8) {
int load_res = 1; int load_result = 1;
if (task_data.smallest_idx > 0) { if (task_data.smallest_idx_ > 0) {
load_res = this->load_track(task_data.smallest_idx); load_result = this->loadTrack(task_data.smallest_idx_);
} }
this->task_complete(); this->taskComplete();
if (load_res == 0) { if (load_result == 0) {
_no_tracks_notice_shown = false; no_tracks_notice_shown_ = false;
router::send(MOD_LCD, TASK_DISPLAY_MSG_TRACK_DETECT_OK, 4000); router::send(module::Lcd, task::DisplayMsgTrackDetectOk, 4000);
return 0; return 0;
} }
if (!_no_tracks_notice_shown) { if (!no_tracks_notice_shown_) {
router::send(MOD_LCD, TASK_DISPLAY_MSG_CONFIG_NO_TRACKS, 3000); router::send(module::Lcd, task::DisplayMsgConfigNoTracks, 3000);
_no_tracks_notice_shown = true; no_tracks_notice_shown_ = true;
} }
return 1; return 1;
} }
if ((unsigned long)(millis() - start) >= timeout_ms) { if ((unsigned long)(millis() - start) >= timeout_ms) {
_task_memory_stale = false; task_memory_stale_ = false;
memcpy(_task_memory, &task_data, sizeof(task_data)); memcpy(task_memory_, &task_data, sizeof(task_data));
return 1; return 1;
} }
} }
} }
int config::handle_active_task(unsigned long timeout_ms) { int Config::handleActiveTask(unsigned long timeout_ms) {
switch (_active_task.type) { switch (active_task_.type_) {
case TASK_CONFIG_TRACK_DETECT: { case task::ConfigTrackDetect: {
if (!_is_track_loaded || _active_task.data == 1) { if (!is_track_loaded_ || active_task_.data_ == 1) {
return task_config_detect_track(timeout_ms); return taskConfigDetectTrack(timeout_ms);
} }
this->task_complete(); this->taskComplete();
return 0; return 0;
} }
case TASK_CONFIG_WRITE_TEMP_TRACK: { case task::ConfigWriteTempTrack: {
int res = this->write_track_from_temp(); int result = this->writeTrackFromTemp();
this->task_complete(); this->taskComplete();
return res; return result;
} }
case TASK_CONFIG_TRACK_DELETE: { case task::ConfigTrackDelete: {
int res = this->delete_track(_active_task.data); int result = this->deleteTrack(active_task_.data_);
this->task_complete(); this->taskComplete();
return res; return result;
} }
case TASK_CONFIG_CFG_RESET: { case task::ConfigReset: {
int res = this->reset_cfg(); int result = this->resetConfig();
this->task_complete(); this->taskComplete();
return res; return result;
} }
case TASK_CONFIG_VBAT_CAL_SET: { case task::ConfigVbatCalSet: {
double cal_value; double cal_value;
memcpy(&cal_value, &_active_task.data, sizeof(double)); memcpy(&cal_value, &active_task_.data_, sizeof(double));
int res = this->write_vbat_cal(cal_value); int result = this->writeVbatCal(cal_value);
this->task_complete(); this->taskComplete();
return res; return result;
} }
case TASK_CONFIG_VBAT_SET_LOW: { case task::ConfigVbatSetLow: {
double low_value; double low_value;
memcpy(&low_value, &_active_task.data, sizeof(double)); memcpy(&low_value, &active_task_.data_, sizeof(double));
int res = this->write_vbat_low(low_value); int result = this->writeVbatLow(low_value);
this->task_complete(); this->taskComplete();
return res; return result;
} }
case TASK_CONFIG_TENG_SET_LOW: { case task::ConfigTengSetLow: {
double low_value; double low_value;
memcpy(&low_value, &_active_task.data, sizeof(double)); memcpy(&low_value, &active_task_.data_, sizeof(double));
int res = this->write_teng_low(low_value); int result = this->writeTengLow(low_value);
this->task_complete(); this->taskComplete();
return res; return result;
} }
case TASK_CONFIG_TENG_SET_HIGH: { case task::ConfigTengSetHigh: {
double high_value; double high_value;
memcpy(&high_value, &_active_task.data, sizeof(double)); memcpy(&high_value, &active_task_.data_, sizeof(double));
int res = this->write_teng_high(high_value); int result = this->writeTengHigh(high_value);
this->task_complete(); this->taskComplete();
return res; return result;
} }
default: default:
@@ -292,78 +292,78 @@ int config::handle_active_task(unsigned long timeout_ms) {
return 0; return 0;
} }
int config::auto_init() { int Config::autoInit() {
this->read_cfg(); this->readConfig();
if (_config.magic != CONFIG_MAGIC) { if (config_.magic_ != CONFIG_MAGIC) {
#ifdef WARN #ifdef WARN
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->warn("Config invalid, overwriting"); logger_->warn("Config invalid, overwriting");
} }
#endif #endif
vehicle_config clean_config; VehicleConfig clean_config;
this->write_cfg(clean_config); this->writeConfig(clean_config);
this->read_cfg(); this->readConfig();
if (_config.magic != CONFIG_MAGIC) { if (config_.magic_ != CONFIG_MAGIC) {
#ifdef ERROR #ifdef ERROR
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->error("Config write failed, EEPROM may be burnt"); logger_->error("Config write failed, EEPROM may be burnt");
} }
#endif #endif
return 1; return 1;
} }
} }
_valid_config = true; valid_config_ = true;
return 0; return 0;
} }
int config::loop(unsigned long timeout_ms) { int Config::loop(unsigned long timeout_ms) {
if (_active_task.type != TASK_NULL && _active_task.target != MOD_NULL) { if (active_task_.type_ != task::Null && active_task_.target_ != module::Null) {
this->handle_active_task(timeout_ms); this->handleActiveTask(timeout_ms);
return 0; return 0;
} }
int res = _queue.pop(_active_task); int result = queue_.pop(active_task_);
if (res == 0) { if (result == 0) {
this->handle_active_task(timeout_ms); this->handleActiveTask(timeout_ms);
} }
return 0; return 0;
} }
int config::get_track(unsigned int idx, track_data &t) { int Config::getTrack(unsigned int idx, TrackData &track_data) {
if (idx < 1 || idx > 8) { if (idx < 1 || idx > 8) {
return 1; return 1;
} }
if (_config.track_slot_occupied[idx - 1] == false) { if (config_.track_slot_occupied_[idx - 1] == false) {
return 1; return 1;
} }
EEPROM.get(eeprom_layout::track_slot_addr(idx), t); EEPROM.get(eeprom_layout::trackSlotAddr(idx), track_data);
if (t.magic != CONFIG_MAGIC) { if (track_data.magic_ != CONFIG_MAGIC) {
return 1; return 1;
} }
return 0; return 0;
} }
int config::load_track(unsigned int idx) { int Config::loadTrack(unsigned int idx) {
if (idx < 1 || idx > 8) { if (idx < 1 || idx > 8) {
return 1; return 1;
} }
if (_config.track_slot_occupied[idx - 1] == false) { if (config_.track_slot_occupied_[idx - 1] == false) {
return 1; return 1;
} }
track_data temp; TrackData track_data;
EEPROM.get(eeprom_layout::track_slot_addr(idx), temp); EEPROM.get(eeprom_layout::trackSlotAddr(idx), track_data);
if (temp.magic != CONFIG_MAGIC) { if (track_data.magic_ != CONFIG_MAGIC) {
return 1; return 1;
} }
_loaded_track = temp; loaded_track_ = track_data;
track_global_write(_loaded_track); trackGlobalWrite(loaded_track_);
_is_track_loaded = true; is_track_loaded_ = true;
return 0; return 0;
} }

76
src/modules/config/config.h
View File

@@ -15,50 +15,50 @@
#include "data/eeprom_layout.h" #include "data/eeprom_layout.h"
#include "base/router.h" #include "base/router.h"
struct task_config_track_detect_data { struct TaskConfigTrackDetectData {
unsigned short last_checked = 0; unsigned short last_checked_ = 0;
unsigned short smallest_idx = 0; unsigned short smallest_idx_ = 0;
double cos; double cos_ = 0;
double sqdiff = 0; double sqdiff_ = 0;
double gps_lat; double gps_lat_ = 0;
double gps_lng; double gps_lng_ = 0;
}; };
class config : public module_base { class Config : public ModuleBase {
private: private:
vehicle_config _config; VehicleConfig config_;
system_logger *_logger; SystemLogger *logger_;
bool _valid_config; bool valid_config_;
track_data _loaded_track; TrackData loaded_track_;
bool _is_track_loaded = false; bool is_track_loaded_ = false;
ring_buffer<Task, 16> _queue; RingBuffer<Task, 16> queue_;
Task _active_task = {}; Task active_task_ = {};
uint8_t _task_memory[64] = {}; uint8_t task_memory_[64] = {};
bool _task_memory_stale = true; bool task_memory_stale_ = true;
bool _no_tracks_notice_shown = false; bool no_tracks_notice_shown_ = false;
int read_cfg(); int readConfig();
int write_cfg(); int writeConfig();
int write_cfg(const vehicle_config &new_config); int writeConfig(const VehicleConfig &new_config);
int handle_active_task(unsigned long timeout_ms); int handleActiveTask(unsigned long timeout_ms);
int task_config_detect_track(unsigned long timeout_ms); int taskConfigDetectTrack(unsigned long timeout_ms);
int task_complete(); int taskComplete();
int write_track(const track_data& in); int writeTrack(const TrackData& track_data);
int write_track_from_temp(); int writeTrackFromTemp();
int delete_track(unsigned short idx); int deleteTrack(unsigned short idx);
int reset_cfg(); int resetConfig();
int write_vbat_cal(double val); int writeVbatCal(double value);
int write_vbat_low(double val); int writeVbatLow(double value);
int write_teng_low(double val); int writeTengLow(double value);
int write_teng_high(double val); int writeTengHigh(double value);
public: public:
int push(const Task &task) override; int push(const Task &task) override;
config(); Config();
config(system_logger *logger); Config(SystemLogger *logger);
~config(); ~Config();
int auto_init(); int autoInit();
int loop(unsigned long timeout_ms = 500); int loop(unsigned long timeout_ms = 500);
int get_track(unsigned int idx, track_data &t); int getTrack(unsigned int idx, TrackData &track_data);
int load_track(unsigned int idx); int loadTrack(unsigned int idx);
}; };

82
src/modules/gps/gps.cpp
View File

@@ -6,43 +6,43 @@
#define MOD "modules/gps/gps.h" #define MOD "modules/gps/gps.h"
int gps::push(const Task &task) { int Gps::push(const Task &task) {
return _queue.push(task); return queue_.push(task);
} }
gps::gps(HardwareSerial *data_stream) Gps::Gps(HardwareSerial *data_stream)
: _gps(nullptr), _data_stream(data_stream), _logger(nullptr) { : gps_(nullptr), data_stream_(data_stream), logger_(nullptr) {
_gps = new TinyGPSPlus(); gps_ = new TinyGPSPlus();
} }
gps::gps(HardwareSerial *data_stream, system_logger *logger) Gps::Gps(HardwareSerial *data_stream, SystemLogger *logger)
: _gps(nullptr), _data_stream(data_stream), _logger(logger) { : gps_(nullptr), data_stream_(data_stream), logger_(logger) {
_gps = new TinyGPSPlus(); gps_ = new TinyGPSPlus();
} }
gps::~gps() { Gps::~Gps() {
_data_stream = nullptr; data_stream_ = nullptr;
delete _gps; delete gps_;
_gps = nullptr; gps_ = nullptr;
} }
int gps::init() { int Gps::init() {
_data_stream->begin(9600); data_stream_->begin(9600);
return 0; return 0;
} }
int gps::loop(unsigned long timeout_ms) { int Gps::loop(unsigned long timeout_ms) {
unsigned long timeout = millis() + timeout_ms; unsigned long timeout = millis() + timeout_ms;
while (_data_stream->available() > 0) { while (data_stream_->available() > 0) {
if (_gps->encode(_data_stream->read())) { if (gps_->encode(data_stream_->read())) {
gps_global_write(this->get_data()); gpsGlobalWrite(this->getData());
uint32_t current_fix_val = _gps->sentencesWithFix(); uint32_t current_fix_value = gps_->sentencesWithFix();
if (_last_fix_val == 0 && current_fix_val > 0) { if (last_fix_value_ == 0 && current_fix_value > 0) {
router::send(MOD_LCD, TASK_DISPLAY_MSG_GPS_FIX, 2000); router::send(module::Lcd, task::DisplayMsgGpsFix, 2000);
router::send(MOD_CFG, TASK_CONFIG_TRACK_DETECT); router::send(module::Config, task::ConfigTrackDetect);
} }
_last_fix_val = current_fix_val; last_fix_value_ = current_fix_value;
} }
if (millis() > timeout) { if (millis() > timeout) {
@@ -53,30 +53,30 @@ int gps::loop(unsigned long timeout_ms) {
return 0; return 0;
} }
gps_data gps::get_data() { GpsData Gps::getData() {
gps_data output; GpsData output;
output.altitude.age = _gps->altitude.age(); output.altitude_.age_ = gps_->altitude.age();
output.altitude.valid = _gps->altitude.isValid(); output.altitude_.valid_ = gps_->altitude.isValid();
output.altitude.value = _gps->altitude.meters(); output.altitude_.value_ = gps_->altitude.meters();
output.lat.age = _gps->location.age(); output.lat_.age_ = gps_->location.age();
output.lat.valid = _gps->location.isValid(); output.lat_.valid_ = gps_->location.isValid();
output.lat.value = _gps->location.lat(); output.lat_.value_ = gps_->location.lat();
output.lng.age = _gps->location.age(); output.lng_.age_ = gps_->location.age();
output.lng.valid = _gps->location.isValid(); output.lng_.valid_ = gps_->location.isValid();
output.lng.value = _gps->location.lng(); output.lng_.value_ = gps_->location.lng();
output.speed.age = _gps->speed.age(); output.speed_.age_ = gps_->speed.age();
output.speed.valid = _gps->speed.isValid(); output.speed_.valid_ = gps_->speed.isValid();
output.speed.value = _gps->speed.kmph(); output.speed_.value_ = gps_->speed.kmph();
output.course.age = _gps->course.age(); output.course_.age_ = gps_->course.age();
output.course.valid = _gps->course.isValid(); output.course_.valid_ = gps_->course.isValid();
output.course.value = _gps->course.deg(); output.course_.value_ = gps_->course.deg();
output.num_fix = _gps->sentencesWithFix(); output.num_fix_ = gps_->sentencesWithFix();
return output; return output;
} }

20
src/modules/gps/gps.h
View File

@@ -13,20 +13,20 @@
#include "data/gps_store.h" #include "data/gps_store.h"
#include "base/router.h" #include "base/router.h"
class gps : public module_base { class Gps : public ModuleBase {
private: private:
TinyGPSPlus *_gps; TinyGPSPlus *gps_;
HardwareSerial *_data_stream; HardwareSerial *data_stream_;
system_logger *_logger; SystemLogger *logger_;
ring_buffer<Task, 16> _queue; RingBuffer<Task, 16> queue_;
uint32_t _last_fix_val = 0; uint32_t last_fix_value_ = 0;
public: public:
int push(const Task &task) override; int push(const Task &task) override;
gps(HardwareSerial *data_stream); Gps(HardwareSerial *data_stream);
gps(HardwareSerial *data_stream, system_logger *logger); Gps(HardwareSerial *data_stream, SystemLogger *logger);
~gps(); ~Gps();
int loop(unsigned long timeout_ms = 500); int loop(unsigned long timeout_ms = 500);
int init(); int init();
gps_data get_data(); GpsData getData();
}; };

364
src/modules/lcd/lcd.cpp
View File

@@ -9,59 +9,59 @@
#define MOD "modules/lcd/lcd.h" #define MOD "modules/lcd/lcd.h"
void lcd::clear() { void Lcd::clear() {
if (!_dispaly_cleared) { if (!display_cleared_) {
_display->clear(); display_->clear();
_dispaly_cleared = true; display_cleared_ = true;
} }
} }
void lcd::print(const String &msg) { void Lcd::print(const String &msg) {
_display->print(msg); display_->print(msg);
_dispaly_cleared = false; display_cleared_ = false;
} }
void lcd::print(char c) { void Lcd::print(char c) {
_display->print(c); display_->print(c);
_dispaly_cleared = false; display_cleared_ = false;
} }
void lcd::print(const char c[]) { void Lcd::print(const char c[]) {
_display->print(c); display_->print(c);
_dispaly_cleared = false; display_cleared_ = false;
} }
void lcd::print(double d, int digits) { void Lcd::print(double d, int digits) {
_display->print(d, digits); display_->print(d, digits);
_dispaly_cleared = false; display_cleared_ = false;
} }
void lcd::print(unsigned long l, int base) { void Lcd::print(unsigned long l, int base) {
_display->print(l, base); display_->print(l, base);
_dispaly_cleared = false; display_cleared_ = false;
} }
void lcd::print(long l, int base) { void Lcd::print(long l, int base) {
_display->print(l, base); display_->print(l, base);
_dispaly_cleared = false; display_cleared_ = false;
} }
void lcd::print(unsigned int i, int base) { void Lcd::print(unsigned int i, int base) {
_display->print(i, base); display_->print(i, base);
_dispaly_cleared = false; display_cleared_ = false;
} }
void lcd::print(int i, int base) { void Lcd::print(int i, int base) {
_display->print(i, base); display_->print(i, base);
_dispaly_cleared = false; display_cleared_ = false;
} }
bool lcd::is_message_task(task_type type) { bool Lcd::isMessageTask(task::Type type) {
switch (type) { switch (type) {
case TASK_DISPLAY_MSG_GPS_FIX: case task::DisplayMsgGpsFix:
case TASK_DISPLAY_MSG_TRACK_DETECT_OK: case task::DisplayMsgTrackDetectOk:
case TASK_DISPLAY_MSG_CONFIG_NO_TRACKS: case task::DisplayMsgConfigNoTracks:
case TASK_DISPLAY_MSG_BAT_LOW: case task::DisplayMsgBatteryLow:
return true; return true;
default: default:
@@ -69,73 +69,73 @@ bool lcd::is_message_task(task_type type) {
} }
} }
void lcd::activate_message(screen::lcd_screen msg_screen, unsigned long duration_ms) { void Lcd::activateMessage(screen::LcdScreen msg_screen, unsigned long duration_ms) {
if (duration_ms == 0) { if (duration_ms == 0) {
duration_ms = _frame_duration; duration_ms = frame_duration_;
} }
_msg_screen = msg_screen; message_screen_ = msg_screen;
_msg_active = true; message_active_ = true;
_msg_end = millis() + duration_ms; message_end_ = millis() + duration_ms;
_screen = _msg_screen; screen_ = message_screen_;
_force_render = true; force_render_ = true;
} }
void lcd::expire_message_if_needed(unsigned long now) { void Lcd::expireMessageIfNeeded(unsigned long now) {
if (!_msg_active) { if (!message_active_) {
return; return;
} }
if ((long)(now - _msg_end) >= 0) { if ((long)(now - message_end_) >= 0) {
_msg_active = false; message_active_ = false;
_msg_screen = screen::blank; message_screen_ = screen::Blank;
_screen = _data_screen; screen_ = data_screen_;
_force_render = true; force_render_ = true;
} }
} }
screen::lcd_screen lcd::get_active_screen() const { screen::LcdScreen Lcd::getActiveScreen() const {
if (_msg_active) { if (message_active_) {
return _msg_screen; return message_screen_;
} }
return _data_screen; return data_screen_;
} }
int lcd::render_gps_debug() { int Lcd::renderGpsDebug() {
this->clear(); this->clear();
gps_data data; GpsData gps_data;
gps_global_read(data); gpsGlobalRead(gps_data);
_display->setCursor(0, 0); display_->setCursor(0, 0);
this->print("Alt: "); this->print("Alt: ");
if (data.altitude.valid) { if (gps_data.altitude_.valid_) {
this->print(data.altitude.value, 5); this->print(gps_data.altitude_.value_, 5);
} else { } else {
this->print("not valid"); this->print("not valid");
} }
_display->setCursor(0, 1); display_->setCursor(0, 1);
this->print("Lat: "); this->print("Lat: ");
if (data.lat.valid) { if (gps_data.lat_.valid_) {
this->print(data.lat.value, 5); this->print(gps_data.lat_.value_, 5);
} else { } else {
this->print("not valid"); this->print("not valid");
} }
_display->setCursor(0, 2); display_->setCursor(0, 2);
this->print("Lng: "); this->print("Lng: ");
if (data.lng.valid) { if (gps_data.lng_.valid_) {
this->print(data.lng.value, 5); this->print(gps_data.lng_.value_, 5);
} else { } else {
this->print("not valid"); this->print("not valid");
} }
_display->setCursor(0, 3); display_->setCursor(0, 3);
this->print("Spd: "); this->print("Spd: ");
if (data.speed.valid) { if (gps_data.speed_.valid_) {
this->print(data.speed.value, 5); this->print(gps_data.speed_.value_, 5);
} else { } else {
this->print("not valid"); this->print("not valid");
} }
@@ -143,134 +143,134 @@ int lcd::render_gps_debug() {
return 0; return 0;
} }
int lcd::render_driver_primary() { int Lcd::renderDriverPrimary() {
this->clear(); this->clear();
gps_data gps; GpsData gps_data;
gps_global_read(gps); gpsGlobalRead(gps_data);
double vbat; double vbat;
vbat_global_read(vbat); vbatGlobalRead(vbat);
_display->setCursor(0,0); display_->setCursor(0,0);
this->print("GPS:"); this->print("GPS:");
if (gps.num_fix != 0) { if (gps_data.num_fix_ != 0) {
this->print("V"); this->print("V");
} else { } else {
this->print("X"); this->print("X");
} }
_display->setCursor(3,2); display_->setCursor(3,2);
this->print("SPEED: "); this->print("SPEED: ");
this->print(gps.speed.value); this->print(gps_data.speed_.value_);
_display->setCursor(0,3); display_->setCursor(0,3);
this->print("VBAT:"); this->print("VBAT:");
this->print(vbat); this->print(vbat);
return 0; return 0;
} }
int lcd::render_msg_gps_fix() { int Lcd::renderMsgGpsFix() {
this->clear(); this->clear();
_display->setCursor(6, 1); display_->setCursor(6, 1);
this->print("GPS INFO"); this->print("GPS INFO");
_display->setCursor(7, 2); display_->setCursor(7, 2);
this->print("FIX OK"); this->print("FIX OK");
return 0; return 0;
} }
int lcd::render_msg_track_detect_ok() { int Lcd::renderMsgTrackDetectOk() {
this->clear(); this->clear();
_display->setCursor(6, 0); display_->setCursor(6, 0);
this->print("GPS INFO"); this->print("GPS INFO");
_display->setCursor(3, 1); display_->setCursor(3, 1);
this->print("TRACK DETECTED"); this->print("TRACK DETECTED");
track_data temp; TrackData track_data;
track_global_read(temp); trackGlobalRead(track_data);
_display->setCursor((20 - strlen(temp.name)) / 2, 2); display_->setCursor((20 - strlen(track_data.name_)) / 2, 2);
this->print(temp.name); this->print(track_data.name_);
return 0; return 0;
} }
int lcd::render_msg_config_no_tracks() { int Lcd::renderMsgConfigNoTracks() {
this->clear(); this->clear();
_display->setCursor(4, 1); display_->setCursor(4, 1);
this->print("CONFIG INFO"); this->print("CONFIG INFO");
_display->setCursor(2, 2); display_->setCursor(2, 2);
this->print("NO TRACKS LOADED"); this->print("NO TRACKS LOADED");
return 0; return 0;
} }
int lcd::render_msg_battery_low() { int Lcd::renderMsgBatteryLow() {
this->clear(); this->clear();
_display->setCursor(2, 1); display_->setCursor(2, 1);
this->print("BATTERY WARNING"); this->print("BATTERY WARNING");
_display->setCursor(6, 2); display_->setCursor(6, 2);
this->print("VBAT LOW"); this->print("VBAT LOW");
return 0; return 0;
} }
int lcd::push(const Task &task) { int Lcd::push(const Task &task) {
return _queue.push(task); return queue_.push(task);
} }
lcd::lcd() Lcd::Lcd()
: _logger(nullptr), : display_cleared_(false),
_screen(screen::blank), logger_(nullptr),
_data_screen(screen::blank), screen_(screen::Blank),
_msg_screen(screen::blank), data_screen_(screen::Blank),
_last_render(0), message_screen_(screen::Blank),
_frame_duration(2000), last_render_(0),
_dispaly_cleared(false) { frame_duration_(2000) {
_display = new LiquidCrystal_I2C(0x27, 20, 4); display_ = new LiquidCrystal_I2C(0x27, 20, 4);
} }
lcd::lcd(system_logger *logger) Lcd::Lcd(SystemLogger *logger)
: _logger(logger), : display_cleared_(false),
_screen(screen::blank), logger_(logger),
_data_screen(screen::blank), screen_(screen::Blank),
_msg_screen(screen::blank), data_screen_(screen::Blank),
_last_render(0), message_screen_(screen::Blank),
_frame_duration(2000), last_render_(0),
_dispaly_cleared(false) { frame_duration_(2000) {
_display = new LiquidCrystal_I2C(0x27, 20, 4); display_ = new LiquidCrystal_I2C(0x27, 20, 4);
} }
lcd::~lcd() { Lcd::~Lcd() {
delete _display; delete display_;
_display = nullptr; display_ = nullptr;
} }
int lcd::init() { int Lcd::init() {
#ifdef DEEP_DEBUG #ifdef DEEP_DEBUG
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->deep_debug(String(MOD) + ": init: Begin"); logger_->deepDebug(String(MOD) + ": init: Begin");
} }
#endif #endif
_display->init(); display_->init();
Wire.setClock(400000); Wire.setClock(400000);
_display->backlight(); display_->backlight();
this->clear(); this->clear();
_display->setCursor(0, 0); display_->setCursor(0, 0);
_force_render = true; force_render_ = true;
#ifdef DEEP_DEBUG #ifdef DEEP_DEBUG
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->deep_debug(String(MOD) + ": init: End"); logger_->deepDebug(String(MOD) + ": init: End");
} }
#endif #endif
return 0; return 0;
} }
int lcd::print_message(String message) { int Lcd::printMessage(String message) {
#ifdef DEEP_DEBUG #ifdef DEEP_DEBUG
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->deep_debug(String(MOD) + ": print_message: Begin"); logger_->deepDebug(String(MOD) + ": printMessage: Begin");
} }
#endif #endif
@@ -332,41 +332,41 @@ int lcd::print_message(String message) {
col = 0; col = 0;
} }
_display->setCursor(col, currentRow++); display_->setCursor(col, currentRow++);
this->print(lines[i]); this->print(lines[i]);
} }
#ifdef INFO #ifdef INFO
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->info(original); logger_->info(original);
} }
#endif #endif
#ifdef DEEP_DEBUG #ifdef DEEP_DEBUG
if (_logger != nullptr) { if (logger_ != nullptr) {
_logger->deep_debug(String(MOD) + ": print_message: End"); logger_->deepDebug(String(MOD) + ": printMessage: End");
} }
#endif #endif
return 0; return 0;
} }
int lcd::loop(unsigned long timeout_ms) { int Lcd::loop(unsigned long timeout_ms) {
unsigned long now = millis(); unsigned long now = millis();
unsigned long start = now; unsigned long start = now;
expire_message_if_needed(now); expireMessageIfNeeded(now);
while (true) { while (true) {
Task next_task; Task next_task;
bool have_task = false; bool have_task = false;
if (_deferred_task_valid) { if (deferred_task_valid_) {
next_task = _deferred_task; next_task = deferred_task_;
_deferred_task_valid = false; deferred_task_valid_ = false;
have_task = true; have_task = true;
} else { } else {
if (_queue.pop(next_task) == 0) { if (queue_.pop(next_task) == 0) {
have_task = true; have_task = true;
} }
} }
@@ -375,43 +375,43 @@ int lcd::loop(unsigned long timeout_ms) {
break; break;
} }
if (_msg_active && is_message_task(next_task.type)) { if (message_active_ && isMessageTask(next_task.type_)) {
_deferred_task = next_task; deferred_task_ = next_task;
_deferred_task_valid = true; deferred_task_valid_ = true;
break; break;
} }
switch (next_task.type) { switch (next_task.type_) {
case TASK_DISPLAY_GPS_DEBUG: case task::DisplayGpsDebug:
_data_screen = screen::gps_debug; data_screen_ = screen::GpsDebug;
if (!_msg_active) { if (!message_active_) {
_screen = _data_screen; screen_ = data_screen_;
_force_render = true; force_render_ = true;
} }
break; break;
case TASK_DISPLAY_DRIVER_PRIMARY: case task::DisplayDriverPrimary:
_data_screen = screen::driver_primary; data_screen_ = screen::DriverPrimary;
if (!_msg_active) { if (!message_active_) {
_screen = _data_screen; screen_ = data_screen_;
_force_render = true; force_render_ = true;
} }
break; break;
case TASK_DISPLAY_MSG_GPS_FIX: case task::DisplayMsgGpsFix:
activate_message(screen::msg_gps_fix, next_task.data); activateMessage(screen::MsgGpsFix, next_task.data_);
break; break;
case TASK_DISPLAY_MSG_TRACK_DETECT_OK: case task::DisplayMsgTrackDetectOk:
activate_message(screen::msg_track_detect_ok, next_task.data); activateMessage(screen::MsgTrackDetectOk, next_task.data_);
break; break;
case TASK_DISPLAY_MSG_CONFIG_NO_TRACKS: case task::DisplayMsgConfigNoTracks:
activate_message(screen::msg_config_no_tracks, next_task.data); activateMessage(screen::MsgConfigNoTracks, next_task.data_);
break; break;
case TASK_DISPLAY_MSG_BAT_LOW: case task::DisplayMsgBatteryLow:
activate_message(screen::msg_battery_low, next_task.data); activateMessage(screen::MsgBatteryLow, next_task.data_);
break; break;
default: default:
@@ -419,7 +419,7 @@ int lcd::loop(unsigned long timeout_ms) {
} }
now = millis(); now = millis();
expire_message_if_needed(now); expireMessageIfNeeded(now);
if ((unsigned long)(now - start) >= timeout_ms) { if ((unsigned long)(now - start) >= timeout_ms) {
break; break;
@@ -427,53 +427,53 @@ int lcd::loop(unsigned long timeout_ms) {
} }
now = millis(); now = millis();
expire_message_if_needed(now); expireMessageIfNeeded(now);
screen::lcd_screen active_screen = get_active_screen(); screen::LcdScreen active_screen = getActiveScreen();
if (_screen != active_screen) { if (screen_ != active_screen) {
_screen = active_screen; screen_ = active_screen;
_force_render = true; force_render_ = true;
} }
if (!_force_render && (unsigned long)(now - _last_render) < _frame_duration) { if (!force_render_ && (unsigned long)(now - last_render_) < frame_duration_) {
return 1; return 1;
} }
switch (_screen) { switch (screen_) {
case screen::blank: case screen::Blank:
this->clear(); this->clear();
break; break;
case screen::gps_debug: case screen::GpsDebug:
this->render_gps_debug(); this->renderGpsDebug();
break; break;
case screen::driver_primary: case screen::DriverPrimary:
this->render_driver_primary(); this->renderDriverPrimary();
break; break;
case screen::msg_gps_fix: case screen::MsgGpsFix:
this->render_msg_gps_fix(); this->renderMsgGpsFix();
break; break;
case screen::msg_track_detect_ok: case screen::MsgTrackDetectOk:
this->render_msg_track_detect_ok(); this->renderMsgTrackDetectOk();
break; break;
case screen::msg_config_no_tracks: case screen::MsgConfigNoTracks:
this->render_msg_config_no_tracks(); this->renderMsgConfigNoTracks();
break; break;
case screen::msg_battery_low: case screen::MsgBatteryLow:
this->render_msg_battery_low(); this->renderMsgBatteryLow();
break; break;
default: default:
break; break;
} }
_last_render = now; last_render_ = now;
_force_render = false; force_render_ = false;
return 1; return 1;
} }

76
src/modules/lcd/lcd.h
View File

@@ -18,34 +18,34 @@
namespace screen { namespace screen {
typedef enum lcd_screen { enum LcdScreen : uint8_t {
blank, Blank,
gps_debug, GpsDebug,
driver_primary, DriverPrimary,
msg_gps_fix, MsgGpsFix,
msg_track_detect_ok, MsgTrackDetectOk,
msg_config_no_tracks, MsgConfigNoTracks,
msg_battery_low, MsgBatteryLow,
} lcd_screen; };
} // namespace screen } // namespace screen
class lcd : public module_base { class Lcd : public ModuleBase {
private: private:
LiquidCrystal_I2C *_display; LiquidCrystal_I2C *display_;
bool _dispaly_cleared; bool display_cleared_;
system_logger *_logger = nullptr; SystemLogger *logger_ = nullptr;
screen::lcd_screen _screen; screen::LcdScreen screen_;
screen::lcd_screen _data_screen; screen::LcdScreen data_screen_;
screen::lcd_screen _msg_screen; screen::LcdScreen message_screen_;
unsigned long _last_render; unsigned long last_render_;
unsigned long _frame_duration; unsigned long frame_duration_;
unsigned long _msg_end = 0; unsigned long message_end_ = 0;
bool _msg_active = false; bool message_active_ = false;
bool _force_render = false; bool force_render_ = false;
ring_buffer<Task, 16> _queue; RingBuffer<Task, 16> queue_;
Task _deferred_task{}; Task deferred_task_{};
bool _deferred_task_valid = false; bool deferred_task_valid_ = false;
void clear(); void clear();
void print(const String &msg); void print(const String &msg);
@@ -57,24 +57,24 @@ private:
void print(unsigned int i, int base = 10); void print(unsigned int i, int base = 10);
void print(int i, int base = 10); void print(int i, int base = 10);
bool is_message_task(task_type type); bool isMessageTask(task::Type type);
void activate_message(screen::lcd_screen msg_screen, unsigned long duration_ms); void activateMessage(screen::LcdScreen msg_screen, unsigned long duration_ms);
void expire_message_if_needed(unsigned long now); void expireMessageIfNeeded(unsigned long now);
screen::lcd_screen get_active_screen() const; screen::LcdScreen getActiveScreen() const;
int render_gps_debug(); int renderGpsDebug();
int render_driver_primary(); int renderDriverPrimary();
int render_msg_gps_fix(); int renderMsgGpsFix();
int render_msg_track_detect_ok(); int renderMsgTrackDetectOk();
int render_msg_config_no_tracks(); int renderMsgConfigNoTracks();
int render_msg_battery_low(); int renderMsgBatteryLow();
public: public:
int push(const Task &task) override; int push(const Task &task) override;
lcd(); Lcd();
lcd(system_logger *logger); Lcd(SystemLogger *logger);
~lcd(); ~Lcd();
int init(); int init();
int print_message(String message); int printMessage(String message);
int loop(unsigned long timeout_ms = 500); int loop(unsigned long timeout_ms = 500);
}; };

59
src/modules/logger/system_logger.cpp
View File

@@ -7,62 +7,57 @@
#include <stdio.h> #include <stdio.h>
system_logger::system_logger(HardwareSerial *output) SystemLogger::SystemLogger(HardwareSerial *output) { output_ = output; }
{
_output = output;
}
system_logger::~system_logger() SystemLogger::~SystemLogger() {}
{
}
int system_logger::print_message(String pre, String message) { int SystemLogger::printMessage(String prefix, String message) {
if (_output->availableForWrite()) { if (output_->availableForWrite()) {
_output->print(millis()); output_->print(millis());
_output->print(pre); output_->print(prefix);
_output->println(message); output_->println(message);
return 0; return 0;
} }
return 1; return 1;
} }
#ifdef INFO #ifdef INFO
int system_logger::info(String message) { int SystemLogger::info(String message) {
return this->print_message(" [INFO] ", message); return this->printMessage(" [INFO] ", message);
} }
int system_logger::dump_config() { int SystemLogger::dumpConfig() {
vehicle_config temp; VehicleConfig config;
config_global_read(temp); configGlobalRead(config);
char buffer[64]; char buffer[64];
// Auto detect // Auto detect
snprintf(buffer, sizeof(buffer), snprintf(buffer, sizeof(buffer),
"\tAuto detect tracks: %d", "\tAuto detect tracks: %d",
temp.auto_detect_track config.auto_detect_track_
); );
this->info(String(buffer)); this->info(String(buffer));
// Track fallback // Track fallback
snprintf(buffer, sizeof(buffer), snprintf(buffer, sizeof(buffer),
"\tTrack fallback: %d", "\tTrack fallback: %d",
temp.track_fallback config.track_fallback_
); );
this->info(String(buffer)); this->info(String(buffer));
this->info("\tVBAT cal factor: " + String(temp.vbat_calibration, 6)); this->info("\tVBAT cal factor: " + String(config.vbat_calibration_, 6));
this->info("\tVBAT low: " + String(temp.vbat_low, 2)); this->info("\tVBAT low: " + String(config.vbat_low_, 2));
this->info("\tTENG low: " + String(temp.teng_low, 2)); this->info("\tTENG low: " + String(config.teng_low_, 2));
this->info("\tTENG high: " + String(temp.teng_high, 2)); this->info("\tTENG high: " + String(config.teng_high_, 2));
// Track slots (one per line) // Track slots (one per line)
for (size_t i = 0; i < 8; i++) { for (size_t i = 0; i < 8; i++) {
snprintf(buffer, sizeof(buffer), snprintf(buffer, sizeof(buffer),
"\tTrack slot %d: %d", "\tTrack slot %d: %d",
i + 1, i + 1,
temp.track_slot_occupied[i] config.track_slot_occupied_[i]
); );
this->info(String(buffer)); this->info(String(buffer));
} }
@@ -74,25 +69,25 @@ int system_logger::dump_config() {
#endif #endif
#ifdef WARN #ifdef WARN
int system_logger::warn(String message) { int SystemLogger::warn(String message) {
return this->print_message(" [WARNING] ", message); return this->printMessage(" [WARNING] ", message);
} }
#endif #endif
#ifdef ERROR #ifdef ERROR
int system_logger::error(String message) { int SystemLogger::error(String message) {
return this->print_message(" [ERROR] ", message); return this->printMessage(" [ERROR] ", message);
} }
#endif #endif
#ifdef DEBUG #ifdef DEBUG
int system_logger::debug(String message) { int SystemLogger::debug(String message) {
return this->print_message(" [DEBUG] ", message); return this->printMessage(" [DEBUG] ", message);
} }
#endif #endif
#ifdef DEEP_DEBUG #ifdef DEEP_DEBUG
int system_logger::deep_debug(String message) { int SystemLogger::deepDebug(String message) {
return this->print_message(" [DEEP_DEBUG] ", message); return this->printMessage(" [DEEP_DEBUG] ", message);
} }
#endif #endif

15
src/modules/logger/system_logger.h
View File

@@ -11,17 +11,16 @@
#include "base/module_base.h" #include "base/module_base.h"
#include "data/config_store.h" #include "data/config_store.h"
class system_logger class SystemLogger {
{
private: private:
HardwareSerial *_output; HardwareSerial *output_;
int print_message(String pre, String message); int printMessage(String prefix, String message);
public: public:
system_logger(HardwareSerial *output); SystemLogger(HardwareSerial *output);
~system_logger(); ~SystemLogger();
#ifdef INFO #ifdef INFO
int info(String message); int info(String message);
int dump_config(); int dumpConfig();
#endif #endif
#ifdef WARN #ifdef WARN
@@ -37,6 +36,6 @@ public:
#endif #endif
#ifdef DEEP_DEBUG #ifdef DEEP_DEBUG
int deep_debug(String message); int deepDebug(String message);
#endif #endif
}; };

24
src/modules/thermocouple/thermocouple.cpp
View File

@@ -5,22 +5,26 @@
#include "thermocouple.h" #include "thermocouple.h"
#include "data/general_store.h" #include "data/general_store.h"
int thermocouple::push(const Task &task) { return _queue.push(task); } int Thermocouple::push(const Task &task) { return queue_.push(task); }
thermocouple::thermocouple() : _logger(nullptr) {} Thermocouple::Thermocouple() : logger_(nullptr) {}
thermocouple::thermocouple(system_logger *logger) : _logger(logger) {} Thermocouple::Thermocouple(SystemLogger *logger) : logger_(logger) {}
thermocouple::~thermocouple() {} Thermocouple::~Thermocouple() {}
int thermocouple::init() { int Thermocouple::init() {
_thermocouple = new MAX6675(THERMO_SCK, THERMO_CS, THERMO_SO); thermocouple_ = new MAX6675(THERMO_SCK, THERMO_CS, THERMO_SO);
return 0; return 0;
} }
int thermocouple::loop(unsigned long timeout_ms) { int Thermocouple::loop(unsigned long timeout_ms) {
if (millis() > _last_read + _update_interval) { (void)timeout_ms;
_temp = _thermocouple->readCelsius();
teng_global_write(_temp); if (millis() > last_read_at_ + update_interval_) {
temperature_ = thermocouple_->readCelsius();
tengGlobalWrite(temperature_);
last_read_at_ = millis();
} }
return 0;
} }

20
src/modules/thermocouple/thermocouple.h
View File

@@ -12,20 +12,20 @@
#include <Arduino.h> #include <Arduino.h>
#include <max6675.h> #include <max6675.h>
class thermocouple : public module_base { class Thermocouple : public ModuleBase {
private: private:
system_logger *_logger; SystemLogger *logger_;
ring_buffer<Task, 16> _queue; RingBuffer<Task, 16> queue_;
MAX6675 *_thermocouple; MAX6675 *thermocouple_;
double _temp; double temperature_;
unsigned long _update_interval = 1000; unsigned long update_interval_ = 1000;
unsigned long _last_read = 0; unsigned long last_read_at_ = 0;
public: public:
int push(const Task &task) override; int push(const Task &task) override;
thermocouple(); Thermocouple();
thermocouple(system_logger *logger); Thermocouple(SystemLogger *logger);
~thermocouple(); ~Thermocouple();
int init(); int init();
int loop(unsigned long timeout_ms = 500); int loop(unsigned long timeout_ms = 500);
}; };