Add fan, USB-C PD and wroom_v1 configuration

Author: GuLinux

platformio.ini

@@ -66,6 +66,22 @@ board = lolin_s2_mini
 [env:esp32_c3_supermini]
 board = lolin_c3_mini
 
+[env:esp32_s3_wroom_n8r2]
+board = esp32-s3-devkitc-1
+board_build.arduino.memory_type = qio_qspi
+board_build.flash_mode = qio
+board_build.psram_type = qio
+board_upload.flash_size = 8MB
+board_upload.maximum_size = 8388608
+board_build.partitions = default_8MB.csv
+build_flags = 
+	${env.build_flags}
+	-DARDUINO_USB_CDC_ON_BOOT=1
+	-DARDUINO_USB_MODE=1
+	-DBOARD_HAS_PSRAM
+	-DCONFIG_PINOUT_WROOM_V1
+
+
 ; debug_server =
 ;   ${platformio.packages_dir}/tool-openocd-esp32/bin/openocd
 ;   -f

src/configuration.h

@@ -9,6 +9,10 @@
 #include "configuration_lolin_c3_mini.h"
 #endif
 
+#ifdef CONFIG_PINOUT_WROOM_V1
+#include "configuration_wroom_v1.h"
+#endif
+
 
 #define APB_STATUS_LED_INVERT_LOGIC false
 #define WIFIMANAGER_MAX_STATIONS 5
@@ -32,7 +36,7 @@
 
 #define APB_INA1219_ADDRESS 0x40
 
-#define MAX_EVENTS_SIZE 800
+#define MAX_EVENTS_SIZE 1200
 
 #if __has_include ("configuration_custom.h")
 #include "configuration_custom.h"

src/configuration_wroom_v1.h

@@ -0,0 +1,36 @@
+#define I2C_SDA_PIN 15
+#define I2C_SCL_PIN 16
+#define APB_STATUS_LED_PIN 4
+
+
+#define SPI_SCK 12
+#define SPI_MISO 13
+#define SPI_MOSI 11
+#define SPI_SS  10
+
+#define APB_PWM_0_PIN 41
+#define APB_PWM_1_PIN 42
+#define APB_PWM_2_PIN 46
+#define APB_PWM_3_PIN 9
+#define APB_PWM_4_PIN 14
+#define APB_PWM_5_PIN 21
+#define APB_PWM_FAN_PIN 3
+#define APB_THERMISTOR_0_PIN 2
+#define APB_THERMISTOR_1_PIN 1
+
+#define CH224K_CFG1_PIN 17
+#define CH224K_CFG2_PIN 18
+#define CH224K_CFG3_PIN 8
+
+#define ONEBUTTON_USER_BUTTON_1 7
+
+// Thermistor PWM pinout. First number in a pair is the PWM pin (output), second thermistor PIN (analog input)
+// IMPORTANT: there is no compiler check for pinout size, so be careful.
+#define APB_PWM_OUTPUTS_PWM_PINOUT {APB_PWM_0_PIN,APB_THERMISTOR_0_PIN, Heater}, \
+                                   {APB_PWM_1_PIN,APB_THERMISTOR_1_PIN, Heater}, \
+                                   {APB_PWM_2_PIN,-1, Output}, \
+                                   {APB_PWM_3_PIN,-1, Output}, \
+                                   {APB_PWM_4_PIN,-1, Output}, \
+                                   {APB_PWM_5_PIN,-1, Output}
+#define APB_PWM_OUTPUTS_SIZE 6
+#define APB_PWM_OUTPUTS_TEMP_SENSORS 2

src/main.cpp

@@ -21,6 +21,7 @@
 #include <asyncbufferedtcplogger.h>
 #include <arduinoota-manager.h>
 #include <ArduinoOTA.h>
+#include "pd_protocol.h"
 
 Scheduler scheduler;
 
@@ -61,7 +62,12 @@ void setup() {
 
   LittleFS.begin();
   APB::Settings::Instance.setup();
-  
+
+  PDProtocol::setVoltage(APB::Settings::Instance.pdVoltage());
+
+  #ifdef APB_PWM_FAN_PIN
+  analogWrite(APB_PWM_FAN_PIN, static_cast<int>(APB::Settings::Instance.fanDuty() * 255.0));    
+  #endif
   APB::StatusLed::Instance.setup(&scheduler);
   #ifdef WIFI_POWER_TX
   WiFi.setTxPower(WIFI_POWER_TX);
@@ -107,7 +113,19 @@ void setup() {
     Log.infoln("[OneButton] User button 1 double clicked, reconnecting WiFi");
     WiFiManager::Instance.reconnect();
   });
