change MOCPP_ to MO_

Author: matth-x

CMakeLists.txt

@@ -4,15 +4,15 @@
 
 cmake_minimum_required(VERSION 3.15)
 
-set(MOCPP_MG_SRC
+set(MO_MG_SRC
     src/MicroOcppMongooseClient_c.cpp
     src/MicroOcppMongooseClient.cpp
     src/MicroOcppMongooseFtp.cpp
 )
 
 if(ESP_PLATFORM)
 
-    idf_component_register(SRCS ${MOCPP_MG_SRC}
+    idf_component_register(SRCS ${MO_MG_SRC}
                         INCLUDE_DIRS "src"
                         REQUIRES esp_timer mbedtls mongoose MicroOcpp)
 
@@ -22,7 +22,7 @@ if(ESP_PLATFORM)
     return()
 endif()
 
-add_library(MicroOcppMongoose ${MOCPP_MG_SRC})
+add_library(MicroOcppMongoose ${MO_MG_SRC})
 
 target_include_directories(MicroOcppMongoose PUBLIC
                             "./src"

README.md

@@ -7,7 +7,7 @@ Mongoose WebSocket adapter for MicroOcpp
 
 The following projects must be available on the include path:
 
-- [Mongoose Embedded Networking Library v6.14 / v7.8](https://github.com/cesanta/mongoose/tree/76e6b23a4f0261dd534d33632f42ea1bba99dc85): The MicroOcppMongoose adapter works with the amalgamated files `mongoose.h` and `mongoose.c`. You may need to copy them from the Mongoose-repository into the `src` folder of your project. To use the backwards-compatibility mode with v6.14, set the build flag `MOCPP_MG_VERSION_614`.
+- [Mongoose Embedded Networking Library v6.14 / v7.8](https://github.com/cesanta/mongoose/tree/76e6b23a4f0261dd534d33632f42ea1bba99dc85): The MicroOcppMongoose adapter works with the amalgamated files `mongoose.h` and `mongoose.c`. You may need to copy them from the Mongoose-repository into the `src` folder of your project. To use the backwards-compatibility mode with v6.14, set the build flag `MO_MG_VERSION_614`.
 - [ArduinoJson v6.19.1](https://github.com/bblanchon/ArduinoJson/tree/079ccadbee4100ad0b2d06f11de8c412b95853c1)
 - [MicroOcpp](https://github.com/matth-x/MicroOcpp)
 

src/MicroOcppMongooseClient.cpp

@@ -10,8 +10,8 @@
 #define DEBUG_MSG_INTERVAL 5000UL
 #define WS_UNRESPONSIVE_THRESHOLD_MS 15000UL
 
-#if defined(MOCPP_MG_VERSION_614)
-#define MOCPP_MG_F_IS_MOcppMongooseClient MG_F_USER_2
+#if defined(MO_MG_VERSION_614)
+#define MO_MG_F_IS_MOcppMongooseClient MG_F_USER_2
 #endif
 
 using namespace MicroOcpp;
@@ -34,49 +34,49 @@ MOcppMongooseClient::MOcppMongooseClient(struct mg_mgr *mgr,
         readonly = false;
     } else {
         //make the credentials non-persistent
-        MOCPP_DBG_WARN("Credentials non-persistent. Use MicroOcpp::makeDefaultFilesystemAdapter(...) for persistency");
+        MO_DBG_WARN("Credentials non-persistent. Use MicroOcpp::makeDefaultFilesystemAdapter(...) for persistency");
         readonly = true;
     }
 
     setting_backend_url_str = declareConfiguration<const char*>(
-        MOCPP_CONFIG_EXT_PREFIX "BackendUrl", backend_url_factory, MOCPP_WSCONN_FN, readonly, true);
+        MO_CONFIG_EXT_PREFIX "BackendUrl", backend_url_factory, MO_WSCONN_FN, readonly, true);
     setting_cb_id_str = declareConfiguration<const char*>(
-        MOCPP_CONFIG_EXT_PREFIX "ChargeBoxId", charge_box_id_factory, MOCPP_WSCONN_FN, readonly, true);
+        MO_CONFIG_EXT_PREFIX "ChargeBoxId", charge_box_id_factory, MO_WSCONN_FN, readonly, true);
     setting_auth_key_str = declareConfiguration<const char*>(
-        "AuthorizationKey", auth_key_factory, MOCPP_WSCONN_FN, readonly, true);
-#if !MOCPP_CA_CERT_LOCAL
+        "AuthorizationKey", auth_key_factory, MO_WSCONN_FN, readonly, true);
+#if !MO_CA_CERT_LOCAL
     setting_ca_cert_str = declareConfiguration<const char*>(
-        MOCPP_CONFIG_EXT_PREFIX "CaCert", CA_cert_factory, MOCPP_WSCONN_FN, readonly, true);
+        MO_CONFIG_EXT_PREFIX "CaCert", CA_cert_factory, MO_WSCONN_FN, readonly, true);
 #else
     ca_cert = CA_cert_factory ? CA_cert_factory : "";
 #endif
 
     ws_ping_interval_int = declareConfiguration<int>(
-        "WebSocketPingInterval", 5, MOCPP_WSCONN_FN);
+        "WebSocketPingInterval", 5, MO_WSCONN_FN);
     reconnect_interval_int = declareConfiguration<int>(
-        MOCPP_CONFIG_EXT_PREFIX "ReconnectInterval", 10, MOCPP_WSCONN_FN);
+        MO_CONFIG_EXT_PREFIX "ReconnectInterval", 10, MO_WSCONN_FN);
     stale_timeout_int = declareConfiguration<int>(
-        MOCPP_CONFIG_EXT_PREFIX "StaleTimeout", 300, MOCPP_WSCONN_FN);
+        MO_CONFIG_EXT_PREFIX "StaleTimeout", 300, MO_WSCONN_FN);
 
