New training button behavior

When the training button is pressed the green LEDs start counting
seconds.  When the 4 second boundary is crossed the yellow LED starts to
blink.  When the 8 second boundary is crossed the blue LED starts to
blink.  When the time reaches 15 seconds the radio clears NVM and
resets.  Upon boot the LoRaSerial radio starts with factory settings.

Author: LeeLeahy2

Firmware/LoRaSerial/LoRaSerial.ino

@@ -166,8 +166,11 @@ uint8_t AESiv[AES_IV_BYTES] = {0}; //Set during hop table generation
 #include <JC_Button.h> // http://librarymanager/All#JC_Button //v2.1.2
 Button *trainBtn = NULL; //We can't instantiate the button here because we don't yet know what pin number to use
 
-const int trainButtonTime = 2000; //ms press and hold before entering training
-bool trainViaButton = false; //Allows auto-creation of server if client times out
+const int trainButtonClientTime = 4 * 1000; //ms press and hold before entering client training
+const int trainButtonServerTime = 8 * 1000; //ms press and hold before entering server training
+const int trainButtonFactoryResetTime = 16 * 1000; //ms press and hold before reset
+
+bool inTraining; //True if training is in process
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
 //Hardware Timers

Firmware/LoRaSerial/States.ino

@@ -1717,12 +1717,16 @@ void updateRadioState()
 
               //If we are training via button, and in point to point mode, and the user has not manually set the server
               //then reboot with current settings after a single client acks
-              if (trainViaButton
-                  && tempSettings.operatingMode == MODE_POINT_TO_POINT
-                  && tempSettings.server == false)
+              if (inTraining
+                  && (trainingSettings.operatingMode == MODE_POINT_TO_POINT)
+                  && (!trainingSettings.server))
               {
+                //Save the training parameters
+                settings = trainingSettings;
+                recordSystemSettings();
+
                 //Reboot the radio with the newly generated random netID/Key parameters
-                commandReset;
+                commandReset();
               }
             }
             break;

Firmware/LoRaSerial/System.ino

@@ -257,35 +257,97 @@ uint8_t systemRead()
 //Check the train button and change state accordingly
 void updateButton()
 {
-  static TrainStates trainState = TRAIN_NO_PRESS;
+  bool buttonPressed;
+  static bool buttonWasPressed;
+  uint32_t deltaTime;
+  static Settings originalSettings;
+  static uint32_t pressedTime;
 
   if (trainBtn != NULL)
   {
-    trainBtn->read();
+    //Determine the previous state of the button
+    buttonPressed = trainBtn->read();
 
-    if (trainState == TRAIN_NO_PRESS && trainBtn->pressedFor(trainButtonTime))
+    //Determine the current button state
+    if (buttonWasPressed)
     {
-      trainState = TRAIN_PRESSED;
-
-      trainViaButton = true;
-      trainingSettings = settings;
-      selectTraining();
-    }
-    else if (trainState == TRAIN_PRESSED && trainBtn->wasReleased())
-    {
-      trainState = TRAIN_IN_PROCESS;
+      //Update the LEDs
+      deltaTime = millis() - pressedTime;
+      buttonLeds(deltaTime);
+      if (!buttonPressed)
+      {
+        //Button just released
+        settings = originalSettings;
+
+        //Check for reset to factory settings
+        if (deltaTime >= trainButtonFactoryResetTime)
+        {
+          //Erase the EEPROM
+          nvmErase();
+
+          //Reboot the radio
+          commandReset();
+        }
+
+        //Starting training or exiting training via the button is only possible
+        //when the radio is not in command mode!
+        else if (!inCommandMode)
+        {
+          //Check for server training request
+          if (deltaTime >= trainButtonServerTime)
+          {
+            //Set the training settings
+            trainingSettings = settings;
+            inTraining = true;
+            if (settings.operatingMode == MODE_POINT_TO_POINT)
+            {
+              //Select a random netID and encryption key
+              generateRandomKeysID(&trainingSettings);
+            }
+            beginTrainingServer();
+          }
+
+          //Check for client training request
+          else if (deltaTime >= trainButtonClientTime)
+          {
+            trainingSettings = settings; //Set the training settings
+            inTraining = true;
+            beginTrainingClient();
+          }
+
+          //Exit training
+          else
+          {
+            //The user has stopped training with the button
+            //Restore the previous settings
+            settings = originalSettings;
+            if (inTraining)
+            {
+              inTraining = false;
+              changeState(RADIO_RESET);
+            }
+          }
+        }
+      }
     }
-    else if (trainState == TRAIN_IN_PROCESS && trainBtn->wasReleased())
-    {
-      settings = trainingSettings; //Return to original radio settings
 
-      recordSystemSettings(); //Record original settings
+    //The button was not previously pressed
+    else
+    {
+      //Determine if the button is pressed
+      if (buttonPressed)
+      {
+        //Button just pressed
+        pressedTime = millis();
 
-      //Reboot the radio
-      petWDT();
-      systemFlush();
-      systemReset();
+        //Save the previous led state
+        if (!inTraining)
+            originalSettings = settings;
+      }
     }
+
+    //Save the current button state
+    buttonWasPressed = buttonPressed;
   }
 }
 
@@ -1001,6 +1063,36 @@ void updateCylonLEDs()
   blinkRadioTxLed(false);
 }
 
