Solar-charger

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "prettier.configPath": ".prettierrc.json"
+}

src/components/Blockly/blocks/index.js

@@ -14,6 +14,7 @@ import "./sensebox-rtc";
 import "./sensebox-ntp";
 import "./sensebox-ble";
 import "./sensebox-sd";
+import "./sensebox-solar";
 import "./mqtt";
 import "./text";
 import "./io";

src/components/Blockly/blocks/sensebox-solar.js

@@ -0,0 +1,157 @@
+import * as Blockly from "blockly";
+import { getColour } from "../helpers/colour";
+import * as Types from "../helpers/types";
+import { selectedBoard } from "../helpers/board";
+
+/**
+ * Solar Charger (SB-041)
+ */
+Blockly.Blocks["sensebox_solar_charger_SB041"] = {
+  init: function () {
+    var board = selectedBoard().title;
+    this.setOutput(true, Types.DECIMAL.typeName);
+    this.setColour(getColour().solar);
+    this.appendDummyInput().appendField(
+      Blockly.Msg.senseBox_solar_charger_SB041,
+    );
+    this.appendDummyInput()
+      .appendField(Blockly.Msg.senseBox_value)
+      .appendField(
+        new Blockly.FieldDropdown(
+          [
+            [
+              Blockly.Msg.senseBox_solar_charger_SB041_charger_connected,
+              "isChargerConnected",
+            ],
+            [
+              Blockly.Msg.senseBox_solar_charger_SB041_solar_panel_voltage,
+              "getSolarPanelVoltage",
+            ],
+            [
+              Blockly.Msg.senseBox_solar_charger_SB041_battery_voltage,
+              "getBatteryVoltage",
+            ],
+            [Blockly.Msg.senseBox_solar_charger_SB041_charging, "isCharging"],
+            [
+              Blockly.Msg.senseBox_solar_charger_SB041_fast_charging,
+              "isFastCharging",
+            ],
+            [
+              Blockly.Msg.senseBox_solar_charger_SB041_battery_level,
+              "getBatteryLevel",
+            ],
+            [
+              Blockly.Msg.senseBox_solar_charger_SB041_good_input_voltage,
+              "isGoodInputVoltage",
+            ],
+            [
+              Blockly.Msg.senseBox_solar_charger_SB041_battery_present,
+              "isBatteryPresent",
+            ],
+            [
+              Blockly.Msg.senseBox_solar_charger_SB041_battery_temperature,
+              "getBatteryTemperature",
+            ],
+          ],
+          this.updateOutputType.bind(this),
+        ),
+        "MEASUREMENT",
+      );
+    if (board === "Mini") {
+      this.setTooltip(Blockly.Msg.senseBox_solar_charger_SB041_tooltip_mini);
+    } else if (board === "MCU-S2") {
+      this.setTooltip(Blockly.Msg.senseBox_solar_charger_SB041_tooltip_esp32);
+    } else {
+      // assume board === "MCU"
+      this.setTooltip(Blockly.Msg.senseBox_solar_charger_SB041_tooltip_mcu);
+    }
+    this.setHelpUrl(Blockly.Msg.senseBox_solar_charger_SB041_helpurl);
+  },
+
+  // Function to update the output type dynamically
+  updateOutputType: function (newMeasurement) {
+    switch (newMeasurement) {
+      case "isChargerConnected":
+      case "isCharging":
+      case "isFastCharging":
+      case "isGoodInputVoltage":
+      case "isBatteryPresent":
+        this.setOutput(true, Types.BOOLEAN.typeName);
+        break;
+
+      case "getSolarPanelVoltage":
+      case "getBatteryVoltage":
+      case "getBatteryLevel":
+      case "getBatteryTemperature":
+        this.setOutput(true, Types.NUMBER.typeName);
+        break;
+
+      default:
+        this.setOutput(true, null); // Fallback
+    }
+  },
+};
+
+/**
+ * Deep Sleep and Restart
+ */
+Blockly.Blocks["sensebox_solar_deep_sleep_and_restart"] = {
+  init: function () {
+    var board = selectedBoard().title;
+    var time_scales = [
+      [Blockly.Msg.sensebox_solar_deep_sleep_and_restart_hours, "3600000"],
+      [Blockly.Msg.sensebox_solar_deep_sleep_and_restart_minutes, "60000"],
+      [Blockly.Msg.sensebox_solar_deep_sleep_and_restart_seconds, "1000"],
+      [Blockly.Msg.sensebox_solar_deep_sleep_and_restart_milliseconds, "1"],
+    ];
+    var sensor_wake_up_seconds = [
+      ["30", "30"],
+      ["60", "60"],
+      ["120", "120"],
+    ];
+    this.setColour(getColour().solar);
+    this.setPreviousStatement(true);
+    this.appendDummyInput().appendField(
+      Blockly.Msg.sensebox_solar_deep_sleep_and_restart,
+    );
+    this.appendDummyInput()
+      .appendField(Blockly.Msg.sensebox_solar_deep_sleep_and_restart_sleep_time)
+      .appendField(new Blockly.FieldNumber(1), "SLEEP_TIME")
+      .appendField(new Blockly.FieldDropdown(time_scales), "TIME_SCALE");
+    this.appendDummyInput()
+      .appendField(
+        Blockly.Msg.sensebox_solar_deep_sleep_and_restart_minimal_wake_up_time,
+      )
+      .appendField(
+        new Blockly.FieldDropdown(sensor_wake_up_seconds),
+        "WAKE_SECONDS",
+      )
+      .appendField(Blockly.Msg.sensebox_solar_deep_sleep_and_restart_seconds);
+    if (board === "MCU-S2") {
+      this.appendDummyInput()
+        .appendField(
+          Blockly.Msg.sensebox_solar_deep_sleep_and_restart_deactivate_ports,
+        )
+        .appendField("GPIO")
+        .appendField(new Blockly.FieldCheckbox("TRUE"), "POWER_OFF_GPIO")
+        .appendField(", UART")
+        .appendField(new Blockly.FieldCheckbox("TRUE"), "POWER_OFF_UART")
+        .appendField(", XB")
+        .appendField(new Blockly.FieldCheckbox("TRUE"), "POWER_OFF_XB");
+    } else {
+      // assume board === "MCU" || board === "MINI"
+      this.appendDummyInput()
+        .appendField(
+          Blockly.Msg.sensebox_solar_deep_sleep_and_restart_deactivate_ports,
+        )
+        .appendField("I2C")
+        .appendField(new Blockly.FieldCheckbox("TRUE"), "POWER_OFF_I2C")
+        .appendField(", UART")
+        .appendField(new Blockly.FieldCheckbox("TRUE"), "POWER_OFF_UART")
+        .appendField(", XB")
+        .appendField(new Blockly.FieldCheckbox("TRUE"), "POWER_OFF_XB");
+    }
+    this.setTooltip(Blockly.Msg.sensebox_solar_deep_sleep_and_restart_tooltip);
+    //this.setHelpUrl(Blockly.Msg.sensebox_solar_deep_sleep_and_restart_helpurl);
+  },
+};

