pohui_pohui/firmware
1
0
Fork 0
mirror of https://github.com/meshtastic/firmware.git synced 2025-09-24 10:19:19 +00:00
Code Issues Actions 7 Packages Projects Releases Wiki Activity

Moduleconfig also changed to localConfig Model.

Browse Source
This commit is contained in:
Thomas Göttgens 2022-05-22 13:27:56 +02:00
parent e8262540d4
commit 6bb3861e95
18 changed files with 165 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/ButtonThread.h
View File

@ -118,8 +118,8 @@ class ButtonThread : public concurrency::OSThread
{ {
// DEBUG_MSG("press!\n"); // DEBUG_MSG("press!\n");
#ifdef BUTTON_PIN #ifdef BUTTON_PIN
if ((BUTTON_PIN != moduleConfig.payloadVariant.canned_message.inputbroker_pin_press) || if ((BUTTON_PIN != moduleConfig.canned_message.inputbroker_pin_press) ||
!moduleConfig.payloadVariant.canned_message.enabled) { !moduleConfig.canned_message.enabled) {
powerFSM.trigger(EVENT_PRESS); powerFSM.trigger(EVENT_PRESS);
} }
#endif #endif

4
src/graphics/Screen.cpp
View File

@ -353,8 +353,8 @@ static void drawCriticalFaultFrame(OLEDDisplay *display, OLEDDisplayUiState *sta
// Ignore messages orginating from phone (from the current node 0x0) unless range test or store and forward module are enabled // Ignore messages orginating from phone (from the current node 0x0) unless range test or store and forward module are enabled
static bool shouldDrawMessage(const MeshPacket *packet) static bool shouldDrawMessage(const MeshPacket *packet)
{ {
return packet->from != 0 && !moduleConfig.payloadVariant.range_test.enabled && return packet->from != 0 && !moduleConfig.range_test.enabled &&
!moduleConfig.payloadVariant.store_forward.enabled; !moduleConfig.store_forward.enabled;
} }
/// Draw the last text message we received /// Draw the last text message we received

16
src/input/RotaryEncoderInterruptImpl1.cpp
View File

@ -7,19 +7,19 @@ RotaryEncoderInterruptImpl1::RotaryEncoderInterruptImpl1() : RotaryEncoderInterr
void RotaryEncoderInterruptImpl1::init() void RotaryEncoderInterruptImpl1::init()
{ {
if (!moduleConfig.payloadVariant.canned_message.rotary1_enabled) { if (!moduleConfig.canned_message.rotary1_enabled) {
// Input device is disabled. // Input device is disabled.
return; return;
} }
uint8_t pinA = moduleConfig.payloadVariant.canned_message.inputbroker_pin_a; uint8_t pinA = moduleConfig.canned_message.inputbroker_pin_a;
uint8_t pinB = moduleConfig.payloadVariant.canned_message.inputbroker_pin_b; uint8_t pinB = moduleConfig.canned_message.inputbroker_pin_b;
uint8_t pinPress = moduleConfig.payloadVariant.canned_message.inputbroker_pin_press; uint8_t pinPress = moduleConfig.canned_message.inputbroker_pin_press;
char eventCw = static_cast<char>(moduleConfig.payloadVariant.canned_message.inputbroker_event_cw); char eventCw = static_cast<char>(moduleConfig.canned_message.inputbroker_event_cw);
char eventCcw = static_cast<char>(moduleConfig.payloadVariant.canned_message.inputbroker_event_ccw); char eventCcw = static_cast<char>(moduleConfig.canned_message.inputbroker_event_ccw);
char eventPressed = static_cast<char>(moduleConfig.payloadVariant.canned_message.inputbroker_event_press); char eventPressed = static_cast<char>(moduleConfig.canned_message.inputbroker_event_press);
// moduleConfig.payloadVariant.canned_message.ext_notification_module_output // moduleConfig.canned_message.ext_notification_module_output
RotaryEncoderInterruptBase::init(pinA, pinB, pinPress, eventCw, eventCcw, eventPressed, RotaryEncoderInterruptBase::init(pinA, pinB, pinPress, eventCw, eventCcw, eventPressed,
RotaryEncoderInterruptImpl1::handleIntA, RotaryEncoderInterruptImpl1::handleIntB, RotaryEncoderInterruptImpl1::handleIntA, RotaryEncoderInterruptImpl1::handleIntB,
RotaryEncoderInterruptImpl1::handleIntPressed); RotaryEncoderInterruptImpl1::handleIntPressed);

8
src/input/UpDownInterruptImpl1.cpp
View File

@ -8,14 +8,14 @@ UpDownInterruptImpl1::UpDownInterruptImpl1() : UpDownInterruptBase("upDown1") {}
void UpDownInterruptImpl1::init() void UpDownInterruptImpl1::init()
{ {
if (!moduleConfig.payloadVariant.canned_message.updown1_enabled) { if (!moduleConfig.canned_message.updown1_enabled) {
// Input device is disabled. // Input device is disabled.
return; return;
} }
uint8_t pinUp = moduleConfig.payloadVariant.canned_message.inputbroker_pin_a; uint8_t pinUp = moduleConfig.canned_message.inputbroker_pin_a;
uint8_t pinDown = moduleConfig.payloadVariant.canned_message.inputbroker_pin_b; uint8_t pinDown = moduleConfig.canned_message.inputbroker_pin_b;
uint8_t pinPress = moduleConfig.payloadVariant.canned_message.inputbroker_pin_press; uint8_t pinPress = moduleConfig.canned_message.inputbroker_pin_press;
char eventDown = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_KEY_DOWN); char eventDown = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_KEY_DOWN);
char eventUp = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_KEY_UP); char eventUp = static_cast<char>(ModuleConfig_CannedMessageConfig_InputEventChar_KEY_UP);

2
src/mesh/NodeDB.cpp
View File

@ -35,7 +35,7 @@ NodeDB nodeDB;
EXT_RAM_ATTR DeviceState devicestate; EXT_RAM_ATTR DeviceState devicestate;
MyNodeInfo &myNodeInfo = devicestate.my_node; MyNodeInfo &myNodeInfo = devicestate.my_node;
LocalConfig config; LocalConfig config;
ModuleConfig moduleConfig; LocalModuleConfig moduleConfig;
ChannelFile channelFile; ChannelFile channelFile;
/** The current change # for radio settings. Starts at 0 on boot and any time the radio settings /** The current change # for radio settings. Starts at 0 on boot and any time the radio settings

2
src/mesh/NodeDB.h
View File

@ -12,7 +12,7 @@ extern DeviceState devicestate;
extern ChannelFile channelFile; extern ChannelFile channelFile;
extern MyNodeInfo &myNodeInfo; extern MyNodeInfo &myNodeInfo;
extern LocalConfig config; extern LocalConfig config;
extern ModuleConfig moduleConfig; extern LocalModuleConfig moduleConfig;
extern User &owner; extern User &owner;
/// Given a node, return how many seconds in the past (vs now) that we last heard from it /// Given a node, return how many seconds in the past (vs now) that we last heard from it

2
src/mesh/Router.cpp
View File

@ -227,7 +227,7 @@ ErrorCode Router::send(MeshPacket *p)
*/ */
bool shouldActuallyEncrypt = true; bool shouldActuallyEncrypt = true;
if (*moduleConfig.payloadVariant.mqtt.address && !moduleConfig.payloadVariant.mqtt.encryption_enabled) { if (*moduleConfig.mqtt.address && !moduleConfig.mqtt.encryption_enabled) {
shouldActuallyEncrypt = false; shouldActuallyEncrypt = false;
} }

28
src/modules/AdminModule.cpp
View File

@ -208,31 +208,31 @@ void AdminModule::handleSetModuleConfig(const ModuleConfig &c)
switch (c.which_payloadVariant) { switch (c.which_payloadVariant) {
case ModuleConfig_mqtt_tag: case ModuleConfig_mqtt_tag:
DEBUG_MSG("Setting module config: MQTT\n"); DEBUG_MSG("Setting module config: MQTT\n");
moduleConfig.payloadVariant.mqtt = c.payloadVariant.mqtt; moduleConfig.mqtt = c.payloadVariant.mqtt;
break; break;
case ModuleConfig_serial_tag: case ModuleConfig_serial_tag:
DEBUG_MSG("Setting module config: Serial\n"); DEBUG_MSG("Setting module config: Serial\n");
moduleConfig.payloadVariant.serial = c.payloadVariant.serial; moduleConfig.serial = c.payloadVariant.serial;
break; break;
case ModuleConfig_external_notification_tag: case ModuleConfig_external_notification_tag:
DEBUG_MSG("Setting module config: External Notification\n"); DEBUG_MSG("Setting module config: External Notification\n");
moduleConfig.payloadVariant.external_notification = c.payloadVariant.external_notification; moduleConfig.external_notification = c.payloadVariant.external_notification;
break; break;
case ModuleConfig_store_forward_tag: case ModuleConfig_store_forward_tag:
DEBUG_MSG("Setting module config: Store & Forward\n"); DEBUG_MSG("Setting module config: Store & Forward\n");
moduleConfig.payloadVariant.store_forward = c.payloadVariant.store_forward; moduleConfig.store_forward = c.payloadVariant.store_forward;
break; break;
case ModuleConfig_range_test_tag: case ModuleConfig_range_test_tag:
DEBUG_MSG("Setting module config: Range Test\n"); DEBUG_MSG("Setting module config: Range Test\n");
moduleConfig.payloadVariant.range_test = c.payloadVariant.range_test; moduleConfig.range_test = c.payloadVariant.range_test;
break; break;
case ModuleConfig_telemetry_tag: case ModuleConfig_telemetry_tag:
DEBUG_MSG("Setting module config: Telemetry\n"); DEBUG_MSG("Setting module config: Telemetry\n");
moduleConfig.payloadVariant.telemetry = c.payloadVariant.telemetry; moduleConfig.telemetry = c.payloadVariant.telemetry;
break; break;
case ModuleConfig_canned_message_tag: case ModuleConfig_canned_message_tag:
DEBUG_MSG("Setting module config: Canned Message\n"); DEBUG_MSG("Setting module config: Canned Message\n");
moduleConfig.payloadVariant.canned_message = c.payloadVariant.canned_message; moduleConfig.canned_message = c.payloadVariant.canned_message;
break; break;
} }
@ -323,38 +323,38 @@ void AdminModule::handleGetModuleConfig(const MeshPacket &req, const uint32_t co
case AdminMessage_ModuleConfigType_MQTT_CONFIG: case AdminMessage_ModuleConfigType_MQTT_CONFIG:
DEBUG_MSG("Getting module config: MQTT\n"); DEBUG_MSG("Getting module config: MQTT\n");
res.get_module_config_response.which_payloadVariant = ModuleConfig_mqtt_tag; res.get_module_config_response.which_payloadVariant = ModuleConfig_mqtt_tag;
res.get_module_config_response.payloadVariant.mqtt = moduleConfig.payloadVariant.mqtt; res.get_module_config_response.payloadVariant.mqtt = moduleConfig.mqtt;
break; break;
case AdminMessage_ModuleConfigType_SERIAL_CONFIG: case AdminMessage_ModuleConfigType_SERIAL_CONFIG:
DEBUG_MSG("Getting module config: Serial\n"); DEBUG_MSG("Getting module config: Serial\n");
res.get_module_config_response.which_payloadVariant = ModuleConfig_serial_tag; res.get_module_config_response.which_payloadVariant = ModuleConfig_serial_tag;
res.get_module_config_response.payloadVariant.serial = moduleConfig.payloadVariant.serial; res.get_module_config_response.payloadVariant.serial = moduleConfig.serial;
break; break;
case AdminMessage_ModuleConfigType_EXTNOTIF_CONFIG: case AdminMessage_ModuleConfigType_EXTNOTIF_CONFIG:
DEBUG_MSG("Getting module config: External Notification\n"); DEBUG_MSG("Getting module config: External Notification\n");
res.get_module_config_response.which_payloadVariant = ModuleConfig_external_notification_tag; res.get_module_config_response.which_payloadVariant = ModuleConfig_external_notification_tag;
res.get_module_config_response.payloadVariant.external_notification = res.get_module_config_response.payloadVariant.external_notification =
moduleConfig.payloadVariant.external_notification; moduleConfig.external_notification;
break; break;
case AdminMessage_ModuleConfigType_STOREFORWARD_CONFIG: case AdminMessage_ModuleConfigType_STOREFORWARD_CONFIG:
DEBUG_MSG("Getting module config: Store & Forward\n"); DEBUG_MSG("Getting module config: Store & Forward\n");
res.get_module_config_response.which_payloadVariant = ModuleConfig_store_forward_tag; res.get_module_config_response.which_payloadVariant = ModuleConfig_store_forward_tag;
res.get_module_config_response.payloadVariant.store_forward = moduleConfig.payloadVariant.store_forward; res.get_module_config_response.payloadVariant.store_forward = moduleConfig.store_forward;
break; break;
case AdminMessage_ModuleConfigType_RANGETEST_CONFIG: case AdminMessage_ModuleConfigType_RANGETEST_CONFIG:
DEBUG_MSG("Getting module config: Range Test\n"); DEBUG_MSG("Getting module config: Range Test\n");
res.get_module_config_response.which_payloadVariant = ModuleConfig_range_test_tag; res.get_module_config_response.which_payloadVariant = ModuleConfig_range_test_tag;
res.get_module_config_response.payloadVariant.range_test = moduleConfig.payloadVariant.range_test; res.get_module_config_response.payloadVariant.range_test = moduleConfig.range_test;
break; break;
case AdminMessage_ModuleConfigType_TELEMETRY_CONFIG: case AdminMessage_ModuleConfigType_TELEMETRY_CONFIG:
DEBUG_MSG("Getting module config: Telemetry\n"); DEBUG_MSG("Getting module config: Telemetry\n");
res.get_module_config_response.which_payloadVariant = ModuleConfig_telemetry_tag; res.get_module_config_response.which_payloadVariant = ModuleConfig_telemetry_tag;
res.get_module_config_response.payloadVariant.telemetry = moduleConfig.payloadVariant.telemetry; res.get_module_config_response.payloadVariant.telemetry = moduleConfig.telemetry;
break; break;
case AdminMessage_ModuleConfigType_CANNEDMSG_CONFIG: case AdminMessage_ModuleConfigType_CANNEDMSG_CONFIG:
DEBUG_MSG("Getting module config: Canned Message\n"); DEBUG_MSG("Getting module config: Canned Message\n");
res.get_module_config_response.which_payloadVariant = ModuleConfig_canned_message_tag; res.get_module_config_response.which_payloadVariant = ModuleConfig_canned_message_tag;
res.get_module_config_response.payloadVariant.canned_message = moduleConfig.payloadVariant.canned_message; res.get_module_config_response.payloadVariant.canned_message = moduleConfig.canned_message;
break; break;
} }

14
src/modules/CannedMessageModule.cpp
View File

@ -28,7 +28,7 @@ extern bool saveProto(const char *filename, size_t protoSize, size_t objSize, co
CannedMessageModule::CannedMessageModule() CannedMessageModule::CannedMessageModule()
: SinglePortModule("canned", PortNum_TEXT_MESSAGE_APP), concurrency::OSThread("CannedMessageModule") : SinglePortModule("canned", PortNum_TEXT_MESSAGE_APP), concurrency::OSThread("CannedMessageModule")
{ {
if (moduleConfig.payloadVariant.canned_message.enabled) { if (moduleConfig.canned_message.enabled) {
this->loadProtoForModule(); this->loadProtoForModule();
if (this->splitConfiguredMessages() <= 0) { if (this->splitConfiguredMessages() <= 0) {
DEBUG_MSG("CannedMessageModule: No messages are configured. Module is disabled\n"); DEBUG_MSG("CannedMessageModule: No messages are configured. Module is disabled\n");
@ -91,9 +91,9 @@ int CannedMessageModule::splitConfiguredMessages()
int CannedMessageModule::handleInputEvent(const InputEvent *event) int CannedMessageModule::handleInputEvent(const InputEvent *event)
{ {
if ((strlen(moduleConfig.payloadVariant.canned_message.allow_input_source) > 0) && if ((strlen(moduleConfig.canned_message.allow_input_source) > 0) &&
(strcmp(moduleConfig.payloadVariant.canned_message.allow_input_source, event->source) != 0) && (strcmp(moduleConfig.canned_message.allow_input_source, event->source) != 0) &&
(strcmp(moduleConfig.payloadVariant.canned_message.allow_input_source, "_any") != 0)) { (strcmp(moduleConfig.canned_message.allow_input_source, "_any") != 0)) {
// Event source is not accepted. // Event source is not accepted.
// Event only accepted if source matches the configured one, or // Event only accepted if source matches the configured one, or
// the configured one is "_any" (or if there is no configured // the configured one is "_any" (or if there is no configured
@ -138,7 +138,7 @@ void CannedMessageModule::sendText(NodeNum dest, const char *message, bool wantR
p->want_ack = true; p->want_ack = true;
p->decoded.payload.size = strlen(message); p->decoded.payload.size = strlen(message);
memcpy(p->decoded.payload.bytes, message, p->decoded.payload.size); memcpy(p->decoded.payload.bytes, message, p->decoded.payload.size);
if (moduleConfig.payloadVariant.canned_message.send_bell) { if (moduleConfig.canned_message.send_bell) {
p->decoded.payload.bytes[p->decoded.payload.size - 1] = 7; // Bell character p->decoded.payload.bytes[p->decoded.payload.size - 1] = 7; // Bell character
p->decoded.payload.bytes[p->decoded.payload.size] = '\0'; // Bell character p->decoded.payload.bytes[p->decoded.payload.size] = '\0'; // Bell character
p->decoded.payload.size++; p->decoded.payload.size++;
@ -151,7 +151,7 @@ void CannedMessageModule::sendText(NodeNum dest, const char *message, bool wantR
int32_t CannedMessageModule::runOnce() int32_t CannedMessageModule::runOnce()
{ {
if ((!moduleConfig.payloadVariant.canned_message.enabled) || (this->runState == CANNED_MESSAGE_RUN_STATE_DISABLED) || if ((!moduleConfig.canned_message.enabled) || (this->runState == CANNED_MESSAGE_RUN_STATE_DISABLED) ||
(this->runState == CANNED_MESSAGE_RUN_STATE_INACTIVE)) { (this->runState == CANNED_MESSAGE_RUN_STATE_INACTIVE)) {
return 30000; // TODO: should return MAX_VAL return 30000; // TODO: should return MAX_VAL
} }
@ -214,7 +214,7 @@ const char *CannedMessageModule::getNextMessage()
} }
bool CannedMessageModule::shouldDraw() bool CannedMessageModule::shouldDraw()
{ {
if (!moduleConfig.payloadVariant.canned_message.enabled) { if (!moduleConfig.canned_message.enabled) {
return false; return false;
} }
return (currentMessageIndex != -1) || (this->runState != CANNED_MESSAGE_RUN_STATE_INACTIVE); return (currentMessageIndex != -1) || (this->runState != CANNED_MESSAGE_RUN_STATE_INACTIVE);

64
src/modules/ExternalNotificationModule.cpp
View File

@ -19,26 +19,26 @@
Quick reference: Quick reference:
moduleConfig.payloadVariant.external_notification.enabled moduleConfig.external_notification.enabled
0 = Disabled (Default) 0 = Disabled (Default)
1 = Enabled 1 = Enabled
moduleConfig.payloadVariant.external_notification.active moduleConfig.external_notification.active
0 = Active Low (Default) 0 = Active Low (Default)
1 = Active High 1 = Active High
moduleConfig.payloadVariant.external_notification.alert_message moduleConfig.external_notification.alert_message
0 = Disabled (Default) 0 = Disabled (Default)
1 = Alert when a text message comes 1 = Alert when a text message comes
moduleConfig.payloadVariant.external_notification.alert_bell moduleConfig.external_notification.alert_bell
0 = Disabled (Default) 0 = Disabled (Default)
1 = Alert when the bell character is received 1 = Alert when the bell character is received
moduleConfig.payloadVariant.external_notification.output moduleConfig.external_notification.output
GPIO of the output. (Default = 13) GPIO of the output. (Default = 13)
moduleConfig.payloadVariant.external_notification.output_ms moduleConfig.external_notification.output_ms
Amount of time in ms for the alert. Default is 1000. Amount of time in ms for the alert. Default is 1000.
*/ */
@ -59,19 +59,19 @@ int32_t ExternalNotificationModule::runOnce()
without having to configure it from the PythonAPI or WebUI. without having to configure it from the PythonAPI or WebUI.
*/ */
// moduleConfig.payloadVariant.external_notification.enabled = 1; // moduleConfig.external_notification.enabled = 1;
// moduleConfig.payloadVariant.external_notification.alert_message = 1; // moduleConfig.external_notification.alert_message = 1;
// moduleConfig.payloadVariant.external_notification.active = 1; // moduleConfig.external_notification.active = 1;
// moduleConfig.payloadVariant.external_notification.alert_bell = 1; // moduleConfig.external_notification.alert_bell = 1;
// moduleConfig.payloadVariant.external_notification.output_ms = 1000; // moduleConfig.external_notification.output_ms = 1000;
// moduleConfig.payloadVariant.external_notification.output = 13; // moduleConfig.external_notification.output = 13;
if (externalCurrentState) { if (externalCurrentState) {
// If the output is turned on, turn it back off after the given period of time. // If the output is turned on, turn it back off after the given period of time.
if (externalTurnedOn + (moduleConfig.payloadVariant.external_notification.output_ms if (externalTurnedOn + (moduleConfig.external_notification.output_ms
? moduleConfig.payloadVariant.external_notification.output_ms ? moduleConfig.external_notification.output_ms
: EXT_NOTIFICATION_MODULE_OUTPUT_MS) < : EXT_NOTIFICATION_MODULE_OUTPUT_MS) <
millis()) { millis()) {
DEBUG_MSG("Turning off external notification\n"); DEBUG_MSG("Turning off external notification\n");
@ -88,10 +88,10 @@ void ExternalNotificationModule::setExternalOn()
externalCurrentState = 1; externalCurrentState = 1;
externalTurnedOn = millis(); externalTurnedOn = millis();
digitalWrite((moduleConfig.payloadVariant.external_notification.output digitalWrite((moduleConfig.external_notification.output
? moduleConfig.payloadVariant.external_notification.output ? moduleConfig.external_notification.output
: EXT_NOTIFICATION_MODULE_OUTPUT), : EXT_NOTIFICATION_MODULE_OUTPUT),
(moduleConfig.payloadVariant.external_notification.active ? true : false)); (moduleConfig.external_notification.active ? true : false));
#endif #endif
} }
@ -100,10 +100,10 @@ void ExternalNotificationModule::setExternalOff()
#ifdef EXT_NOTIFY_OUT #ifdef EXT_NOTIFY_OUT
externalCurrentState = 0; externalCurrentState = 0;
digitalWrite((moduleConfig.payloadVariant.external_notification.output digitalWrite((moduleConfig.external_notification.output
? moduleConfig.payloadVariant.external_notification.output ? moduleConfig.external_notification.output
: EXT_NOTIFICATION_MODULE_OUTPUT), : EXT_NOTIFICATION_MODULE_OUTPUT),
(moduleConfig.payloadVariant.external_notification.active ? false : true)); (moduleConfig.external_notification.active ? false : true));
#endif #endif
} }
@ -124,21 +124,21 @@ ExternalNotificationModule::ExternalNotificationModule()
without having to configure it from the PythonAPI or WebUI. without having to configure it from the PythonAPI or WebUI.
*/ */
// moduleConfig.payloadVariant.external_notification.enabled = 1; // moduleConfig.external_notification.enabled = 1;
// moduleConfig.payloadVariant.external_notification.alert_message = 1; // moduleConfig.external_notification.alert_message = 1;
// moduleConfig.payloadVariant.external_notification.active = 1; // moduleConfig.external_notification.active = 1;
// moduleConfig.payloadVariant.external_notification.alert_bell = 1; // moduleConfig.external_notification.alert_bell = 1;
// moduleConfig.payloadVariant.external_notification.output_ms = 1000; // moduleConfig.external_notification.output_ms = 1000;
// moduleConfig.payloadVariant.external_notification.output = 13; // moduleConfig.external_notification.output = 13;
if (moduleConfig.payloadVariant.external_notification.enabled) { if (moduleConfig.external_notification.enabled) {
DEBUG_MSG("Initializing External Notification Module\n"); DEBUG_MSG("Initializing External Notification Module\n");
// Set the direction of a pin // Set the direction of a pin
pinMode((moduleConfig.payloadVariant.external_notification.output pinMode((moduleConfig.external_notification.output
? moduleConfig.payloadVariant.external_notification.output ? moduleConfig.external_notification.output
: EXT_NOTIFICATION_MODULE_OUTPUT), : EXT_NOTIFICATION_MODULE_OUTPUT),
OUTPUT); OUTPUT);
@ -157,13 +157,13 @@ ProcessMessage ExternalNotificationModule::handleReceived(const MeshPacket &mp)
#ifndef NO_ESP32 #ifndef NO_ESP32
#ifdef EXT_NOTIFY_OUT #ifdef EXT_NOTIFY_OUT
if (moduleConfig.payloadVariant.external_notification.enabled) { if (moduleConfig.external_notification.enabled) {
if (getFrom(&mp) != nodeDB.getNodeNum()) { if (getFrom(&mp) != nodeDB.getNodeNum()) {
// TODO: This may be a problem if messages are sent in unicide, but I'm not sure if it will. // TODO: This may be a problem if messages are sent in unicide, but I'm not sure if it will.
// Need to know if and how this could be a problem. // Need to know if and how this could be a problem.
if (moduleConfig.payloadVariant.external_notification.alert_bell) { if (moduleConfig.external_notification.alert_bell) {
auto &p = mp.decoded; auto &p = mp.decoded;
DEBUG_MSG("externalNotificationModule - Notification Bell\n"); DEBUG_MSG("externalNotificationModule - Notification Bell\n");
for (int i = 0; i < p.payload.size; i++) { for (int i = 0; i < p.payload.size; i++) {
@ -173,7 +173,7 @@ ProcessMessage ExternalNotificationModule::handleReceived(const MeshPacket &mp)
} }
} }
if (moduleConfig.payloadVariant.external_notification.alert_message) { if (moduleConfig.external_notification.alert_message) {
DEBUG_MSG("externalNotificationModule - Notification Module\n"); DEBUG_MSG("externalNotificationModule - Notification Module\n");
setExternalOn(); setExternalOn();
} }

2
src/modules/Telemetry/DeviceTelemetry.cpp
View File

@ -21,7 +21,7 @@ int32_t DeviceTelemetryModule::runOnce()
sendOurTelemetry(); sendOurTelemetry();
// OSThread library. Multiply the preference value by 1000 to convert seconds to miliseconds // OSThread library. Multiply the preference value by 1000 to convert seconds to miliseconds
return getIntervalOrDefaultMs(moduleConfig.payloadVariant.telemetry.device_update_interval); return getIntervalOrDefaultMs(moduleConfig.telemetry.device_update_interval);
#endif #endif
} }

48
src/modules/Telemetry/EnvironmentTelemetry.cpp
View File

@ -50,17 +50,17 @@ int32_t EnvironmentTelemetryModule::runOnce()
without having to configure it from the PythonAPI or WebUI. without having to configure it from the PythonAPI or WebUI.
*/ */
/* /*
moduleConfig.payloadVariant.telemetry.environment_measurement_enabled = 1; moduleConfig.telemetry.environment_measurement_enabled = 1;
moduleConfig.payloadVariant.telemetry.environment_screen_enabled = 1; moduleConfig.telemetry.environment_screen_enabled = 1;
moduleConfig.payloadVariant.telemetry.environment_read_error_count_threshold = 5; moduleConfig.telemetry.environment_read_error_count_threshold = 5;
moduleConfig.payloadVariant.telemetry.environment_update_interval = 600; moduleConfig.telemetry.environment_update_interval = 600;
moduleConfig.payloadVariant.telemetry.environment_recovery_interval = 60; moduleConfig.telemetry.environment_recovery_interval = 60;
moduleConfig.payloadVariant.telemetry.environment_sensor_pin = 13; // If one-wire moduleConfig.telemetry.environment_sensor_pin = 13; // If one-wire
moduleConfig.payloadVariant.telemetry.environment_sensor_type = TelemetrySensorType::TelemetrySensorType_BME280; moduleConfig.telemetry.environment_sensor_type = TelemetrySensorType::TelemetrySensorType_BME280;
*/ */
if (!(moduleConfig.payloadVariant.telemetry.environment_measurement_enabled || if (!(moduleConfig.telemetry.environment_measurement_enabled ||
moduleConfig.payloadVariant.telemetry.environment_screen_enabled)) { moduleConfig.telemetry.environment_screen_enabled)) {
// If this module is not enabled, and the user doesn't want the display screen don't waste any OSThread time on it // If this module is not enabled, and the user doesn't want the display screen don't waste any OSThread time on it
return (INT32_MAX); return (INT32_MAX);
} }
@ -69,11 +69,11 @@ int32_t EnvironmentTelemetryModule::runOnce()
// This is the first time the OSThread library has called this function, so do some setup // This is the first time the OSThread library has called this function, so do some setup
firstTime = 0; firstTime = 0;
if (moduleConfig.payloadVariant.telemetry.environment_measurement_enabled) { if (moduleConfig.telemetry.environment_measurement_enabled) {
DEBUG_MSG("Environment Telemetry: Initializing\n"); DEBUG_MSG("Environment Telemetry: Initializing\n");
// it's possible to have this module enabled, only for displaying values on the screen. // it's possible to have this module enabled, only for displaying values on the screen.
// therefore, we should only enable the sensor loop if measurement is also enabled // therefore, we should only enable the sensor loop if measurement is also enabled
switch (moduleConfig.payloadVariant.telemetry.environment_sensor_type) { switch (moduleConfig.telemetry.environment_sensor_type) {
case TelemetrySensorType_DHT11: case TelemetrySensorType_DHT11:
case TelemetrySensorType_DHT12: case TelemetrySensorType_DHT12:
@ -97,35 +97,35 @@ int32_t EnvironmentTelemetryModule::runOnce()
return (INT32_MAX); return (INT32_MAX);
} else { } else {
// if we somehow got to a second run of this module with measurement disabled, then just wait forever // if we somehow got to a second run of this module with measurement disabled, then just wait forever
if (!moduleConfig.payloadVariant.telemetry.environment_measurement_enabled) if (!moduleConfig.telemetry.environment_measurement_enabled)
return (INT32_MAX); return (INT32_MAX);
// this is not the first time OSThread library has called this function // this is not the first time OSThread library has called this function
// so just do what we intend to do on the interval // so just do what we intend to do on the interval
if (sensor_read_error_count > moduleConfig.payloadVariant.telemetry.environment_read_error_count_threshold) { if (sensor_read_error_count > moduleConfig.telemetry.environment_read_error_count_threshold) {
if (moduleConfig.payloadVariant.telemetry.environment_recovery_interval > 0) { if (moduleConfig.telemetry.environment_recovery_interval > 0) {
DEBUG_MSG("Environment Telemetry: TEMPORARILY DISABLED; The " DEBUG_MSG("Environment Telemetry: TEMPORARILY DISABLED; The "
"telemetry_module_environment_read_error_count_threshold has been exceed: %d. Will retry reads in " "telemetry_module_environment_read_error_count_threshold has been exceed: %d. Will retry reads in "
"%d seconds\n", "%d seconds\n",
moduleConfig.payloadVariant.telemetry.environment_read_error_count_threshold, moduleConfig.telemetry.environment_read_error_count_threshold,
moduleConfig.payloadVariant.telemetry.environment_recovery_interval); moduleConfig.telemetry.environment_recovery_interval);
sensor_read_error_count = 0; sensor_read_error_count = 0;
return (moduleConfig.payloadVariant.telemetry.environment_recovery_interval * 1000); return (moduleConfig.telemetry.environment_recovery_interval * 1000);
} }
DEBUG_MSG("Environment Telemetry: DISABLED; The telemetry_module_environment_read_error_count_threshold has " DEBUG_MSG("Environment Telemetry: DISABLED; The telemetry_module_environment_read_error_count_threshold has "
"been exceed: %d. Reads will not be retried until after device reset\n", "been exceed: %d. Reads will not be retried until after device reset\n",
moduleConfig.payloadVariant.telemetry.environment_read_error_count_threshold); moduleConfig.telemetry.environment_read_error_count_threshold);
return (INT32_MAX); return (INT32_MAX);
} else if (sensor_read_error_count > 0) { } else if (sensor_read_error_count > 0) {
DEBUG_MSG("Environment Telemetry: There have been %d sensor read failures. Will retry %d more times\n", DEBUG_MSG("Environment Telemetry: There have been %d sensor read failures. Will retry %d more times\n",
sensor_read_error_count, sensor_read_error_count, sensor_read_error_count, sensor_read_error_count, sensor_read_error_count, sensor_read_error_count,
moduleConfig.payloadVariant.telemetry.environment_read_error_count_threshold - sensor_read_error_count); moduleConfig.telemetry.environment_read_error_count_threshold - sensor_read_error_count);
} }
if (!sendOurTelemetry()) { if (!sendOurTelemetry()) {
// if we failed to read the sensor, then try again // if we failed to read the sensor, then try again
// as soon as we can according to the maximum polling frequency // as soon as we can according to the maximum polling frequency
switch (moduleConfig.payloadVariant.telemetry.environment_sensor_type) { switch (moduleConfig.telemetry.environment_sensor_type) {
case TelemetrySensorType_DHT11: case TelemetrySensorType_DHT11:
case TelemetrySensorType_DHT12: case TelemetrySensorType_DHT12:
case TelemetrySensorType_DHT21: case TelemetrySensorType_DHT21:
@ -143,7 +143,7 @@ int32_t EnvironmentTelemetryModule::runOnce()
} }
} }
} }
return getIntervalOrDefaultMs(moduleConfig.payloadVariant.telemetry.environment_update_interval); return getIntervalOrDefaultMs(moduleConfig.telemetry.environment_update_interval);
#endif #endif
} }
@ -161,7 +161,7 @@ uint32_t GetTimeSinceMeshPacket(const MeshPacket *mp)
bool EnvironmentTelemetryModule::wantUIFrame() bool EnvironmentTelemetryModule::wantUIFrame()
{ {
return moduleConfig.payloadVariant.telemetry.environment_screen_enabled; return moduleConfig.telemetry.environment_screen_enabled;
} }
float EnvironmentTelemetryModule::CelsiusToFahrenheit(float c) float EnvironmentTelemetryModule::CelsiusToFahrenheit(float c)
@ -195,7 +195,7 @@ void EnvironmentTelemetryModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiSt
display->setFont(FONT_SMALL); display->setFont(FONT_SMALL);
String last_temp = String(lastMeasurement.variant.environment_metrics.temperature, 0) + "°C"; String last_temp = String(lastMeasurement.variant.environment_metrics.temperature, 0) + "°C";
if (moduleConfig.payloadVariant.telemetry.environment_display_fahrenheit) { if (moduleConfig.telemetry.environment_display_fahrenheit) {
last_temp = String(CelsiusToFahrenheit(lastMeasurement.variant.environment_metrics.temperature), 0) + "°F"; last_temp = String(CelsiusToFahrenheit(lastMeasurement.variant.environment_metrics.temperature), 0) + "°F";
} }
display->drawString(x, y += fontHeight(FONT_MEDIUM) - 2, "From: " + String(lastSender) + "(" + String(agoSecs) + "s)"); display->drawString(x, y += fontHeight(FONT_MEDIUM) - 2, "From: " + String(lastSender) + "(" + String(agoSecs) + "s)");
@ -244,7 +244,7 @@ bool EnvironmentTelemetryModule::sendOurTelemetry(NodeNum dest, bool wantReplies
DEBUG_MSG("-----------------------------------------\n"); DEBUG_MSG("-----------------------------------------\n");
DEBUG_MSG("Environment Telemetry: Read data\n"); DEBUG_MSG("Environment Telemetry: Read data\n");
switch (moduleConfig.payloadVariant.telemetry.environment_sensor_type) { switch (moduleConfig.telemetry.environment_sensor_type) {
case TelemetrySensorType_DS18B20: case TelemetrySensorType_DS18B20:
if (!dallasSensor.getMeasurement(&m)) if (!dallasSensor.getMeasurement(&m))
sensor_read_error_count++; sensor_read_error_count++;

6
src/modules/Telemetry/Sensor/DHTSensor.cpp
View File

@ -10,14 +10,14 @@ DHTSensor::DHTSensor() : TelemetrySensor{} {}
int32_t DHTSensor::runOnce() int32_t DHTSensor::runOnce()
{ {
if (TelemetrySensorType_DHT11 || TelemetrySensorType_DHT12) { if (TelemetrySensorType_DHT11 || TelemetrySensorType_DHT12) {
dht = new DHT(moduleConfig.payloadVariant.telemetry.environment_sensor_pin, DHT11); dht = new DHT(moduleConfig.telemetry.environment_sensor_pin, DHT11);
} else { } else {
dht = new DHT(moduleConfig.payloadVariant.telemetry.environment_sensor_pin, DHT22); dht = new DHT(moduleConfig.telemetry.environment_sensor_pin, DHT22);
} }
dht->begin(); dht->begin();
dht->read(); dht->read();
DEBUG_MSG("Telemetry: Opened DHT11/DHT12 on pin: %d\n", moduleConfig.payloadVariant.telemetry.environment_sensor_pin); DEBUG_MSG("Telemetry: Opened DHT11/DHT12 on pin: %d\n", moduleConfig.telemetry.environment_sensor_pin);
return (DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS); return (DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
} }

4
src/modules/Telemetry/Sensor/DallasSensor.cpp
View File

@ -10,12 +10,12 @@ DallasSensor::DallasSensor() : TelemetrySensor{} {}
int32_t DallasSensor::runOnce() int32_t DallasSensor::runOnce()
{ {
oneWire = new OneWire(moduleConfig.payloadVariant.telemetry.environment_sensor_pin); oneWire = new OneWire(moduleConfig.telemetry.environment_sensor_pin);
ds18b20 = new DS18B20(oneWire); ds18b20 = new DS18B20(oneWire);
ds18b20->begin(); ds18b20->begin();
ds18b20->setResolution(12); ds18b20->setResolution(12);
ds18b20->requestTemperatures(); ds18b20->requestTemperatures();
DEBUG_MSG("Telemetry: Opened DS18B20 on pin: %d\n", moduleConfig.payloadVariant.telemetry.environment_sensor_pin); DEBUG_MSG("Telemetry: Opened DS18B20 on pin: %d\n", moduleConfig.telemetry.environment_sensor_pin);
return (DS18B20_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS); return (DS18B20_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
} }

18
src/modules/esp32/RangeTestModule.cpp
View File

@ -36,23 +36,23 @@ int32_t RangeTestModule::runOnce()
without having to configure it from the PythonAPI or WebUI. without having to configure it from the PythonAPI or WebUI.
*/ */
// moduleConfig.payloadVariant.range_test.enabled = 1; // moduleConfig.range_test.enabled = 1;
// moduleConfig.payloadVariant.range_test.sender = 45; // moduleConfig.range_test.sender = 45;
// moduleConfig.payloadVariant.range_test.save = 1; // moduleConfig.range_test.save = 1;
// Fixed position is useful when testing indoors. // Fixed position is useful when testing indoors.
// radioConfig.preferences.fixed_position = 1; // radioConfig.preferences.fixed_position = 1;
uint32_t senderHeartbeat = moduleConfig.payloadVariant.range_test.sender * 1000; uint32_t senderHeartbeat = moduleConfig.range_test.sender * 1000;
if (moduleConfig.payloadVariant.range_test.enabled) { if (moduleConfig.range_test.enabled) {
if (firstTime) { if (firstTime) {
rangeTestModuleRadio = new RangeTestModuleRadio(); rangeTestModuleRadio = new RangeTestModuleRadio();
firstTime = 0; firstTime = 0;
if (moduleConfig.payloadVariant.range_test.sender) { if (moduleConfig.range_test.sender) {
DEBUG_MSG("Initializing Range Test Module -- Sender\n"); DEBUG_MSG("Initializing Range Test Module -- Sender\n");
return (5000); // Sending first message 5 seconds after initilization. return (5000); // Sending first message 5 seconds after initilization.
} else { } else {
@ -62,7 +62,7 @@ int32_t RangeTestModule::runOnce()
} else { } else {
if (moduleConfig.payloadVariant.range_test.sender) { if (moduleConfig.range_test.sender) {
// If sender // If sender
DEBUG_MSG("Range Test Module - Sending heartbeat every %d ms\n", (senderHeartbeat)); DEBUG_MSG("Range Test Module - Sending heartbeat every %d ms\n", (senderHeartbeat));
@ -131,7 +131,7 @@ ProcessMessage RangeTestModuleRadio::handleReceived(const MeshPacket &mp)
{ {
#ifndef NO_ESP32 #ifndef NO_ESP32
if (moduleConfig.payloadVariant.range_test.enabled) { if (moduleConfig.range_test.enabled) {
/* /*
auto &p = mp.decoded; auto &p = mp.decoded;
@ -141,7 +141,7 @@ ProcessMessage RangeTestModuleRadio::handleReceived(const MeshPacket &mp)
if (getFrom(&mp) != nodeDB.getNodeNum()) { if (getFrom(&mp) != nodeDB.getNodeNum()) {
if (moduleConfig.payloadVariant.range_test.save) { if (moduleConfig.range_test.save) {
appendFile(mp); appendFile(mp);
} }

64
src/modules/esp32/SerialModule.cpp
View File

@ -76,13 +76,13 @@ int32_t SerialModule::runOnce()
without having to configure it from the PythonAPI or WebUI. without having to configure it from the PythonAPI or WebUI.
*/ */
// moduleConfig.payloadVariant.serial.enabled = 1; // moduleConfig.serial.enabled = 1;
// moduleConfig.payloadVariant.serial.rxd = 35; // moduleConfig.serial.rxd = 35;
// moduleConfig.payloadVariant.serial.txd = 15; // moduleConfig.serial.txd = 15;
// moduleConfig.payloadVariant.serial.timeout = 1000; // moduleConfig.serial.timeout = 1000;
// moduleConfig.payloadVariant.serial.echo = 1; // moduleConfig.serial.echo = 1;
if (moduleConfig.payloadVariant.serial.enabled) { if (moduleConfig.serial.enabled) {
if (firstTime) { if (firstTime) {
@ -91,65 +91,65 @@ int32_t SerialModule::runOnce()
uint32_t baud = 0; uint32_t baud = 0;
if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_Default) { if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_Default) {
baud = 38400; baud = 38400;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_110) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_110) {
baud = 110; baud = 110;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_300) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_300) {
baud = 300; baud = 300;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_600) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_600) {
baud = 600; baud = 600;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_1200) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_1200) {
baud = 1200; baud = 1200;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_2400) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_2400) {
baud = 2400; baud = 2400;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_4800) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_4800) {
baud = 4800; baud = 4800;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_9600) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_9600) {
baud = 9600; baud = 9600;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_19200) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_19200) {
baud = 19200; baud = 19200;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_38400) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_38400) {
baud = 38400; baud = 38400;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_57600) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_57600) {
baud = 57600; baud = 57600;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_115200) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_115200) {
baud = 115200; baud = 115200;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_230400) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_230400) {
baud = 230400; baud = 230400;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_460800) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_460800) {
baud = 460800; baud = 460800;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_576000) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_576000) {
baud = 576000; baud = 576000;
} else if (moduleConfig.payloadVariant.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_921600) { } else if (moduleConfig.serial.baud == ModuleConfig_SerialConfig_Serial_Baud_BAUD_921600) {
baud = 921600; baud = 921600;
} }
if (moduleConfig.payloadVariant.serial.rxd && moduleConfig.payloadVariant.serial.txd) { if (moduleConfig.serial.rxd && moduleConfig.serial.txd) {
Serial2.begin(baud, SERIAL_8N1, moduleConfig.payloadVariant.serial.rxd, moduleConfig.payloadVariant.serial.txd); Serial2.begin(baud, SERIAL_8N1, moduleConfig.serial.rxd, moduleConfig.serial.txd);
} else { } else {
Serial2.begin(baud, SERIAL_8N1, RXD2, TXD2); Serial2.begin(baud, SERIAL_8N1, RXD2, TXD2);
} }
if (moduleConfig.payloadVariant.serial.timeout) { if (moduleConfig.serial.timeout) {
Serial2.setTimeout( Serial2.setTimeout(
moduleConfig.payloadVariant.serial.timeout); // Number of MS to wait to set the timeout for the string. moduleConfig.serial.timeout); // Number of MS to wait to set the timeout for the string.
} else { } else {
Serial2.setTimeout(TIMEOUT); // Number of MS to wait to set the timeout for the string. Serial2.setTimeout(TIMEOUT); // Number of MS to wait to set the timeout for the string.
@ -211,7 +211,7 @@ ProcessMessage SerialModuleRadio::handleReceived(const MeshPacket &mp)
{ {
#ifndef NO_ESP32 #ifndef NO_ESP32
if (moduleConfig.payloadVariant.serial.enabled) { if (moduleConfig.serial.enabled) {
auto &p = mp.decoded; auto &p = mp.decoded;
// DEBUG_MSG("Received text msg self=0x%0x, from=0x%0x, to=0x%0x, id=%d, msg=%.*s\n", // DEBUG_MSG("Received text msg self=0x%0x, from=0x%0x, to=0x%0x, id=%d, msg=%.*s\n",
@ -220,10 +220,10 @@ ProcessMessage SerialModuleRadio::handleReceived(const MeshPacket &mp)
if (getFrom(&mp) == nodeDB.getNodeNum()) { if (getFrom(&mp) == nodeDB.getNodeNum()) {
/* /*
* If moduleConfig.payloadVariant.serial.echo is true, then echo the packets that are sent out * If moduleConfig.serial.echo is true, then echo the packets that are sent out
* back to the TX of the serial interface. * back to the TX of the serial interface.
*/ */
if (moduleConfig.payloadVariant.serial.echo) { if (moduleConfig.serial.echo) {
// For some reason, we get the packet back twice when we send out of the radio. // For some reason, we get the packet back twice when we send out of the radio.
// TODO: need to find out why. // TODO: need to find out why.
@ -237,13 +237,13 @@ ProcessMessage SerialModuleRadio::handleReceived(const MeshPacket &mp)
} else { } else {
if (moduleConfig.payloadVariant.serial.mode == ModuleConfig_SerialConfig_Serial_Mode_MODE_Default || if (moduleConfig.serial.mode == ModuleConfig_SerialConfig_Serial_Mode_MODE_Default ||
moduleConfig.payloadVariant.serial.mode == ModuleConfig_SerialConfig_Serial_Mode_MODE_SIMPLE) { moduleConfig.serial.mode == ModuleConfig_SerialConfig_Serial_Mode_MODE_SIMPLE) {
// DEBUG_MSG("* * Message came from the mesh\n"); // DEBUG_MSG("* * Message came from the mesh\n");
// Serial2.println("* * Message came from the mesh"); // Serial2.println("* * Message came from the mesh");
Serial2.printf("%s", p.payload.bytes); Serial2.printf("%s", p.payload.bytes);
} else if (moduleConfig.payloadVariant.serial.mode == ModuleConfig_SerialConfig_Serial_Mode_MODE_PROTO) { } else if (moduleConfig.serial.mode == ModuleConfig_SerialConfig_Serial_Mode_MODE_PROTO) {
} }
} }

26
src/modules/esp32/StoreForwardModule.cpp
View File

@ -19,7 +19,7 @@ int32_t StoreForwardModule::runOnce()
#ifndef NO_ESP32 #ifndef NO_ESP32
if (moduleConfig.payloadVariant.store_forward.enabled) { if (moduleConfig.store_forward.enabled) {
if (config.device.role == Config_DeviceConfig_Role_Router) { if (config.device.role == Config_DeviceConfig_Role_Router) {
@ -242,7 +242,7 @@ void StoreForwardModule::sendMessage(NodeNum dest, char *str)
ProcessMessage StoreForwardModule::handleReceived(const MeshPacket &mp) ProcessMessage StoreForwardModule::handleReceived(const MeshPacket &mp)
{ {
#ifndef NO_ESP32 #ifndef NO_ESP32
if (moduleConfig.payloadVariant.store_forward.enabled) { if (moduleConfig.store_forward.enabled) {
DEBUG_MSG("--- S&F Received something\n"); DEBUG_MSG("--- S&F Received something\n");
@ -295,7 +295,7 @@ ProcessMessage StoreForwardModule::handleReceived(const MeshPacket &mp)
ProcessMessage StoreForwardModule::handleReceivedProtobuf(const MeshPacket &mp, StoreAndForward *p) ProcessMessage StoreForwardModule::handleReceivedProtobuf(const MeshPacket &mp, StoreAndForward *p)
{ {
if (!moduleConfig.payloadVariant.store_forward.enabled) { if (!moduleConfig.store_forward.enabled) {
// If this module is not enabled in any capacity, don't handle the packet, and allow other modules to consume // If this module is not enabled in any capacity, don't handle the packet, and allow other modules to consume
return ProcessMessage::CONTINUE; return ProcessMessage::CONTINUE;
} }
@ -391,11 +391,11 @@ StoreForwardModule::StoreForwardModule()
without having to configure it from the PythonAPI or WebUI. without having to configure it from the PythonAPI or WebUI.
*/ */
moduleConfig.payloadVariant.store_forward.enabled = 1; moduleConfig.store_forward.enabled = 1;
config.power.is_always_powered = 1; config.power.is_always_powered = 1;
} }
if (moduleConfig.payloadVariant.store_forward.enabled) { if (moduleConfig.store_forward.enabled) {
// Router // Router
if (config.device.role == Config_DeviceConfig_Role_Router) { if (config.device.role == Config_DeviceConfig_Role_Router) {
@ -406,20 +406,20 @@ StoreForwardModule::StoreForwardModule()
// Do the startup here // Do the startup here
// Maximum number of records to return. // Maximum number of records to return.
if (moduleConfig.payloadVariant.store_forward.history_return_max) if (moduleConfig.store_forward.history_return_max)
this->historyReturnMax = moduleConfig.payloadVariant.store_forward.history_return_max; this->historyReturnMax = moduleConfig.store_forward.history_return_max;
// Maximum time window for records to return (in minutes) // Maximum time window for records to return (in minutes)
if (moduleConfig.payloadVariant.store_forward.history_return_window) if (moduleConfig.store_forward.history_return_window)
this->historyReturnWindow = moduleConfig.payloadVariant.store_forward.history_return_window; this->historyReturnWindow = moduleConfig.store_forward.history_return_window;
// Maximum number of records to store in memory // Maximum number of records to store in memory
if (moduleConfig.payloadVariant.store_forward.records) if (moduleConfig.store_forward.records)
this->records = moduleConfig.payloadVariant.store_forward.records; this->records = moduleConfig.store_forward.records;
// Maximum number of records to store in memory // Maximum number of records to store in memory
if (moduleConfig.payloadVariant.store_forward.heartbeat) if (moduleConfig.store_forward.heartbeat)
this->heartbeat = moduleConfig.payloadVariant.store_forward.heartbeat; this->heartbeat = moduleConfig.store_forward.heartbeat;
// Popupate PSRAM with our data structures. // Popupate PSRAM with our data structures.
this->populatePSRAM(); this->populatePSRAM();

18
src/mqtt/MQTT.cpp
View File

@ -111,18 +111,18 @@ void MQTT::reconnect()
const char *mqttUsername = "meshdev"; const char *mqttUsername = "meshdev";
const char *mqttPassword = "large4cats"; const char *mqttPassword = "large4cats";
if (*moduleConfig.payloadVariant.mqtt.address) { if (*moduleConfig.mqtt.address) {
serverAddr = moduleConfig.payloadVariant.mqtt.address; // Override the default serverAddr = moduleConfig.mqtt.address; // Override the default
mqttUsername = mqttUsername =
moduleConfig.payloadVariant.mqtt.username; // do not use the hardcoded credentials for a custom mqtt server moduleConfig.mqtt.username; // do not use the hardcoded credentials for a custom mqtt server
mqttPassword = moduleConfig.payloadVariant.mqtt.password; mqttPassword = moduleConfig.mqtt.password;
} else { } else {
// we are using the default server. Use the hardcoded credentials by default, but allow overriding // we are using the default server. Use the hardcoded credentials by default, but allow overriding
if (*moduleConfig.payloadVariant.mqtt.username && moduleConfig.payloadVariant.mqtt.username[0] != '\0') { if (*moduleConfig.mqtt.username && moduleConfig.mqtt.username[0] != '\0') {
mqttUsername = moduleConfig.payloadVariant.mqtt.username; mqttUsername = moduleConfig.mqtt.username;
} }
if (*moduleConfig.payloadVariant.mqtt.password && moduleConfig.payloadVariant.mqtt.password[0] != '\0') { if (*moduleConfig.mqtt.password && moduleConfig.mqtt.password[0] != '\0') {
mqttPassword = moduleConfig.payloadVariant.mqtt.password; mqttPassword = moduleConfig.mqtt.password;
} }
} }
@ -175,7 +175,7 @@ bool MQTT::wantsLink() const
{ {
bool hasChannel = false; bool hasChannel = false;
if (moduleConfig.payloadVariant.mqtt.disabled) { if (moduleConfig.mqtt.disabled) {
// DEBUG_MSG("MQTT disabled...\n"); // DEBUG_MSG("MQTT disabled...\n");
} else { } else {
// No need for link if no channel needed it // No need for link if no channel needed it