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

Refactor names to follow new convention

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

3
src/base/module_base.h
View File

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

2
src/base/modules.cpp
View File

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

2
src/base/modules.h
View File

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

32
src/base/ring_buffer.h
View File

@@ -5,34 +5,34 @@
#include <inttypes.h>
template<typename T, uint8_t SIZE>
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;}
bool isEmpty() const { return count_ == 0; }
bool isFull() const { return count_ == SIZE; }
uint8_t size() const { return count_; }
};

24
src/base/router.cpp
View File

@@ -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

2
src/base/router.h
View File

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

81
src/base/task.h
View File

@@ -5,46 +5,53 @@
#include <inttypes.h>
#include <Arduino.h>
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_;
};

63
src/custom_types.h
View File

@@ -6,51 +6,52 @@
#include <string.h>
#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<typename T>
inline void copy_from_volatile(T& dst, const volatile T& src) {
inline void copyFromVolatile(T& dst, const volatile T& src) {
memcpy(&dst, (const void*)&src, sizeof(T));
}
template<typename T>
inline void copy_to_volatile(volatile T& dst, const T& src) {
inline void copyToVolatile(volatile T& dst, const T& src) {
memcpy((void*)&dst, &src, sizeof(T));
}

10
src/data/config_store.cpp
View File

@@ -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);
}

6
src/data/config_store.h
View File

@@ -6,7 +6,7 @@
#include "custom_types.h"
#include <EEPROM.h>
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);
void configGlobalRead(VehicleConfig& out);
void configGlobalWrite(const VehicleConfig& in);

22
src/data/eeprom_layout.h
View File

@@ -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

8
src/data/general_store.cpp
View File

@@ -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;
}

8
src/data/general_store.h
View File

@@ -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);
void tengGlobalRead(double& out);
void tengGlobalWrite(const double& in);

10
src/data/gps_store.cpp
View File

@@ -3,12 +3,12 @@
// SPDX-License-Identifier: GPL-3.0-or-later
#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);
void gpsGlobalWrite(const GpsData& in) {
copyToVolatile(gps_data_global, in);
}

6
src/data/gps_store.h
View File

@@ -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);
void gpsGlobalRead(GpsData& out);
void gpsGlobalWrite(const GpsData& in);

30
src/data/track_store.cpp
View File

@@ -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);
}

14
src/data/track_store.h
View File

@@ -6,12 +6,12 @@
#include "custom_types.h"
#include <EEPROM.h>
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);
void trackTempGlobalRead(TrackData& out);
void trackTempGlobalWrite(const TrackData& in);

57
src/main.cpp
View File

@@ -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();
}

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

@@ -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 Battery::loop(unsigned long timeout_ms) {
(void)timeout_ms;
if (millis() > last_read_at_ + update_interval_) {
int adc_read = analogRead(VBAT_PIN);
_vbat = _cal * adc_read;
vbat_ = calibration_ * adc_read;
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();
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);
int res = queue_.pop(active_task);
if (res == 0) {
if (active_task.target == MOD_BAT) {
if (active_task.target_ == module::Battery) {
switch (active_task.type) {
case TASK_BATTERY_CAL:
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;
}

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

@@ -9,25 +9,25 @@
#include "modules/logger/system_logger.h"
#include <Arduino.h>
class battery : public module_base {
class Battery : public ModuleBase {
private:
system_logger *_logger;
ring_buffer<Task, 16> _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<Task, 16> 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);
};

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

@@ -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;

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

@@ -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<Task, 16> _queue;
HardwareSerial *data_stream_;
unsigned long baud_rate_ = 115200;
SystemLogger *logger_;
char buffer_[256];
unsigned int index_ = 0;
bool buffer_open_ = false;
RingBuffer<Task, 16> 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);
};

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

@@ -8,282 +8,282 @@
#include <math.h>
#include <string.h>
int config::push(const Task &task) { return _queue.push(task); }
int Config::push(const Task &task) { return queue_.push(task); }
int config::task_complete() {
_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;
}

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

@@ -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<Task, 16> _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<Task, 16> 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);
};

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

@@ -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,30 +53,30 @@ 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;
}

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

@@ -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<Task, 16> _queue;
uint32_t _last_fix_val = 0;
TinyGPSPlus *gps_;
HardwareSerial *data_stream_;
SystemLogger *logger_;
RingBuffer<Task, 16> 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();
GpsData getData();
};

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

@@ -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;
}

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

@@ -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<Task, 16> _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<Task, 16> 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);
};

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

@@ -7,62 +7,57 @@
#include <stdio.h>
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

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

@@ -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
};

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

@@ -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();
}
return 0;
}

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

@@ -12,20 +12,20 @@
#include <Arduino.h>
#include <max6675.h>
class thermocouple : public module_base {
class Thermocouple : public ModuleBase {
private:
system_logger *_logger;
ring_buffer<Task, 16> _queue;
MAX6675 *_thermocouple;
double _temp;
unsigned long _update_interval = 1000;
unsigned long _last_read = 0;
SystemLogger *logger_;
RingBuffer<Task, 16> 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);
};