+//Acknowledge the button press
+void buttonLeds(uint32_t pressedMilliseconds)
+{
+  const uint32_t blinkTime = 1000 / 4;  //Blink 4 times per second
+  uint8_t on;
+  const uint32_t onTime = blinkTime / 2;
+  uint8_t seconds;
+
+  //Display the number of seconds the button has been pushed
+  seconds = pressedMilliseconds / 1000;
+  setRSSI((pressedMilliseconds >= trainButtonFactoryResetTime) ? 15 : seconds);
+
+  if (!inCommandMode)
+  {
+    //Determine the blink state
+    on = (pressedMilliseconds % blinkTime) >= onTime;
+
+    //Determine which LED to blink
+    if (pressedMilliseconds >= trainButtonServerTime)
+    {
+      //Blink the blue LED
+      digitalWrite(BLUE_LED, on);
+      digitalWrite(YELLOW_LED, 0);
+    }
+    else if (pressedMilliseconds >= trainButtonClientTime)
+      //Blink the yellow LED
+      digitalWrite(YELLOW_LED, on);
+  }
+}
+
 //Update the LED values depending upon the selected display
 //This is the only function that touches the LEDs
 void updateLeds()

Firmware/LoRaSerial/settings.h

@@ -227,14 +227,6 @@ typedef struct _VIRTUAL_CIRCUIT
 #define ADD_VC_STATE_NAMES_TABLE
 #include "Virtual_Circuit_Protocol.h"
 
-//Train button states
-typedef enum
-{
-  TRAIN_NO_PRESS = 0,
-  TRAIN_PRESSED,
-  TRAIN_IN_PROCESS,
-} TrainStates;
-
 enum
 { //#, Width - Computed with:
   //        triggerWidth = 25
@@ -358,7 +350,7 @@ typedef enum
   LEDS_RADIO_USE,   // 3: Green1: RX, Green2: Link, Green3: RSSI, Green4: TX
   //    Blue: Bad frames, Yellow: Bad CRC
   LEDS_RSSI,        // 4: Green: RSSI, Blue: Serial TX, Yellow: Serial RX
-  LEDS_RESERVED_1,  // 5
+  LEDS_BUTTON_PRESS,// 5: Green: Seconds, Yellow: Client, Blue: Server
   LEDS_RESERVED_2,  // 6
   LEDS_CYLON,       // 7: Display the cylon pattern on the green LEDs, others off