src/components/Blockly/generator/generator.js

@@ -31,16 +31,12 @@ import store from "../../../store";
 var ota = store.getState().general.platform
   ? store.getState().general.platform
   : null;
-var board = store.getState().board.board 
-  ? store.getState().board.board 
-  : null;
+var board = store.getState().board.board ? store.getState().board.board : null;
 store.subscribe(() => {
   ota = store.getState().general.platform
     ? store.getState().general.platform
     : null;
-  board = store.getState().board.board
-    ? store.getState().board.board
-    : null;
+  board = store.getState().board.board ? store.getState().board.board : null;
 });
 
 /**
@@ -114,14 +110,14 @@ Blockly.Generator.Arduino.init = function (workspace) {
 
   // creates a list of code to be setup before the setup block
   Blockly.Generator.Arduino.preSetupCode_ = Object.create(null);
-  
+
   // creates a list of code to be setup before the setup block
   Blockly.Generator.Arduino.setupCode_ = Object.create(null);
 
-  // creates a list of code to be setup before the setup block
+  // creates a list of phyphox code to be in the setup block
   Blockly.Generator.Arduino.phyphoxSetupCode_ = Object.create(null);
 
-  // creates a list of code to be setup before the setup block
+  // creates a list of lora code to be in the setup block
   Blockly.Generator.Arduino.loraSetupCode_ = Object.create(null);
 
   // creates a list of code for the loop to be runned once
@@ -203,10 +199,13 @@ Blockly.Generator.Arduino.finish = function (code) {
     functionsCode += Blockly.Generator.Arduino.functionNames_[key] + "\n";
   }
 
-  if(Blockly.Generator.Arduino.preSetupCode_["Wire.begin"]) {
-    preSetupCode += Blockly.Generator.Arduino.preSetupCode_["Wire.begin"] + "\n";
-    if(Blockly.Generator.Arduino.preSetupCode_["vl53l8cx_clock_address"]) {
-      preSetupCode += Blockly.Generator.Arduino.preSetupCode_["vl53l8cx_clock_address"] + "\n";
+  if (Blockly.Generator.Arduino.preSetupCode_["Wire.begin"]) {
+    preSetupCode +=
+      Blockly.Generator.Arduino.preSetupCode_["Wire.begin"] + "\n";
+    if (Blockly.Generator.Arduino.preSetupCode_["vl53l8cx_clock_address"]) {
+      preSetupCode +=
+        Blockly.Generator.Arduino.preSetupCode_["vl53l8cx_clock_address"] +
+        "\n";
     }
   }
 
@@ -219,7 +218,8 @@ Blockly.Generator.Arduino.finish = function (code) {
   }
 
   for (const key in Blockly.Generator.Arduino.phyphoxSetupCode_) {
-    phyphoxSetupCode += Blockly.Generator.Arduino.phyphoxSetupCode_[key] + "\n" || "";
+    phyphoxSetupCode +=
+      Blockly.Generator.Arduino.phyphoxSetupCode_[key] + "\n" || "";
   }
 
   setupCode =

src/components/Blockly/generator/index.js

@@ -14,6 +14,7 @@ import "./sensebox-rtc";
 import "./sensebox-ntp";
 import "./sensebox-ble";
 import "./sensebox-sd";
+import "./sensebox-solar";
 import "./mqtt";
 import "./logic";
 import "./text";

src/components/Blockly/generator/sensebox-solar.js

@@ -0,0 +1,88 @@
+import * as Blockly from "blockly";
+import { selectedBoard } from "../helpers/board";
+
+/**
+ * Solar Charger (SB-041)
+ */
+Blockly.Generator.Arduino.forBlock["sensebox_solar_charger_SB041"] =
+  function () {
+    var measurement = this.getFieldValue("MEASUREMENT");
+    Blockly.Generator.Arduino.libraries_["library_solar_charger_SB041"] =
+      "#include <SolarChargerSB041.h>;";
+    Blockly.Generator.Arduino.variables_["define_solar_charger_SB041"] =
+      "SolarChargerSB041 charger;";
+
+    Blockly.Generator.Arduino.setupCode_["begin_solar_charger_SB041"] =
+      "charger.begin();";
+    Blockly.Generator.Arduino.loopCodeOnce_["update_solar_charger_SB041"] =
+      "charger.update();";
+    return [`charger.${measurement}()`, Blockly.Generator.Arduino.ORDER_ATOMIC];
+  };
+
+/**
+ * Deep Sleep and Restart
+ */
+Blockly.Generator.Arduino.forBlock["sensebox_solar_deep_sleep_and_restart"] =
+  function () {
+    var board = selectedBoard().title;
+    var sleep_time = this.getFieldValue("SLEEP_TIME");
+    var time_scale = this.getFieldValue("TIME_SCALE");
+    var wake_seconds = this.getFieldValue("WAKE_UP_SECONDS");
+    if (board === "MCU-S2") {
+      var powerOffGPIO = this.getFieldValue("POWER_OFF_GPIO") === "TRUE";
+      var powerOffUART = this.getFieldValue("POWER_OFF_UART") === "TRUE";
+      var powerOffXB = this.getFieldValue("POWER_OFF_XB") === "TRUE";
+      Blockly.Generator.Arduino.libraries_["library_esp32_hal_gpio"] =
+        "#include <esp32-hal-gpio.h>;";
+      Blockly.Generator.Arduino.libraries_["library_pins_arduino"] =
+        "#include <pins_arduino.h>;";
+      Blockly.Generator.Arduino.codeFunctions_["deep_sleep_and_restart"] = `
+// power saving deep sleep for specific time and a final restart
+void deep_sleep_and_restart(int sleep_time, bool powerOffGPIO, bool powerOffUART, bool powerOffXB) {
+  digitalWrite(IO_ENABLE, powerOffGPIO ? HIGH : LOW);
+  digitalWrite(PIN_XB1_ENABLE, powerOffUART ? HIGH : LOW);
+  digitalWrite(PIN_UART_ENABLE, powerOffXB ? HIGH : LOW);
+  digitalWrite(PD_ENABLE, LOW);
+  esp_sleep_enable_timer_wakeup(max(0, sleep_time - 1000));
+  delay(1000);
+  esp_deep_sleep_start();
+}
+`;
+      return `deep_sleep_and_restart(${sleep_time} * ${time_scale}, ${powerOffGPIO}, ${powerOffUART}, ${powerOffXB});`;
+    } else {
+      // assume board === "MCU" || board === "Mini"
+      var powerOffI2C = this.getFieldValue("POWER_OFF_I2C") === "TRUE";
+      var powerOffUART = this.getFieldValue("POWER_OFF_UART") === "TRUE";
+      var powerOffXB = this.getFieldValue("POWER_OFF_XB") === "TRUE";
+      Blockly.Generator.Arduino.libraries_["library_low_power"] =
+        "#include <ArduinoLowPower.h>;";
+      Blockly.Generator.Arduino.codeFunctions_["deep_sleep_and_restart"] = `
+// power saving deep sleep for specific time and a final restart
+void deep_sleep_and_restart(int sleep_time, bool powerOffI2C, bool powerOffUART, bool powerOffXB) {
+  senseBoxIO.powerI2C(!powerOffI2C);
+  senseBoxIO.powerUART(!powerOffUART);
+  senseBoxIO.powerXB1(!powerOffXB);
+  senseBoxIO.powerXB2(!powerOffXB);
+  LowPower.deepSleep(max(0, sleep_time - 1000));
+  delay(1000);
+  noInterrupts();
+  NVIC_SystemReset();
+  while (true);
+}
+`;
+      return `deep_sleep_and_restart(${sleep_time} * ${time_scale}, ${powerOffI2C}, ${powerOffUART}, ${powerOffXB});`;
+    }
+  };
+
+/**
+ * Ensure Wake Time
+ */
+Blockly.Generator.Arduino.forBlock["sensebox_solar_ensure_wake_time"] =
+  function () {
+    var wake_time = this.getFieldValue("wake_time");
+    var time_scale = this.getFieldValue("time_scale");
+    return `
+// ensure minimal wake time
+while(millis() < ${wake_time}${time_scale});
+`;
+  };

