implemented soft power button on-off

platformio.ini

@@ -20,13 +20,13 @@ board = STM32L031K6
 build_flags = 
 	-DHARDWAREVERSION=11
 
-[env:LedBoardV10]
+; [env:LedBoardV10]
-board = STM32L031K6
+; board = STM32L031K6
-build_flags = 
+; build_flags = 
-	-DHARDWAREVERSION=10
+; 	-DHARDWAREVERSION=10
 
-[env:ledboard_PROTO]
+; [env:ledboard_PROTO]
-board = nucleo_l031K6
+; board = nucleo_l031K6
-build_flags = 
+; build_flags = 
-	-DHARDWAREVERSION=09
+; 	-DHARDWAREVERSION=09
 

src/board.h

@@ -63,20 +63,20 @@
 
   #elif HARDWAREVERSION==11
   
-    #define LED3        PB6     
+    #define LED1        PB6     
     #define LED2        PB7     
-    #define LED1        PB2   
+    #define LED3        PB0   
 
     #define DETECT3     PA6     
     #define DETECT2     PA5     
     #define DETECT1     PA4     
 
-    #define SWITCH3     PB5     // TOGGLE3
+    #define SWITCH1     PB5     // TOGGLE3
-    #define SWITCH32    PB4     // MOMENTARY3
+    #define SWITCH12    PB4     // MOMENTARY3
     #define SWITCH2     PA1     // TOGGLE2
     #define SWITCH22    PA3     // MOMENTARY2
-    #define SWITCH1     PA7     // TOGGLE1
+    #define SWITCH3     PA7     // TOGGLE1
-    #define SWITCH12    PA9     // MOMENTARY1
+    #define SWITCH32    PA9     // MOMENTARY1
 
     #define BTN_PWR     PA2
     #define PW_HOLD     PA10

src/led.cpp

@@ -16,9 +16,15 @@ c_leds *getledlist(void)
 void initLeds(void)
 {
   ledlist.init();
+#if HARDWAREVERSION == 11
+  ledlist.AddLed(LED1, DETECT1, 1, 844, YELLOW, false);
+  ledlist.AddLed(LED2, DETECT2, 2, 512, RED, false);
+  ledlist.AddLed(LED3, DETECT3, 3, 92, GREEN, false);
+#else
   ledlist.AddLed(LED1, DETECT1, 1, 844, YELLOW, true);
   ledlist.AddLed(LED2, DETECT2, 2, 512, RED, true);
   ledlist.AddLed(LED3, DETECT3, 3, 92, GREEN, true);
+#endif
 
   ledlist.begin();
 }
@@ -48,6 +54,23 @@ void turnOffAllLed()
   ledlist.turnAllOff();
 }
 
+void turnOnAllLed( void )
+{
+  ledlist.turnAllOn();
+}
+
+void setAllLeds( bool state)
+{
+  if(state)
+  {
+    turnOnAllLed();
+  }
+  else
+  {
+    turnOffAllLed();
+  }
+}
+
 //#############################################
 //#            leds functions                 #
 //#############################################
@@ -115,6 +138,14 @@ void c_leds::turnAllOff(void)
   }
 }
 
+void c_leds::turnAllOn(void)
+{
+  for (auto &&port : v_ledports)
+  {
+    port.turnOn();
+  }
+}
+
 c_ledport *c_leds::getLed(e_ledcolor color)
 {
   for (auto &&port : v_ledports)
@@ -238,4 +269,3 @@ bool c_led::checkIndex(uint16_t index)
   }
   return false;
 }
-

src/led.h

@@ -84,6 +84,7 @@ public:
 
 
   void turnAllOff(void);
+  void turnAllOn(void);
 };
 
 c_leds *getledlist(void);
@@ -93,7 +94,10 @@ void turnOnLed(e_ledcolor color);
 void turnOffLed(e_ledcolor color);
 void turnOffLed(uint16_t index);
 void turnOnLed(uint16_t index);
-void turnOffAllLed();
+void turnOffAllLed(void);
+void turnOnAllLed(void);
+void setAllLeds( bool state);
+
 
 #endif //LEDH
 

src/main.cpp

@@ -10,6 +10,7 @@
 #include "led.h"
 #include "power.h"
 
+
 #define GAMESELECTTIMEOUT 10000 // 10sec * 1000ms
 
 typedef enum
