diff --git a/.clang-format b/.clang-format
index 8ba7304c4686d7bf03150814f7a17554ba424175..7abb256cdd1d5fc9f2a79f19dfa70d6f55c6fe63 100644
--- a/.clang-format
+++ b/.clang-format
@@ -9,6 +9,7 @@ AllowShortFunctionsOnASingleLine: Inline
AlwaysBreakTemplateDeclarations: Yes
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeBraces: Custom
+NamespaceIndentation: All
BraceWrapping:
AfterFunction: false
...
diff --git a/host/host_central_mast/include/MessageType.h b/host/host_central_mast/include/MessageType.h
new file mode 100644
index 0000000000000000000000000000000000000000..787afad32ef6fba58a5e7519ca06dff97b827988
--- /dev/null
+++ b/host/host_central_mast/include/MessageType.h
@@ -0,0 +1,16 @@
+//
+// Created by zoe on 1/24/23.
+//
+
+#ifndef HOST_CENTRAL_MAST_MESSAGETYPE_H
+#define HOST_CENTRAL_MAST_MESSAGETYPE_H
+
+enum MessageType { dataAck, hostChange };
+
+typedef struct response {
+ MessageType type;
+ uint8_t mac[6];
+ long time; // Clang-Tidy: Narrowing conversion from 'unsigned long' to signed type 'long' is implementation-defined
+ // (see rtc in main.cpp)
+} response;
+#endif // HOST_CENTRAL_MAST_MESSAGETYPE_H
diff --git a/host/host_central_mast/lib/TimeManager/NTPException.hpp b/host/host_central_mast/lib/NTPManager/NTPException.hpp
similarity index 100%
rename from host/host_central_mast/lib/TimeManager/NTPException.hpp
rename to host/host_central_mast/lib/NTPManager/NTPException.hpp
diff --git a/host/host_central_mast/lib/TimeManager/TimeManager.cpp b/host/host_central_mast/lib/NTPManager/NTPManager.cpp
similarity index 65%
rename from host/host_central_mast/lib/TimeManager/TimeManager.cpp
rename to host/host_central_mast/lib/NTPManager/NTPManager.cpp
index 4d5c5b5fdf75b8616b4dcb56a65c63f4689ffc59..f99ff9e7c17706d16cb9ab1a33debc07f283df1d 100644
--- a/host/host_central_mast/lib/TimeManager/TimeManager.cpp
+++ b/host/host_central_mast/lib/NTPManager/NTPManager.cpp
@@ -2,18 +2,18 @@
// Created by zoe on 12/19/22.
//
-#include "TimeManager.h"
+#include "NTPManager.h"
-TimeManager::TimeManager(TinyGsmSim7000 &modem) : modem(modem) {}
+NTPManager::NTPManager(TinyGsmSim7000 &modem) : modem(modem) {}
-void TimeManager::syncNTP(const std::string &ntpServer, const std::string &backupNtpServer) {
+void NTPManager::syncNTP(const std::string &ntpServer, const std::string &backupNtpServer) {
// create list of ntp servers
std::vector<std::string> ntpServers;
ntpServers.push_back(ntpServer);
ntpServers.push_back(backupNtpServer);
tryNtpServerSync(backupNtpServer, ntpServers);
}
-void TimeManager::tryNtpServerSync(const std::string &backupNtpServer,
+void NTPManager::tryNtpServerSync(const std::string &backupNtpServer,
std::vector<std::string> &ntpServers) { // try to sync ntp with each server
for (const auto &server : ntpServers) {
try {
@@ -21,15 +21,16 @@ void TimeManager::tryNtpServerSync(const std::string &backupNtpServer,
return;
} catch (NTPException &e) {
if (server == backupNtpServer) {
- esp_log_write(ESP_LOG_ERROR, TAG, "Failed to sync NTP with %s (%s)\n", server.c_str(), e.what());
+ esp_log_write(ESP_LOG_ERROR, TAG_TIMEMANAGER, "Failed to sync NTP with %s (%s)\n", server.c_str(),
+ e.what());
}
- esp_log_write(ESP_LOG_ERROR, TAG, "Failed to sync NTP with %s (%s). Retrying with backup...\n",
+ esp_log_write(ESP_LOG_ERROR, TAG_TIMEMANAGER, "Failed to sync NTP with %s (%s). Retrying with backup...\n",
server.c_str(), e.what());
}
}
}
-void TimeManager::synchronizeNTPWithModem(const std::string &ntpServer) {
- esp_log_write(ESP_LOG_DEBUG, TAG, "NTP Server Syncing...\n");
+void NTPManager::synchronizeNTPWithModem(const std::string &ntpServer) {
+ esp_log_write(ESP_LOG_DEBUG, TAG_TIMEMANAGER, "NTP Server Syncing...\n");
long error = modem.NTPServerSync(ntpServer.c_str(), timeZone);
/**
@@ -46,11 +47,11 @@ void TimeManager::synchronizeNTPWithModem(const std::string &ntpServer) {
if (error != 1 && error != 255) {
throw NTPException(modem.ShowNTPError(error).c_str());
} else {
- esp_log_write(ESP_LOG_DEBUG, TAG, "NTP: Network time synchronization is successful\n");
+ esp_log_write(ESP_LOG_DEBUG, TAG_TIMEMANAGER, "NTP: Network time synchronization is successful\n");
}
}
-time_t TimeManager::timeToUnixEpochSeconds(const std::string &time, const std::string &format) {
+time_t NTPManager::timeToUnixEpochSeconds(const std::string &time, const std::string &format) {
// 22/10/27,10:16:20+00
struct tm tm {};
time_t dateInEpoch = 0;
@@ -77,11 +78,11 @@ time_t TimeManager::timeToUnixEpochSeconds(const std::string &time, const std::s
return dateInEpoch;
}
-void TimeManager::writeModemTimeToRTC() {
+void NTPManager::writeModemTimeToRTC() {
auto gsmDateTimeString = modem.getGSMDateTime(DATE_FULL);
- esp_log_write(ESP_LOG_DEBUG, TAG, "GSM DateTime: %s\n", gsmDateTimeString.c_str());
+ esp_log_write(ESP_LOG_DEBUG, TAG_TIMEMANAGER, "GSM DateTime: %s\n", gsmDateTimeString.c_str());
time_t time = timeToUnixEpochSeconds(gsmDateTimeString.c_str());
rtc.setTime(time);
- esp_log_write(ESP_LOG_INFO, TAG, "Time set to EPOCH: %s\n", String(rtc.getEpoch()).c_str());
+ esp_log_write(ESP_LOG_INFO, TAG_TIMEMANAGER, "Time set to EPOCH: %s\n", String(rtc.getEpoch()).c_str());
}
diff --git a/host/host_central_mast/lib/TimeManager/TimeManager.h b/host/host_central_mast/lib/NTPManager/NTPManager.h
similarity index 78%
rename from host/host_central_mast/lib/TimeManager/TimeManager.h
rename to host/host_central_mast/lib/NTPManager/NTPManager.h
index d970a292d388ae4b6cc0bce139d0c9196b3bd147..37a2a192bd13c63fec4e1627e962dca6d07067ce 100644
--- a/host/host_central_mast/lib/TimeManager/TimeManager.h
+++ b/host/host_central_mast/lib/NTPManager/NTPManager.h
@@ -2,11 +2,12 @@
// Created by zoe on 12/19/22.
//
-#ifndef HOST_CENTRAL_MAST_TIMEMANAGER_H
-#define HOST_CENTRAL_MAST_TIMEMANAGER_H
+#ifndef HOST_CENTRAL_MAST_NTPMANAGER_H
+#define HOST_CENTRAL_MAST_NTPMANAGER_H
#define TINY_GSM_MODEM_SIM7000
+#include "Definitions.h"
#include "ESP32Time.h"
#include "NTPException.hpp"
#include "StringToTimeConversionException.hpp"
@@ -14,13 +15,11 @@
#include <iomanip>
#include <string>
-class TimeManager {
+class NTPManager {
public:
- explicit TimeManager(TinyGsmSim7000 &modem);
+ explicit NTPManager(TinyGsmSim7000 &modem);
private:
- constexpr static char *TAG = "TimeManager";
- ESP32Time rtc;
int timeZone = 0;
// I would like this to be a const reference but the functions used by the modem are not const
@@ -40,4 +39,4 @@ class TimeManager {
void writeModemTimeToRTC();
};
-#endif // HOST_CENTRAL_MAST_TIMEMANAGER_H
\ No newline at end of file
+#endif // HOST_CENTRAL_MAST_NTPMANAGER_H
\ No newline at end of file
diff --git a/host/host_central_mast/lib/TimeManager/StringToTimeConversionException.hpp b/host/host_central_mast/lib/NTPManager/StringToTimeConversionException.hpp
similarity index 83%
rename from host/host_central_mast/lib/TimeManager/StringToTimeConversionException.hpp
rename to host/host_central_mast/lib/NTPManager/StringToTimeConversionException.hpp
index 32e63f4de431138be07c1746bccce54c3f0a8757..f93acc337a2333fae8e3d8c493f7cc2b069d0a5c 100644
--- a/host/host_central_mast/lib/TimeManager/StringToTimeConversionException.hpp
+++ b/host/host_central_mast/lib/NTPManager/StringToTimeConversionException.hpp
@@ -5,16 +5,16 @@
#ifndef HOST_CENTRAL_MAST_STRINGTOTIMECONVERSIONEXCEPTION_HPP
#define HOST_CENTRAL_MAST_STRINGTOTIMECONVERSIONEXCEPTION_HPP
+#include "NTPManager.h"
#include <exception>
#include <string>
-#include "TimeManager.h"
class StringToTimeConversionException : public std::exception {
public:
explicit StringToTimeConversionException(const std::string &message) : message(message) {}
const char *what() const noexcept override {
- esp_log_write(ESP_LOG_ERROR, "TimeManager", "Error converting time to epoch: %s",
+ esp_log_write(ESP_LOG_ERROR, "NTPManager", "Error converting time to epoch: %s",
message.c_str());
return message.c_str();
}
diff --git a/host/host_central_mast/lib/NetworkConnectionManager/ConnectionManager.cpp b/host/host_central_mast/lib/NetworkConnectionManager/ConnectionManager.cpp
index 29feb8c907b49bf79d48081e135be854dd8a2488..bdadaf9ee807376bef8b8450d30e54380bb3a49d 100644
--- a/host/host_central_mast/lib/NetworkConnectionManager/ConnectionManager.cpp
+++ b/host/host_central_mast/lib/NetworkConnectionManager/ConnectionManager.cpp
@@ -3,10 +3,6 @@
//
#include "ConnectionManager.h"
-#include "LTEConnectionException.hpp"
-#include "ModemFunctionalityLevel.h"
-
-#include <utility>
ConnectionManager::ConnectionManager(TinyGsm &modem, GPRSCredentials credentials, ModemPins modemPins)
: modem(modem), credentials(std::move(credentials)), modemPins(modemPins) {}
@@ -14,17 +10,16 @@ ConnectionManager::ConnectionManager(TinyGsm &modem, GPRSCredentials credentials
void ConnectionManager::restartModem() {
// Restart takes quite some time
// To skip it, call init() instead of restart()
- esp_log_write(ESP_LOG_DEBUG, TAG_GSM.c_str(), "Restarting modem...\n");
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Restarting modem...\n");
if (!modem.restart()) {
- esp_log_write(ESP_LOG_WARN, TAG_GSM.c_str(),
- "Failed to restart modem, attempting to continue without restarting\n");
+ esp_log_write(ESP_LOG_WARN, TAG_GSM, "Failed to restart modem, attempting to continue without restarting\n");
}
}
void ConnectionManager::initModem() {
- esp_log_write(ESP_LOG_DEBUG, TAG_GSM.c_str(), "Initializing modem...\n");
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Initializing modem...\n");
if (!modem.init()) {
- esp_log_write(ESP_LOG_WARN, TAG_GSM.c_str(), "Failed to initialize modem, attempting to continue...\n");
+ esp_log_write(ESP_LOG_WARN, TAG_GSM, "Failed to initialize modem, attempting to continue...\n");
}
setModemFunctionalityLevel(MINIMAL);
}
@@ -100,9 +95,9 @@ bool ConnectionManager::gprsConnect() {
bool ConnectionManager::isNetworkConnected() {
return modem.isNetworkConnected();
}
-std::string ConnectionManager::connect(int port, RequestInformation requestInformation) {
+std::string ConnectionManager::connect(RequestInformation requestInformation) {
TinyGsmClient client{modem, 0};
- if (!client.connect(requestInformation.host.c_str(), port)) {
+ if (!client.connect(requestInformation.host.c_str(), requestInformation.port)) {
throw LTEConnectionException("Failed to connect to host");
}
@@ -115,7 +110,7 @@ std::string ConnectionManager::connect(int port, RequestInformation requestInfor
while (client.connected()) {
line += client.readStringUntil('\n');
if (line == "\r") {
- esp_log_write(ESP_LOG_DEBUG, TAG_GSM.c_str(), "headers received\n");
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "headers received\n");
break;
}
}
@@ -131,9 +126,11 @@ void ConnectionManager::modemPowerOn() {
}
void ConnectionManager::modemPowerOff() {
+ // Try to power-off (modem may decide to restart automatically)
+ // To turn off modem completely, please use Reset/Enable pins
modem.sendAT("+CPOWD=1");
if (modem.waitResponse(10000L) != 1) {
- esp_log_write(ESP_LOG_WARN, TAG_GSM.c_str(), "Failed to power off modem\n");
+ esp_log_write(ESP_LOG_WARN, TAG_GSM, "Failed to power off modem\n");
}
modem.poweroff();
pinMode(modemPins.pwr, OUTPUT);
@@ -157,3 +154,28 @@ bool ConnectionManager::waitForNetwork() {
bool ConnectionManager::gprsDisconnect() {
return modem.gprsDisconnect();
}
+void ConnectionManager::logModemInformation() {
+ bool res = modem.isGprsConnected();
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "GPRS connected: %s\n", res ? "true" : "false");
+
+ String ccid = modem.getSimCCID();
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "CCID: %s\n", ccid.c_str());
+
+ String imei = modem.getIMEI();
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "IMEI: %s\n", imei.c_str());
+
+ String imsi = modem.getIMSI();
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "IMSI: %s\n", imsi.c_str());
+
+ String cop = modem.getOperator();
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Operator: %s\n", cop.c_str());
+
+ IPAddress local = modem.localIP();
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Local IP: %s\n", local.toString().c_str());
+
+ int csq = modem.getSignalQuality();
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Signal quality: %d\n", csq);
+}
+bool ConnectionManager::isGprsConnected() {
+ return modem.isGprsConnected();
+}
diff --git a/host/host_central_mast/lib/NetworkConnectionManager/ConnectionManager.h b/host/host_central_mast/lib/NetworkConnectionManager/ConnectionManager.h
index 4f774d0dc2738115cf535dd8edb219ed18d86da0..70b4668a810fb0ceb0a858f4f4d52218201603c4 100644
--- a/host/host_central_mast/lib/NetworkConnectionManager/ConnectionManager.h
+++ b/host/host_central_mast/lib/NetworkConnectionManager/ConnectionManager.h
@@ -7,15 +7,16 @@
#define TINY_GSM_MODEM_SIM7000
+#include "Definitions.h"
#include "GPRSCredentials.h"
+#include "LTEConnectionException.hpp"
#include "Mode.h"
#include "ModemFunctionalityLevel.h"
#include "NetworkMode.h"
#include "RequestInformation.h"
#include "StreamDebugger.h"
#include <TinyGsmClient.h>
-
-static const std::string TAG_GSM = "GSM";
+#include <utility>
class ConnectionManager {
@@ -35,7 +36,7 @@ class ConnectionManager {
public:
ConnectionManager(TinyGsm &modem, GPRSCredentials credentials, ModemPins modemPins);
- std::string connect(int port, RequestInformation requestInformation);
+ std::string connect(RequestInformation requestInformation);
void enableGPS();
@@ -66,6 +67,9 @@ class ConnectionManager {
void unlockSimCard();
bool waitForNetwork();
+
+ void logModemInformation();
+ bool isGprsConnected();
};
#endif // HOST_CENTRAL_MAST_CONNECTIONMANAGER_H
diff --git a/host/host_central_mast/lib/NetworkConnectionManager/RequestInformation.h b/host/host_central_mast/lib/NetworkConnectionManager/RequestInformation.h
index 84843cfb43fc8feffa7381d381f0cde7976d40b4..5d416119edc8ec9ad36e153efadc564a8f347c60 100644
--- a/host/host_central_mast/lib/NetworkConnectionManager/RequestInformation.h
+++ b/host/host_central_mast/lib/NetworkConnectionManager/RequestInformation.h
@@ -6,31 +6,42 @@
#define HOST_CENTRAL_MAST_REQUESTINFORMATION_H
#include <Arduino.h>
+#include <Definitions.h>
+#include <map>
+
+enum RequestMethod {
+ GET,
+ POST,
+};
struct RequestInformation {
- String method;
+ RequestMethod method;
+ std::map<String, String> headers;
+ int port;
String host;
String path;
String body;
- RequestInformation(String method, String host, String path, String body) {
+ RequestInformation(const RequestMethod &method, const String &host, const int &port, const String &path,
+ const String &body, const std::map<String, String> &headers) {
this->method = method;
+ this->port = port;
+ this->headers = headers;
this->host = host;
this->path = path;
this->body = body;
}
- // TODO: Move to configuration file
- const String INFLUXDB_TOKEN =
- "dUh2gbVLv7e3egqocxriDsJQNUacA9qZ5YXsYtdnVAglnHgy4nx-jDVO7nGlSF34BosfnuwnUDaviC7dQeC5RQ==";
-
String buildRequest() {
+ String methodString = method == RequestMethod::GET ? "GET" : "POST";
String request = "";
- request += method + " " + path + " HTTP/1.1\r\n";
+ request += methodString + " " + path + " HTTP/1.1\r\n";
request += "Host: " + host + "\r\n";
- request += "Authorization: Token " + INFLUXDB_TOKEN + "\r\n";
- request += "User-Agent: ESP32\r\n";
- request += "Content-Type: text/plain\r\n";
+ request += "User-Agent: ESP32-Host\r\n";
+ for (auto &header : headers) {
+ request += header.first + ": " + header.second + "\r\n";
+ }
+ // request += "Authorization: Token " + INFLUXDB_TOKEN + "\r\n";
request += "Content-Length: " + String(body.length()) + "\r\n";
if (body.length() > 0) {
request += "\r\n";
diff --git a/host/host_central_mast/lib/ResendManager/ResendManager.cpp b/host/host_central_mast/lib/ResendManager/ResendManager.cpp
index 1c8eb125fc9721b8a816b221231682e2c1135711..64d6557ab417c4535f6ab7801f0ce12b566d0021 100644
--- a/host/host_central_mast/lib/ResendManager/ResendManager.cpp
+++ b/host/host_central_mast/lib/ResendManager/ResendManager.cpp
@@ -14,7 +14,7 @@ void ResendManager::init() {
}
uint ResendManager::getLastResendFileId() const { // get the next file id to be resend
- auto filesInDirectory = getFilesInDirectory(resendDirectoryPath);
+ auto filesInDirectory = SDUtilities::getFilesInDirectory(resendDirectoryPath);
// convert the file names to uint
std::list<uint> fileUintIDs;
@@ -38,24 +38,24 @@ uint ResendManager::getLastResendFileId() const { // get the next file id to be
}
void ResendManager::createResendDirectory() const { // create directory if it doesn't exist
- createDirectory("/resend");
+ SDUtilities::createDirectory("/resend");
}
void ResendManager::storeForResend(const String &messageToBeSend) {
// create file
String filename = String(nextResendFileId);
- writeFile(messageToBeSend, resendDirectoryPath + "/" + filename);
+ SDUtilities::writeFile(messageToBeSend, resendDirectoryPath + "/" + filename);
ResendManager::incrementCount();
}
std::optional<ResendPointType> ResendManager::loadNextToBeResendMessage() {
// get first file in resend directory
- auto filename = getFirstFileNameInDirectory(resendDirectoryPath.c_str());
+ auto filename = SDUtilities::getFirstFileNameInDirectory(resendDirectoryPath.c_str());
if (filename.has_value()) {
// read file
- auto message = readFile(resendDirectoryPath + "/" + filename.value().c_str());
+ auto message = SDUtilities::readFile(resendDirectoryPath + "/" + filename.value().c_str());
return ResendPointType{message, filename.value()};
}
return std::nullopt;
diff --git a/host/host_central_mast/lib/Utilities/Definitions.h b/host/host_central_mast/lib/Utilities/Definitions.h
index ed28c034d527ae43c36652bfff858197a1e0594b..5f5cc45c375b37d12d8845de1fdf8f605cc936d2 100644
--- a/host/host_central_mast/lib/Utilities/Definitions.h
+++ b/host/host_central_mast/lib/Utilities/Definitions.h
@@ -6,6 +6,7 @@
#define HOST_CENTRAL_MAST_DEFINITIONS_H
#include "Arduino.h"
+#include "ESP32Time.h"
#define uS_TO_S_FACTOR 1000000ULL // Conversion factor for micro seconds to seconds
#define TIME_TO_SLEEP 5 // Time ESP32 will go to sleep (in seconds)
@@ -22,6 +23,23 @@
#define SD_CS 13
#define LED_PIN 12
+// See all AT commands, if wanted
+// #define DUMP_AT_COMMANDS
+
+#define TAG_ESPNOW "ESPNOW"
+#define TAG_MAIN "MAIN"
+#define TAG_SD "SD"
+#define TAG_GSM "GSM"
+#define TAG_TIMEMANAGER "TIMEMANAGER"
+#define TAG_SDUTILITIES "SDUTILITIES"
+
+#define SD_CARD_FAIL_COUNTER 100
+
+constexpr bool PRINT_TO_SERIAL = true;
+
+// global definition of RTC. Initialised in main
+extern ESP32Time rtc;
+
const String INFLUXDB_TOKEN =
"dUh2gbVLv7e3egqocxriDsJQNUacA9qZ5YXsYtdnVAglnHgy4nx-jDVO7nGlSF34BosfnuwnUDaviC7dQeC5RQ==";
diff --git a/host/host_central_mast/lib/Utilities/SDCardLogger.cpp b/host/host_central_mast/lib/Utilities/SDCardLogger.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b7fe7c7dcd2ef8b075cd67faae9ae187f01922b0
--- /dev/null
+++ b/host/host_central_mast/lib/Utilities/SDCardLogger.cpp
@@ -0,0 +1,60 @@
+//
+// Created by zoe on 1/24/23.
+//
+
+#include "SDCardLogger.h"
+
+namespace SDCardLogger {
+
+ char log_print_buffer[512];
+ bool printToSerial = false;
+
+ void printDebugToSerial(bool printToSerialAsWell) {
+ printToSerial = printToSerialAsWell;
+ }
+ int vprintf_into_sd(const char *szFormat, va_list args) {
+ String logstring = "[" + rtc.getDateTime() + "] ";
+ logstring += szFormat;
+
+ if (!SDUtilities::isSDAvailable()) {
+ if (printToSerial) {
+ logstring += " (SD card not available)\n";
+ vprintf(logstring.c_str(), args);
+ }
+ return 1;
+ }
+
+ // write evaluated format string into buffer
+ int ret = vsnprintf(log_print_buffer, sizeof(log_print_buffer), logstring.c_str(), args);
+
+ String date = rtc.getDate();
+ String filename = "/log_" + date + ".txt";
+
+ // output is now in buffer. write to file.
+ if (ret >= 0) {
+ if (!SD.exists(filename)) {
+ File writeLog = SD.open(filename, FILE_WRITE);
+ if (!writeLog) {
+ Serial.println("Couldn't open " + filename + " for writing");
+ SDUtilities::setSDAvailable(false);
+ return 1;
+ }
+ delay(50);
+ writeLog.close();
+ }
+
+ File logFile = SD.open(filename, FILE_APPEND);
+
+ // debug output
+ if (printToSerial) {
+ vprintf(logstring.c_str(), args);
+ }
+ logFile.write((uint8_t *)log_print_buffer, (size_t)ret);
+ // to be safe in case of crashes: flush the output
+ logFile.flush();
+ logFile.close();
+ }
+ return ret;
+ }
+
+} // namespace SDCardLogger
diff --git a/host/host_central_mast/lib/Utilities/SDCardLogger.h b/host/host_central_mast/lib/Utilities/SDCardLogger.h
new file mode 100644
index 0000000000000000000000000000000000000000..c14a07dc0ae0e4579daeb1b41c775253ebd9ca25
--- /dev/null
+++ b/host/host_central_mast/lib/Utilities/SDCardLogger.h
@@ -0,0 +1,17 @@
+//
+// Created by zoe on 1/24/23.
+//
+
+#ifndef HOST_CENTRAL_MAST_SDCARDLOGGER_H
+#define HOST_CENTRAL_MAST_SDCARDLOGGER_H
+
+#include "Definitions.h"
+#include "SD.h"
+#include "Utilities.h"
+
+namespace SDCardLogger {
+ void printDebugToSerial(bool printToSerialAsWell);
+ int vprintf_into_sd(const char *szFormat, va_list args);
+}; // namespace SDCardLogger
+
+#endif // HOST_CENTRAL_MAST_SDCARDLOGGER_H
diff --git a/host/host_central_mast/lib/Utilities/Utilities.cpp b/host/host_central_mast/lib/Utilities/Utilities.cpp
index 21f3aca77fc6d9ceaeff1491862931f78cce6f39..316d33c95d27260f7b3c0ca299ed049db6305bce 100644
--- a/host/host_central_mast/lib/Utilities/Utilities.cpp
+++ b/host/host_central_mast/lib/Utilities/Utilities.cpp
@@ -4,148 +4,302 @@
#include "Utilities.h"
-void setupSDCard();
-void saveStringToSDCard(const std::string &dataString);
-std::list<String> getFilesInDirectory(const String &dirname) {
- std::list<String> files;
- File dir = openDirectory(dirname);
- while (true) {
- File nextFile = dir.openNextFile();
- if (!nextFile) {
- break;
- }
- if (!nextFile.isDirectory()) {
- files.emplace_back(nextFile.name());
- }
- nextFile.close();
- }
- return files;
-}
+namespace SDUtilities {
+
+ bool SDAvailable = true;
-std::optional<String> getLastFileInDirectory(const String &dirname) {
+ void setSDAvailable(bool sdAvailable) {
+ SDAvailable = sdAvailable;
+ }
- File root = openDirectory(dirname);
- root.rewindDirectory();
+ // Used to try to remount SD card if it fails more than x times (100)
+ int sdFailCounter = 0;
+
+ bool isSDAvailable() {
+ return SDAvailable;
+ }
- File file = root.openNextFile();
- while (file) {
- File nextFile = root.openNextFile();
- if (!nextFile) {
- break;
+ void tryRemountingSD() {
+ try {
+ setupSDCard(SD_MISO, SD_MOSI, SD_SCLK, SD_CS);
+ setSDAvailable(true);
+ } catch (SDSetupException &e) {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "Couldn't remount SD card: %s\n", e.what());
}
- file = nextFile;
+ sdFailCounter = 0;
}
- // log
- if (file) {
- esp_log_write(ESP_LOG_INFO, "getLastFileInDirectory", "Last file name: %s\n", file.name());
- return file.name();
- } else {
- esp_log_write(ESP_LOG_INFO, "getLastFileInDirectory", "No file found\n");
- return std::nullopt;
+
+ bool checkSDAvailability(const String &errorMessage) {
+ if (!isSDAvailable()) {
+ sdFailCounter++;
+ if (sdFailCounter % SD_CARD_FAIL_COUNTER == 0) {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "SD card not available. Trying to remount...\n");
+ tryRemountingSD();
+ }
+ String message = errorMessage + " (SD card not available, failed " + sdFailCounter + " times)\n";
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "%s", message.c_str());
+ // if re-mount was successful, this will be true
+ return isSDAvailable();
+ }
+ return true;
+ };
+
+ std::list<String> getFilesInDirectory(const String &dirname) {
+ if (!checkSDAvailability("Couldn't get files in directory " + dirname)) {
+ return {};
+ }
+ std::list<String> files;
+ File dir = openDirectory(dirname);
+ while (true) {
+ File nextFile = dir.openNextFile();
+ if (!nextFile) {
+ break;
+ }
+ if (!nextFile.isDirectory()) {
+ files.emplace_back(nextFile.name());
+ }
+ nextFile.close();
+ }
+ return files;
}
-}
-File openDirectory(const String &dirname) {
- File root = SD.open(dirname);
- if (!root) {
- esp_log_write(ESP_LOG_ERROR, "openDirectory", "Failed to open directory\n");
- throw;
+
+ std::optional<String> getLastFileInDirectory(const String &dirname) {
+
+ if (!checkSDAvailability("Couldn't get last file in directory " + dirname)) {
+ return std::nullopt;
+ }
+
+ File root = openDirectory(dirname);
+ root.rewindDirectory();
+
+ File file = root.openNextFile();
+ while (file) {
+ File nextFile = root.openNextFile();
+ if (!nextFile) {
+ break;
+ }
+ file = nextFile;
+ }
+ // log
+ if (file) {
+ esp_log_write(ESP_LOG_INFO, TAG_SDUTILITIES, "Last file name: %s\n", file.name());
+ return file.name();
+ } else {
+ esp_log_write(ESP_LOG_INFO, TAG_SDUTILITIES, "No file found\n");
+ return std::nullopt;
+ }
}
- if (!root.isDirectory()) {
- esp_log_write(ESP_LOG_ERROR, "openDirectory", "Not a directory\n");
- throw;
+ File openDirectory(const String &dirname) {
+
+ if (!checkSDAvailability("Couldn't open directory " + dirname)) {
+ throw;
+ }
+
+ File root = SD.open(dirname);
+ if (!root) {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "Failed to open directory\n");
+ throw;
+ }
+ if (!root.isDirectory()) {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "Not a directory\n");
+ throw;
+ }
+ return root;
}
- return root;
-}
-std::optional<String> getFirstFileNameInDirectory(const String &dirname) {
- File root = openDirectory(dirname);
- root.rewindDirectory();
+ std::optional<String> getFirstFileNameInDirectory(const String &dirname) {
- File file = root.openNextFile();
- if (file) {
- esp_log_write(ESP_LOG_INFO, "getFirstFileNameInDirectory", "file found: %s\n", file.name());
- return file.name();
- } else {
- esp_log_write(ESP_LOG_INFO, "getFirstFileNameInDirectory", "no file found\n");
- return std::nullopt;
+ if (!checkSDAvailability("Couldn't get first file in directory " + dirname)) {
+ return std::nullopt;
+ }
+
+ File root = openDirectory(dirname);
+ root.rewindDirectory();
+
+ File file = root.openNextFile();
+ if (file) {
+ esp_log_write(ESP_LOG_INFO, TAG_SDUTILITIES, "file found: %s\n", file.name());
+ return file.name();
+ } else {
+ esp_log_write(ESP_LOG_INFO, TAG_SDUTILITIES, "no file found\n");
+ return std::nullopt;
+ }
}
-}
-File openForWrite(const String &filePath) {
- File file = SD.open(filePath, FILE_WRITE);
- if (!file) {
- esp_log_write(ESP_LOG_ERROR, "SD", "Failed to open file for writing\n");
- throw;
+ File openForWrite(const String &filePath) {
+
+ if (!checkSDAvailability("Couldn't open file " + filePath + " for writing")) {
+ throw;
+ }
+
+ File file = SD.open(filePath, FILE_WRITE);
+ if (!file) {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "Failed to open file for writing\n");
+ throw;
+ }
+ return file;
}
- return file;
-}
-File openForRead(const String &filePath) {
- File file = SD.open(filePath, FILE_READ);
- if (!file) {
- esp_log_write(ESP_LOG_ERROR, "SD", "Failed to open file for reading\n");
- throw;
+ File openForRead(const String &filePath) {
+
+ if (!checkSDAvailability("Couldn't open file " + filePath + " for reading")) {
+ throw;
+ }
+
+ File file = SD.open(filePath, FILE_READ);
+ if (!file) {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "Failed to open file for reading\n");
+ throw;
+ }
+ return file;
}
- return file;
-}
-void writeFile(const String &messageToBeSend, const String &filePath) {
- File file = openForWrite(filePath);
- if (file.print(messageToBeSend)) {
- esp_log_write(ESP_LOG_INFO, "SD", "File written %s\n", filePath.c_str());
- } else {
- esp_log_write(ESP_LOG_ERROR, "SD", "Write failed %s\n", filePath.c_str());
- throw;
+ void writeFile(const String &messageToBeSend, const String &filePath) {
+
+ if (!checkSDAvailability("Couldn't write to file " + filePath)) {
+ throw;
+ }
+
+ File file = openForWrite(filePath);
+ if (file.print(messageToBeSend)) {
+ esp_log_write(ESP_LOG_INFO, TAG_SDUTILITIES, "File written %s\n", filePath.c_str());
+ } else {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "Write failed %s\n", filePath.c_str());
+ throw;
+ }
+ file.close();
}
- file.close();
-}
-String readFile(const String &filePath) {
- File file = openForRead(filePath);
- String ret;
+ String readFile(const String &filePath) {
+
+ if (!checkSDAvailability("Couldn't read file " + filePath)) {
+ throw;
+ }
+
+ File file = openForRead(filePath);
- while (file.available()) {
- ret += (char)file.read();
+ String ret;
+
+ while (file.available()) {
+ ret += (char)file.read();
+ }
+
+ file.close();
+ return ret;
}
- file.close();
- return ret;
-}
+ void createDirectory(const String &dirname) {
-void createDirectory(const String &dirname) {
- if (!SD.exists(dirname)) {
- SD.mkdir(dirname);
- esp_log_write(ESP_LOG_INFO, "createDirectory", "Created directory: %s\n", dirname.c_str());
- } else {
- esp_log_write(ESP_LOG_WARN, "createDirectory", "Directory already exists\n");
+ if (!checkSDAvailability("Couldn't create directory " + dirname)) {
+ throw;
+ }
+
+ if (!SD.exists(dirname)) {
+ SD.mkdir(dirname);
+ esp_log_write(ESP_LOG_INFO, TAG_SDUTILITIES, "Created directory: %s\n", dirname.c_str());
+ } else {
+ esp_log_write(ESP_LOG_WARN, TAG_SDUTILITIES, "Directory already exists\n");
+ }
}
-}
-void setupSDCard(int MISO, int MOSI, int SCLK, int CS) {
- SPI.begin(SCLK, MISO, MOSI, CS);
- if (!SD.begin(CS)) {
- esp_log_write(ESP_LOG_ERROR, "Utilities", "Card MOUNT FAIL\n");
- throw SDSetupException("Card MOUNT FAIL");
- } else {
- uint32_t cardSize = SD.cardSize() / (1024 * 1024);
- String sdcardSizeString = "SDCard Size: " + String(cardSize) + "MB";
- esp_log_write(ESP_LOG_DEBUG, "Utilities", "%s\n", sdcardSizeString.c_str());
+ void setupSDCard(int MISO, int MOSI, int SCLK, int CS) {
+ SPI.begin(SCLK, MISO, MOSI, CS);
+ if (!SD.begin(CS)) {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "Card MOUNT FAIL\n");
+ throw SDSetupException("Card MOUNT FAIL");
+ } else {
+ uint32_t cardSize = SD.cardSize() / (1024 * 1024);
+ String sdcardSizeString = "SDCard Size: " + String(cardSize) + "MB";
+ esp_log_write(ESP_LOG_DEBUG, TAG_SDUTILITIES, "%s\n", sdcardSizeString.c_str());
+ }
}
-}
-void saveStringToSDCard(const std::string &dataString) {
- File dataFile = SD.open("/datalog.txt", FILE_APPEND);
+ void saveStringToSDCard(const std::string &dataString) {
+
+ if (!checkSDAvailability("Couldn't save string to SD card")) {
+ throw SDCardException("Couldn't save string to SD card");
+ }
- // if the file is available, write to it:
- if (dataFile) {
- if (dataString.length() > 0) {
- dataFile.println(dataString.c_str());
+ File dataFile = SD.open("/datalog.txt", FILE_APPEND);
+
+ // if the file is available, write to it:
+ if (dataFile) {
+ if (dataString.length() > 0) {
+ dataFile.println(dataString.c_str());
+ }
+ dataFile.close();
+ }
+ // if the file isn't open, pop up an error:
+ else {
+ esp_log_write(ESP_LOG_ERROR, TAG_SDUTILITIES, "error opening datalog.txt\n");
+ throw SDCardException("error opening datalog.txt");
}
- dataFile.close();
}
- // if the file isn't open, pop up an error:
- else {
- esp_log_write(ESP_LOG_ERROR, "Utilities", "error opening datalog.txt\n");
- throw SDCardException("error opening datalog.txt");
+} // namespace SDUtilities
+
+// I don't think this does anything. Copied from the example
+void turnOffLEDs() { // Set LED OFF
+ pinMode(LED_PIN, OUTPUT);
+ digitalWrite(LED_PIN, HIGH);
+
+ pinMode(PWR_PIN, OUTPUT);
+ digitalWrite(PWR_PIN, HIGH);
+ delay(300);
+ digitalWrite(PWR_PIN, LOW);
+}
+
+String getMacAddressAsString(const uint8_t *mac) {
+ String macAddress;
+ for (int i = 0; i < 6; i++) {
+ macAddress += String(mac[i], HEX);
+ }
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "MAC: %s\n", macAddress.c_str());
+ return macAddress;
+}
+
+String documentToLineProtocolString(const DynamicJsonDocument &doc) {
+ String measurementType = doc["measurementType"].as<String>();
+ String sensorName = doc["sensorName"].as<String>();
+ String timestamp = doc["timestamp"].as<String>();
+ String protocol = doc["protocol"].as<String>();
+ String value = doc["value"].as<String>();
+ String channel = doc["channel"].as<String>();
+ String clientMac = doc["clientMac"].as<String>();
+
+ String lineData = sensorName + ",clientMac=" + clientMac + ",protocol=" + protocol + ",channel=" + channel + " "
+ + measurementType + "=" + value + " " + timestamp;
+ return lineData;
+}
+DynamicJsonDocument parseReceivedJsonData(char *data) {
+ DynamicJsonDocument doc(250);
+ auto error = deserializeJson(doc, data);
+ if (error) {
+ esp_log_write(ESP_LOG_ERROR, TAG_ESPNOW, "Error while parsing json: %s\n", error.c_str());
+ // TODO error handling
}
+ return doc;
+}
+
+String documentToServerReadableString(const DynamicJsonDocument &doc) {
+ StaticJsonDocument<1024> serverDoc;
+ String hostMacAddressString = WiFi.macAddress();
+ hostMacAddressString.replace(":", "");
+ hostMacAddressString.toLowerCase();
+
+ serverDoc["host"] = hostMacAddressString;
+ serverDoc["client"] = doc["clientMac"].as<String>();
+ serverDoc["sensorProtocol"] = doc["protocol"].as<String>();
+ serverDoc["protocolAddress"] = doc["channel"].as<String>();
+ serverDoc["hardwareName"] = doc["sensorName"].as<String>();
+ // each value is a element in the readigs array
+ JsonArray readings = serverDoc.createNestedArray("readings");
+ JsonObject reading = readings.createNestedObject();
+ reading["name"] = doc["measurementType"].as<String>();
+ reading["value"] = doc["value"].as<float>();
+ serverDoc["time"] = doc["timestamp"].as<uint32_t>();
+
+ String serverString;
+ serializeJson(serverDoc, serverString);
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "Server readable data: %s\n", serverString.c_str());
+ return serverString;
}
\ No newline at end of file
diff --git a/host/host_central_mast/lib/Utilities/Utilities.h b/host/host_central_mast/lib/Utilities/Utilities.h
index 1156c0289983da90d2735fea2786e1933ab91b54..dc18e3459e0fabe83c64f2e09a4a9ae3bf8c45f6 100644
--- a/host/host_central_mast/lib/Utilities/Utilities.h
+++ b/host/host_central_mast/lib/Utilities/Utilities.h
@@ -5,21 +5,34 @@
#ifndef HOST_CENTRAL_MAST_UTILITIES_H
#define HOST_CENTRAL_MAST_UTILITIES_H
+#include "ArduinoJson.h"
#include "SD.h"
#include "SDCardException.h"
#include "SDSetupException.h"
+#include "WiFi.h"
#include <Arduino.h>
#include <Definitions.h>
#include <WString.h>
#include <list>
-File openDirectory(const String &dirname);
-std::list<String> getFilesInDirectory(const String &dirname);
-std::optional<String> getFirstFileNameInDirectory(const String &dirname);
-std::optional<String> getLastFileInDirectory(const String &dirname);
-void writeFile(const String &messageToBeSend, const String &filePath);
-String readFile(const String &filePath);
-void createDirectory(const String &dirname);
-void setupSDCard(int MISO, int MOSI, int SCLK, int CS);
-void saveStringToSDCard(const std::string &dataString);
+namespace SDUtilities {
+ File openDirectory(const String &dirname);
+ std::list<String> getFilesInDirectory(const String &dirname);
+ std::optional<String> getFirstFileNameInDirectory(const String &dirname);
+ std::optional<String> getLastFileInDirectory(const String &dirname);
+ void writeFile(const String &messageToBeSend, const String &filePath);
+ String readFile(const String &filePath);
+ void createDirectory(const String &dirname);
+ void setupSDCard(int MISO, int MOSI, int SCLK, int CS);
+ void saveStringToSDCard(const std::string &dataString);
+ void setSDAvailable(bool sdAvailable);
+ bool isSDAvailable();
+} // namespace SDUtilities
+
+void turnOffLEDs();
+String getMacAddressAsString(const uint8_t *mac);
+String documentToLineProtocolString(const DynamicJsonDocument &doc);
+DynamicJsonDocument parseReceivedJsonData(char *data);
+String documentToServerReadableString(const DynamicJsonDocument &doc);
+
#endif // HOST_CENTRAL_MAST_UTILITIES_H
diff --git a/host/host_central_mast/src/main.cpp b/host/host_central_mast/src/main.cpp
index 850beacb573f5cbca01def4d59d8400f2089349f..042d4e623cda2bc188513c93b6a1c60b2a0caeb2 100644
--- a/host/host_central_mast/src/main.cpp
+++ b/host/host_central_mast/src/main.cpp
@@ -1,45 +1,34 @@
-#include "FS.h"
-#include "SD.h"
+/***
+ * code is modified from the original code found at
+ * https://github.com/Xinyuan-LilyGO/LilyGO-T-SIM7000G/blob/master/examples/Arduino_TinyGSM/AllFunctions/AllFunctions.ino
+ */
+
+#define TINY_GSM_MODEM_SIM7000
+
+#include "ConnectionManager.h"
+#include "MessageType.h"
+#include "SDCardLogger.h"
#include "SPI.h"
#include "Utilities.h"
-#include "time.h"
-#include <Arduino.h>
#include <ArduinoJson.h>
+#include <Definitions.h>
#include <ESP32Time.h>
+#include <NTPManager.h>
+#include <ResendManager.h>
+#include <TinyGsmClient.h>
#include <WiFi.h>
#include <esp_log.h>
#include <esp_now.h>
+#include <map>
#include <queue>
#include <sys/unistd.h>
-static const std::string TAG = "MAIN";
-static const std::string TAG_ESPNOW = "ESPNOW";
-static const std::string TAG_GSM = "GSM";
-
-/*
- FILE: AllFunctions.ino
- AUTHOR: Koby Hale
- PURPOSE: Test functionality
-*/
+ESP32Time rtc;
-#define TINY_GSM_MODEM_SIM7000
#define TINY_GSM_RX_BUFFER 1024 // Set RX buffer to 1Kb
#define SerialAT Serial1
-// See all AT commands, if wanted
-#define DUMP_AT_COMMANDS
-
-// set GSM PIN, if any
-#define GSM_PIN ""
-
-// Your GPRS credentials, if any
-const char apn[] = "m2m.public.at"; // SET TO YOUR APN
-const char gprsUser[] = "";
-const char gprsPass[] = "";
-
-#include <TinyGsmClient.h>
-
-#ifdef DUMP_AT_COMMANDS // if enabled it requires the streamDebugger lib
+#ifdef DUMP_AT_COMMANDS // if enabled it requires the streamDebugger library
#include <StreamDebugger.h>
StreamDebugger debugger(SerialAT, Serial);
TinyGsm modem(debugger);
@@ -47,75 +36,35 @@ TinyGsm modem(debugger);
TinyGsm modem(SerialAT);
#endif
-#include "Definitions.h"
+const GPRSCredentials gprsCredentials = GPRSCredentials("m2m.public.at", "", "");
+
+ConnectionManager connectionManager{modem, gprsCredentials,
+ ConnectionManager::ModemPins{PIN_DTR, PIN_TX, PIN_RX, PWR_PIN}};
-enum MessageType { dataAck, hostChange };
-typedef struct response {
- MessageType type;
- uint8_t mac[6];
- long time;
-} response;
+NTPManager ntpManager{modem};
uint8_t BROADCAST_MAC[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
esp_now_peer_info_t broadcast = {};
response announce = {};
-ESP32Time rtc;
-
SemaphoreHandle_t xMutex;
TaskHandle_t ESPNOWTask;
static std::queue<String> queue;
+ResendManager resendManager;
+
void on_data_sent(const uint8_t *mac_addr, esp_now_send_status_t status) {
// go to sleep
}
-static char log_print_buffer[512];
-
-int vprintf_into_sd(const char *szFormat, va_list args) {
- String logstring = "[" + rtc.getDateTime() + "] ";
- logstring += szFormat;
- // write evaluated format string into buffer
- int ret = vsnprintf(log_print_buffer, sizeof(log_print_buffer), logstring.c_str(), args);
-
- String date = rtc.getDate();
- String filename = "/log_" + date + ".txt";
-
- // output is now in buffer. write to file.
- if (ret >= 0) {
- if (!SD.exists(filename)) {
- File writeLog = SD.open(filename, FILE_WRITE);
- if (!writeLog)
- Serial.println("Couldn't open " + filename + " for writing");
- delay(50);
- writeLog.close();
- }
-
- File logFile = SD.open(filename, FILE_APPEND);
-
- // debug output
- vprintf(logstring.c_str(), args);
- logFile.write((uint8_t *)log_print_buffer, (size_t)ret);
- // to be safe in case of crashes: flush the output
- logFile.flush();
- logFile.close();
- }
- return ret;
-}
-
-String getMacAddressAsString(const uint8_t *mac);
-DynamicJsonDocument parseReceivedJsonData(char *data);
-String documentToLineProtocolString(const DynamicJsonDocument &doc);
-
-void syncUTCTimeToRTC();
void on_data_recv(const uint8_t *mac, const uint8_t *incomingData, int len) {
- esp_log_write(ESP_LOG_INFO, TAG_ESPNOW.c_str(), "Message recieved\n");
+ esp_log_write(ESP_LOG_INFO, TAG_ESPNOW, "Message received\n");
// copy received data to a char array
char data[len];
memcpy(data, incomingData, len);
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "Raw received Data: %s\n", data);
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "Raw received Data: %s\n", data);
if (!esp_now_is_peer_exist(mac)) {
esp_now_peer_info_t client = {};
@@ -125,10 +74,18 @@ void on_data_recv(const uint8_t *mac, const uint8_t *incomingData, int len) {
esp_err_t status = esp_now_add_peer(&client);
if (status != ESP_OK) {
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "Failed to add new Peer: %d", status);
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "Failed to add new Peer: %d", status);
}
}
+ // TODO: Think if response to client may contain error messages
+ response response = {};
+ response.type = dataAck;
+ esp_read_mac(response.mac, ESP_MAC_WIFI_STA);
+ response.time = rtc.getEpoch();
+ esp_err_t success = esp_now_send(mac, (uint8_t *)&response, sizeof(response));
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, (success == ESP_OK) ? "Response sent\n" : "Failed to respond\n");
+
DynamicJsonDocument doc = parseReceivedJsonData(data);
String macAddress = getMacAddressAsString(mac);
@@ -141,110 +98,82 @@ void on_data_recv(const uint8_t *mac, const uint8_t *incomingData, int len) {
std::string dataString{};
serializeJson(doc, dataString);
- saveStringToSDCard(dataString);
+ try {
+ SDUtilities::saveStringToSDCard(dataString);
+ } catch (const std::exception &e) {
+ esp_log_write(ESP_LOG_ERROR, TAG_ESPNOW, "Failed to save data to SD card: %s", e.what());
+ }
- String lineData = documentToLineProtocolString(doc);
+ String serverData = documentToServerReadableString(doc);
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "Line protocol data: %s\n", lineData.c_str());
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "Data to be sent: %s\n", serverData.c_str());
xSemaphoreTake(xMutex, portMAX_DELAY);
- queue.push(lineData);
+ queue.push(serverData);
xSemaphoreGive(xMutex);
-
- response response = {};
- response.type = dataAck;
- esp_read_mac(response.mac, ESP_MAC_WIFI_STA);
- response.time = rtc.getEpoch();
- esp_err_t success = esp_now_send(mac, (uint8_t *)&response, sizeof(response));
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), (success == ESP_OK) ? "Response sent\n" : "Failed to respond\n");
}
-String documentToLineProtocolString(const DynamicJsonDocument &doc) {
- String measurementType = doc["measurementType"].as<String>();
- String sensorName = doc["sensorName"].as<String>();
- String timestamp = doc["timestamp"].as<String>();
- String protocol = doc["protocol"].as<String>();
- String value = doc["value"].as<String>();
- String channel = doc["channel"].as<String>();
- String clientMac = doc["clientMac"].as<String>();
-
- String lineData = sensorName + ",clientMac=" + clientMac + ",protocol=" + protocol + ",channel=" + channel + " "
- + measurementType + "=" + value + " " + timestamp;
- return lineData;
-}
-DynamicJsonDocument parseReceivedJsonData(char *data) {
- DynamicJsonDocument doc(250);
- auto error = deserializeJson(doc, data);
- if (error) {
- esp_log_write(ESP_LOG_ERROR, TAG_ESPNOW.c_str(), "Error while parsing json: %s\n", error.f_str());
- // TODO error handling
- }
- return doc;
-}
-String getMacAddressAsString(const uint8_t *mac) {
- String macAddress;
- for (int i = 0; i < 6; i++) {
- macAddress += String(mac[i], HEX);
+[[noreturn]] void esp_loop() {
+ while (true) {
}
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "MAC: %s\n", macAddress.c_str());
- return macAddress;
}
[[noreturn]] void ESPNOWReceiveTask(void *parameter) {
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "ESPNOWReceiveTask started on core %d\n", xPortGetCoreID());
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "ESPNOWReceiveTask started on core %d\n", xPortGetCoreID());
WiFi.mode(WIFI_STA);
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "Initialising ESPNow...\n");
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "Initialising ESPNow...\n");
if (esp_now_init() != ESP_OK) {
// initialization failed
- esp_log_write(ESP_LOG_ERROR, TAG_ESPNOW.c_str(), "Initialising ESPNow FAILED\n");
+ esp_log_write(ESP_LOG_ERROR, TAG_ESPNOW, "Initialising ESPNow FAILED\n");
exit(ESP_FAIL);
}
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "Initialising ESPNow SUCCESS\n");
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "Initialising ESPNow SUCCESS\n");
esp_now_register_recv_cb(on_data_recv);
- while (true) {
+ broadcast.channel = 0;
+ broadcast.encrypt = false;
+ memcpy(&broadcast.peer_addr, &BROADCAST_MAC, sizeof(BROADCAST_MAC));
+ if (esp_now_add_peer(&broadcast) != ESP_OK) {
+ esp_log_write(ESP_LOG_WARN, TAG_ESPNOW, "Failed to add Broadcast Host");
}
-}
-
-time_t timeToUnixEpochSeconds(const std::string &time) {
- // 22/10/27,10:16:20+00
- struct tm tm {};
- time_t dateInEpoch = 0;
-
- if (strptime(time.c_str(), "%y/%m/%d,%T+00", &tm)) {
- time_t curTime;
- struct tm *timeinfo;
-
- timeinfo = localtime(&curTime);
-
- timeinfo->tm_year = tm.tm_year;
- timeinfo->tm_mon = tm.tm_mon;
- timeinfo->tm_mday = tm.tm_mday;
- timeinfo->tm_hour = tm.tm_hour;
- timeinfo->tm_min = tm.tm_min;
- timeinfo->tm_sec = tm.tm_sec;
- timeinfo->tm_isdst = -1;
- dateInEpoch = mktime(timeinfo);
+ announce.type = hostChange;
+ esp_read_mac(announce.mac, ESP_MAC_WIFI_STA);
+ announce.time = rtc.getEpoch();
+ if (esp_now_send(BROADCAST_MAC, (uint8_t *)&announce, sizeof(announce)) != ESP_OK) {
+ esp_log_write(ESP_LOG_WARN, TAG_ESPNOW, "Failed to announce mac");
+ } else {
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "Mac announced!");
}
- return dateInEpoch;
+
+ esp_loop();
}
void setup() {
// Set console baud rate
Serial.begin(115200);
delay(10);
- setupSDCard(SD_MISO, SD_MOSI, SD_SCLK, SD_CS);
+ try {
+ SDUtilities::setupSDCard(SD_MISO, SD_MOSI, SD_SCLK, SD_CS);
+ } catch (const SDSetupException &e) {
+ SDUtilities::setSDAvailable(false);
+ esp_log_write(ESP_LOG_ERROR, TAG_MAIN, "SD Card setup failed: %s\n", e.what());
+ }
+
+ SDCardLogger::printDebugToSerial(PRINT_TO_SERIAL);
// https://stackoverflow.com/questions/60442350/arduinos-esp-log-set-vprintf-does-not-work-on-esp32
- esp_log_set_vprintf(&vprintf_into_sd);
+ esp_log_set_vprintf(&SDCardLogger::vprintf_into_sd);
esp_log_level_set("*", ESP_LOG_VERBOSE);
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "%s", WiFi.macAddress().c_str());
+ esp_log_write(ESP_LOG_DEBUG, TAG_MAIN, "%s", WiFi.macAddress().c_str());
+
+ resendManager.init();
+ turnOffLEDs();
xMutex = xSemaphoreCreateMutex();
@@ -261,207 +190,101 @@ void setup() {
0); /* Core where the task should run */
SerialAT.begin(UART_BAUD, SERIAL_8N1, PIN_RX, PIN_TX);
+}
- // Restart takes quite some time
- // To skip it, call init() instead of restart()
- esp_log_write(ESP_LOG_DEBUG, TAG_GSM.c_str(), "Initializing modem...\n");
- if (!modem.restart()) {
- esp_log_write(ESP_LOG_WARN, TAG_GSM.c_str(),
- "Failed to restart modem, attempting to continue without restarting\n");
- }
+void loop() {
- syncUTCTimeToRTC();
+ connectionManager.modemPowerOn();
+ delay(5000L);
- broadcast.channel = 0;
- broadcast.encrypt = false;
- memcpy(&broadcast.peer_addr, &BROADCAST_MAC, sizeof(BROADCAST_MAC));
- if (esp_now_add_peer(&broadcast) != ESP_OK) {
- esp_log_write(ESP_LOG_WARN, TAG_ESPNOW.c_str(), "Failed to add Broadcast Host");
- }
+ // Restart takes quite some time
+ // To skip it, call init() instead of restart()
+ connectionManager.restartModem();
- announce.type = hostChange;
- esp_read_mac(announce.mac, ESP_MAC_WIFI_STA);
announce.time = rtc.getEpoch();
if (esp_now_send(BROADCAST_MAC, (uint8_t *)&announce, sizeof(announce)) != ESP_OK) {
- esp_log_write(ESP_LOG_WARN, TAG_ESPNOW.c_str(), "Failed to announce mac");
+ esp_log_write(ESP_LOG_WARN, TAG_ESPNOW, "Failed to announce mac\n");
} else {
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "Mac announced!");
+ esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW, "Mac announced!\n");
}
-}
-void syncUTCTimeToRTC() {
- esp_log_write(ESP_LOG_DEBUG, TAG_GSM.c_str(), "NTP Server Syncing...\n");
- modem.NTPServerSync("pool.ntp.org", 0);
- auto gsmDateTimeString = modem.getGSMDateTime(DATE_FULL);
- esp_log_write(ESP_LOG_DEBUG, TAG_GSM.c_str(), "GSM DateTime: %s\n", gsmDateTimeString.c_str());
- time_t time = timeToUnixEpochSeconds(gsmDateTimeString.c_str());
- rtc.setTime(time);
- esp_log_write(ESP_LOG_INFO, TAG_GSM.c_str(), "Time set to EPOCH: %s\n", String(rtc.getEpoch()).c_str());
-}
-struct RequestInformation {
- String method;
- String host;
- String path;
- String body;
-};
-
-String buildRequest(const RequestInformation &requestInformation) {
- String request = "";
- request += requestInformation.method + " " + requestInformation.path + " HTTP/1.1\r\n";
- request += "Host: " + requestInformation.host + "\r\n";
- request += "Authorization: Token " + INFLUXDB_TOKEN + "\r\n";
- request += "User-Agent: ESP32\r\n";
- request += "Content-Type: text/plain\r\n";
- request += "Content-Length: " + String(requestInformation.body.length()) + "\r\n";
- request += "\r\n";
- request += requestInformation.body;
- return request;
-}
-
-void loop() {
+ connectionManager.disableGPS();
- // Restart takes quite some time
- // To skip it, call init() instead of restart()
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "Initializing modem...\n");
- if (!modem.init()) {
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(),
- "Failed to restart modem, attempting to continue without restarting\n");
+ try {
+ // may fail if already set
+ connectionManager.setNetworkMode(LTE_ONLY);
+ connectionManager.setPreferredMode(CAT_M);
+ } catch (const std::exception &e) {
+ esp_log_write(ESP_LOG_ERROR, TAG_GSM, "Error setting network mode: %s\n", e.what());
}
- announce.time = rtc.getEpoch();
- if (esp_now_send(BROADCAST_MAC, (uint8_t *)&announce, sizeof(announce)) != ESP_OK) {
- esp_log_write(ESP_LOG_WARN, TAG_ESPNOW.c_str(), "Failed to announce mac\n");
- } else {
- esp_log_write(ESP_LOG_DEBUG, TAG_ESPNOW.c_str(), "Mac announced!\n");
- }
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Modem Name: %s\n", modem.getModemName().c_str());
- String name = modem.getModemName();
- delay(500);
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "Modem Name %s\n", name.c_str());
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Modem Info: %s\n", modem.getModemInfo().c_str());
- String modemInfo = modem.getModemInfo();
- delay(500);
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "Modem Info: %s\n", modemInfo.c_str());
+ connectionManager.unlockSimCard();
- // Set SIM7000G GPIO4 LOW ,turn off GPS power
- // CMD:AT+SGPIO=0,4,1,0
- // Only in version 20200415 is there a function to control GPS power
- modem.sendAT("+SGPIO=0,4,1,0");
- if (modem.waitResponse(10000L) != 1) {
- DBG(" SGPIO=0,4,1,0 false ");
+ if (!connectionManager.waitForNetwork()) {
+ esp_log_write(ESP_LOG_ERROR, TAG_GSM, "Network not available\n");
+ return;
}
- modem.sendAT("+CFUN=0 ");
- if (modem.waitResponse(10000L) != 1) {
- DBG(" +CFUN=0 false ");
+ if (connectionManager.isNetworkConnected()) {
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Network connected\n");
}
+
delay(200);
- /*
- 2 Automatic
- 13 GSM only
- 38 LTE only
- 51 GSM and LTE only
- * * * */
- String res;
- res = modem.setNetworkMode(38);
- if (res != "1") {
- DBG("setNetworkMode false ");
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Connecting to %s\n", gprsCredentials.apn.c_str());
+ if (!connectionManager.gprsConnect()) {
+ esp_log_write(ESP_LOG_ERROR, TAG_GSM, "GPRS not connected\n");
return;
}
- delay(200);
- /*
- 1 CAT-M
- 2 NB-Iot
- 3 CAT-M and NB-IoT
- * * */
- // res = modem.setPreferredMode(1);
- // if (res != "1") {
- //
- // DBG("setPreferredMode false ");
- // return;
- // }
- delay(200);
+ connectionManager.logModemInformation();
- /*AT+CBANDCFG=<mode>,<band>[,<band>…]
- * <mode> "CAT-M" "NB-IOT"
- * <band> The value of <band> must is in the band list of getting from AT+CBANDCFG=?
- * For example, my SIM card carrier "NB-iot" supports B8. I will configure +CBANDCFG= "Nb-iot ",8
- */
- modem.sendAT("+CBANDCFG=\"CAT-M\",8 ");
- if (modem.waitResponse(10000L) != 1) {
- DBG(" +CBANDCFG=\"NB-IOT\" ");
+ ntpManager.syncNTP("pool.ntp.org", "at.pool.ntp.org");
+
+ try {
+ ntpManager.writeModemTimeToRTC();
+ } catch (const std::exception &e) {
+ esp_log_write(ESP_LOG_ERROR, TAG_GSM, "Error writing time to rtc: %s\n", e.what());
}
- delay(200);
- modem.sendAT("+CFUN=1 ");
- if (modem.waitResponse(10000L) != 1) {
- DBG(" +CFUN=1 false ");
+ if (connectionManager.isGprsConnected()) {
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "GPRS connected\n");
+ // make list of map of headers
+ std::map<String, String> headers;
+ headers["Content-Type"] = "application/json";
+ headers["Accept"] = "application/json";
+
+ xSemaphoreTake(xMutex, portMAX_DELAY);
+ String data = queue.front();
+ queue.pop();
+ xSemaphoreGive(xMutex);
+
+ RequestInformation requestInformation{POST, "influxdb.qe-forte.uibk.ac.at",
+ 80, "/api/v2/write?org=QE&bucket=esp32test&precision=s",
+ data, headers};
+
+ try {
+ connectionManager.connect(requestInformation);
+ } catch (const std::exception &e) {
+ esp_log_write(ESP_LOG_ERROR, TAG_GSM, "Error sending data: %s\n", e.what());
+ }
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "Data sent: %s\n", data.c_str());
}
- delay(200);
- // modem.disableGPS();
- delay(200);
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "%s\n", String(modem.getSignalQuality()).c_str());
- delay(200);
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "Trying to connect to network\n");
- modem.gprsConnect(apn, gprsUser, gprsPass);
- delay(200);
- syncUTCTimeToRTC();
+ connectionManager.gprsDisconnect();
+ delay(5000L);
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "Waiting for network...\n");
- if (!modem.isNetworkConnected()) {
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "Network not connected\n");
- return;
+ if (!modem.isGprsConnected()) {
+ esp_log_write(ESP_LOG_DEBUG, TAG_GSM, "GPRS disconnected\n");
} else {
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "Network connected\n");
- delay(200);
-
- // quality
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "%s\n", String(modem.getSignalQuality()).c_str());
- // make a http post request
- String url = "influxdb.qe-forte.uibk.ac.at";
- String path = "/api/v2/write?org=QE&bucket=esp32test&precision=s";
- Serial.print("Connecting to ");
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "%s\n", url.c_str());
- // Use WiFiClient class to create TCP connections
-
- while (!queue.empty()) {
-
- xSemaphoreTake(xMutex, portMAX_DELAY);
- String lineData = queue.front();
- queue.pop();
- xSemaphoreGive(xMutex);
-
- RequestInformation requestInformation{.method = "POST", .host = url, .path = path, .body = lineData};
-
- //"sensorName":"DRS26","timestamp":1666872216,"protocol":"I2C","value":0,"channel":0,"measurementType":"CIRCUMFERENCE_INCREMENT"
-
- String request = buildRequest(requestInformation);
- esp_log_write(ESP_LOG_VERBOSE, TAG.c_str(), "request: %s\n", request.c_str());
-
- TinyGsmClient client{modem};
- const int httpPort = 80;
- if (!client.connect(url.c_str(), httpPort)) {
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "connection failed\n");
- return;
- }
-
- client.print(request);
-
- // print response
- while (client.connected()) {
- String line = client.readStringUntil('\n');
- if (line == "\r") {
- esp_log_write(ESP_LOG_DEBUG, TAG.c_str(), "headers received\n");
- break;
- }
- }
- client.stop();
- delay(1000);
- }
- DBG("Network connected");
+ esp_log_write(ESP_LOG_ERROR, TAG_GSM, "GPRS not disconnected\n");
}
- delay(1000);
+
+ connectionManager.modemPowerOff();
+
+ delay(10000);
}
diff --git a/host/host_central_mast/src/main2.cpp b/host/host_central_mast/src/main2.cpp
deleted file mode 100644
index aaedda0570dfadd1926531602f0c527d39e6f870..0000000000000000000000000000000000000000
--- a/host/host_central_mast/src/main2.cpp
+++ /dev/null
@@ -1,304 +0,0 @@
-///**************************************************************
-// *
-// * This sketch connects to a website and downloads a page.
-// * It can be used to perform HTTP/RESTful API calls.
-// *
-// * TinyGSM Getting Started guide:
-// * https://tiny.cc/tinygsm-readme
-// *
-// **************************************************************/
-//
-//// Select your modem:
-//// #define TINY_GSM_MODEM_SIM800
-//// #define TINY_GSM_MODEM_SIM808
-//// #define TINY_GSM_MODEM_SIM868
-//// #define TINY_GSM_MODEM_SIM900
-//#define TINY_GSM_MODEM_SIM7000
-//// #define TINY_GSM_MODEM_SIM7000SSL
-//// #define TINY_GSM_MODEM_SIM7080
-//// #define TINY_GSM_MODEM_SIM5360
-//// #define TINY_GSM_MODEM_SIM7600
-//// #define TINY_GSM_MODEM_UBLOX
-//// #define TINY_GSM_MODEM_SARAR4
-//// #define TINY_GSM_MODEM_M95
-//// #define TINY_GSM_MODEM_BG96
-//// #define TINY_GSM_MODEM_A6
-//// #define TINY_GSM_MODEM_A7
-//// #define TINY_GSM_MODEM_M590
-//// #define TINY_GSM_MODEM_MC60
-//// #define TINY_GSM_MODEM_MC60E
-//// #define TINY_GSM_MODEM_ESP8266
-//// #define TINY_GSM_MODEM_XBEE
-//// #define TINY_GSM_MODEM_SEQUANS_MONARCH
-//
-//// Set serial for debug console (to the Serial Monitor, default speed 115200)
-//#define SerialMon Serial
-//
-//// Set serial for AT commands (to the module)
-//// Use Hardware Serial on Mega, Leonardo, Micro
-//#ifndef __AVR_ATmega328P__
-//#define SerialAT Serial1
-//
-//// or Software Serial on Uno, Nano
-//#else
-//#include <SoftwareSerial.h>
-//SoftwareSerial SerialAT(2, 3); // RX, TX
-//#endif
-//
-//// Increase RX buffer to capture the entire response
-//// Chips without internal buffering (A6/A7, ESP8266, M590)
-//// need enough space in the buffer for the entire response
-//// else data will be lost (and the http library will fail).
-//#if !defined(TINY_GSM_RX_BUFFER)
-//#define TINY_GSM_RX_BUFFER 650
-//#endif
-//
-//// See all AT commands, if wanted
-//#define DUMP_AT_COMMANDS
-//
-//// Define the serial console for debug prints, if needed
-//#define TINY_GSM_DEBUG SerialMon
-//
-//// Range to attempt to autobaud
-//// NOTE: DO NOT AUTOBAUD in production code. Once you've established
-//// communication, set a fixed baud rate using modem.setBaud(#).
-//#define GSM_AUTOBAUD_MIN 9600
-//#define GSM_AUTOBAUD_MAX 115200
-//
-//// Add a reception delay, if needed.
-//// This may be needed for a fast processor at a slow baud rate.
-//// #define TINY_GSM_YIELD() { delay(2); }
-//
-//// Uncomment this if you want to use SSL
-//// #define USE_SSL
-//
-//// Define how you're planning to connect to the internet.
-//// This is only needed for this example, not in other code.
-//#define TINY_GSM_USE_GPRS true
-//#define TINY_GSM_USE_WIFI false
-//
-//// set GSM PIN, if any
-//#define GSM_PIN ""
-//
-//// Your GPRS credentials, if any
-//const char apn[] = "m2m.public.at";
-//const char gprsUser[] = "";
-//const char gprsPass[] = "";
-//
-//// Your WiFi connection credentials, if applicable
-//const char wifiSSID[] = "YourSSID";
-//const char wifiPass[] = "YourWiFiPass";
-//
-//// Server details
-//const char server[] = "vsh.pp.ua";
-//const char resource[] = "/TinyGSM/logo.txt";
-//
-//#include <TinyGsmClient.h>
-//#include <WiFi.h>
-//#include <esp_now.h>
-//
-//// Just in case someone defined the wrong thing..
-//#if TINY_GSM_USE_GPRS && not defined TINY_GSM_MODEM_HAS_GPRS
-//#undef TINY_GSM_USE_GPRS
-//#undef TINY_GSM_USE_WIFI
-//#define TINY_GSM_USE_GPRS false
-//#define TINY_GSM_USE_WIFI true
-//#endif
-//#if TINY_GSM_USE_WIFI && not defined TINY_GSM_MODEM_HAS_WIFI
-//#undef TINY_GSM_USE_GPRS
-//#undef TINY_GSM_USE_WIFI
-//#define TINY_GSM_USE_GPRS true
-//#define TINY_GSM_USE_WIFI false
-//#endif
-//
-//#ifdef DUMP_AT_COMMANDS
-//#include <StreamDebugger.h>
-//StreamDebugger debugger(SerialAT, SerialMon);
-//TinyGsm modem(debugger);
-//#else
-//TinyGsm modem(SerialAT);
-//#endif
-//
-//#ifdef USE_SSL
-//TinyGsmClientSecure client_satellite(modem);
-//const int port = 443;
-//#else
-//TinyGsmClient client_satellite(modem);
-//const int port = 80;
-//#endif
-//
-//TaskHandle_t Task1;
-//
-//void on_data_sent(const uint8_t *mac_addr, esp_now_send_status_t status)
-//{
-// // go to sleep
-//}
-//
-//void on_data_recv(const uint8_t *mac, const uint8_t *incomingData, int len)
-//{
-// // print mac
-// Serial.print("Message recieved: Core ");
-// Serial.println(xPortGetCoreID());
-// for (int i = 0; i < 6; i++) {
-// Serial.print(mac[i], HEX);
-// Serial.print(":");
-// }
-// Serial.println();
-// char data[len];
-// memcpy(data, incomingData, len);
-// Serial.println(data);
-//}
-//
-//[[noreturn]] void Task1code(void *parameter)
-//{
-// Serial.println(xPortGetCoreID());
-// WiFi.mode(WIFI_STA);
-// Serial.println("ESPNow init");
-// if (esp_now_init() != ESP_OK) {
-// // initialization failed
-// Serial.println("ESPNow init failed");
-// // not sure about this
-// }
-// Serial.println("ESPNow init success");
-// esp_now_register_recv_cb(on_data_recv);
-//
-// while (true) {
-// }
-//}
-//
-//void setup2()
-//{
-// // Set console baud rate
-// SerialMon.begin(115200);
-// delay(10);
-//
-// // !!!!!!!!!!!
-// // Set your reset, enable, power pins here
-// // !!!!!!!!!!!
-//
-// SerialMon.println("Wait...");
-//
-// xTaskCreatePinnedToCore(Task1code, /* Function to implement the task */
-// "Task1", /* Name of the task */
-// 10000, /* Stack size in words */
-// nullptr, /* Task input parameter */
-// 0, /* Priority of the task */
-// &Task1, /* Task handle. */
-// 0); /* Core where the task should run */
-//
-// // Set GSM module baud rate
-// // TinyGsmAutoBaud(SerialAT, GSM_AUTOBAUD_MIN, GSM_AUTOBAUD_MAX);
-// modem.setBaud(9600);
-// // SerialAT.begin(9600);
-// delay(6000);
-//
-// // Restart takes quite some time
-// // To skip it, call init() instead of restart()
-// SerialMon.println("Initializing modem...");
-// modem.restart();
-// // modem.init();
-//
-// String modemInfo = modem.getModemInfo();
-// SerialMon.print("Modem Info: ");
-// SerialMon.println(modemInfo);
-//
-//#if TINY_GSM_USE_GPRS
-// // Unlock your SIM card with a PIN if needed
-// if (GSM_PIN && modem.getSimStatus() != 3) {
-// modem.simUnlock(GSM_PIN);
-// }
-//#endif
-//}
-//
-//void loop2()
-//{
-//#if TINY_GSM_USE_WIFI
-// // Wifi connection parameters must be set before waiting for the network
-// SerialMon.print(F("Setting SSID/password..."));
-// if (!modem.networkConnect(wifiSSID, wifiPass)) {
-// SerialMon.println(" fail");
-// delay(10000);
-// return;
-// }
-// SerialMon.println(" success");
-//#endif
-//
-//#if TINY_GSM_USE_GPRS && defined TINY_GSM_MODEM_XBEE
-// // The XBee must run the gprsConnect function BEFORE waiting for network!
-// modem.gprsConnect(apn, gprsUser, gprsPass);
-//#endif
-//
-// SerialMon.print("Waiting for network...");
-// if (!modem.waitForNetwork()) {
-// SerialMon.println(" fail");
-// delay(10000);
-// return;
-// }
-// SerialMon.println(" success");
-//
-// if (modem.isNetworkConnected()) {
-// SerialMon.println("Network connected");
-// }
-//
-//#if TINY_GSM_USE_GPRS
-// // GPRS connection parameters are usually set after network registration
-// SerialMon.print(F("Connecting to "));
-// SerialMon.print(apn);
-// if (!modem.gprsConnect(apn, gprsUser, gprsPass)) {
-// SerialMon.println(" fail");
-// delay(10000);
-// return;
-// }
-// SerialMon.println(" success");
-//
-// if (modem.isGprsConnected()) {
-// SerialMon.println("GPRS connected");
-// }
-//#endif
-//
-// SerialMon.print("Connecting to ");
-// SerialMon.println(server);
-// if (!client_satellite.connect(server, port)) {
-// SerialMon.println(" fail");
-// delay(10000);
-// return;
-// }
-// SerialMon.println(" success");
-//
-// // Make a HTTP GET request:
-// SerialMon.println("Performing HTTP GET request...");
-// client_satellite.print(String("GET ") + resource + " HTTP/1.1\r\n");
-// client_satellite.print(String("Host: ") + server + "\r\n");
-// client_satellite.print("Connection: close\r\n\r\n");
-// client_satellite.println();
-//
-// uint32_t timeout = millis();
-// while (client_satellite.connected() && millis() - timeout < 10000L) {
-// // Print available data
-// while (client_satellite.available()) {
-// char c = client_satellite.read();
-// SerialMon.print(c);
-// timeout = millis();
-// }
-// }
-// SerialMon.println();
-//
-// // Shutdown
-//
-// client_satellite.stop();
-// SerialMon.println(F("Server disconnected"));
-//
-//#if TINY_GSM_USE_WIFI
-// modem.networkDisconnect();
-// SerialMon.println(F("WiFi disconnected"));
-//#endif
-//#if TINY_GSM_USE_GPRS
-// modem.gprsDisconnect();
-// SerialMon.println(F("GPRS disconnected"));
-//#endif
-//
-// // Do nothing forevermore
-// while (true) {
-// delay(1000);
-// }
-//}