src/components/Blockly/helpers/colour.js

@@ -16,6 +16,7 @@ const colours = {
   webserver: 40,
   phyphox: 25,
   motors: 190,
+  solar: 0,
 };
 
 export const getColour = () => {

src/components/Blockly/index.js

@@ -44,6 +44,12 @@ const Value = (p) => {
   return React.createElement("value", props, children);
 };
 
+const Statement = (p) => {
+  const { children, ...props } = p;
+  props.is = "blockly";
+  return React.createElement("statement", props, children);
+};
+
 const Field = (p) => {
   const { children, ...props } = p;
   props.is = "blockly";
@@ -68,4 +74,4 @@ const Label = (p) => {
   return React.createElement("label", props, children);
 };
 
-export { Block, Category, Value, Field, Shadow, Sep, Label };
+export { Block, Category, Value, Statement, Field, Shadow, Sep, Label };

src/components/Blockly/msg/de.js

@@ -15,6 +15,7 @@ import { RTC } from "./de/sensebox-rtc";
 import { NTP } from "./de/sensebox-ntp";
 import { SD } from "./de/sensebox-sd";
 import { SENSORS } from "./de/sensebox-sensors";
+import { SOLAR } from "./de/sensebox-solar";
 import { SENSEBOX } from "./de/sensebox";
 import { TELEGRAM } from "./de/sensebox-telegram";
 import { WEB } from "./de/sensebox-web";
@@ -45,6 +46,7 @@ export const De = {
   ...NTP,
   ...SD,
   ...SENSORS,
+  ...SOLAR,
   ...SENSEBOX,
   ...TELEGRAM,
   ...WEB,