-  userButton.setup(ONEBUTTON_USER_BUTTON_1, INPUT, false);
+  userButton.attachLongPressStop([]() {
+    Log.infoln("[OneButton] User button 1 long press, restarting");
+    delay(2000);
+    ESP.restart();
+  });
+  #ifdef ONEBUTTON_USER_BUTTON_1_ACTIVE_HIGH
+  #define _BTN_ACTIVELOW false
+  #define _BTN_MODE INPUT_PULLDOWN
+  #else
+  #define _BTN_ACTIVELOW true
+  #define _BTN_MODE INPUT_PULLUP
+  #endif
+  userButton.setup(ONEBUTTON_USER_BUTTON_1, _BTN_MODE, _BTN_ACTIVELOW);
 #endif
 
   new Task(100, TASK_FOREVER, [](){ ArduinoOTAManager::Instance.loop(); }, &scheduler, true);

src/pd_protocol.cpp

@@ -0,0 +1,56 @@
+#include "pd_protocol.h"
+#include <ArduinoLog.h>
+
+const std::map<PDProtocol::Voltage, PDProtocol::PinoutConfig> PDProtocol::voltageToCommand = {
+    {Voltage::NOT_AVAILABLE, {0, 0, 0}},
+    {Voltage::V5, {1, 0, 0}},
+    {Voltage::V9, {0, 0, 0}},
+    {Voltage::V12, {0, 0, 1}},
+    {Voltage::V15, {0, 1, 1}},
+};
+
+PDProtocol::PinoutConfig PDProtocol::lastConfig = PDProtocol::voltageToCommand.at(Voltage::NOT_AVAILABLE);
+
+const std::forward_list<PDProtocol::Voltage> PDProtocol::supportedVoltages = {
+#if defined(CH224K_CFG1_PIN) && defined(CH224K_CFG2_PIN) && defined(CH224K_CFG3_PIN)
+    Voltage::V5,
+    Voltage::V9,
+    Voltage::V12,
+    Voltage::V15,
+    #else
+    Voltage::NOT_AVAILABLE,
+#endif
+};
+
+void PDProtocol::setVoltage(Voltage voltage) {
+    #if defined(CH224K_CFG1_PIN) && defined(CH224K_CFG2_PIN) && defined(CH224K_CFG3_PIN)
+        if(voltage == NOT_AVAILABLE ||  voltageToCommand.find(voltage) == voltageToCommand.end()) {
+            Log.error("PDProtocol: Unsupported voltage %dV\n", static_cast<int>(voltage));
+            return;
+        }
+        const auto &[cfg1, cfg2, cfg3] = voltageToCommand.at(voltage);
+        pinMode(CH224K_CFG1_PIN, OUTPUT);
+        pinMode(CH224K_CFG2_PIN, OUTPUT);
+        pinMode(CH224K_CFG3_PIN, OUTPUT);
+        digitalWrite(CH224K_CFG1_PIN, cfg1);
+        digitalWrite(CH224K_CFG2_PIN, cfg2);
+        digitalWrite(CH224K_CFG3_PIN, cfg3);
+        lastConfig = std::make_tuple(cfg1, cfg2, cfg3);
+        Log.infoln("PDProtocol: Set voltage to %dV (CFG1=%d, CFG2=%d, CFG3=%d)", static_cast<int>(voltage), cfg1, cfg2, cfg3);
+    #endif
+}
+
+PDProtocol::Voltage PDProtocol::getVoltage() {
+    #if defined(CH224K_CFG1_PIN) && defined(CH224K_CFG2_PIN) && defined(CH224K_CFG3_PIN)
+        for(const auto &[voltage, pinout] : voltageToCommand) {
+            if(pinout == lastConfig) {
+                return voltage;
+            }
+        }
+    #endif
+    return NOT_AVAILABLE;
+}
+
+std::forward_list<PDProtocol::Voltage> PDProtocol::getSupportedVoltages() {
+    return supportedVoltages;
+}

src/pd_protocol.h

@@ -0,0 +1,19 @@
+#pragma once
+#include "configuration.h"
+#include <map>
+#include <tuple>
+#include <forward_list>
+
+class PDProtocol {
+public:
+    enum Voltage { NOT_AVAILABLE=0, V5 = 5, V9 = 9, V12 = 12, V15 = 15 };
+
+    static void setVoltage(Voltage voltage);
+    static Voltage getVoltage();
+    static std::forward_list<Voltage> getSupportedVoltages();
+private:
+    using PinoutConfig = std::tuple<uint8_t, uint8_t, uint8_t>; // (CFG1, CFG2, CFG3)
+    static const std::map<Voltage, PinoutConfig> voltageToCommand;
+    static const std::forward_list<Voltage> supportedVoltages;
+    static PinoutConfig lastConfig;
+};