@@ -117,6 +118,10 @@ void loop()
 {
   handleButtons();
   HandlePower();
+  if(getPowerState() != on)
+  {
+    return;
+  }
   HandleGameSelectTimeout();
 
   switch (currentGame)
@@ -159,8 +164,6 @@ void loop()
 
   case none:
   {
-    batteryCheck();
-    batterydisplay();
     delay(1000);
     turnOffAllLed();
     if (buttonIsPressed(GREEN) && currentGame == none)

src/power.cpp

@@ -1,28 +1,24 @@
 #include "power.h"
-#include "board.h"
-#include "rtc.h"
-#include "low_Power.h"
-#include "led.h"
-#include "buttons.h"
 
 #ifdef BTN_PWR
-#include "JC_Button.h"
-Button buttonPower(BTN_PWR);
-#endif
 
-bool doShutdown = false;
+Button buttonPower(BTN_PWR, 250UL, 1U, 0);
+#endif
 
 #ifdef VBATTPIN
-#include "Battery.h"
 Battery battery(VBATTMIN, VBATTMAX, VBATTPIN);
 #endif
 
+uint64_t delay_timer = 0;
+uint64_t powerOnOffDelay = 0;
+powerStates powerstate = off;
+
 void initBattery(void)
 {
 #ifdef VBATTPIN
 #ifdef MEAS_EN
   battery.begin(VBATTREF, (R12 + R13) / R13); //R1 = 220K, R2 = 100K, factor = (R1+R2)/R2
-  battery.onDemand(MEAS_EN, LOW);
+  battery.onDemand(MEAS_EN, HIGH);
 #else
   battery.begin(VBATTREF, (R12 + R13) / R13); //R1 = 220K, R2 = 100K, factor = (R1+R2)/R2
 #endif
@@ -50,76 +46,182 @@ void batterydisplay(void)
 #endif
 }
 
-void batteryCheck(void)
+void powerOn(void)
 {
-#ifdef VBATTPIN
+  digitalWrite(PW_HOLD, HIGH);
-  if (battery.voltage() < VBATTMIN)
-  {
-    for (int i = 0; i < 10; i++)
-    {
-      turnOnLed(1);
-      delay(300);
-      turnOffLed(1);
-      delay(300);
-    }
-    delay(5000);
-    shutdown();
-  }
-#endif
 }
 
-void initShutdown(void)
+void powerOff(void)
+{
+  digitalWrite(PW_HOLD, LOW);
+}
+
+bool handleBattery(void)
+{
+#ifdef VBATTPIN
+  uint64_t currentmillis = millis();
+  if (currentmillis - delay_timer > BATTERYMEASUREDELAY)
+  {
+    // uint16_t vbatt = battery.voltage();
+    // if (vbatt < VBATTMIN)
+    // {
+
+    delay_timer = currentmillis;
+    // delay(5000);
+    // shutdown();
+  }
+
+#endif
+  return false;
+}
+
+void initPowerOn(void)
 {
 #ifdef PW_HOLD
   pinMode(PW_HOLD, OUTPUT);
+  powerstate = poweringOn;
   buttonPower.begin();
-  digitalWrite(PW_HOLD, LOW);
-  delay(2000);
-  digitalWrite(PW_HOLD, HIGH);
-  doShutdown = false;
 #endif
 }
 
 //low power
 void initPower(void)
 {
-  LowPower_init();
   initBattery();
-  initShutdown();
+  initPowerOn();
 }
 
 void shutdown(void)
 {
-  LowPower_shutdown();
+  powerOff();
-  delay(2000);
+  //LowPower_shutdown();
+  delay(10000);
 }
 
-
+powerStates getPowerState(void)
-
-void HandlePowerOn(void)
 {
-  if (buttonPower.read())
+  return powerstate;
+}
+
+//handle power asynchronious
+void handlePowerState(void)
+{
+  bool buttonread = buttonPower.read(); //update powerbutton
+  switch (powerstate)
   {
-    if (buttonPower.pressedFor(2000))
+  case off:
   {
-      doShutdown = true;
+    if (buttonread)
-      delay(500);
+    {
+      powerstate = poweringOn;
+    }
+    powerOff();
+  }
+  break;
+  case poweringOn:
+  {
+    if (buttonPower.pressedFor(POWERBUTTONDELAY))
+    {
+      turnOnLed(1);
+      powerstate = poweringOn2;
+    }
+    else if (buttonPower.pressedFor(1000))
+    {
+      turnOnLed(2);
+    }
+    else if (buttonPower.pressedFor(500))
+    {
+      turnOnLed(3);
     }
     else
     {
-      doShutdown = false;
+      turnOffAllLed();
+      powerstate = off;
     }
   }
+  break;
+  case poweringOn2:
+  {
+    if (!buttonread)
+    {
+      powerstate = on;
+      powerOn();
+      turnOffAllLed();
+    }
+  }
+  break;
+  case on:
+  {
+    if (buttonPower.pressedFor(500))
+    {
+      powerstate = poweringOff;
+      turnOnAllLed();
+    }
+    if (HandleTimeOut())
+    {
+      powerstate = timeOut;
+    }
+    if (handleBattery())
+    {
+      powerstate = lowBatt;
+    }
+  }
+  break;
+  case poweringOff:
+  {
+    if (buttonPower.pressedFor(3000))
+    {
+      turnOffLed(1);
+      powerstate = poweringOff2;
+    }
+    else if (buttonPower.pressedFor(2000))
+    {
+      turnOffLed(2);
+    }
+    else if (buttonPower.pressedFor(1000))
+    {
+      turnOffLed(3);
+    }
     else
     {
-    if (doShutdown & buttonPower.releasedFor(2000))
+      turnOffAllLed();
-    {
+      powerstate = on;
-      digitalWrite(PW_HOLD, LOW);
     }
   }
+  break;
+  case poweringOff2:
+  {
+    if(!buttonread)
+    {
+      powerstate = off;
+    }
+  }
+  break;
+  case timeOut:
+  {
+    powerstate = off;
+    powerOff();
+    delay(5000);
+  }
+  break;
+  case lowBatt:
+  {
+    powerstate = off;
+    for (int i = 0; i < 6; i++)
+    {
+      turnOnAllLed();
+      delay(200);
+      turnOffAllLed();
+      delay(200);
+    }
+  }
+  break;
+  }
 }
 
-void HandleTimeOut(void)
+//handleTimeout
+//return true when timed out
+bool HandleTimeOut(void)
 {
   uint64_t currentmillis = millis();
   static uint64_t lasttimeOut = 0;
@@ -134,8 +236,7 @@ void HandleTimeOut(void)
   //check if lastTime is initialized or timeout expired
   if ((currentmillis - lasttimeOut > IDLESHUTDOWN))
   {
-    turnOffAllLed();
+    return true;
-    shutdown();
   }
   else
   {
@@ -146,11 +247,10 @@ void HandleTimeOut(void)
       lasttimeOut = currentmillis;
     }
   }
+  return false;
 }
 
 void HandlePower(void)
 {
-  HandleTimeOut();
+  handlePowerState();
-  batteryCheck();
-  HandlePowerOn();
 }

src/power.h

@@ -1,11 +1,40 @@
 #pragma once
 
+#include "led.h"
+#include "buttons.h"
+#include "board.h"
+
+#ifdef BTN_PWR
+#include "JC_Button.h"
+#endif
+
+#ifdef VBATTPIN
+//https://github.com/rlogiacco/BatterySense
+#include "Battery.h"
+#endif
+
+#define POWERBUTTONDELAY 1500
+#define BATTERYMEASUREDELAY 5000
+
+typedef enum
+{
+  off,
+  poweringOn,
+  poweringOn2,
+  on,
+  poweringOff,
+  poweringOff2,
+  timeOut,
+  lowBatt
+} powerStates;
+
 //battery
 void batterydisplay(void);
-void batteryCheck(void);
+bool handleBattery(void);
 
 //low power
 void initPower(void);
 void shutdown(void);
-void HandleTimeOut(void);
+bool HandleTimeOut(void);
 void HandlePower(void);
+powerStates getPowerState( void );

variants/STM32L031K6/variant.h

@@ -87,8 +87,8 @@ extern "C" {
 #define SERIAL_UART_INSTANCE    2 //ex: 2 for Serial2 (USART2)
 // Default pin used for 'Serial' instance (ex: ST-Link)
 // Mandatory for Firmata
-#define PIN_SERIAL_RX           PA15
+//#define PIN_SERIAL_RX           PA15
-#define PIN_SERIAL_TX           PA2
+//#define PIN_SERIAL_TX           PA2
 
 #ifdef __cplusplus
 } // extern "C"