From 3b2abd3f71548dd6ff09767c3ffcc63658b2ec50 Mon Sep 17 00:00:00 2001 From: Hector van der Aa Date: Sun, 29 Mar 2026 15:04:28 +0200 Subject: [PATCH] Refactor names to follow new convention --- src/base/module_base.h | 5 +- src/base/modules.cpp | 2 +- src/base/modules.h | 2 +- src/base/ring_buffer.h | 34 +- src/base/router.cpp | 26 +- src/base/router.h | 4 +- src/base/task.h | 81 ++-- src/custom_types.h | 65 ++-- src/data/config_store.cpp | 10 +- src/data/config_store.h | 6 +- src/data/eeprom_layout.h | 22 +- src/data/general_store.cpp | 10 +- src/data/general_store.h | 8 +- src/data/gps_store.cpp | 12 +- src/data/gps_store.h | 6 +- src/data/track_store.cpp | 30 +- src/data/track_store.h | 14 +- src/main.cpp | 57 ++- src/modules/battery/battery.cpp | 75 ++-- src/modules/battery/battery.h | 28 +- src/modules/cmd/cmd.cpp | 431 +++++++++++----------- src/modules/cmd/cmd.h | 102 ++--- src/modules/config/config.cpp | 360 +++++++++--------- src/modules/config/config.h | 76 ++-- src/modules/gps/gps.cpp | 84 ++--- src/modules/gps/gps.h | 22 +- src/modules/lcd/lcd.cpp | 364 +++++++++--------- src/modules/lcd/lcd.h | 76 ++-- src/modules/logger/system_logger.cpp | 59 ++- src/modules/logger/system_logger.h | 17 +- src/modules/thermocouple/thermocouple.cpp | 26 +- src/modules/thermocouple/thermocouple.h | 22 +- 32 files changed, 1073 insertions(+), 1063 deletions(-) diff --git a/src/base/module_base.h b/src/base/module_base.h index 55a274c..708ab26 100644 --- a/src/base/module_base.h +++ b/src/base/module_base.h @@ -4,8 +4,7 @@ #pragma once #include "base/task.h" -class module_base -{ +class ModuleBase { public: virtual int push(const Task& task) = 0; -}; \ No newline at end of file +}; diff --git a/src/base/modules.cpp b/src/base/modules.cpp index 2cd6363..0873bf0 100644 --- a/src/base/modules.cpp +++ b/src/base/modules.cpp @@ -3,4 +3,4 @@ // SPDX-License-Identifier: GPL-3.0-or-later #include "base/modules.h" -module_base* modules[MOD_COUNT] = {nullptr}; \ No newline at end of file +ModuleBase* module_registry[module::Count] = {nullptr}; diff --git a/src/base/modules.h b/src/base/modules.h index f98757b..673dc49 100644 --- a/src/base/modules.h +++ b/src/base/modules.h @@ -6,4 +6,4 @@ #include "base/module_base.h" #include "base/task.h" -extern module_base* modules[MOD_COUNT]; \ No newline at end of file +extern ModuleBase* module_registry[module::Count]; diff --git a/src/base/ring_buffer.h b/src/base/ring_buffer.h index 4d217e7..5a0e8ef 100644 --- a/src/base/ring_buffer.h +++ b/src/base/ring_buffer.h @@ -5,34 +5,34 @@ #include template -class ring_buffer { +class RingBuffer { private: - T _buffer[SIZE]; - volatile uint8_t _head = 0; - volatile uint8_t _tail = 0; - volatile uint8_t _count = 0; + T buffer_[SIZE]; + volatile uint8_t head_ = 0; + volatile uint8_t tail_ = 0; + volatile uint8_t count_ = 0; public: int push(const T& item) { - if (_count == SIZE) { + if (count_ == SIZE) { return 1; } - _buffer[_head] = item; - _head = (_head++) % SIZE; - _count++; + buffer_[head_] = item; + head_ = (head_++) % SIZE; + count_++; return 0; } int pop(T& item) { - if (_count == 0) { + if (count_ == 0) { return 1; } - item = _buffer[_tail]; - _tail = (_tail++) % SIZE; - _count--; + item = buffer_[tail_]; + tail_ = (tail_++) % SIZE; + count_--; return 0; } - bool is_empty() const { return _count == 0;} - bool is_full() const { return _count == SIZE;} - uint8_t size() const { return _count;} -}; \ No newline at end of file + bool isEmpty() const { return count_ == 0; } + bool isFull() const { return count_ == SIZE; } + uint8_t size() const { return count_; } +}; diff --git a/src/base/router.cpp b/src/base/router.cpp index 2efa14c..16783d4 100644 --- a/src/base/router.cpp +++ b/src/base/router.cpp @@ -6,37 +6,37 @@ namespace router { int send(const Task &task) { - if (task.target == MOD_ALL) { + if (task.target_ == module::All) { 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; } - if (mod->push(task) != 0) { + if (module_ptr->push(task) != 0) { ret = 1; } } return ret; } - if (task.target >= MOD_COUNT) { + if (task.target_ >= module::Count) { 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 mod->push(task); + return module_ptr->push(task); } -int send(module_id target, task_type type, uint32_t data) { - Task t{target, type, data}; - return send(t); +int send(module::Id target, task::Type type, uint32_t data) { + Task task{target, type, data}; + return send(task); } -} // namespace router \ No newline at end of file +} // namespace router diff --git a/src/base/router.h b/src/base/router.h index 7e634e1..9f852e8 100644 --- a/src/base/router.h +++ b/src/base/router.h @@ -9,5 +9,5 @@ namespace router { int send(const Task& task); - int send(module_id target, task_type type, uint32_t data = 0); -} \ No newline at end of file + int send(module::Id target, task::Type type, uint32_t data = 0); +} diff --git a/src/base/task.h b/src/base/task.h index 1de840e..217af0f 100644 --- a/src/base/task.h +++ b/src/base/task.h @@ -5,46 +5,53 @@ #include #include -enum module_id : uint8_t { - // modules/cmd - MOD_CMD, - // modules/config - MOD_CFG, - // modules/gps - MOD_GPS, - // modules/lcd - MOD_LCD, - // modules/battery - MOD_BAT, - // modules/thermocouple - MOD_THC, - MOD_COUNT, - MOD_NULL, - MOD_ALL, +namespace module { + +enum Id : uint8_t { + Cmd, + Config, + Gps, + Lcd, + Battery, + Thermocouple, + Count, + Null, + All, }; -enum task_type : uint8_t { - TASK_NULL, - TASK_DISPLAY_GPS_DEBUG, - TASK_DISPLAY_DRIVER_PRIMARY, - TASK_DISPLAY_MSG_GPS_FIX, - TASK_DISPLAY_MSG_TRACK_DETECT_OK, - TASK_DISPLAY_MSG_CONFIG_NO_TRACKS, - TASK_DISPLAY_MSG_BAT_LOW, - TASK_CONFIG_TRACK_DETECT, - TASK_CONFIG_WRITE_TEMP_TRACK, - TASK_CONFIG_TRACK_DELETE, - TASK_CONFIG_CFG_RESET, - TASK_CONFIG_VBAT_CAL_SET, - TASK_CONFIG_VBAT_SET_LOW, - TASK_CONFIG_TENG_SET_LOW, - TASK_CONFIG_TENG_SET_HIGH, - TASK_BATTERY_CAL, - TASK_ALL_CONFIG_UPDATED, +} // namespace module + +namespace task { + +enum Type : uint8_t { + Null, + DisplayGpsDebug, + DisplayDriverPrimary, + DisplayMsgGpsFix, + DisplayMsgTrackDetectOk, + DisplayMsgConfigNoTracks, + DisplayMsgBatteryLow, + ConfigTrackDetect, + ConfigWriteTempTrack, + ConfigTrackDelete, + ConfigReset, + ConfigVbatCalSet, + ConfigVbatSetLow, + ConfigTengSetLow, + ConfigTengSetHigh, + BatteryCal, + AllConfigUpdated, }; +} // namespace task + struct Task { - module_id target; - task_type type; - uint32_t data; + Task(module::Id target = module::Null, + task::Type type = task::Null, + uint32_t data = 0) + : target_(target), type_(type), data_(data) {} + + module::Id target_; + task::Type type_; + uint32_t data_; }; diff --git a/src/custom_types.h b/src/custom_types.h index c055155..9ba2640 100644 --- a/src/custom_types.h +++ b/src/custom_types.h @@ -6,51 +6,52 @@ #include #define CONFIG_MAGIC 0xBEEF -struct vehicle_config{ - uint16_t magic = CONFIG_MAGIC; - bool auto_detect_track = true; - uint8_t track_fallback = 0; - bool track_slot_occupied[8] = {false}; - double vbat_calibration = 0; - double vbat_low = 0; - double teng_low = 0; - double teng_high = 0; + +struct VehicleConfig { + uint16_t magic_ = CONFIG_MAGIC; + bool auto_detect_track_ = true; + uint8_t track_fallback_ = 0; + bool track_slot_occupied_[8] = {false}; + double vbat_calibration_ = 0; + double vbat_low_ = 0; + double teng_low_ = 0; + double teng_high_ = 0; }; -struct lat_lng { - double lat; - double lng; +struct LatLng { + double lat_; + double lng_; }; -struct track_data { - uint16_t magic = CONFIG_MAGIC; - unsigned short id; - char name[21]; - lat_lng pt_a; - lat_lng pt_b; +struct TrackData { + uint16_t magic_ = CONFIG_MAGIC; + unsigned short id_; + char name_[21]; + LatLng point_a_; + LatLng point_b_; }; -struct gps_sub_data { - uint32_t age; - bool valid; - double value; +struct GpsSubData { + uint32_t age_; + bool valid_; + double value_; }; -struct gps_data { - gps_sub_data altitude; - gps_sub_data lat; - gps_sub_data lng; - gps_sub_data speed; - gps_sub_data course; - uint32_t num_fix; +struct GpsData { + GpsSubData altitude_; + GpsSubData lat_; + GpsSubData lng_; + GpsSubData speed_; + GpsSubData course_; + uint32_t num_fix_; }; template -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)); } template -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)); -} \ No newline at end of file +} diff --git a/src/data/config_store.cpp b/src/data/config_store.cpp index 6fa2c41..c255475 100644 --- a/src/data/config_store.cpp +++ b/src/data/config_store.cpp @@ -3,12 +3,12 @@ // SPDX-License-Identifier: GPL-3.0-or-later #include "data/config_store.h" - volatile vehicle_config config_global = {}; + volatile VehicleConfig config_global = {}; - void config_global_read(vehicle_config& out) { - copy_from_volatile(out, config_global); + void configGlobalRead(VehicleConfig& out) { + copyFromVolatile(out, config_global); } - void config_global_write(const vehicle_config& in) { - copy_to_volatile(config_global, in); + void configGlobalWrite(const VehicleConfig& in) { + copyToVolatile(config_global, in); } diff --git a/src/data/config_store.h b/src/data/config_store.h index e346526..950d662 100644 --- a/src/data/config_store.h +++ b/src/data/config_store.h @@ -6,7 +6,7 @@ #include "custom_types.h" #include -extern volatile vehicle_config config_global; +extern volatile VehicleConfig config_global; -void config_global_read(vehicle_config& out); -void config_global_write(const vehicle_config& in); \ No newline at end of file +void configGlobalRead(VehicleConfig& out); +void configGlobalWrite(const VehicleConfig& in); diff --git a/src/data/eeprom_layout.h b/src/data/eeprom_layout.h index 61b780d..9ddf4ae 100644 --- a/src/data/eeprom_layout.h +++ b/src/data/eeprom_layout.h @@ -7,19 +7,19 @@ namespace eeprom_layout { -static const uint16_t total_bytes = 4096; -static const uint16_t config_addr = 0; -static const uint16_t config_reserved_bytes = 256; -static const uint16_t track_slots = 8; -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_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 TOTAL_BYTES = 4096; +static const uint16_t CONFIG_ADDR = 0; +static const uint16_t CONFIG_RESERVED_BYTES = 256; +static const uint16_t TRACK_SLOTS = 8; +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_END_ADDR = TRACK_BASE_ADDR + (TRACK_SLOTS * TRACK_SLOT_BYTES); +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) { - return track_base_addr + ((idx - 1) * track_slot_bytes); +inline uint16_t trackSlotAddr(uint8_t idx) { + return TRACK_BASE_ADDR + ((idx - 1) * TRACK_SLOT_BYTES); } } // namespace eeprom_layout diff --git a/src/data/general_store.cpp b/src/data/general_store.cpp index b553081..05dca47 100644 --- a/src/data/general_store.cpp +++ b/src/data/general_store.cpp @@ -6,18 +6,18 @@ volatile double vbat_global = 0; volatile double teng_global = 0; - void vbat_global_read(double& out) { + void vbatGlobalRead(double& out) { out = vbat_global; } - void vbat_global_write(const double& in) { + void vbatGlobalWrite(const double& in) { vbat_global = in; } - void teng_global_read(double& out) { + void tengGlobalRead(double& out) { out = vbat_global; } - void teng_global_write(const double& in) { + void tengGlobalWrite(const double& in) { vbat_global = in; - } \ No newline at end of file + } diff --git a/src/data/general_store.h b/src/data/general_store.h index 3b5ac6c..a6babf8 100644 --- a/src/data/general_store.h +++ b/src/data/general_store.h @@ -6,8 +6,8 @@ extern volatile double vbat_global; extern volatile double teng_global; -void vbat_global_read(double& out); -void vbat_global_write(const double& in); +void vbatGlobalRead(double& out); +void vbatGlobalWrite(const double& in); -void teng_global_read(double& out); -void teng_global_write(const double& in); \ No newline at end of file +void tengGlobalRead(double& out); +void tengGlobalWrite(const double& in); diff --git a/src/data/gps_store.cpp b/src/data/gps_store.cpp index 0afdb02..064f1e5 100644 --- a/src/data/gps_store.cpp +++ b/src/data/gps_store.cpp @@ -3,12 +3,12 @@ // SPDX-License-Identifier: GPL-3.0-or-later #include "gps_store.h" - volatile gps_data gps_data_global = {}; + volatile GpsData gps_data_global = {}; - void gps_global_read(gps_data& out) { - copy_from_volatile(out, gps_data_global); + void gpsGlobalRead(GpsData& out) { + copyFromVolatile(out, gps_data_global); } - void gps_global_write(const gps_data& in) { - copy_to_volatile(gps_data_global, in); - } \ No newline at end of file + void gpsGlobalWrite(const GpsData& in) { + copyToVolatile(gps_data_global, in); + } diff --git a/src/data/gps_store.h b/src/data/gps_store.h index 734ac62..3942f14 100644 --- a/src/data/gps_store.h +++ b/src/data/gps_store.h @@ -5,7 +5,7 @@ #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 gps_global_write(const gps_data& in); \ No newline at end of file +void gpsGlobalRead(GpsData& out); +void gpsGlobalWrite(const GpsData& in); diff --git a/src/data/track_store.cpp b/src/data/track_store.cpp index cf8077f..f2b73f4 100644 --- a/src/data/track_store.cpp +++ b/src/data/track_store.cpp @@ -4,34 +4,34 @@ #include "data/track_store.h" #include "data/eeprom_layout.h" - volatile track_data track_data_global = {}; -volatile track_data track_data_temp_global = {}; + volatile TrackData track_data_global = {}; +volatile TrackData track_data_temp_global = {}; - void track_global_read(track_data& out) { - copy_from_volatile(out, track_data_global); + void trackGlobalRead(TrackData& out) { + 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) { return 1; } - track_data temp; - EEPROM.get(eeprom_layout::track_slot_addr(idx), temp); - if (temp.magic != CONFIG_MAGIC) { + TrackData track_data; + EEPROM.get(eeprom_layout::trackSlotAddr(idx), track_data); + if (track_data.magic_ != CONFIG_MAGIC) { return 1; } - out = temp; + out = track_data; return 0; } - void track_global_write(const track_data& in) { - copy_to_volatile(track_data_global, in); + void trackGlobalWrite(const TrackData& in) { + copyToVolatile(track_data_global, in); } - void track_temp_global_read(track_data& out) { - copy_from_volatile(out, track_data_temp_global); + void trackTempGlobalRead(TrackData& out) { + copyFromVolatile(out, track_data_temp_global); } - void track_temp_global_write(const track_data& in) { - copy_to_volatile(track_data_temp_global, in); + void trackTempGlobalWrite(const TrackData& in) { + copyToVolatile(track_data_temp_global, in); } diff --git a/src/data/track_store.h b/src/data/track_store.h index 146fce2..6295eba 100644 --- a/src/data/track_store.h +++ b/src/data/track_store.h @@ -6,12 +6,12 @@ #include "custom_types.h" #include -extern volatile track_data track_data_global; -extern volatile track_data track_data_temp_global; +extern volatile TrackData track_data_global; +extern volatile TrackData track_data_temp_global; -void track_global_read(track_data& out); -int track_global_read(unsigned short idx, track_data& out); -void track_global_write(const track_data& in); +void trackGlobalRead(TrackData& out); +int trackGlobalRead(unsigned short idx, TrackData& out); +void trackGlobalWrite(const TrackData& in); -void track_temp_global_read(track_data& out); -void track_temp_global_write(const track_data& in); \ No newline at end of file +void trackTempGlobalRead(TrackData& out); +void trackTempGlobalWrite(const TrackData& in); diff --git a/src/main.cpp b/src/main.cpp index 0a66fb4..3783f2f 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -16,63 +16,62 @@ #include "modules/battery/battery.h" +SystemLogger *logger = new SystemLogger(&Serial); -system_logger *logger_output = new system_logger(&Serial); - -lcd *driver_display = new lcd(logger_output); -gps *gps_module = new gps(&Serial2, logger_output); -config *system_config = new config(logger_output); -cmd *command_handler = new cmd(&Serial, logger_output); -battery *battery_handler = new battery(logger_output); +Lcd *display = new Lcd(logger); +Gps *gps_module = new Gps(&Serial2, logger); +Config *system_config = new Config(logger); +Cmd *command_handler = new Cmd(&Serial, logger); +Battery *battery_module = new Battery(logger); void setup() { wdt_disable(); - modules[MOD_LCD] = driver_display; - modules[MOD_GPS] = gps_module; - modules[MOD_CFG] = system_config; - modules[MOD_CMD] = command_handler; - modules[MOD_BAT] = battery_handler; + module_registry[module::Lcd] = display; + module_registry[module::Gps] = gps_module; + module_registry[module::Config] = system_config; + module_registry[module::Cmd] = command_handler; + module_registry[module::Battery] = battery_module; - driver_display->init(); - driver_display->print_message("Starting Initialization"); + display->init(); + display->printMessage("Starting Initialization"); delay(1000); - driver_display->print_message("Cmd Init..."); + display->printMessage("Cmd Init..."); command_handler->init(); delay(1000); - driver_display->print_message("Cmd Init Complete"); + display->printMessage("Cmd Init Complete"); delay(1000); - driver_display->print_message("Config Init..."); - int result = system_config->auto_init(); + display->printMessage("Config Init..."); + int result = system_config->autoInit(); delay(1000); if (result != 0) { - driver_display->print_message("Configuration Read Failed"); + display->printMessage("Configuration Read Failed"); } else { - driver_display->print_message("Config Init Complete"); + display->printMessage("Config Init Complete"); } delay(1000); - driver_display->print_message("GPS Init..."); + display->printMessage("GPS Init..."); gps_module->init(); delay(1000); - driver_display->print_message("GPS Init Complete"); + display->printMessage("GPS Init Complete"); delay(1000); - driver_display->print_message("Sensors Init..."); - battery_handler->init(); + display->printMessage("Sensors Init..."); + battery_module->init(); delay(1000); - driver_display->print_message("Sensors Init Complete"); + display->printMessage("Sensors Init Complete"); delay(1000); - router::send(MOD_LCD, TASK_DISPLAY_DRIVER_PRIMARY); + router::send(module::Lcd, task::DisplayDriverPrimary); } void loop() { gps_module->loop(); - driver_display->loop(); - command_handler->parse_task(); + display->loop(); + command_handler->parseTask(); system_config->loop(); - battery_handler->loop(); + battery_module->loop(); } diff --git a/src/modules/battery/battery.cpp b/src/modules/battery/battery.cpp index e05fb91..325a4f8 100644 --- a/src/modules/battery/battery.cpp +++ b/src/modules/battery/battery.cpp @@ -7,67 +7,72 @@ #include "data/config_store.h" #include "data/general_store.h" -int battery::calibrate(const Task &task) { +int Battery::calibrate(const Task &task) { double actual_voltage; - memcpy(&actual_voltage, &task.data, sizeof(double)); + memcpy(&actual_voltage, &task.data_, sizeof(double)); int adc_read = analogRead(VBAT_PIN); double cal_factor = actual_voltage / adc_read; uint32_t output_val; 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; } -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); - vehicle_config config; - config_global_read(config); - _cal = config.vbat_calibration; - _low = config.vbat_low; + VehicleConfig config; + configGlobalRead(config); + calibration_ = config.vbat_calibration_; + low_threshold_ = config.vbat_low_; + return 0; } -int battery::loop(unsigned long timeout_ms) { - if (millis() > _last_read + _update_interval) { - int adc_read = analogRead(VBAT_PIN); - _vbat = _cal * adc_read; +int Battery::loop(unsigned long timeout_ms) { + (void)timeout_ms; - vbat_global_write(_vbat); - if (_vbat < _low) { - if (_warning_sent == 0 || millis() > _warning_sent + _warning_timeout) { - router::send(MOD_LCD, TASK_DISPLAY_MSG_BAT_LOW, 2000); - _warning_sent = millis(); + if (millis() > last_read_at_ + update_interval_) { + int adc_read = analogRead(VBAT_PIN); + vbat_ = calibration_ * adc_read; + + vbatGlobalWrite(vbat_); + if (vbat_ < low_threshold_) { + if (warning_sent_at_ == 0 || millis() > warning_sent_at_ + warning_timeout_) { + router::send(module::Lcd, task::DisplayMsgBatteryLow, 2000); + warning_sent_at_ = millis(); } } + last_read_at_ = millis(); } - Task active_task; - int res = _queue.pop(active_task); - if (res == 0) { - if (active_task.target == MOD_BAT) { - switch (active_task.type) { - case TASK_BATTERY_CAL: + Task active_task; + int res = queue_.pop(active_task); + if (res == 0) { + if (active_task.target_ == module::Battery) { + + switch (active_task.type_) { + case task::BatteryCal: this->calibrate(active_task); break; default: break; } - } else if (active_task.target == MOD_ALL) { - switch (active_task.type) + } else if (active_task.target_ == module::All) { + switch (active_task.type_) { - case TASK_ALL_CONFIG_UPDATED: { - vehicle_config config; - config_global_read(config); - _cal = config.vbat_calibration; - _low = config.vbat_low; + case task::AllConfigUpdated: { + VehicleConfig config; + configGlobalRead(config); + calibration_ = config.vbat_calibration_; + low_threshold_ = config.vbat_low_; break; } @@ -77,4 +82,4 @@ int battery::loop(unsigned long timeout_ms) { } } return 0; -} \ No newline at end of file +} diff --git a/src/modules/battery/battery.h b/src/modules/battery/battery.h index c0fdc95..3933278 100644 --- a/src/modules/battery/battery.h +++ b/src/modules/battery/battery.h @@ -9,25 +9,25 @@ #include "modules/logger/system_logger.h" #include -class battery : public module_base { +class Battery : public ModuleBase { private: - system_logger *_logger; - ring_buffer _queue; - double _vbat = 0; - double _cal = 0; - double _low = 0; - unsigned long _warning_sent = 0; - unsigned long _warning_timeout = 10000; - unsigned long _update_interval = 1000; - unsigned long _last_read = 0; + SystemLogger *logger_; + RingBuffer queue_; + double vbat_ = 0; + double calibration_ = 0; + double low_threshold_ = 0; + unsigned long warning_sent_at_ = 0; + unsigned long warning_timeout_ = 10000; + unsigned long update_interval_ = 1000; + unsigned long last_read_at_ = 0; int calibrate(const Task& task); public: int push(const Task &task) override; - battery(); - battery(system_logger *logger); - ~battery(); + Battery(); + Battery(SystemLogger *logger); + ~Battery(); int init(); int loop(unsigned long timeout_ms = 500); -}; \ No newline at end of file +}; diff --git a/src/modules/cmd/cmd.cpp b/src/modules/cmd/cmd.cpp index bae8f40..f1764c5 100644 --- a/src/modules/cmd/cmd.cpp +++ b/src/modules/cmd/cmd.cpp @@ -10,7 +10,7 @@ #include "data/general_store.h" #include "base/router.h" -char *cmd::trim_arg(char *input) { +char *Cmd::trimArg(char *input) { if (input == nullptr) { return nullptr; } @@ -33,7 +33,7 @@ char *cmd::trim_arg(char *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; char *p = 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; *p = '\0'; - argv[argc] = trim_arg(token_start); + argv[argc] = trimArg(token_start); argc++; if (separator == '\0') { @@ -67,71 +67,71 @@ unsigned short cmd::split_args(char *input, char *argv[], unsigned short max_arg return argc; } -cmd::command_id cmd::parse_command_name(const char *input) { +Cmd::CommandId Cmd::parseCommandName(const char *input) { if (input == nullptr) { - return CMD_UNKNOWN; + return Unknown; } if (strcmp(input, "REBOOT") == 0) { - return CMD_REBOOT; + return Reboot; } if (strcmp(input, "CFG_DUMP") == 0) { - return CMD_CFG_DUMP; + return ConfigDump; } if (strcmp(input, "TRACK_PUT") == 0) { - return CMD_PUT_TRACK; + return PutTrack; } if (strcmp(input, "TRACK_DELETE") == 0) { - return CMD_DELETE_TRACK; + return DeleteTrack; } if (strcmp(input, "TRACK_DUMP") == 0) { - return CMD_DUMP_TRACK; + return DumpTrack; } if (strcmp(input, "CFG_RESET") == 0) { - return CMD_CFG_RESET; + return ConfigReset; } if (strcmp(input, "TRACK_AUTODETECT") == 0) { - return CMD_TRACK_AUTODETECT; + return TrackAutodetect; } if (strcmp(input, "DISPLAY_GPS_DEBUG") == 0) { - return CMD_DISPLAY_GPS_DEBUG; + return DisplayGpsDebug; } if (strcmp(input, "DISPLAY_DRIVER_PRIMARY") == 0) { - return CMD_DISPLAY_DRIVER_PRIMARY; + return DisplayDriverPrimary; } if (strcmp(input, "BATTERY_CAL") == 0) { - return CMD_BATTERY_CAL; + return BatteryCal; } if (strcmp(input, "BATTERY_PRINT_VBAT") == 0) { - return CMD_BATTERY_PRINT_VBAT; + return BatteryPrintVbat; } if (strcmp(input, "BATTERY_SET_LOW") == 0) { - return CMD_BATTERY_SET_LOW; + return BatterySetLow; } if (strcmp(input, "THERMO_SET_LOW") == 0) { - return CMD_THERMO_SET_LOW; + return ThermoSetLow; } 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') { return 1; } @@ -144,51 +144,51 @@ int cmd::parse_track_slot_id(const char *id_str, unsigned short &id_out) { return 0; } -int cmd::dump_track_slot(unsigned short id) { - vehicle_config cfg; - config_global_read(cfg); - bool occupied = cfg.track_slot_occupied[id - 1]; +int Cmd::dumpTrackSlot(unsigned short id) { + VehicleConfig config; + configGlobalRead(config); + bool occupied = config.track_slot_occupied_[id - 1]; - track_data track; - int res = track_global_read(id, track); - if (res != 0) { + TrackData track_data; + int result = trackGlobalRead(id, track_data); + if (result != 0) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("Track slot " + String(id) + " has no valid track data"); + if (logger_ != nullptr) { + logger_->error("Track slot " + String(id) + " has no valid track data"); } #endif return 1; } #ifdef INFO - if (_logger != nullptr) { - _logger->info("Track dump for slot " + String(id)); - _logger->info(String("\tOccupied flag: ") + String(occupied)); - _logger->info(String("\tID: ") + String(track.id)); - _logger->info(String("\tName: ") + String(track.name)); - _logger->info(String("\tPoint A lat: ") + String(track.pt_a.lat, 6)); - _logger->info(String("\tPoint A lng: ") + String(track.pt_a.lng, 6)); - _logger->info(String("\tPoint B lat: ") + String(track.pt_b.lat, 6)); - _logger->info(String("\tPoint B lng: ") + String(track.pt_b.lng, 6)); + if (logger_ != nullptr) { + logger_->info("Track dump for slot " + String(id)); + logger_->info(String("\tOccupied flag: ") + String(occupied)); + logger_->info(String("\tID: ") + String(track_data.id_)); + logger_->info(String("\tName: ") + String(track_data.name_)); + logger_->info(String("\tPoint A lat: ") + String(track_data.point_a_.lat_, 6)); + logger_->info(String("\tPoint A lng: ") + String(track_data.point_a_.lng_, 6)); + logger_->info(String("\tPoint B lat: ") + String(track_data.point_b_.lat_, 6)); + logger_->info(String("\tPoint B lng: ") + String(track_data.point_b_.lng_, 6)); } #endif return 0; } -int cmd::handle_reboot_command(unsigned short argc) { +int Cmd::handleRebootCommand(unsigned short argc) { if (argc != 1) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("REBOOT expects no arguments"); + if (logger_ != nullptr) { + logger_->error("REBOOT expects no arguments"); } #endif return 1; } #ifdef INFO - if (_logger != nullptr) { - _logger->info("Rebooting"); + if (logger_ != nullptr) { + logger_->info("Rebooting"); } #endif delay(200); @@ -198,196 +198,196 @@ int cmd::handle_reboot_command(unsigned short argc) { return 0; } -int cmd::handle_dumpcfg_command(unsigned short argc) { +int Cmd::handleDumpConfigCommand(unsigned short argc) { if (argc != 1) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("DUMPCFG expects no arguments"); + if (logger_ != nullptr) { + logger_->error("DUMPCFG expects no arguments"); } #endif return 1; } #ifdef INFO - if (_logger != nullptr) { - _logger->dump_config(); + if (logger_ != nullptr) { + logger_->dumpConfig(); } #endif return 0; } -int cmd::handle_track_put_command(unsigned short argc, char *argv[]) { +int Cmd::handleTrackPutCommand(unsigned short argc, char *argv[]) { if (argc != 7) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("TRACK_PUT expects 6 arguments"); + if (logger_ != nullptr) { + logger_->error("TRACK_PUT expects 6 arguments"); } #endif return 1; } - track_data new_track; - if (parse_track_slot_id(argv[1], new_track.id) != 0) { + TrackData new_track; + if (parseTrackSlotId(argv[1], new_track.id_) != 0) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error(String("ID out of range: ") + String(argv[1])); + if (logger_ != nullptr) { + logger_->error(String("ID out of range: ") + String(argv[1])); } #endif return 1; } - strncpy(new_track.name, argv[2], sizeof(new_track.name) - 1); - new_track.name[sizeof(new_track.name) - 1] = '\0'; + strncpy(new_track.name_, argv[2], sizeof(new_track.name_) - 1); + new_track.name_[sizeof(new_track.name_) - 1] = '\0'; - lat_lng pt_a; - pt_a.lat = strtod(argv[3], nullptr); - pt_a.lng = strtod(argv[4], nullptr); - new_track.pt_a = pt_a; + LatLng point_a; + point_a.lat_ = strtod(argv[3], nullptr); + point_a.lng_ = strtod(argv[4], nullptr); + new_track.point_a_ = point_a; - lat_lng pt_b; - pt_b.lat = strtod(argv[5], nullptr); - pt_b.lng = strtod(argv[6], nullptr); - new_track.pt_b = pt_b; + LatLng point_b; + point_b.lat_ = strtod(argv[5], nullptr); + point_b.lng_ = strtod(argv[6], nullptr); + new_track.point_b_ = point_b; #ifdef INFO - if (_logger != nullptr) { - _logger->info("Loading new track"); - _logger->info(String("ID: ") + String(new_track.id)); - _logger->info(String("Name: ") + new_track.name); - _logger->info(String("Point A lat: ") + String(new_track.pt_a.lat)); - _logger->info(String("Point A lng: ") + String(new_track.pt_a.lng)); - _logger->info(String("Point B lat: ") + String(new_track.pt_b.lat)); - _logger->info(String("Point B lng: ") + String(new_track.pt_b.lng)); + if (logger_ != nullptr) { + logger_->info("Loading new track"); + logger_->info(String("ID: ") + String(new_track.id_)); + logger_->info(String("Name: ") + new_track.name_); + logger_->info(String("Point A lat: ") + String(new_track.point_a_.lat_)); + logger_->info(String("Point A lng: ") + String(new_track.point_a_.lng_)); + logger_->info(String("Point B lat: ") + String(new_track.point_b_.lat_)); + logger_->info(String("Point B lng: ") + String(new_track.point_b_.lng_)); } #endif - track_temp_global_write(new_track); - return router::send(MOD_CFG, TASK_CONFIG_WRITE_TEMP_TRACK); + trackTempGlobalWrite(new_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) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("TRACK_DELETE expects 1 argument"); + if (logger_ != nullptr) { + logger_->error("TRACK_DELETE expects 1 argument"); } #endif return 1; } unsigned short id; - if (parse_track_slot_id(argv[1], id) != 0) { + if (parseTrackSlotId(argv[1], id) != 0) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error(String("ID out of range: ") + String(argv[1])); + if (logger_ != nullptr) { + logger_->error(String("ID out of range: ") + String(argv[1])); } #endif 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) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("TRACK_DUMP expects 1 argument"); + if (logger_ != nullptr) { + logger_->error("TRACK_DUMP expects 1 argument"); } #endif return 1; } unsigned short id; - if (parse_track_slot_id(argv[1], id) != 0) { + if (parseTrackSlotId(argv[1], id) != 0) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error(String("ID out of range: ") + String(argv[1])); + if (logger_ != nullptr) { + logger_->error(String("ID out of range: ") + String(argv[1])); } #endif 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) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("CFG_RESET expects no arguments"); + if (logger_ != nullptr) { + logger_->error("CFG_RESET expects no arguments"); } #endif return 1; } #ifdef INFO - if (_logger != nullptr) { - _logger->info("Resetting config"); + if (logger_ != nullptr) { + logger_->info("Resetting config"); } #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) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("TRACK_AUTODETECT expects no arguments"); + if (logger_ != nullptr) { + logger_->error("TRACK_AUTODETECT expects no arguments"); } #endif return 1; } #ifdef INFO - if (_logger != nullptr) { - _logger->info("Detecting track"); + if (logger_ != nullptr) { + logger_->info("Detecting track"); } #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) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("DISPLAY_GPS_DEBUG expects no arguments"); + if (logger_ != nullptr) { + logger_->error("DISPLAY_GPS_DEBUG expects no arguments"); } #endif return 1; } #ifdef INFO - if (_logger != nullptr) { - _logger->info("Switching to GPS_DEBUG display"); + if (logger_ != nullptr) { + logger_->info("Switching to GPS_DEBUG display"); } #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) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("DISPLAY_DRIVER_PRIMARY expects no arguments"); + if (logger_ != nullptr) { + logger_->error("DISPLAY_DRIVER_PRIMARY expects no arguments"); } #endif return 1; } #ifdef INFO - if (_logger != nullptr) { - _logger->info("Switching to DRIVER_PRIMARY display"); + if (logger_ != nullptr) { + logger_->info("Switching to DRIVER_PRIMARY display"); } #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) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("BATTERY_CAL expects 1 argument"); + if (logger_ != nullptr) { + logger_->error("BATTERY_CAL expects 1 argument"); } #endif return 1; @@ -396,19 +396,19 @@ int cmd::handle_battery_cal(unsigned short argc, char *argv[]) { uint32_t task_data; memcpy(&task_data, &vbat, sizeof(uint32_t)); #ifdef INFO - if (_logger != nullptr) { - _logger->info("Calibrating VBAT"); + if (logger_ != nullptr) { + logger_->info("Calibrating VBAT"); } #endif - router::send(MOD_BAT, TASK_BATTERY_CAL, task_data); + router::send(module::Battery, task::BatteryCal, task_data); return 0; } -int cmd::handle_battery_print_vbat(unsigned short argc) { +int Cmd::handleBatteryPrintVbat(unsigned short argc) { if (argc != 1) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("BATTERY_PRINT_VBAT expects no arguments"); + if (logger_ != nullptr) { + logger_->error("BATTERY_PRINT_VBAT expects no arguments"); } #endif return 1; @@ -416,18 +416,19 @@ int cmd::handle_battery_print_vbat(unsigned short argc) { #ifdef INFO double vbat; - vbat_global_read(vbat); - if (_logger != nullptr) { - _logger->info("VBAT: " + String(vbat)); + vbatGlobalRead(vbat); + if (logger_ != nullptr) { + logger_->info("VBAT: " + String(vbat)); } #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) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("BATTERY_SET_LOW expects 1 argument"); + if (logger_ != nullptr) { + logger_->error("BATTERY_SET_LOW expects 1 argument"); } #endif return 1; @@ -436,19 +437,19 @@ int cmd::handle_battery_set_low(unsigned short argc, char* argv[]) { uint32_t task_data; memcpy(&task_data, &low, sizeof(uint32_t)); #ifdef INFO - if (_logger != nullptr) { - _logger->info("Setting warning level for VBAT"); + if (logger_ != nullptr) { + logger_->info("Setting warning level for VBAT"); } #endif - router::send(MOD_CFG, TASK_CONFIG_VBAT_SET_LOW, task_data); + router::send(module::Config, task::ConfigVbatSetLow, task_data); return 0; } -int cmd::handle_thermo_set_low(unsigned short argc, char* argv[]) { +int Cmd::handleThermoSetLow(unsigned short argc, char* argv[]) { if (argc != 2) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("THERMO_SET_LOW expects 1 argument"); + if (logger_ != nullptr) { + logger_->error("THERMO_SET_LOW expects 1 argument"); } #endif return 1; @@ -457,19 +458,19 @@ int cmd::handle_thermo_set_low(unsigned short argc, char* argv[]) { uint32_t task_data; memcpy(&task_data, &low, sizeof(uint32_t)); #ifdef INFO - if (_logger != nullptr) { - _logger->info("Setting low level for TENG"); + if (logger_ != nullptr) { + logger_->info("Setting low level for TENG"); } #endif - router::send(MOD_CFG, TASK_CONFIG_TENG_SET_LOW, task_data); + router::send(module::Config, task::ConfigTengSetLow, task_data); return 0; } -int cmd::handle_thermo_set_high(unsigned short argc, char* argv[]) { +int Cmd::handleThermoSetHigh(unsigned short argc, char* argv[]) { if (argc != 2) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("THERMO_SET_HIGH expects 1 argument"); + if (logger_ != nullptr) { + logger_->error("THERMO_SET_HIGH expects 1 argument"); } #endif return 1; @@ -478,156 +479,156 @@ int cmd::handle_thermo_set_high(unsigned short argc, char* argv[]) { uint32_t task_data; memcpy(&task_data, &low, sizeof(uint32_t)); #ifdef INFO - if (_logger != nullptr) { - _logger->info("Setting high level for TENG"); + if (logger_ != nullptr) { + logger_->info("Setting high level for TENG"); } #endif - router::send(MOD_CFG, TASK_CONFIG_TENG_SET_LOW, task_data); + router::send(module::Config, task::ConfigTengSetLow, task_data); return 0; } -int cmd::handle_unknown_command(unsigned short argc, char *argv[]) { +int Cmd::handleUnknownCommand(unsigned short argc, char *argv[]) { #ifdef ERROR - if (_logger != nullptr) { + if (logger_ != nullptr) { 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 { - _logger->error("Unknown command"); + logger_->error("Unknown command"); } } #endif 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) { - case CMD_REBOOT: - return this->handle_reboot_command(argc); + case Reboot: + return this->handleRebootCommand(argc); - case CMD_CFG_DUMP: - return this->handle_dumpcfg_command(argc); + case ConfigDump: + return this->handleDumpConfigCommand(argc); - case CMD_PUT_TRACK: - return this->handle_track_put_command(argc, argv); + case PutTrack: + return this->handleTrackPutCommand(argc, argv); - case CMD_DELETE_TRACK: - return this->handle_track_delete_command(argc, argv); + case DeleteTrack: + return this->handleTrackDeleteCommand(argc, argv); - case CMD_DUMP_TRACK: - return this->handle_track_dump_command(argc, argv); + case DumpTrack: + return this->handleTrackDumpCommand(argc, argv); - case CMD_CFG_RESET: - return this->handle_cfg_reset_command(argc); + case ConfigReset: + return this->handleConfigResetCommand(argc); - case CMD_TRACK_AUTODETECT: - return this->handle_track_autodetect_command(argc); + case TrackAutodetect: + return this->handleTrackAutodetectCommand(argc); - case CMD_DISPLAY_GPS_DEBUG: - return this->handle_display_gps_debug(argc); + case DisplayGpsDebug: + return this->handleDisplayGpsDebug(argc); - case CMD_DISPLAY_DRIVER_PRIMARY: - return this->handle_display_driver_primary(argc); + case DisplayDriverPrimary: + return this->handleDisplayDriverPrimary(argc); - case CMD_BATTERY_CAL: - return this->handle_battery_cal(argc, argv); + case BatteryCal: + return this->handleBatteryCal(argc, argv); - case CMD_BATTERY_PRINT_VBAT: - return this->handle_battery_print_vbat(argc); + case BatteryPrintVbat: + return this->handleBatteryPrintVbat(argc); - case CMD_BATTERY_SET_LOW: - return this->handle_battery_set_low(argc, argv); + case BatterySetLow: + return this->handleBatterySetLow(argc, argv); - case CMD_THERMO_SET_LOW: - return this->handle_thermo_set_low(argc, argv); + case ThermoSetLow: + return this->handleThermoSetLow(argc, argv); - case CMD_THERMO_SET_HIGH: - return this->handle_thermo_set_high(argc, argv); + case ThermoSetHigh: + return this->handleThermoSetHigh(argc, argv); - case CMD_UNKNOWN: + case Unknown: default: - return this->handle_unknown_command(argc, argv); + return this->handleUnknownCommand(argc, argv); } } -int cmd::try_parse() { +int Cmd::tryParse() { #ifdef DEBUG - if (_logger != nullptr) { - _logger->debug("Attempting to parse command"); + if (logger_ != nullptr) { + logger_->debug("Attempting to parse command"); } #endif - char *argvp[_max_args]; - unsigned short argc = split_args(_buffer, argvp, _max_args); + char *argvp[MAX_ARGS]; + unsigned short argc = splitArgs(buffer_, argvp, MAX_ARGS); if (argc == 0 || argvp[0] == nullptr || argvp[0][0] == '\0') { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("Empty command"); + if (logger_ != nullptr) { + logger_->error("Empty command"); } #endif return 1; } - command_id command = parse_command_name(argvp[0]); - return dispatch_command(command, argc, argvp); + CommandId command = parseCommandName(argvp[0]); + return dispatchCommand(command, argc, argvp); } -int cmd::push(const Task &task) { - return _queue.push(task); +int Cmd::push(const Task &task) { + return queue_.push(task); } -cmd::cmd(HardwareSerial *data_stream) - : _data_stream(data_stream), _logger(nullptr) {} +Cmd::Cmd(HardwareSerial *data_stream) + : data_stream_(data_stream), logger_(nullptr) {} -cmd::cmd(HardwareSerial *data_stream, system_logger *logger) - : _data_stream(data_stream), _logger(logger) {} +Cmd::Cmd(HardwareSerial *data_stream, SystemLogger *logger) + : data_stream_(data_stream), logger_(logger) {} -cmd::~cmd() {} +Cmd::~Cmd() {} -int cmd::init() { - _data_stream->begin(_baud_rate); +int Cmd::init() { + data_stream_->begin(baud_rate_); return 0; } -int cmd::parse_task(unsigned long timeout_ms) { +int Cmd::parseTask(unsigned long timeout_ms) { unsigned long start = millis(); - while (_data_stream->available()) { + while (data_stream_->available()) { if ((unsigned long)(millis() - start) >= timeout_ms) { return 1; } - char c = _data_stream->read(); + char current_char = data_stream_->read(); - if (c == '<') { - _buf_open = true; - _idx = 0; + if (current_char == '<') { + buffer_open_ = true; + index_ = 0; continue; } - if (!_buf_open) { + if (!buffer_open_) { continue; } - if (c == '>') { - _buffer[_idx] = '\0'; - _buf_open = false; - return this->try_parse(); + if (current_char == '>') { + buffer_[index_] = '\0'; + buffer_open_ = false; + return this->tryParse(); } - if (_idx >= sizeof(_buffer) - 1) { - _buf_open = false; - _idx = 0; + if (index_ >= sizeof(buffer_) - 1) { + buffer_open_ = false; + index_ = 0; #ifdef ERROR - if (_logger != nullptr) { - _logger->error("Command parser buffer overflow"); + if (logger_ != nullptr) { + logger_->error("Command parser buffer overflow"); } #endif return 1; } - _buffer[_idx] = c; - _idx++; + buffer_[index_] = current_char; + index_++; } return 0; diff --git a/src/modules/cmd/cmd.h b/src/modules/cmd/cmd.h index f71e861..7c9096c 100644 --- a/src/modules/cmd/cmd.h +++ b/src/modules/cmd/cmd.h @@ -12,64 +12,64 @@ #include "custom_types.h" #include "modules/logger/system_logger.h" -class cmd : public module_base { +class Cmd : public ModuleBase { private: - enum command_id { - CMD_UNKNOWN = 0, - CMD_REBOOT, - CMD_PUT_TRACK, - CMD_DELETE_TRACK, - CMD_DUMP_TRACK, - CMD_CFG_RESET, - CMD_CFG_DUMP, - CMD_TRACK_AUTODETECT, - CMD_DISPLAY_GPS_DEBUG, - CMD_DISPLAY_DRIVER_PRIMARY, - CMD_BATTERY_CAL, - CMD_BATTERY_PRINT_VBAT, - CMD_BATTERY_SET_LOW, - CMD_THERMO_SET_LOW, - CMD_THERMO_SET_HIGH, + enum CommandId { + Unknown = 0, + Reboot, + PutTrack, + DeleteTrack, + DumpTrack, + ConfigReset, + ConfigDump, + TrackAutodetect, + DisplayGpsDebug, + DisplayDriverPrimary, + BatteryCal, + BatteryPrintVbat, + BatterySetLow, + ThermoSetLow, + ThermoSetHigh, }; - HardwareSerial *_data_stream; - unsigned long _baud_rate = 115200; - system_logger *_logger; - char _buffer[256]; - unsigned int _idx = 0; - bool _buf_open = false; - ring_buffer _queue; + HardwareSerial *data_stream_; + unsigned long baud_rate_ = 115200; + SystemLogger *logger_; + char buffer_[256]; + unsigned int index_ = 0; + bool buffer_open_ = false; + RingBuffer queue_; - static const unsigned short _max_args = 10; + static const unsigned short MAX_ARGS = 10; - int try_parse(); - unsigned short split_args(char *input, char *argv[], unsigned short max_args); - char *trim_arg(char *input); - command_id parse_command_name(const char *input); - int dispatch_command(command_id command, unsigned short argc, char *argv[]); - int parse_track_slot_id(const char *id_str, unsigned short &id_out); - int dump_track_slot(unsigned short id); - int handle_reboot_command(unsigned short argc); - int handle_dumpcfg_command(unsigned short argc); - int handle_track_put_command(unsigned short argc, char *argv[]); - int handle_track_delete_command(unsigned short argc, char *argv[]); - int handle_track_dump_command(unsigned short argc, char *argv[]); - int handle_cfg_reset_command(unsigned short argc); - int handle_track_autodetect_command(unsigned short argc); - int handle_display_gps_debug(unsigned short argc); - int handle_display_driver_primary(unsigned short argc); - int handle_battery_cal(unsigned short argc, char *argv[]); - int handle_battery_print_vbat(unsigned short argc); - int handle_battery_set_low(unsigned short argc, char *argv[]); - int handle_thermo_set_low(unsigned short argc, char *argv[]); - int handle_thermo_set_high(unsigned short argc, char *argv[]); - int handle_unknown_command(unsigned short argc, char *argv[]); + int tryParse(); + unsigned short splitArgs(char *input, char *argv[], unsigned short max_args); + char *trimArg(char *input); + CommandId parseCommandName(const char *input); + int dispatchCommand(CommandId command, unsigned short argc, char *argv[]); + int parseTrackSlotId(const char *id_str, unsigned short &id_out); + int dumpTrackSlot(unsigned short id); + int handleRebootCommand(unsigned short argc); + int handleDumpConfigCommand(unsigned short argc); + int handleTrackPutCommand(unsigned short argc, char *argv[]); + int handleTrackDeleteCommand(unsigned short argc, char *argv[]); + int handleTrackDumpCommand(unsigned short argc, char *argv[]); + int handleConfigResetCommand(unsigned short argc); + int handleTrackAutodetectCommand(unsigned short argc); + int handleDisplayGpsDebug(unsigned short argc); + int handleDisplayDriverPrimary(unsigned short argc); + int handleBatteryCal(unsigned short argc, char *argv[]); + int handleBatteryPrintVbat(unsigned short argc); + int handleBatterySetLow(unsigned short argc, char *argv[]); + int handleThermoSetLow(unsigned short argc, char *argv[]); + int handleThermoSetHigh(unsigned short argc, char *argv[]); + int handleUnknownCommand(unsigned short argc, char *argv[]); public: int push(const Task &task) override; - cmd(HardwareSerial *data_stream); - cmd(HardwareSerial *data_stream, system_logger *logger); - ~cmd(); + Cmd(HardwareSerial *data_stream); + Cmd(HardwareSerial *data_stream, SystemLogger *logger); + ~Cmd(); int init(); - int parse_task(unsigned long timeout_ms = 500); + int parseTask(unsigned long timeout_ms = 500); }; diff --git a/src/modules/config/config.cpp b/src/modules/config/config.cpp index 932f9c6..5bbfd65 100644 --- a/src/modules/config/config.cpp +++ b/src/modules/config/config.cpp @@ -8,282 +8,282 @@ #include #include -int config::push(const Task &task) { return _queue.push(task); } +int Config::push(const Task &task) { return queue_.push(task); } -int config::task_complete() { - _task_memory_stale = true; - _active_task = {MOD_NULL, TASK_NULL, 0}; +int Config::taskComplete() { + task_memory_stale_ = true; + active_task_ = Task(module::Null, task::Null, 0); return 0; } -int config::write_track(const track_data &in) { - track_data copy = in; - copy.magic = CONFIG_MAGIC; - if (copy.id < 1 || copy.id > 8) { +int Config::writeTrack(const TrackData &track_data) { + TrackData track_copy = track_data; + track_copy.magic_ = CONFIG_MAGIC; + if (track_copy.id_ < 1 || track_copy.id_ > 8) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("Cannot write track data with out of range id, aborting"); + if (logger_ != nullptr) { + logger_->error("Cannot write track data with out of range id, aborting"); } #endif return 1; } - EEPROM.put(eeprom_layout::track_slot_addr(copy.id), copy); - _config.track_slot_occupied[copy.id - 1] = true; - this->write_cfg(); + EEPROM.put(eeprom_layout::trackSlotAddr(track_copy.id_), track_copy); + config_.track_slot_occupied_[track_copy.id_ - 1] = true; + this->writeConfig(); #ifdef INFO - if (_logger != nullptr) { - _logger->info("Succesfully wrote new track into slot " + String(copy.id)); + if (logger_ != nullptr) { + logger_->info("Succesfully wrote new track into slot " + String(track_copy.id_)); } #endif return 0; } -int config::write_track_from_temp() { - track_data new_track; - track_temp_global_read(new_track); - return this->write_track(new_track); +int Config::writeTrackFromTemp() { + TrackData track_data; + trackTempGlobalRead(track_data); + return this->writeTrack(track_data); } -int config::delete_track(unsigned short idx) { +int Config::deleteTrack(unsigned short idx) { if (idx < 1 || idx > 8) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("Cannot delete track with out of range id, aborting"); + if (logger_ != nullptr) { + logger_->error("Cannot delete track with out of range id, aborting"); } #endif return 1; } - if (_config.track_slot_occupied[idx - 1] == false) { + if (config_.track_slot_occupied_[idx - 1] == false) { #ifdef WARN - if (_logger != nullptr) { - _logger->warn("Requested delete on empty track slot " + String(idx)); + if (logger_ != nullptr) { + logger_->warn("Requested delete on empty track slot " + String(idx)); } #endif return 0; } - _config.track_slot_occupied[idx - 1] = false; + config_.track_slot_occupied_[idx - 1] = false; - if (_is_track_loaded && _loaded_track.id == idx) { - _is_track_loaded = false; - _loaded_track = {}; - track_global_write(_loaded_track); + if (is_track_loaded_ && loaded_track_.id_ == idx) { + is_track_loaded_ = false; + loaded_track_ = {}; + trackGlobalWrite(loaded_track_); } - int write_res = this->write_cfg(); + int write_result = this->writeConfig(); #ifdef INFO - if (_logger != nullptr && write_res == 0) { - _logger->info("Succesfully deleted track slot " + String(idx)); + if (logger_ != nullptr && write_result == 0) { + logger_->info("Succesfully deleted track slot " + String(idx)); } #endif - return write_res; + return write_result; } -int config::reset_cfg() { - vehicle_config clean_config; - _config = clean_config; - _is_track_loaded = false; - _loaded_track = {}; - _task_memory_stale = true; - _no_tracks_notice_shown = false; - track_global_write(_loaded_track); +int Config::resetConfig() { + VehicleConfig clean_config; + config_ = clean_config; + is_track_loaded_ = false; + loaded_track_ = {}; + task_memory_stale_ = true; + no_tracks_notice_shown_ = false; + trackGlobalWrite(loaded_track_); #ifdef INFO - if (_logger != nullptr) { - _logger->info("Resetting configuration to factory defaults"); + if (logger_ != nullptr) { + logger_->info("Resetting configuration to factory defaults"); } #endif - return this->write_cfg(); + return this->writeConfig(); } -int config::write_vbat_cal(double val) { - _config.vbat_calibration = val; - return this->write_cfg(); +int Config::writeVbatCal(double value) { + config_.vbat_calibration_ = value; + return this->writeConfig(); } -int config::write_vbat_low(double val) { - _config.vbat_low = val; - return this->write_cfg(); +int Config::writeVbatLow(double value) { + config_.vbat_low_ = value; + return this->writeConfig(); } -int config::write_teng_low(double val) { - _config.teng_low = val; - return this->write_cfg(); +int Config::writeTengLow(double value) { + config_.teng_low_ = value; + return this->writeConfig(); } -int config::write_teng_high(double val) { - _config.teng_high = val; - return this->write_cfg(); +int Config::writeTengHigh(double value) { + config_.teng_high_ = value; + 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() { - EEPROM.get(eeprom_layout::config_addr, _config); - config_global_write(_config); +int Config::readConfig() { + EEPROM.get(eeprom_layout::CONFIG_ADDR, config_); + configGlobalWrite(config_); return 0; } -int config::write_cfg() { - EEPROM.put(eeprom_layout::config_addr, _config); - config_global_write(_config); +int Config::writeConfig() { + EEPROM.put(eeprom_layout::CONFIG_ADDR, config_); + configGlobalWrite(config_); #ifdef INFO - if (_logger != nullptr) { - _logger->info("Config updated and saved to EEPROM"); + if (logger_ != nullptr) { + logger_->info("Config updated and saved to EEPROM"); } #endif - router::send(MOD_ALL, TASK_ALL_CONFIG_UPDATED); + router::send(module::All, task::AllConfigUpdated); return 0; } -int config::write_cfg(const vehicle_config &new_config) { - _config = new_config; - EEPROM.put(eeprom_layout::config_addr, new_config); - config_global_write(new_config); +int Config::writeConfig(const VehicleConfig &new_config) { + config_ = new_config; + EEPROM.put(eeprom_layout::CONFIG_ADDR, new_config); + configGlobalWrite(new_config); return 0; } -int config::task_config_detect_track(unsigned long timeout_ms) { +int Config::taskConfigDetectTrack(unsigned long timeout_ms) { unsigned long start = millis(); - bool min_one = false; + bool has_at_least_one_track = false; for (size_t i = 0; i < 8; i++) { - if (_config.track_slot_occupied[i] == true) { - min_one = true; + if (config_.track_slot_occupied_[i] == true) { + has_at_least_one_track = true; break; } } - if (!min_one) { - if (!_no_tracks_notice_shown) { - router::send(MOD_LCD, TASK_DISPLAY_MSG_CONFIG_NO_TRACKS, 3000); - _no_tracks_notice_shown = true; + if (!has_at_least_one_track) { + if (!no_tracks_notice_shown_) { + router::send(module::Lcd, task::DisplayMsgConfigNoTracks, 3000); + no_tracks_notice_shown_ = true; } - this->task_complete(); + this->taskComplete(); return 1; } - task_config_track_detect_data task_data; + TaskConfigTrackDetectData task_data; - if (!_task_memory_stale) { - memcpy(&task_data, _task_memory, sizeof(task_data)); + if (!task_memory_stale_) { + memcpy(&task_data, task_memory_, sizeof(task_data)); } else { - gps_data current_gps; - gps_global_read(current_gps); - task_data.gps_lat = current_gps.lat.value; - task_data.gps_lng = current_gps.lng.value; - task_data.cos = cos(task_data.gps_lat * M_PI / 180); + GpsData current_gps; + gpsGlobalRead(current_gps); + task_data.gps_lat_ = current_gps.lat_.value_; + task_data.gps_lng_ = current_gps.lng_.value_; + task_data.cos_ = cos(task_data.gps_lat_ * M_PI / 180); } while (true) { - task_data.last_checked++; + task_data.last_checked_++; - track_data temp; - int res = this->get_track(task_data.last_checked, temp); - if (res == 0) { - double delta_lat = temp.pt_a.lat - task_data.gps_lat; - double delta_lng = (temp.pt_a.lng - task_data.gps_lng) * task_data.cos; + TrackData track_data; + int result = this->getTrack(task_data.last_checked_, track_data); + if (result == 0) { + double delta_lat = track_data.point_a_.lat_ - task_data.gps_lat_; + 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; - if (dist2 < task_data.sqdiff || task_data.smallest_idx == 0) { - task_data.smallest_idx = task_data.last_checked; - task_data.sqdiff = dist2; + if (dist2 < task_data.sqdiff_ || task_data.smallest_idx_ == 0) { + task_data.smallest_idx_ = task_data.last_checked_; + task_data.sqdiff_ = dist2; } } - if (task_data.last_checked >= 8) { - int load_res = 1; - if (task_data.smallest_idx > 0) { - load_res = this->load_track(task_data.smallest_idx); + if (task_data.last_checked_ >= 8) { + int load_result = 1; + if (task_data.smallest_idx_ > 0) { + load_result = this->loadTrack(task_data.smallest_idx_); } - this->task_complete(); - if (load_res == 0) { - _no_tracks_notice_shown = false; - router::send(MOD_LCD, TASK_DISPLAY_MSG_TRACK_DETECT_OK, 4000); + this->taskComplete(); + if (load_result == 0) { + no_tracks_notice_shown_ = false; + router::send(module::Lcd, task::DisplayMsgTrackDetectOk, 4000); return 0; } - if (!_no_tracks_notice_shown) { - router::send(MOD_LCD, TASK_DISPLAY_MSG_CONFIG_NO_TRACKS, 3000); - _no_tracks_notice_shown = true; + if (!no_tracks_notice_shown_) { + router::send(module::Lcd, task::DisplayMsgConfigNoTracks, 3000); + no_tracks_notice_shown_ = true; } return 1; } if ((unsigned long)(millis() - start) >= timeout_ms) { - _task_memory_stale = false; - memcpy(_task_memory, &task_data, sizeof(task_data)); + task_memory_stale_ = false; + memcpy(task_memory_, &task_data, sizeof(task_data)); return 1; } } } -int config::handle_active_task(unsigned long timeout_ms) { - switch (_active_task.type) { - case TASK_CONFIG_TRACK_DETECT: { - if (!_is_track_loaded || _active_task.data == 1) { - return task_config_detect_track(timeout_ms); +int Config::handleActiveTask(unsigned long timeout_ms) { + switch (active_task_.type_) { + case task::ConfigTrackDetect: { + if (!is_track_loaded_ || active_task_.data_ == 1) { + return taskConfigDetectTrack(timeout_ms); } - this->task_complete(); + this->taskComplete(); return 0; } - case TASK_CONFIG_WRITE_TEMP_TRACK: { - int res = this->write_track_from_temp(); - this->task_complete(); - return res; + case task::ConfigWriteTempTrack: { + int result = this->writeTrackFromTemp(); + this->taskComplete(); + return result; } - case TASK_CONFIG_TRACK_DELETE: { - int res = this->delete_track(_active_task.data); - this->task_complete(); - return res; + case task::ConfigTrackDelete: { + int result = this->deleteTrack(active_task_.data_); + this->taskComplete(); + return result; } - case TASK_CONFIG_CFG_RESET: { - int res = this->reset_cfg(); - this->task_complete(); - return res; + case task::ConfigReset: { + int result = this->resetConfig(); + this->taskComplete(); + return result; } - case TASK_CONFIG_VBAT_CAL_SET: { + case task::ConfigVbatCalSet: { double cal_value; - memcpy(&cal_value, &_active_task.data, sizeof(double)); - int res = this->write_vbat_cal(cal_value); - this->task_complete(); - return res; + memcpy(&cal_value, &active_task_.data_, sizeof(double)); + int result = this->writeVbatCal(cal_value); + this->taskComplete(); + return result; } - case TASK_CONFIG_VBAT_SET_LOW: { + case task::ConfigVbatSetLow: { double low_value; - memcpy(&low_value, &_active_task.data, sizeof(double)); - int res = this->write_vbat_low(low_value); - this->task_complete(); - return res; + memcpy(&low_value, &active_task_.data_, sizeof(double)); + int result = this->writeVbatLow(low_value); + this->taskComplete(); + return result; } - case TASK_CONFIG_TENG_SET_LOW: { + case task::ConfigTengSetLow: { double low_value; - memcpy(&low_value, &_active_task.data, sizeof(double)); - int res = this->write_teng_low(low_value); - this->task_complete(); - return res; + memcpy(&low_value, &active_task_.data_, sizeof(double)); + int result = this->writeTengLow(low_value); + this->taskComplete(); + return result; } - case TASK_CONFIG_TENG_SET_HIGH: { + case task::ConfigTengSetHigh: { double high_value; - memcpy(&high_value, &_active_task.data, sizeof(double)); - int res = this->write_teng_high(high_value); - this->task_complete(); - return res; + memcpy(&high_value, &active_task_.data_, sizeof(double)); + int result = this->writeTengHigh(high_value); + this->taskComplete(); + return result; } default: @@ -292,78 +292,78 @@ int config::handle_active_task(unsigned long timeout_ms) { return 0; } -int config::auto_init() { - this->read_cfg(); - if (_config.magic != CONFIG_MAGIC) { +int Config::autoInit() { + this->readConfig(); + if (config_.magic_ != CONFIG_MAGIC) { #ifdef WARN - if (_logger != nullptr) { - _logger->warn("Config invalid, overwriting"); + if (logger_ != nullptr) { + logger_->warn("Config invalid, overwriting"); } #endif - vehicle_config clean_config; - this->write_cfg(clean_config); - this->read_cfg(); - if (_config.magic != CONFIG_MAGIC) { + VehicleConfig clean_config; + this->writeConfig(clean_config); + this->readConfig(); + if (config_.magic_ != CONFIG_MAGIC) { #ifdef ERROR - if (_logger != nullptr) { - _logger->error("Config write failed, EEPROM may be burnt"); + if (logger_ != nullptr) { + logger_->error("Config write failed, EEPROM may be burnt"); } #endif return 1; } } - _valid_config = true; + valid_config_ = true; return 0; } -int config::loop(unsigned long timeout_ms) { - if (_active_task.type != TASK_NULL && _active_task.target != MOD_NULL) { - this->handle_active_task(timeout_ms); +int Config::loop(unsigned long timeout_ms) { + if (active_task_.type_ != task::Null && active_task_.target_ != module::Null) { + this->handleActiveTask(timeout_ms); return 0; } - int res = _queue.pop(_active_task); - if (res == 0) { - this->handle_active_task(timeout_ms); + int result = queue_.pop(active_task_); + if (result == 0) { + this->handleActiveTask(timeout_ms); } 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) { return 1; } - if (_config.track_slot_occupied[idx - 1] == false) { + if (config_.track_slot_occupied_[idx - 1] == false) { return 1; } - EEPROM.get(eeprom_layout::track_slot_addr(idx), t); - if (t.magic != CONFIG_MAGIC) { + EEPROM.get(eeprom_layout::trackSlotAddr(idx), track_data); + if (track_data.magic_ != CONFIG_MAGIC) { return 1; } return 0; } -int config::load_track(unsigned int idx) { +int Config::loadTrack(unsigned int idx) { if (idx < 1 || idx > 8) { return 1; } - if (_config.track_slot_occupied[idx - 1] == false) { + if (config_.track_slot_occupied_[idx - 1] == false) { return 1; } - track_data temp; - EEPROM.get(eeprom_layout::track_slot_addr(idx), temp); - if (temp.magic != CONFIG_MAGIC) { + TrackData track_data; + EEPROM.get(eeprom_layout::trackSlotAddr(idx), track_data); + if (track_data.magic_ != CONFIG_MAGIC) { return 1; } - _loaded_track = temp; - track_global_write(_loaded_track); - _is_track_loaded = true; + loaded_track_ = track_data; + trackGlobalWrite(loaded_track_); + is_track_loaded_ = true; return 0; } diff --git a/src/modules/config/config.h b/src/modules/config/config.h index 68b3a6a..e7c8948 100644 --- a/src/modules/config/config.h +++ b/src/modules/config/config.h @@ -15,50 +15,50 @@ #include "data/eeprom_layout.h" #include "base/router.h" -struct task_config_track_detect_data { - unsigned short last_checked = 0; - unsigned short smallest_idx = 0; - double cos; - double sqdiff = 0; - double gps_lat; - double gps_lng; +struct TaskConfigTrackDetectData { + unsigned short last_checked_ = 0; + unsigned short smallest_idx_ = 0; + double cos_ = 0; + double sqdiff_ = 0; + double gps_lat_ = 0; + double gps_lng_ = 0; }; -class config : public module_base { +class Config : public ModuleBase { private: - vehicle_config _config; - system_logger *_logger; - bool _valid_config; - track_data _loaded_track; - bool _is_track_loaded = false; - ring_buffer _queue; - Task _active_task = {}; - uint8_t _task_memory[64] = {}; - bool _task_memory_stale = true; - bool _no_tracks_notice_shown = false; + VehicleConfig config_; + SystemLogger *logger_; + bool valid_config_; + TrackData loaded_track_; + bool is_track_loaded_ = false; + RingBuffer queue_; + Task active_task_ = {}; + uint8_t task_memory_[64] = {}; + bool task_memory_stale_ = true; + bool no_tracks_notice_shown_ = false; - int read_cfg(); - int write_cfg(); - int write_cfg(const vehicle_config &new_config); - int handle_active_task(unsigned long timeout_ms); - int task_config_detect_track(unsigned long timeout_ms); - int task_complete(); - int write_track(const track_data& in); - int write_track_from_temp(); - int delete_track(unsigned short idx); - int reset_cfg(); - int write_vbat_cal(double val); - int write_vbat_low(double val); - int write_teng_low(double val); - int write_teng_high(double val); + int readConfig(); + int writeConfig(); + int writeConfig(const VehicleConfig &new_config); + int handleActiveTask(unsigned long timeout_ms); + int taskConfigDetectTrack(unsigned long timeout_ms); + int taskComplete(); + int writeTrack(const TrackData& track_data); + int writeTrackFromTemp(); + int deleteTrack(unsigned short idx); + int resetConfig(); + int writeVbatCal(double value); + int writeVbatLow(double value); + int writeTengLow(double value); + int writeTengHigh(double value); public: int push(const Task &task) override; - config(); - config(system_logger *logger); - ~config(); - int auto_init(); + Config(); + Config(SystemLogger *logger); + ~Config(); + int autoInit(); int loop(unsigned long timeout_ms = 500); - int get_track(unsigned int idx, track_data &t); - int load_track(unsigned int idx); + int getTrack(unsigned int idx, TrackData &track_data); + int loadTrack(unsigned int idx); }; diff --git a/src/modules/gps/gps.cpp b/src/modules/gps/gps.cpp index f64351c..71b6481 100644 --- a/src/modules/gps/gps.cpp +++ b/src/modules/gps/gps.cpp @@ -6,43 +6,43 @@ #define MOD "modules/gps/gps.h" -int gps::push(const Task &task) { - return _queue.push(task); +int Gps::push(const Task &task) { + return queue_.push(task); } -gps::gps(HardwareSerial *data_stream) - : _gps(nullptr), _data_stream(data_stream), _logger(nullptr) { - _gps = new TinyGPSPlus(); +Gps::Gps(HardwareSerial *data_stream) + : gps_(nullptr), data_stream_(data_stream), logger_(nullptr) { + gps_ = new TinyGPSPlus(); } -gps::gps(HardwareSerial *data_stream, system_logger *logger) - : _gps(nullptr), _data_stream(data_stream), _logger(logger) { - _gps = new TinyGPSPlus(); +Gps::Gps(HardwareSerial *data_stream, SystemLogger *logger) + : gps_(nullptr), data_stream_(data_stream), logger_(logger) { + gps_ = new TinyGPSPlus(); } -gps::~gps() { - _data_stream = nullptr; - delete _gps; - _gps = nullptr; +Gps::~Gps() { + data_stream_ = nullptr; + delete gps_; + gps_ = nullptr; } -int gps::init() { - _data_stream->begin(9600); +int Gps::init() { + data_stream_->begin(9600); return 0; } -int gps::loop(unsigned long timeout_ms) { +int Gps::loop(unsigned long timeout_ms) { unsigned long timeout = millis() + timeout_ms; - while (_data_stream->available() > 0) { - if (_gps->encode(_data_stream->read())) { - gps_global_write(this->get_data()); - uint32_t current_fix_val = _gps->sentencesWithFix(); - if (_last_fix_val == 0 && current_fix_val > 0) { - router::send(MOD_LCD, TASK_DISPLAY_MSG_GPS_FIX, 2000); - router::send(MOD_CFG, TASK_CONFIG_TRACK_DETECT); + while (data_stream_->available() > 0) { + if (gps_->encode(data_stream_->read())) { + gpsGlobalWrite(this->getData()); + uint32_t current_fix_value = gps_->sentencesWithFix(); + if (last_fix_value_ == 0 && current_fix_value > 0) { + router::send(module::Lcd, task::DisplayMsgGpsFix, 2000); + router::send(module::Config, task::ConfigTrackDetect); } - _last_fix_val = current_fix_val; + last_fix_value_ = current_fix_value; } if (millis() > timeout) { @@ -53,32 +53,32 @@ int gps::loop(unsigned long timeout_ms) { return 0; } -gps_data gps::get_data() { - gps_data output; +GpsData Gps::getData() { + GpsData output; - output.altitude.age = _gps->altitude.age(); - output.altitude.valid = _gps->altitude.isValid(); - output.altitude.value = _gps->altitude.meters(); + output.altitude_.age_ = gps_->altitude.age(); + output.altitude_.valid_ = gps_->altitude.isValid(); + output.altitude_.value_ = gps_->altitude.meters(); - output.lat.age = _gps->location.age(); - output.lat.valid = _gps->location.isValid(); - output.lat.value = _gps->location.lat(); + output.lat_.age_ = gps_->location.age(); + output.lat_.valid_ = gps_->location.isValid(); + output.lat_.value_ = gps_->location.lat(); - output.lng.age = _gps->location.age(); - output.lng.valid = _gps->location.isValid(); - output.lng.value = _gps->location.lng(); + output.lng_.age_ = gps_->location.age(); + output.lng_.valid_ = gps_->location.isValid(); + output.lng_.value_ = gps_->location.lng(); - output.speed.age = _gps->speed.age(); - output.speed.valid = _gps->speed.isValid(); - output.speed.value = _gps->speed.kmph(); + output.speed_.age_ = gps_->speed.age(); + output.speed_.valid_ = gps_->speed.isValid(); + output.speed_.value_ = gps_->speed.kmph(); - output.course.age = _gps->course.age(); - output.course.valid = _gps->course.isValid(); - output.course.value = _gps->course.deg(); + output.course_.age_ = gps_->course.age(); + output.course_.valid_ = gps_->course.isValid(); + output.course_.value_ = gps_->course.deg(); - output.num_fix = _gps->sentencesWithFix(); + output.num_fix_ = gps_->sentencesWithFix(); return output; } -#undef MOD \ No newline at end of file +#undef MOD diff --git a/src/modules/gps/gps.h b/src/modules/gps/gps.h index 52d95e6..b09d16d 100644 --- a/src/modules/gps/gps.h +++ b/src/modules/gps/gps.h @@ -13,20 +13,20 @@ #include "data/gps_store.h" #include "base/router.h" -class gps : public module_base { +class Gps : public ModuleBase { private: - TinyGPSPlus *_gps; - HardwareSerial *_data_stream; - system_logger *_logger; - ring_buffer _queue; - uint32_t _last_fix_val = 0; + TinyGPSPlus *gps_; + HardwareSerial *data_stream_; + SystemLogger *logger_; + RingBuffer queue_; + uint32_t last_fix_value_ = 0; public: int push(const Task &task) override; - gps(HardwareSerial *data_stream); - gps(HardwareSerial *data_stream, system_logger *logger); - ~gps(); + Gps(HardwareSerial *data_stream); + Gps(HardwareSerial *data_stream, SystemLogger *logger); + ~Gps(); int loop(unsigned long timeout_ms = 500); int init(); - gps_data get_data(); -}; \ No newline at end of file + GpsData getData(); +}; diff --git a/src/modules/lcd/lcd.cpp b/src/modules/lcd/lcd.cpp index 8f876a1..826fa3c 100644 --- a/src/modules/lcd/lcd.cpp +++ b/src/modules/lcd/lcd.cpp @@ -9,59 +9,59 @@ #define MOD "modules/lcd/lcd.h" -void lcd::clear() { - if (!_dispaly_cleared) { - _display->clear(); - _dispaly_cleared = true; +void Lcd::clear() { + if (!display_cleared_) { + display_->clear(); + display_cleared_ = true; } } -void lcd::print(const String &msg) { - _display->print(msg); - _dispaly_cleared = false; +void Lcd::print(const String &msg) { + display_->print(msg); + display_cleared_ = false; } -void lcd::print(char c) { - _display->print(c); - _dispaly_cleared = false; +void Lcd::print(char c) { + display_->print(c); + display_cleared_ = false; } -void lcd::print(const char c[]) { - _display->print(c); - _dispaly_cleared = false; +void Lcd::print(const char c[]) { + display_->print(c); + display_cleared_ = false; } -void lcd::print(double d, int digits) { - _display->print(d, digits); - _dispaly_cleared = false; +void Lcd::print(double d, int digits) { + display_->print(d, digits); + display_cleared_ = false; } -void lcd::print(unsigned long l, int base) { - _display->print(l, base); - _dispaly_cleared = false; +void Lcd::print(unsigned long l, int base) { + display_->print(l, base); + display_cleared_ = false; } -void lcd::print(long l, int base) { - _display->print(l, base); - _dispaly_cleared = false; +void Lcd::print(long l, int base) { + display_->print(l, base); + display_cleared_ = false; } -void lcd::print(unsigned int i, int base) { - _display->print(i, base); - _dispaly_cleared = false; +void Lcd::print(unsigned int i, int base) { + display_->print(i, base); + display_cleared_ = false; } -void lcd::print(int i, int base) { - _display->print(i, base); - _dispaly_cleared = false; +void Lcd::print(int i, int base) { + display_->print(i, base); + display_cleared_ = false; } -bool lcd::is_message_task(task_type type) { +bool Lcd::isMessageTask(task::Type type) { switch (type) { - case TASK_DISPLAY_MSG_GPS_FIX: - case TASK_DISPLAY_MSG_TRACK_DETECT_OK: - case TASK_DISPLAY_MSG_CONFIG_NO_TRACKS: - case TASK_DISPLAY_MSG_BAT_LOW: + case task::DisplayMsgGpsFix: + case task::DisplayMsgTrackDetectOk: + case task::DisplayMsgConfigNoTracks: + case task::DisplayMsgBatteryLow: return true; 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) { - duration_ms = _frame_duration; + duration_ms = frame_duration_; } - _msg_screen = msg_screen; - _msg_active = true; - _msg_end = millis() + duration_ms; - _screen = _msg_screen; - _force_render = true; + message_screen_ = msg_screen; + message_active_ = true; + message_end_ = millis() + duration_ms; + screen_ = message_screen_; + force_render_ = true; } -void lcd::expire_message_if_needed(unsigned long now) { - if (!_msg_active) { +void Lcd::expireMessageIfNeeded(unsigned long now) { + if (!message_active_) { return; } - if ((long)(now - _msg_end) >= 0) { - _msg_active = false; - _msg_screen = screen::blank; - _screen = _data_screen; - _force_render = true; + if ((long)(now - message_end_) >= 0) { + message_active_ = false; + message_screen_ = screen::Blank; + screen_ = data_screen_; + force_render_ = true; } } -screen::lcd_screen lcd::get_active_screen() const { - if (_msg_active) { - return _msg_screen; +screen::LcdScreen Lcd::getActiveScreen() const { + if (message_active_) { + return message_screen_; } - return _data_screen; + return data_screen_; } -int lcd::render_gps_debug() { +int Lcd::renderGpsDebug() { this->clear(); - gps_data data; - gps_global_read(data); + GpsData gps_data; + gpsGlobalRead(gps_data); - _display->setCursor(0, 0); + display_->setCursor(0, 0); this->print("Alt: "); - if (data.altitude.valid) { - this->print(data.altitude.value, 5); + if (gps_data.altitude_.valid_) { + this->print(gps_data.altitude_.value_, 5); } else { this->print("not valid"); } - _display->setCursor(0, 1); + display_->setCursor(0, 1); this->print("Lat: "); - if (data.lat.valid) { - this->print(data.lat.value, 5); + if (gps_data.lat_.valid_) { + this->print(gps_data.lat_.value_, 5); } else { this->print("not valid"); } - _display->setCursor(0, 2); + display_->setCursor(0, 2); this->print("Lng: "); - if (data.lng.valid) { - this->print(data.lng.value, 5); + if (gps_data.lng_.valid_) { + this->print(gps_data.lng_.value_, 5); } else { this->print("not valid"); } - _display->setCursor(0, 3); + display_->setCursor(0, 3); this->print("Spd: "); - if (data.speed.valid) { - this->print(data.speed.value, 5); + if (gps_data.speed_.valid_) { + this->print(gps_data.speed_.value_, 5); } else { this->print("not valid"); } @@ -143,134 +143,134 @@ int lcd::render_gps_debug() { return 0; } -int lcd::render_driver_primary() { +int Lcd::renderDriverPrimary() { this->clear(); - gps_data gps; - gps_global_read(gps); + GpsData gps_data; + gpsGlobalRead(gps_data); double vbat; - vbat_global_read(vbat); + vbatGlobalRead(vbat); - _display->setCursor(0,0); + display_->setCursor(0,0); this->print("GPS:"); - if (gps.num_fix != 0) { + if (gps_data.num_fix_ != 0) { this->print("V"); } else { this->print("X"); } - _display->setCursor(3,2); + display_->setCursor(3,2); 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); return 0; } -int lcd::render_msg_gps_fix() { +int Lcd::renderMsgGpsFix() { this->clear(); - _display->setCursor(6, 1); + display_->setCursor(6, 1); this->print("GPS INFO"); - _display->setCursor(7, 2); + display_->setCursor(7, 2); this->print("FIX OK"); return 0; } -int lcd::render_msg_track_detect_ok() { +int Lcd::renderMsgTrackDetectOk() { this->clear(); - _display->setCursor(6, 0); + display_->setCursor(6, 0); this->print("GPS INFO"); - _display->setCursor(3, 1); + display_->setCursor(3, 1); this->print("TRACK DETECTED"); - track_data temp; - track_global_read(temp); + TrackData track_data; + trackGlobalRead(track_data); - _display->setCursor((20 - strlen(temp.name)) / 2, 2); - this->print(temp.name); + display_->setCursor((20 - strlen(track_data.name_)) / 2, 2); + this->print(track_data.name_); return 0; } -int lcd::render_msg_config_no_tracks() { +int Lcd::renderMsgConfigNoTracks() { this->clear(); - _display->setCursor(4, 1); + display_->setCursor(4, 1); this->print("CONFIG INFO"); - _display->setCursor(2, 2); + display_->setCursor(2, 2); this->print("NO TRACKS LOADED"); return 0; } -int lcd::render_msg_battery_low() { +int Lcd::renderMsgBatteryLow() { this->clear(); - _display->setCursor(2, 1); + display_->setCursor(2, 1); this->print("BATTERY WARNING"); - _display->setCursor(6, 2); + display_->setCursor(6, 2); this->print("VBAT LOW"); return 0; } -int lcd::push(const Task &task) { - return _queue.push(task); +int Lcd::push(const Task &task) { + return queue_.push(task); } -lcd::lcd() - : _logger(nullptr), - _screen(screen::blank), - _data_screen(screen::blank), - _msg_screen(screen::blank), - _last_render(0), - _frame_duration(2000), - _dispaly_cleared(false) { - _display = new LiquidCrystal_I2C(0x27, 20, 4); +Lcd::Lcd() + : display_cleared_(false), + logger_(nullptr), + screen_(screen::Blank), + data_screen_(screen::Blank), + message_screen_(screen::Blank), + last_render_(0), + frame_duration_(2000) { + display_ = new LiquidCrystal_I2C(0x27, 20, 4); } -lcd::lcd(system_logger *logger) - : _logger(logger), - _screen(screen::blank), - _data_screen(screen::blank), - _msg_screen(screen::blank), - _last_render(0), - _frame_duration(2000), - _dispaly_cleared(false) { - _display = new LiquidCrystal_I2C(0x27, 20, 4); +Lcd::Lcd(SystemLogger *logger) + : display_cleared_(false), + logger_(logger), + screen_(screen::Blank), + data_screen_(screen::Blank), + message_screen_(screen::Blank), + last_render_(0), + frame_duration_(2000) { + display_ = new LiquidCrystal_I2C(0x27, 20, 4); } -lcd::~lcd() { - delete _display; - _display = nullptr; +Lcd::~Lcd() { + delete display_; + display_ = nullptr; } -int lcd::init() { +int Lcd::init() { #ifdef DEEP_DEBUG - if (_logger != nullptr) { - _logger->deep_debug(String(MOD) + ": init: Begin"); + if (logger_ != nullptr) { + logger_->deepDebug(String(MOD) + ": init: Begin"); } #endif - _display->init(); + display_->init(); Wire.setClock(400000); - _display->backlight(); + display_->backlight(); this->clear(); - _display->setCursor(0, 0); - _force_render = true; + display_->setCursor(0, 0); + force_render_ = true; #ifdef DEEP_DEBUG - if (_logger != nullptr) { - _logger->deep_debug(String(MOD) + ": init: End"); + if (logger_ != nullptr) { + logger_->deepDebug(String(MOD) + ": init: End"); } #endif return 0; } -int lcd::print_message(String message) { +int Lcd::printMessage(String message) { #ifdef DEEP_DEBUG - if (_logger != nullptr) { - _logger->deep_debug(String(MOD) + ": print_message: Begin"); + if (logger_ != nullptr) { + logger_->deepDebug(String(MOD) + ": printMessage: Begin"); } #endif @@ -332,41 +332,41 @@ int lcd::print_message(String message) { col = 0; } - _display->setCursor(col, currentRow++); + display_->setCursor(col, currentRow++); this->print(lines[i]); } #ifdef INFO - if (_logger != nullptr) { - _logger->info(original); + if (logger_ != nullptr) { + logger_->info(original); } #endif #ifdef DEEP_DEBUG - if (_logger != nullptr) { - _logger->deep_debug(String(MOD) + ": print_message: End"); + if (logger_ != nullptr) { + logger_->deepDebug(String(MOD) + ": printMessage: End"); } #endif return 0; } -int lcd::loop(unsigned long timeout_ms) { +int Lcd::loop(unsigned long timeout_ms) { unsigned long now = millis(); unsigned long start = now; - expire_message_if_needed(now); + expireMessageIfNeeded(now); while (true) { Task next_task; bool have_task = false; - if (_deferred_task_valid) { - next_task = _deferred_task; - _deferred_task_valid = false; + if (deferred_task_valid_) { + next_task = deferred_task_; + deferred_task_valid_ = false; have_task = true; } else { - if (_queue.pop(next_task) == 0) { + if (queue_.pop(next_task) == 0) { have_task = true; } } @@ -375,43 +375,43 @@ int lcd::loop(unsigned long timeout_ms) { break; } - if (_msg_active && is_message_task(next_task.type)) { - _deferred_task = next_task; - _deferred_task_valid = true; + if (message_active_ && isMessageTask(next_task.type_)) { + deferred_task_ = next_task; + deferred_task_valid_ = true; break; } - switch (next_task.type) { - case TASK_DISPLAY_GPS_DEBUG: - _data_screen = screen::gps_debug; - if (!_msg_active) { - _screen = _data_screen; - _force_render = true; + switch (next_task.type_) { + case task::DisplayGpsDebug: + data_screen_ = screen::GpsDebug; + if (!message_active_) { + screen_ = data_screen_; + force_render_ = true; } break; - case TASK_DISPLAY_DRIVER_PRIMARY: - _data_screen = screen::driver_primary; - if (!_msg_active) { - _screen = _data_screen; - _force_render = true; + case task::DisplayDriverPrimary: + data_screen_ = screen::DriverPrimary; + if (!message_active_) { + screen_ = data_screen_; + force_render_ = true; } break; - case TASK_DISPLAY_MSG_GPS_FIX: - activate_message(screen::msg_gps_fix, next_task.data); + case task::DisplayMsgGpsFix: + activateMessage(screen::MsgGpsFix, next_task.data_); break; - case TASK_DISPLAY_MSG_TRACK_DETECT_OK: - activate_message(screen::msg_track_detect_ok, next_task.data); + case task::DisplayMsgTrackDetectOk: + activateMessage(screen::MsgTrackDetectOk, next_task.data_); break; - case TASK_DISPLAY_MSG_CONFIG_NO_TRACKS: - activate_message(screen::msg_config_no_tracks, next_task.data); + case task::DisplayMsgConfigNoTracks: + activateMessage(screen::MsgConfigNoTracks, next_task.data_); break; - case TASK_DISPLAY_MSG_BAT_LOW: - activate_message(screen::msg_battery_low, next_task.data); + case task::DisplayMsgBatteryLow: + activateMessage(screen::MsgBatteryLow, next_task.data_); break; default: @@ -419,7 +419,7 @@ int lcd::loop(unsigned long timeout_ms) { } now = millis(); - expire_message_if_needed(now); + expireMessageIfNeeded(now); if ((unsigned long)(now - start) >= timeout_ms) { break; @@ -427,53 +427,53 @@ int lcd::loop(unsigned long timeout_ms) { } now = millis(); - expire_message_if_needed(now); + expireMessageIfNeeded(now); - screen::lcd_screen active_screen = get_active_screen(); - if (_screen != active_screen) { - _screen = active_screen; - _force_render = true; + screen::LcdScreen active_screen = getActiveScreen(); + if (screen_ != active_screen) { + screen_ = active_screen; + 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; } - switch (_screen) { - case screen::blank: + switch (screen_) { + case screen::Blank: this->clear(); break; - case screen::gps_debug: - this->render_gps_debug(); + case screen::GpsDebug: + this->renderGpsDebug(); break; - case screen::driver_primary: - this->render_driver_primary(); + case screen::DriverPrimary: + this->renderDriverPrimary(); break; - case screen::msg_gps_fix: - this->render_msg_gps_fix(); + case screen::MsgGpsFix: + this->renderMsgGpsFix(); break; - case screen::msg_track_detect_ok: - this->render_msg_track_detect_ok(); + case screen::MsgTrackDetectOk: + this->renderMsgTrackDetectOk(); break; - case screen::msg_config_no_tracks: - this->render_msg_config_no_tracks(); + case screen::MsgConfigNoTracks: + this->renderMsgConfigNoTracks(); break; - case screen::msg_battery_low: - this->render_msg_battery_low(); + case screen::MsgBatteryLow: + this->renderMsgBatteryLow(); break; default: break; } - _last_render = now; - _force_render = false; + last_render_ = now; + force_render_ = false; return 1; } diff --git a/src/modules/lcd/lcd.h b/src/modules/lcd/lcd.h index f58dd45..3bb565c 100644 --- a/src/modules/lcd/lcd.h +++ b/src/modules/lcd/lcd.h @@ -18,34 +18,34 @@ namespace screen { -typedef enum lcd_screen { - blank, - gps_debug, - driver_primary, - msg_gps_fix, - msg_track_detect_ok, - msg_config_no_tracks, - msg_battery_low, -} lcd_screen; +enum LcdScreen : uint8_t { + Blank, + GpsDebug, + DriverPrimary, + MsgGpsFix, + MsgTrackDetectOk, + MsgConfigNoTracks, + MsgBatteryLow, +}; } // namespace screen -class lcd : public module_base { +class Lcd : public ModuleBase { private: - LiquidCrystal_I2C *_display; - bool _dispaly_cleared; - system_logger *_logger = nullptr; - screen::lcd_screen _screen; - screen::lcd_screen _data_screen; - screen::lcd_screen _msg_screen; - unsigned long _last_render; - unsigned long _frame_duration; - unsigned long _msg_end = 0; - bool _msg_active = false; - bool _force_render = false; - ring_buffer _queue; - Task _deferred_task{}; - bool _deferred_task_valid = false; + LiquidCrystal_I2C *display_; + bool display_cleared_; + SystemLogger *logger_ = nullptr; + screen::LcdScreen screen_; + screen::LcdScreen data_screen_; + screen::LcdScreen message_screen_; + unsigned long last_render_; + unsigned long frame_duration_; + unsigned long message_end_ = 0; + bool message_active_ = false; + bool force_render_ = false; + RingBuffer queue_; + Task deferred_task_{}; + bool deferred_task_valid_ = false; void clear(); void print(const String &msg); @@ -57,24 +57,24 @@ private: void print(unsigned int i, int base = 10); void print(int i, int base = 10); - bool is_message_task(task_type type); - void activate_message(screen::lcd_screen msg_screen, unsigned long duration_ms); - void expire_message_if_needed(unsigned long now); - screen::lcd_screen get_active_screen() const; + bool isMessageTask(task::Type type); + void activateMessage(screen::LcdScreen msg_screen, unsigned long duration_ms); + void expireMessageIfNeeded(unsigned long now); + screen::LcdScreen getActiveScreen() const; - int render_gps_debug(); - int render_driver_primary(); - int render_msg_gps_fix(); - int render_msg_track_detect_ok(); - int render_msg_config_no_tracks(); - int render_msg_battery_low(); + int renderGpsDebug(); + int renderDriverPrimary(); + int renderMsgGpsFix(); + int renderMsgTrackDetectOk(); + int renderMsgConfigNoTracks(); + int renderMsgBatteryLow(); public: int push(const Task &task) override; - lcd(); - lcd(system_logger *logger); - ~lcd(); + Lcd(); + Lcd(SystemLogger *logger); + ~Lcd(); int init(); - int print_message(String message); + int printMessage(String message); int loop(unsigned long timeout_ms = 500); }; diff --git a/src/modules/logger/system_logger.cpp b/src/modules/logger/system_logger.cpp index d5988e7..5d6cce2 100644 --- a/src/modules/logger/system_logger.cpp +++ b/src/modules/logger/system_logger.cpp @@ -7,62 +7,57 @@ #include -system_logger::system_logger(HardwareSerial *output) -{ - _output = output; -} +SystemLogger::SystemLogger(HardwareSerial *output) { output_ = output; } -system_logger::~system_logger() -{ -} +SystemLogger::~SystemLogger() {} -int system_logger::print_message(String pre, String message) { - if (_output->availableForWrite()) { - _output->print(millis()); - _output->print(pre); - _output->println(message); +int SystemLogger::printMessage(String prefix, String message) { + if (output_->availableForWrite()) { + output_->print(millis()); + output_->print(prefix); + output_->println(message); return 0; } return 1; } #ifdef INFO -int system_logger::info(String message) { - return this->print_message(" [INFO] ", message); +int SystemLogger::info(String message) { + return this->printMessage(" [INFO] ", message); } -int system_logger::dump_config() { - vehicle_config temp; - config_global_read(temp); +int SystemLogger::dumpConfig() { + VehicleConfig config; + configGlobalRead(config); char buffer[64]; // Auto detect snprintf(buffer, sizeof(buffer), "\tAuto detect tracks: %d", - temp.auto_detect_track + config.auto_detect_track_ ); this->info(String(buffer)); // Track fallback snprintf(buffer, sizeof(buffer), "\tTrack fallback: %d", - temp.track_fallback + config.track_fallback_ ); this->info(String(buffer)); - this->info("\tVBAT cal factor: " + String(temp.vbat_calibration, 6)); - this->info("\tVBAT low: " + String(temp.vbat_low, 2)); - this->info("\tTENG low: " + String(temp.teng_low, 2)); - this->info("\tTENG high: " + String(temp.teng_high, 2)); + this->info("\tVBAT cal factor: " + String(config.vbat_calibration_, 6)); + this->info("\tVBAT low: " + String(config.vbat_low_, 2)); + this->info("\tTENG low: " + String(config.teng_low_, 2)); + this->info("\tTENG high: " + String(config.teng_high_, 2)); // Track slots (one per line) for (size_t i = 0; i < 8; i++) { snprintf(buffer, sizeof(buffer), "\tTrack slot %d: %d", i + 1, - temp.track_slot_occupied[i] + config.track_slot_occupied_[i] ); this->info(String(buffer)); } @@ -74,25 +69,25 @@ int system_logger::dump_config() { #endif #ifdef WARN -int system_logger::warn(String message) { - return this->print_message(" [WARNING] ", message); +int SystemLogger::warn(String message) { + return this->printMessage(" [WARNING] ", message); } #endif #ifdef ERROR -int system_logger::error(String message) { - return this->print_message(" [ERROR] ", message); +int SystemLogger::error(String message) { + return this->printMessage(" [ERROR] ", message); } #endif #ifdef DEBUG -int system_logger::debug(String message) { - return this->print_message(" [DEBUG] ", message); +int SystemLogger::debug(String message) { + return this->printMessage(" [DEBUG] ", message); } #endif #ifdef DEEP_DEBUG -int system_logger::deep_debug(String message) { - return this->print_message(" [DEEP_DEBUG] ", message); +int SystemLogger::deepDebug(String message) { + return this->printMessage(" [DEEP_DEBUG] ", message); } #endif diff --git a/src/modules/logger/system_logger.h b/src/modules/logger/system_logger.h index 6ef5fa8..3af3194 100644 --- a/src/modules/logger/system_logger.h +++ b/src/modules/logger/system_logger.h @@ -11,17 +11,16 @@ #include "base/module_base.h" #include "data/config_store.h" -class system_logger -{ +class SystemLogger { private: - HardwareSerial *_output; - int print_message(String pre, String message); + HardwareSerial *output_; + int printMessage(String prefix, String message); public: - system_logger(HardwareSerial *output); - ~system_logger(); + SystemLogger(HardwareSerial *output); + ~SystemLogger(); #ifdef INFO int info(String message); - int dump_config(); + int dumpConfig(); #endif #ifdef WARN @@ -37,6 +36,6 @@ public: #endif #ifdef DEEP_DEBUG - int deep_debug(String message); + int deepDebug(String message); #endif -}; \ No newline at end of file +}; diff --git a/src/modules/thermocouple/thermocouple.cpp b/src/modules/thermocouple/thermocouple.cpp index 495d768..6563e20 100644 --- a/src/modules/thermocouple/thermocouple.cpp +++ b/src/modules/thermocouple/thermocouple.cpp @@ -5,22 +5,26 @@ #include "thermocouple.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() { - _thermocouple = new MAX6675(THERMO_SCK, THERMO_CS, THERMO_SO); +int Thermocouple::init() { + thermocouple_ = new MAX6675(THERMO_SCK, THERMO_CS, THERMO_SO); return 0; } -int thermocouple::loop(unsigned long timeout_ms) { - if (millis() > _last_read + _update_interval) { - _temp = _thermocouple->readCelsius(); - teng_global_write(_temp); +int Thermocouple::loop(unsigned long timeout_ms) { + (void)timeout_ms; + + if (millis() > last_read_at_ + update_interval_) { + temperature_ = thermocouple_->readCelsius(); + tengGlobalWrite(temperature_); + last_read_at_ = millis(); } -} \ No newline at end of file + return 0; +} diff --git a/src/modules/thermocouple/thermocouple.h b/src/modules/thermocouple/thermocouple.h index e6778ec..0908304 100644 --- a/src/modules/thermocouple/thermocouple.h +++ b/src/modules/thermocouple/thermocouple.h @@ -12,20 +12,20 @@ #include #include -class thermocouple : public module_base { +class Thermocouple : public ModuleBase { private: - system_logger *_logger; - ring_buffer _queue; - MAX6675 *_thermocouple; - double _temp; - unsigned long _update_interval = 1000; - unsigned long _last_read = 0; + SystemLogger *logger_; + RingBuffer queue_; + MAX6675 *thermocouple_; + double temperature_; + unsigned long update_interval_ = 1000; + unsigned long last_read_at_ = 0; public: int push(const Task &task) override; - thermocouple(); - thermocouple(system_logger *logger); - ~thermocouple(); + Thermocouple(); + Thermocouple(SystemLogger *logger); + ~Thermocouple(); int init(); int loop(unsigned long timeout_ms = 500); -}; \ No newline at end of file +};