src/settings.cpp

@@ -9,6 +9,7 @@
 #define APB_KEY_VERSION "version"
 
 #define APB_KEY_STATUS_LED_DUTY "status_led_duty"
+#define APB_KEY_FAN_DUTY "fan_duty"
 #define APB_KEY_POWER_SOURCE_TYPE "power_src_type"
 
 #define LOG_SCOPE "APB::Configuration - "
@@ -50,6 +51,8 @@ void APB::Settings::load() {
         return;
     }
     _statusLedDuty = prefs.getFloat(APB_KEY_STATUS_LED_DUTY, 1);
+    _fanDuty = prefs.getFloat(APB_KEY_FAN_DUTY, 1.0);
+    _pdVoltage = static_cast<PDProtocol::Voltage>(prefs.getUShort("pd_voltage", static_cast<uint16_t>(PDProtocol::V12)));
     _powerSource = static_cast<PowerMonitor::PowerSource>(prefs.getUShort(APB_KEY_POWER_SOURCE_TYPE, static_cast<uint16_t>(PowerMonitor::AC)));
     wifiSettings.load();
     Log.infoln(LOG_SCOPE "Preferences loaded");
@@ -59,6 +62,8 @@ void APB::Settings::loadDefaults() {
     wifiSettings.loadDefaults();
     _powerSource = PowerMonitor::AC;
     _statusLedDuty = 1.0;
+    _fanDuty = 1.0;
+    _pdVoltage = PDProtocol::V12;
 }
 
 
@@ -68,11 +73,16 @@ void APB::Settings::save() {
     prefs.putUShort(APB_KEY_VERSION, APB_PREFS_VERSION);
     wifiSettings.save();
     prefs.putFloat(APB_KEY_STATUS_LED_DUTY, _statusLedDuty);
+    prefs.putFloat(APB_KEY_FAN_DUTY, _fanDuty);
     prefs.putUShort(APB_KEY_POWER_SOURCE_TYPE, static_cast<uint16_t>(_powerSource));
+    prefs.putUShort("pd_voltage", static_cast<uint16_t>(_pdVoltage));
     Log.infoln(LOG_SCOPE "Preferences saved");
 }
 
