Bruteforcing Arduino 3.0 support

nullstalgia · nullstalgia · commit a9b66ef466a8 · 2026-01-23T04:17:15.000-08:00
diff --git a/include/Hashing.h b/include/Hashing.h
@@ -19,10 +19,10 @@ namespace OpenShock {
     MD5() { mbedtls_md5_init(&ctx); }
     ~MD5() { mbedtls_md5_free(&ctx); }
 
-    inline bool begin() { return mbedtls_md5_starts_ret(&ctx) == 0; }
-    inline bool update(const uint8_t* data, std::size_t dataLen) { return mbedtls_md5_update_ret(&ctx, data, dataLen) == 0; }
+    inline bool begin() { return mbedtls_md5_starts(&ctx) == 0; }
+    inline bool update(const uint8_t* data, std::size_t dataLen) { return mbedtls_md5_update(&ctx, data, dataLen) == 0; }
     inline bool update(std::string_view data) { return update(reinterpret_cast<const uint8_t*>(data.data()), data.length()); }
-    inline bool finish(std::array<uint8_t, 16>& hash) { return mbedtls_md5_finish_ret(&ctx, hash.data()) == 0; }
+    inline bool finish(std::array<uint8_t, 16>& hash) { return mbedtls_md5_finish(&ctx, hash.data()) == 0; }
 
   private:
     mbedtls_md5_context ctx;
@@ -35,10 +35,10 @@ namespace OpenShock {
     SHA1() { mbedtls_sha1_init(&ctx); }
     ~SHA1() { mbedtls_sha1_free(&ctx); }
 
-    inline bool begin() { return mbedtls_sha1_starts_ret(&ctx) == 0; }
-    inline bool update(const uint8_t* data, std::size_t dataLen) { return mbedtls_sha1_update_ret(&ctx, data, dataLen) == 0; }
+    inline bool begin() { return mbedtls_sha1_starts(&ctx) == 0; }
+    inline bool update(const uint8_t* data, std::size_t dataLen) { return mbedtls_sha1_update(&ctx, data, dataLen) == 0; }
     inline bool update(std::string_view data) { return update(reinterpret_cast<const uint8_t*>(data.data()), data.length()); }
-    inline bool finish(std::array<uint8_t, 20>& hash) { return mbedtls_sha1_finish_ret(&ctx, hash.data()) == 0; }
+    inline bool finish(std::array<uint8_t, 20>& hash) { return mbedtls_sha1_finish(&ctx, hash.data()) == 0; }
 
   private:
     mbedtls_sha1_context ctx;
@@ -51,10 +51,10 @@ namespace OpenShock {
     SHA256() { mbedtls_sha256_init(&ctx); }
     ~SHA256() { mbedtls_sha256_free(&ctx); }
 
-    inline bool begin() { return mbedtls_sha256_starts_ret(&ctx, 0) == 0; }
-    inline bool update(const uint8_t* data, std::size_t dataLen) { return mbedtls_sha256_update_ret(&ctx, data, dataLen) == 0; }
+    inline bool begin() { return mbedtls_sha256_starts(&ctx, 0) == 0; }
+    inline bool update(const uint8_t* data, std::size_t dataLen) { return mbedtls_sha256_update(&ctx, data, dataLen) == 0; }
     inline bool update(std::string_view data) { return update(reinterpret_cast<const uint8_t*>(data.data()), data.length()); }
-    inline bool finish(std::array<uint8_t, 32>& hash) { return mbedtls_sha256_finish_ret(&ctx, hash.data()) == 0; }
+    inline bool finish(std::array<uint8_t, 32>& hash) { return mbedtls_sha256_finish(&ctx, hash.data()) == 0; }
 
   private:
     mbedtls_sha256_context ctx;
diff --git a/include/RGBPatternManager.h b/include/RGBPatternManager.h
@@ -47,7 +47,6 @@ namespace OpenShock {
     gpio_num_t m_gpioPin;
     uint8_t m_brightness;  // 0-255
     std::vector<RGBState> m_pattern;
-    rmt_obj_t* m_rmtHandle;
     TaskHandle_t m_taskHandle;
     SimpleMutex m_taskMutex;
   };
diff --git a/include/radio/RFTransmitter.h b/include/radio/RFTransmitter.h
@@ -23,7 +23,7 @@ namespace OpenShock {
 
     inline gpio_num_t GetTxPin() const { return m_txPin; }
 
-    inline bool ok() const { return m_rmtHandle != nullptr && m_queueHandle != nullptr && m_taskHandle != nullptr; }
+    inline bool ok() const { return m_txPin != GPIO_NUM_NC && m_queueHandle != nullptr && m_taskHandle != nullptr; }
 
     bool SendCommand(ShockerModelType model, uint16_t shockerId, ShockerCommandType type, uint8_t intensity, uint16_t durationMs, bool overwriteExisting = true);
     void ClearPendingCommands();
@@ -35,7 +35,6 @@ namespace OpenShock {
     struct Command;
 
     gpio_num_t m_txPin;
-    rmt_obj_t* m_rmtHandle;
     QueueHandle_t m_queueHandle;
     TaskHandle_t m_taskHandle;
   };
diff --git a/include/span.h b/include/span.h
@@ -14,6 +14,7 @@ This is an implementation of C++20's std::span
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
+#include <exception>
 
 #ifndef TCB_SPAN_NO_EXCEPTIONS
 // Attempt to discover whether we're being compiled with exception support
diff --git a/platformio.ini b/platformio.ini
@@ -9,7 +9,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [env]
-platform = espressif32 @ 6.12.0
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip
 board = az-delivery-devkit-v4 ; Overridden per board
 framework = arduino
 
@@ -54,7 +54,7 @@ build_src_flags =
 lib_deps =
 	https://github.com/google/flatbuffers#8b02fe6178427b96aea25396b53ea4ae8cadd7d8
 	https://github.com/OpenShock/ESPAsyncWebServer#469816c6bd287e3ecdda9e519c2532db019aa3c1
-	https://github.com/OpenShock/BadWebSockets#ec5eae735d94b3774498f8fd7564dce1cd5a5339
+	https://github.com/OpenShock/BadWebSockets#93de92a3a64f87f9a7cd24e6abf8f67f076f2f16
 custom_openshock.flash_size = 4MB; Can be overridden per board
 board_build.filesystem = littlefs
 board_build.embed_files = certificates/x509_crt_bundle
diff --git a/src/CaptivePortal.cpp b/src/CaptivePortal.cpp
@@ -4,6 +4,7 @@
 
 const char* const TAG = "CaptivePortal";
 
+#include "CaptivePortalConfig.h"
 #include "CaptivePortalInstance.h"
 #include "CommandHandler.h"
 #include "config/Config.h"
@@ -155,9 +156,10 @@ bool CaptivePortal::Init()
 void CaptivePortal::SetAlwaysEnabled(bool alwaysEnabled)
 {
   s_alwaysEnabled = alwaysEnabled;
-  Config::SetCaptivePortalConfig({
+  CaptivePortalConfig config = {
     .alwaysEnabled = alwaysEnabled,
-  });
+  };
+  Config::SetCaptivePortalConfig(config);
 }
 bool CaptivePortal::IsAlwaysEnabled()
 {
diff --git a/src/OtaUpdateManager.cpp b/src/OtaUpdateManager.cpp
@@ -393,7 +393,12 @@ static void otaum_updatetask(void* arg)
 
     // Increase task watchdog timeout.
     // Prevents panics on some ESP32s when clearing large partitions.
-    esp_task_wdt_init(15, true);
+    esp_task_wdt_config_t twdt_config = {
+        .timeout_ms = 15,
+        .idle_core_mask = (1 << CONFIG_FREERTOS_NUMBER_OF_CORES) - 1,    // Bitmask of all cores
+        .trigger_panic = true,
+    };
+    ESP_ERROR_CHECK(esp_task_wdt_init(&twdt_config));
 
     // Flash app and filesystem partitions.
     if (!_flashFilesystemPartition(filesystemPartition, release.filesystemBinaryUrl, release.filesystemBinaryHash)) continue;
@@ -407,7 +412,8 @@ static void otaum_updatetask(void* arg)
     }
 
     // Set task watchdog timeout back to default.
-    esp_task_wdt_init(5, true);
+    twdt_config.timeout_ms = 5;
+    ESP_ERROR_CHECK(esp_task_wdt_init(&twdt_config));
 
     // Send reboot message.
     _sendProgressMessage(Serialization::Types::OtaUpdateProgressTask::Rebooting, 0.0f);
diff --git a/src/RGBPatternManager.cpp b/src/RGBPatternManager.cpp
@@ -16,11 +16,12 @@ using namespace OpenShock;
 // TODO: Support multiple LEDs ?
 // TODO: Support other LED types ?
 
+const int32_t kRmtTimeoutMs         = 100;
+
 RGBPatternManager::RGBPatternManager(gpio_num_t gpioPin)
   : m_gpioPin(GPIO_NUM_NC)
   , m_brightness(255)
   , m_pattern()
-  , m_rmtHandle(nullptr)
   , m_taskHandle(nullptr)
   , m_taskMutex()
 {
@@ -34,14 +35,17 @@ RGBPatternManager::RGBPatternManager(gpio_num_t gpioPin)
     return;
   }
 
-  m_rmtHandle = rmtInit(gpioPin, RMT_TX_MODE, RMT_MEM_64);
-  if (m_rmtHandle == NULL) {
+  bool success = rmtInit(gpioPin, RMT_TX_MODE, RMT_MEM_NUM_BLOCKS_1, 10'000'000); // RMT_MEM_64, 10MHz
+  if (!success) {
     OS_LOGE(TAG, "Failed to initialize RMT for pin %hhi", gpioPin);
     return;
   }
 
-  float realTick = rmtSetTick(m_rmtHandle, 100.F);
-  OS_LOGD(TAG, "RMT tick is %f ns for pin %hhi", realTick, gpioPin);
+  success = rmtSetEOT(gpioPin, 0);
+  if (!success) {
+    OS_LOGE(TAG, "Failed to set EOT level for pin %hhi", gpioPin);
+    return;
+  }
 
   SetBrightness(20);
 
@@ -52,7 +56,7 @@ RGBPatternManager::~RGBPatternManager()
 {
   ClearPattern();
 
-  rmtDeinit(m_rmtHandle);
+  rmtDeinit(m_gpioPin);
 }
 
 void RGBPatternManager::SetPattern(const RGBState* pattern, std::size_t patternLength)
@@ -106,8 +110,8 @@ void RGBPatternManager::RunPattern(void* arg)
 {
   RGBPatternManager* thisPtr = reinterpret_cast<RGBPatternManager*>(arg);
 
-  rmt_obj_t* rmtHandle           = thisPtr->m_rmtHandle;
   uint8_t brightness             = thisPtr->m_brightness;
+  gpio_num_t gpioPin             = thisPtr->m_gpioPin;
   std::vector<RGBState>& pattern = thisPtr->m_pattern;
 
   std::array<rmt_data_t, 24> led_data;  // 24 bits per LED (8 bits per color * 3 colors)
@@ -143,7 +147,7 @@ void RGBPatternManager::RunPattern(void* arg)
       }
 
       // Send the data
-      rmtWriteBlocking(rmtHandle, led_data.data(), led_data.size());
+      rmtWrite(gpioPin, led_data.data(), led_data.size(), kRmtTimeoutMs);
       vTaskDelay(pdMS_TO_TICKS(state.duration));
     }
   }
diff --git a/src/VisualStateManager.cpp b/src/VisualStateManager.cpp
@@ -13,6 +13,8 @@ const char* const TAG = "VisualStateManager";
 
 #include <memory>
 
+#include "esp_wifi.h"
+
 #ifndef OPENSHOCK_LED_GPIO
 #define OPENSHOCK_LED_GPIO GPIO_NUM_NC
 #endif  // OPENSHOCK_LED_GPIO
diff --git a/src/http/HTTPRequestManager.cpp b/src/http/HTTPRequestManager.cpp
@@ -11,6 +11,7 @@ const char* const TAG = "HTTPRequestManager";
 #include "util/StringUtils.h"
 
 #include <HTTPClient.h>
+#include <WiFi.h>
 
 #include <algorithm>
 #include <memory>
diff --git a/src/radio/RFTransmitter.cpp b/src/radio/RFTransmitter.cpp
@@ -18,6 +18,7 @@ const BaseType_t kTaskPriority      = 1;
 const uint32_t kTaskStackSize       = 4096;  // PROFILED: 1.4KB stack usage
 const float kTickrateNs             = 1000;
 const int64_t kTerminatorDurationMs = 300;
+const int32_t kRmtTimeoutMs         = 100;
 const uint8_t kFlagOverwrite        = 1 << 0;
 const uint8_t kFlagDeleteTask       = 1 << 1;
 const TickType_t kTaskIdleDelay     = pdMS_TO_TICKS(5);
@@ -35,21 +36,24 @@ struct RFTransmitter::Command {
 
 RFTransmitter::RFTransmitter(gpio_num_t gpioPin)
   : m_txPin(gpioPin)
-  , m_rmtHandle(nullptr)
   , m_queueHandle(nullptr)
   , m_taskHandle(nullptr)
 {
   OS_LOGD(TAG, "[pin-%hhi] Creating RFTransmitter", m_txPin);
 
-  m_rmtHandle = rmtInit(static_cast<int>(m_txPin), RMT_TX_MODE, RMT_MEM_64);
-  if (m_rmtHandle == nullptr) {
+  bool success = rmtInit(gpioPin, RMT_TX_MODE, RMT_MEM_NUM_BLOCKS_1, 1'000'000); // RMT_MEM_64, 1MHz
+  if (!success) {
     OS_LOGE(TAG, "[pin-%hhi] Failed to create rmt object", m_txPin);
     destroy();
     return;
   }
 
-  float realTick = rmtSetTick(m_rmtHandle, kTickrateNs);
-  OS_LOGD(TAG, "[pin-%hhi] real tick set to: %fns", m_txPin, realTick);
+  success = rmtSetEOT(gpioPin, 0);
+  if (!success) {
+    OS_LOGE(TAG, "Failed to set EOT level for pin %hhi", gpioPin);
+    destroy();
+    return;
+  }
 
   m_queueHandle = xQueueCreate(kQueueSize, sizeof(Command));
   if (m_queueHandle == nullptr) {
@@ -144,9 +148,8 @@ void RFTransmitter::destroy()
     vQueueDelete(m_queueHandle);
     m_queueHandle = nullptr;
   }
-  if (m_rmtHandle != nullptr) {
-    rmtDeinit(m_rmtHandle);
-    m_rmtHandle = nullptr;
+  if (m_txPin != GPIO_NUM_NC) {
+    rmtDeinit(m_txPin);
   }
 }
 
@@ -175,15 +178,15 @@ static bool modifySequence(std::vector<Rmt::Sequence>& sequences, ShockerModelTy
   return false;
 }
 
-static void writeSequences(rmt_obj_t* rmt_handle, std::vector<Rmt::Sequence>& sequences)
+static void writeSequences(gpio_num_t m_txPin, std::vector<Rmt::Sequence>& sequences)
 {
   // Send queued commands
   for (auto seq = sequences.begin(); seq != sequences.end();) {
     int64_t timeToLive = seq->transmitEnd() - OpenShock::millis();
 
     if (timeToLive > 0) {
       // Send the command
-      rmtWriteBlocking(rmt_handle, seq->payload(), seq->size());
+      rmtWrite(m_txPin, seq->payload(), seq->size(), kRmtTimeoutMs);
     } else {
       // Remove command if it has sent out its termination sequence for long enough
       if (timeToLive <= -kTerminatorDurationMs) {
@@ -192,7 +195,7 @@ static void writeSequences(rmt_obj_t* rmt_handle, std::vector<Rmt::Sequence>& se
       }
 
       // Send the termination sequence to stop the shocker
-      rmtWriteBlocking(rmt_handle, seq->terminator(), seq->size());
+      rmtWrite(m_txPin, seq->terminator(), seq->size(), kRmtTimeoutMs);
     }
 
     // Move to the next command
@@ -242,6 +245,6 @@ void RFTransmitter::TransmitTask()
       }
     }
 
-    writeSequences(m_rmtHandle, sequences);
+    writeSequences(m_txPin, sequences);
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`
`5`	`5`	`const char* const TAG = "CaptivePortal";`
`6`	`6`
	`7`	`+#include "CaptivePortalConfig.h"`
`7`	`8`	`#include "CaptivePortalInstance.h"`
`8`	`9`	`#include "CommandHandler.h"`
`9`	`10`	`#include "config/Config.h"`
`@@ -155,9 +156,10 @@ bool CaptivePortal::Init()`
`155`	`156`	`void CaptivePortal::SetAlwaysEnabled(bool alwaysEnabled)`
`156`	`157`	`{`
`157`	`158`	`s_alwaysEnabled = alwaysEnabled;`
`158`		`- Config::SetCaptivePortalConfig({`
	`159`	`+ CaptivePortalConfig config = {`
`159`	`160`	`.alwaysEnabled = alwaysEnabled,`
`160`		`- });`
	`161`	`+ };`
	`162`	`+ Config::SetCaptivePortalConfig(config);`
`161`	`163`	`}`
`162`	`164`	`bool CaptivePortal::IsAlwaysEnabled()`
`163`	`165`	`{`