-    configuration_load(MOCPP_WSCONN_FN); //load configs with values stored on flash
+    configuration_load(MO_WSCONN_FN); //load configs with values stored on flash
 
     reloadConfigs(); //load WS creds with configs values
 
-#if defined(MOCPP_MG_VERSION_614)
-    MOCPP_DBG_DEBUG("use MG version %s (tested with 6.14)", MG_VERSION);
+#if defined(MO_MG_VERSION_614)
+    MO_DBG_DEBUG("use MG version %s (tested with 6.14)", MG_VERSION);
 #else
-    MOCPP_DBG_DEBUG("use MG version %s (tested with 7.8)", MG_VERSION);
+    MO_DBG_DEBUG("use MG version %s (tested with 7.8)", MG_VERSION);
 #endif
 
     maintainWsConn();
 }
 
 MOcppMongooseClient::~MOcppMongooseClient() {
-    MOCPP_DBG_DEBUG("destruct MOcppMongooseClient");
+    MO_DBG_DEBUG("destruct MOcppMongooseClient");
     if (websocket) {
         reconnect(); //close WS connection, won't be reopened
-#if defined(MOCPP_MG_VERSION_614)
-        websocket->flags &= ~MOCPP_MG_F_IS_MOcppMongooseClient;
+#if defined(MO_MG_VERSION_614)
+        websocket->flags &= ~MO_MG_F_IS_MOcppMongooseClient;
         websocket->user_data = nullptr;
 #else
         websocket->fn_data = nullptr;
@@ -93,7 +93,7 @@ bool MOcppMongooseClient::sendTXT(const char *msg, size_t length) {
         return false;
     }
     size_t sent;
-#if defined(MOCPP_MG_VERSION_614)
+#if defined(MO_MG_VERSION_614)
     if (websocket->send_mbuf.len > 0) {
         sent = 0;
         return false;
@@ -105,7 +105,7 @@ bool MOcppMongooseClient::sendTXT(const char *msg, size_t length) {
     sent = mg_ws_send(websocket, msg, length, WEBSOCKET_OP_TEXT);
 #endif
     if (sent < length) {
-        MOCPP_DBG_WARN("mg_ws_send did only accept %zu out of %zu bytes", sent, length);
+        MO_DBG_WARN("mg_ws_send did only accept %zu out of %zu bytes", sent, length);
         //flush broken package and wait for next retry
         (void)0;
     }
@@ -119,24 +119,24 @@ void MOcppMongooseClient::maintainWsConn() {
 
         //WS successfully connected?
         if (!isConnectionOpen()) {
-            MOCPP_DBG_DEBUG("WS unconnected");
+            MO_DBG_DEBUG("WS unconnected");
         } else if (mocpp_tick_ms() - last_recv >= (ws_ping_interval_int && ws_ping_interval_int->getInt() > 0 ? (ws_ping_interval_int->getInt() * 1000UL) : 0UL) + WS_UNRESPONSIVE_THRESHOLD_MS) {
             //WS connected but unresponsive
-            MOCPP_DBG_DEBUG("WS unresponsive");
+            MO_DBG_DEBUG("WS unresponsive");
         }
     }
 
     if (websocket && isConnectionOpen() &&
             stale_timeout_int && stale_timeout_int->getInt() > 0 && mocpp_tick_ms() - last_recv >= (stale_timeout_int->getInt() * 1000UL)) {
-        MOCPP_DBG_INFO("connection %s -- stale, reconnect", url.c_str());
+        MO_DBG_INFO("connection %s -- stale, reconnect", url.c_str());
         reconnect();
         return;
     }
 
     if (websocket && isConnectionOpen() &&
             ws_ping_interval_int && ws_ping_interval_int->getInt() > 0 && mocpp_tick_ms() - last_hb >= (ws_ping_interval_int->getInt() * 1000UL)) {
         last_hb = mocpp_tick_ms();
-#if defined(MOCPP_MG_VERSION_614)
+#if defined(MO_MG_VERSION_614)
         mg_send_websocket_frame(websocket, WEBSOCKET_OP_PING, "", 0);
 #else
         mg_ws_send(websocket, "", 0, WEBSOCKET_OP_PING);
@@ -156,11 +156,11 @@ void MOcppMongooseClient::maintainWsConn() {
         return;
     }
 
-    MOCPP_DBG_DEBUG("(re-)connect to %s", url.c_str());
+    MO_DBG_DEBUG("(re-)connect to %s", url.c_str());
 
     last_reconnection_attempt = mocpp_tick_ms();
 
-#if defined(MOCPP_MG_VERSION_614)
+#if defined(MO_MG_VERSION_614)
 
     struct mg_connect_opts opts;
     memset(&opts, 0, sizeof(opts));
@@ -174,7 +174,7 @@ void MOcppMongooseClient::maintainWsConn() {
             url.c_str()[2] == ':') {
         //yes, disable SSL
         ca_string = nullptr;
-        MOCPP_DBG_WARN("Insecure connection (WS)");
+        MO_DBG_WARN("Insecure connection (WS)");
     }
 
     opts.ssl_ca_cert = ca_string;
@@ -184,7 +184,7 @@ void MOcppMongooseClient::maintainWsConn() {
     if (!auth_key.empty()) {
         auto ret = snprintf(extra_headers, 128, "Authorization: Basic %s\r\n", basic_auth64.c_str());
         if (ret < 0 || ret >= 128) {
-            MOCPP_DBG_ERR("Basic Authentication failed: %d", ret);
+            MO_DBG_ERR("Basic Authentication failed: %d", ret);
             (void)0;
         }
     }
@@ -199,7 +199,7 @@ void MOcppMongooseClient::maintainWsConn() {
         *extra_headers ? extra_headers : nullptr);
 
     if (websocket) {
-        websocket->flags |= MOCPP_MG_F_IS_MOcppMongooseClient;
+        websocket->flags |= MO_MG_F_IS_MOcppMongooseClient;
     }
 
 #else
@@ -220,7 +220,7 @@ void MOcppMongooseClient::reconnect() {
     if (!websocket) {
         return;
     }
-#if defined(MOCPP_MG_VERSION_614)
+#if defined(MO_MG_VERSION_614)
     if (!connection_closing) {
         const char *msg = "socket closed by client";
         mg_send_websocket_frame(websocket, WEBSOCKET_OP_CLOSE, msg, strlen(msg));
@@ -233,7 +233,7 @@ void MOcppMongooseClient::reconnect() {
 
 void MOcppMongooseClient::setBackendUrl(const char *backend_url_cstr) {
     if (!backend_url_cstr) {
-        MOCPP_DBG_ERR("invalid argument");
+        MO_DBG_ERR("invalid argument");
         return;
     }
 
@@ -245,7 +245,7 @@ void MOcppMongooseClient::setBackendUrl(const char *backend_url_cstr) {
 
 void MOcppMongooseClient::setChargeBoxId(const char *cb_id_cstr) {
     if (!cb_id_cstr) {
-        MOCPP_DBG_ERR("invalid argument");
+        MO_DBG_ERR("invalid argument");
         return;
     }
 
@@ -257,7 +257,7 @@ void MOcppMongooseClient::setChargeBoxId(const char *cb_id_cstr) {
 
 void MOcppMongooseClient::setAuthKey(const char *auth_key_cstr) {
     if (!auth_key_cstr) {
-        MOCPP_DBG_ERR("invalid argument");
+        MO_DBG_ERR("invalid argument");
         return;
     }
 
@@ -269,11 +269,11 @@ void MOcppMongooseClient::setAuthKey(const char *auth_key_cstr) {
 
 void MOcppMongooseClient::setCaCert(const char *ca_cert_cstr) {
     if (!ca_cert_cstr) {
-        MOCPP_DBG_ERR("invalid argument");
+        MO_DBG_ERR("invalid argument");
         return;
     }
 
-#if !MOCPP_CA_CERT_LOCAL
+#if !MO_CA_CERT_LOCAL
     if (setting_ca_cert_str) {
         setting_ca_cert_str->setString(ca_cert_cstr);
         configuration_save();
@@ -302,7 +302,7 @@ void MOcppMongooseClient::reloadConfigs() {
         auth_key = setting_auth_key_str->getString();
     }
 
-#if !MOCPP_CA_CERT_LOCAL
+#if !MO_CA_CERT_LOCAL
     if (setting_ca_cert_str) {
         ca_cert = setting_ca_cert_str->getString();
     }
@@ -316,7 +316,7 @@ void MOcppMongooseClient::reloadConfigs() {
     basic_auth64.clear();
 
     if (backend_url.empty()) {
-        MOCPP_DBG_DEBUG("empty URL closes connection");
+        MO_DBG_DEBUG("empty URL closes connection");
         return;
     } else {
         url = backend_url;
@@ -331,19 +331,19 @@ void MOcppMongooseClient::reloadConfigs() {
     if (!auth_key.empty()) {
         std::string token = cb_id + ":" + auth_key;
 
-        MOCPP_DBG_DEBUG("auth Token=%s", token.c_str());
+        MO_DBG_DEBUG("auth Token=%s", token.c_str());
 
         unsigned int base64_length = encode_base64_length(token.length());
         std::vector<unsigned char> base64 (base64_length + 1);
 
         // encode_base64() places a null terminator automatically, because the output is a string
         base64_length = encode_base64((const unsigned char*) token.c_str(), token.length(), &base64[0]);
 
-        MOCPP_DBG_DEBUG("auth64 len=%u, auth64 Token=%s", base64_length, &base64[0]);
+        MO_DBG_DEBUG("auth64 len=%u, auth64 Token=%s", base64_length, &base64[0]);
 
         basic_auth64 = (const char*) &base64[0];
     } else {
-        MOCPP_DBG_DEBUG("no authentication");
+        MO_DBG_DEBUG("no authentication");
         (void) 0;
     }
 }
@@ -375,13 +375,13 @@ unsigned long MOcppMongooseClient::getLastConnected() {
     return last_connection_established;
 }
 
-#if defined(MOCPP_MG_VERSION_614)
+#if defined(MO_MG_VERSION_614)
 
 void ws_cb(struct mg_connection *nc, int ev, void *ev_data, void *user_data) {
 
     MOcppMongooseClient *osock = nullptr;
 
-    if (user_data && nc->flags & MG_F_IS_WEBSOCKET && nc->flags & MOCPP_MG_F_IS_MOcppMongooseClient) {
+    if (user_data && nc->flags & MG_F_IS_WEBSOCKET && nc->flags & MO_MG_F_IS_MOcppMongooseClient) {
         osock = reinterpret_cast<MOcppMongooseClient*>(user_data);
     } else {
         return;
@@ -391,18 +391,18 @@ void ws_cb(struct mg_connection *nc, int ev, void *ev_data, void *user_data) {
         case MG_EV_CONNECT: {
             int status = *((int *) ev_data);
             if (status != 0) {
-                MOCPP_DBG_WARN("connection %s -- error %d", osock->getUrl(), status);
+                MO_DBG_WARN("connection %s -- error %d", osock->getUrl(), status);
                 (void)0;
             }
             break;
         }
         case MG_EV_WEBSOCKET_HANDSHAKE_DONE: {
             struct http_message *hm = (struct http_message *) ev_data;
             if (hm->resp_code == 101) {
-                MOCPP_DBG_INFO("connection %s -- connected!", osock->getUrl());
+                MO_DBG_INFO("connection %s -- connected!", osock->getUrl());
                 osock->setConnectionOpen(true);
             } else {
-                MOCPP_DBG_WARN("connection %s -- HTTP error %d", osock->getUrl(), hm->resp_code);
+                MO_DBG_WARN("connection %s -- HTTP error %d", osock->getUrl(), hm->resp_code);
                 (void)0;
                 /* Connection will be closed after this. */
             }
@@ -417,7 +417,7 @@ void ws_cb(struct mg_connection *nc, int ev, void *ev_data, void *user_data) {
             struct websocket_message *wm = (struct websocket_message *) ev_data;
 
             if (!osock->getReceiveTXTcallback()((const char *) wm->data, wm->size)) { //forward message to Context
-                MOCPP_DBG_ERR("processing WS input failed");
+                MO_DBG_ERR("processing WS input failed");
                 (void)0;
             }
             osock->updateRcvTimer();
@@ -428,7 +428,7 @@ void ws_cb(struct mg_connection *nc, int ev, void *ev_data, void *user_data) {
             break;
         }
         case MG_EV_CLOSE: {
-            MOCPP_DBG_INFO("connection %s -- closed", osock->getUrl());
+            MO_DBG_INFO("connection %s -- closed", osock->getUrl());
             osock->cleanConnection();
             break;
         }
@@ -439,17 +439,17 @@ void ws_cb(struct mg_connection *nc, int ev, void *ev_data, void *user_data) {
 
 void ws_cb(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
     if (ev != 2) {
-        MOCPP_DBG_VERBOSE("Cb fn with event: %d\n", ev);
+        MO_DBG_VERBOSE("Cb fn with event: %d\n", ev);
         (void)0;
     }
 
     MOcppMongooseClient *osock = reinterpret_cast<MOcppMongooseClient*>(fn_data);
     if (!osock) {
         if (ev == MG_EV_ERROR || ev == MG_EV_CLOSE) {
-            MOCPP_DBG_INFO("connection %s", ev == MG_EV_CLOSE ? "closed" : "error");
+            MO_DBG_INFO("connection %s", ev == MG_EV_CLOSE ? "closed" : "error");
             (void)0;
         } else {
-            MOCPP_DBG_ERR("invalid state %d", ev);
+            MO_DBG_ERR("invalid state %d", ev);
             (void)0;
         }
         return;
@@ -469,25 +469,25 @@ void ws_cb(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
             struct mg_tls_opts opts = {.ca = ca_string};
             mg_tls_init(c, &opts);
         } else {
-            MOCPP_DBG_WARN("Insecure connection (WS)");
+            MO_DBG_WARN("Insecure connection (WS)");
         }
     } else if (ev == MG_EV_WS_OPEN) {
         // WS connection established. Perform MQTT login
-        MOCPP_DBG_INFO("connection %s -- connected!", osock->getUrl());
+        MO_DBG_INFO("connection %s -- connected!", osock->getUrl());
         osock->setConnectionOpen(true);
         osock->updateRcvTimer();
     } else if (ev == MG_EV_WS_MSG) {
         struct mg_ws_message *wm = (struct mg_ws_message *) ev_data;
         if (!osock->getReceiveTXTcallback()((const char*) wm->data.ptr, wm->data.len)) {
-            MOCPP_DBG_WARN("processing input message failed");
+            MO_DBG_WARN("processing input message failed");
         }
         osock->updateRcvTimer();
     } else if (ev == MG_EV_WS_CTL) {
         osock->updateRcvTimer();
     }
 
     if (ev == MG_EV_ERROR || ev == MG_EV_CLOSE) {
-        MOCPP_DBG_INFO("connection %s -- %s", osock->getUrl(), ev == MG_EV_CLOSE ? "closed" : "error");
+        MO_DBG_INFO("connection %s -- %s", osock->getUrl(), ev == MG_EV_CLOSE ? "closed" : "error");
         osock->cleanConnection();
     }
 }