-APB::PowerMonitor::PowerSource APB::Settings::powerSource() const {
+
+
+APB::PowerMonitor::PowerSource APB::Settings::powerSource() const
+{
     return _powerSource;
 }
 

src/settings.h

@@ -6,6 +6,7 @@
 #include <wifisettings.h>
 #include "powermonitor.h"
 #include <unordered_map>
+#include "pd_protocol.h"
 
 #define APB_CONFIG_DIRECTORY "/config"
 
@@ -20,7 +21,11 @@ class Settings {
     GuLinux::WiFiSettings &wifi() { return wifiSettings; }
 
     float statusLedDuty() const { return _statusLedDuty; };
+    float fanDuty() const { return _fanDuty; };
+    PDProtocol::Voltage pdVoltage() const { return _pdVoltage; }
+    void setPdVoltage(PDProtocol::Voltage voltage) { _pdVoltage = voltage; }
     void setStatusLedDuty(float duty) { _statusLedDuty = duty; }
+    void setFanDuty(float duty) { _fanDuty = duty; }
     PowerMonitor::PowerSource powerSource() const;
     void setPowerSource(PowerMonitor::PowerSource powerSource);
 
@@ -29,6 +34,8 @@ class Settings {
     Preferences prefs;
     GuLinux::WiFiSettings wifiSettings;
     float _statusLedDuty;
+    float _fanDuty;
+    PDProtocol::Voltage _pdVoltage = PDProtocol::V12;
     PowerMonitor::PowerSource _powerSource;
     void loadDefaults();
 };

src/webserver.cpp

@@ -37,6 +37,8 @@ void APB::WebServer::setup() {
     onJsonRequest("/api/config/accessPoint", [](AsyncWebServerRequest *request, JsonVariant &json){ WiFiManager::Instance.onConfigAccessPoint(request, json); }, HTTP_POST | HTTP_DELETE);
     onJsonRequest("/api/config/station", [](AsyncWebServerRequest *request, JsonVariant &json){ WiFiManager::Instance.onConfigStation(request, json); }, HTTP_POST | HTTP_DELETE);
     onJsonRequest("/api/config/statusLedDuty", std::bind(&WebServer::onConfigStatusLedDuty, this, _1, _2), HTTP_POST);
+    onJsonRequest("/api/config/fanDuty", std::bind(&WebServer::onConfigFanDuty, this, _1, _2), HTTP_POST);
+    onJsonRequest("/api/config/pdVoltage", std::bind(&WebServer::onConfigPDVoltage, this, _1, _2), HTTP_POST);
     onJsonRequest("/api/config/powerSourceType", std::bind(&WebServer::onConfigPowerSourceType, this, _1, _2), HTTP_POST);
     webserver.on("/api/metrics", HTTP_GET, std::bind(&WebServer::onGetMetrics, this, _1));
     webserver.on("/api/config/write", HTTP_POST, std::bind(&WebServer::onPostWriteConfig, this, _1));
@@ -107,13 +109,18 @@ void APB::WebServer::onGetStatus(AsyncWebServerRequest *request) {
     response.root()["has_power_monitor"] = PowerMonitor::Instance.status().initialised;
     response.root()["has_ambient_sensor"] = Ambient::Instance.isInitialised();
     response.root()["has_serial"] = static_cast<bool>(Serial);
+    response.root()["pdVoltageRequested"] = PDProtocol::getVoltage();
 }
 
 void APB::WebServer::onGetConfig(AsyncWebServerRequest *request) {
     JsonWebResponse response(request);
     JsonObject rootObject = response.root().to<JsonObject>();
     WiFiManager::Instance.onGetConfig(rootObject);
     rootObject["ledDuty"] = Settings::Instance.statusLedDuty();
+    #ifdef APB_PWM_FAN_PIN
+    rootObject["fanDuty"] = Settings::Instance.fanDuty();
+    #endif
+    rootObject["pdVoltage"] = Settings::Instance.pdVoltage();
     rootObject["powerSourceType"] = Settings::PowerSourcesNames.at(Settings::Instance.powerSource());
 }
 
@@ -265,6 +272,37 @@ void APB::WebServer::onConfigStatusLedDuty(AsyncWebServerRequest *request, JsonV
     response.root()["duty"] = StatusLed::Instance.duty();
 }
 
+void APB::WebServer::onConfigPDVoltage(AsyncWebServerRequest *request, JsonVariant &json) {
+    WebValidation validation{request, json};
+    if(validation.required<PDProtocol::Voltage>("pdVoltage")
+        .invalid()) return;
+    bool valid_voltage = std::any_of(PDProtocol::getSupportedVoltages().begin(), PDProtocol::getSupportedVoltages().end(),
+        [json](PDProtocol::Voltage v){ return v == json["pdVoltage"].as<PDProtocol::Voltage>(); });
+    if(!valid_voltage) {
+        JsonWebResponse::error(JsonWebResponse::BadRequest, "Invalid voltage", request);
+        return;
+    }
+    Settings::Instance.setPdVoltage(json["pdVoltage"].as<PDProtocol::Voltage>());
+    PDProtocol::setVoltage(Settings::Instance.pdVoltage());
+    JsonWebResponse response(request);
+    response.root()["pdVoltage"] = PDProtocol::getVoltage();
+}
+
+void APB::WebServer::onConfigFanDuty(AsyncWebServerRequest *request, JsonVariant &json) {
+    #ifndef APB_PWM_FAN_PIN
+        JsonWebResponse(request).error(JsonWebResponse::NotFound, "Fan control not supported on this hardware", request);
+    #else
+        WebValidation validation{request, json};
+        if(validation.required<float>("duty")
+            .range("duty", {0}, {1})
+            .invalid()) return;
+        int analogValue = json["duty"].as<float>() * 255.0;
+        analogWrite(APB_PWM_FAN_PIN, analogValue);    
+        JsonWebResponse response(request);
+        response.root()["duty"] = Settings::Instance.fanDuty();
+    #endif
+}
+
 void APB::WebServer::onConfigPowerSourceType(AsyncWebServerRequest *request, JsonVariant &json) {
     WebValidation validation{request, json};
     std::forward_list<String> choices;

src/webserver.h

@@ -39,6 +39,8 @@ class WebServer : public AsyncWebServerBase {
     void onRestart(AsyncWebServerRequest *request);
     void onPostSetPWMOutputs(AsyncWebServerRequest *request, JsonVariant &json);
     void onConfigStatusLedDuty(AsyncWebServerRequest *request, JsonVariant &json);
+    void onConfigFanDuty(AsyncWebServerRequest *request, JsonVariant &json);
+    void onConfigPDVoltage(AsyncWebServerRequest *request, JsonVariant &json);
     void onConfigPowerSourceType(AsyncWebServerRequest *request, JsonVariant &json);
 };
 }