Rework balise trigger and fix ECOUTE lockup

4 files changed, 101 insertions, 59 deletions

diff --git a/src/common/includes/Core/fsm.h b/src/common/includes/Core/fsm.h
index 5ac353e..03025aa 100644
--- a/src/common/includes/Core/fsm.h
+++ b/src/common/includes/Core/fsm.h
@@ -48,13 +48,23 @@ enum fsm_state_e {
 
 typedef enum fsm_state_e fsm_state_t;
 
+// List of all states the balise FSM of the relay can be in
+enum balise_fsm_state_e {
+     BALISE_FSM_EVEN_HOUR = 0, // Even hours.
+     BALISE_FSM_ODD_HOUR,      // Odd hours
+     BALISE_FSM_PENDING,       // Waiting for transmission of balise
+};
+
+typedef enum balise_fsm_state_e balise_fsm_state_t;
+
+
 // All signals that the FSM can read, most of them are actually booleans
 struct fsm_input_signals_t {
     /* Signals coming from repeater electronics */
     int sq;                // Squelch detection
     int discrim_u;         // FM discriminator says RX is too high in frequency
     int qrp;               // The relay is currently running with low power
-    int start_tm;          // 2-hour pulse
+    int hour_is_even;      // 1 if hour is even
     float temp;            // temperature in degrees C
     float humidity;        // relative humidity, range [0-100] %
     int wind_generator_ok; // false if the generator is folded out of the wind
@@ -83,8 +93,6 @@ struct fsm_output_signals_t {
     int cw_psk31_trigger;  // Set to true to trigger a CW or PSK31 transmission.
                            // PSK31 is sent if cw_dit_duration is 0
 
-    /* Acknowledgements for input signals */
-    int ack_start_tm;      // Set to 1 to clear start_tm
 };
 
 // Initialise local structures
@@ -93,6 +101,8 @@ void fsm_init(void);
 // Call the FSM once and update the internal state
 void fsm_update(void);
 
+void fsm_balise_update(void);
+
 // Setter for inputs
 void fsm_update_inputs(struct fsm_input_signals_t* inputs);
 
diff --git a/src/common/src/Core/fsm.c b/src/common/src/Core/fsm.c
index 4383e12..7fabb55 100644
--- a/src/common/src/Core/fsm.c
+++ b/src/common/src/Core/fsm.c
@@ -35,6 +35,7 @@ static struct fsm_input_signals_t fsm_in;
 static struct fsm_output_signals_t fsm_out;
 
 static fsm_state_t current_state;
+static balise_fsm_state_t balise_state;
 
 // Keep track of when we last entered a given state, measured
 // in ms using the timestamp_now() function
@@ -75,6 +76,7 @@ void fsm_init() {
     timestamp_state[FSM_OISIF] = timestamp_now();
 
     current_state = FSM_OISIF;
+    balise_state = BALISE_FSM_EVEN_HOUR;
 }
 
 // Calculate the time spent in the current state
@@ -108,6 +110,14 @@ static const char* state_name(fsm_state_t state) {
     }
 }
 
+static const char* balise_state_name(balise_fsm_state_t state) {
+    switch (state) {
+        case BALISE_FSM_EVEN_HOUR: return "BALISE_FSM_EVEN_HOUR";
+        case BALISE_FSM_ODD_HOUR: return "BALISE_FSM_ODD_HOUR";
+        case BALISE_FSM_PENDING: return "BALISE_FSM_PENDING";
+        default: return "ERROR!";
+    }
+}
 // Calculate the time difference between two states
 static uint64_t state_delta_ms(fsm_state_t state_first, fsm_state_t state_second) {
     uint64_t delta = timestamp_state[state_second] - timestamp_state[state_first];
@@ -150,6 +160,9 @@ static const char* fsm_select_letter(void) {
     return letter_all_ok;
 }
 
+
+int qso_occurred = 0;
+
 void fsm_update() {
 
     fsm_state_t next_state = current_state;
@@ -162,12 +175,6 @@ void fsm_update() {
     fsm_out.msg_frequency = 960;
     // other output signals keep their value
 
-    // Clear the ack flag if the start_tm has been cleared
-    if (!fsm_in.start_tm && fsm_out.ack_start_tm) {
-        usart_debug("ACK start_tm reset\r\n");
-        fsm_out.ack_start_tm = 0;
-    }
-
     switch (current_state) {
         case FSM_OISIF:
 
@@ -192,7 +199,7 @@ void fsm_update() {
             if (fsm_in.tone_1750) {
                 next_state = FSM_OPEN1;
             }
-            else if (fsm_in.start_tm) {
+            else if (balise_state == BALISE_FSM_PENDING) {
                 if (fsm_in.qrp || fsm_in.swr_high) {
                     next_state = FSM_BALISE_SPECIALE;
                 }
@@ -219,6 +226,7 @@ void fsm_update() {
         case FSM_OPEN2:
             fsm_out.tx_on = 1;
             fsm_out.modulation = 1;
+            qso_occurred = 0; // Reset QSO Flag
 
             if (fsm_current_state_time_ms() > 200) {
                 next_state = FSM_LETTRE;
@@ -257,29 +265,32 @@ void fsm_update() {
             if (fsm_in.sq) {
                 next_state = FSM_QSO;
             }
-            else if (fsm_current_state_time_s() > 6 &&
-                    state_delta_ms(FSM_OPEN2, FSM_ECOUTE) < 1000ul * 5) {
-                next_state = FSM_ATTENTE;
-            }
-            else if (fsm_current_state_time_s() > 5 &&
-                    state_delta_ms(FSM_OPEN2, FSM_ECOUTE) < 1000ul * 5 * 60 &&
-                    state_delta_ms(FSM_QSO, FSM_ECOUTE) < 1000ul * 15) {
-                next_state = FSM_OISIF;
-            }
-            else if (fsm_current_state_time_s() > 5 &&
-                    state_delta_ms(FSM_OPEN2, FSM_ECOUTE) < 1000ul * 10 * 60 &&
-                    state_delta_ms(FSM_QSO, FSM_ECOUTE) < 1000ul * 15) {
-                next_state = FSM_TEXTE_73;
-            }
-            else if (fsm_current_state_time_s() > 5 &&
-                    state_delta_ms(FSM_OPEN2, FSM_ECOUTE) < 1000ul * 15 * 60 &&
-                    state_delta_ms(FSM_QSO, FSM_ECOUTE) < 1000ul * 15) {
-                next_state = FSM_TEXTE_HB9G;
-            }
-            else if (fsm_current_state_time_s() > 5 &&
-                    state_delta_ms(FSM_OPEN2, FSM_ECOUTE) >= 1000ul * 15 * 60 &&
-                    state_delta_ms(FSM_QSO, FSM_ECOUTE) < 1000ul * 15) {
-                next_state = FSM_TEXTE_LONG;
+            else {
+                if (fsm_current_state_time_s() > 5 && qso_occurred) {
+                    if (state_delta_ms(FSM_OPEN2, FSM_ECOUTE) >= 1000ul * 15 * 60) {
+                        next_state = FSM_TEXTE_LONG;
+                    }
+                    else if (state_delta_ms(FSM_OPEN2, FSM_ECOUTE) >= 1000ul * 10 * 60) {
+                        next_state = FSM_TEXTE_HB9G;
+                    }
+                    else if (state_delta_ms(FSM_OPEN2, FSM_ECOUTE) >= 1000ul * 5 * 60) {
+                        next_state = FSM_TEXTE_73;
+                    }
+                    else {
+                        next_state = FSM_OISIF;
+                    }
+                }
+
+                if (fsm_current_state_time_s() > 6 && !qso_occurred) {
+                    next_state = FSM_ATTENTE;
+                }
+
+                /* If everything fails and the state was not changed after 7
+                 * seconds, fall back to oisif
+                 */
+                if (fsm_current_state_time_s() > 7) {
+                    next_state = FSM_OISIF;
+                }
             }
             break;
 
@@ -295,6 +306,7 @@ void fsm_update() {
         case FSM_QSO:
             fsm_out.tx_on = 1;
             fsm_out.modulation = 1;
+            qso_occurred = 1;  // Set QSO Flag
 
             // Save the starting timestamp, if there is none
             if (last_qso_start_timestamp == 0) {
@@ -397,7 +409,6 @@ void fsm_update() {
             fsm_out.tx_on = 1;
             fsm_out.msg_frequency   = 588;
             fsm_out.cw_dit_duration = 110;
-            fsm_out.ack_start_tm    = 1;
 
             {
                 const float supply_voltage = round_float_to_half_steps(analog_measure_12v());
@@ -454,7 +465,6 @@ void fsm_update() {
             fsm_out.tx_on = 1;
             fsm_out.msg_frequency   = 696;
             fsm_out.cw_dit_duration = 70;
-            fsm_out.ack_start_tm    = 1;
 
             {
                 const float supply_voltage = round_float_to_half_steps(analog_measure_12v());
@@ -553,3 +563,44 @@ void fsm_get_outputs(struct fsm_output_signals_t* out)
 {
     *out = fsm_out;
 }
+
+void fsm_balise_update() {
+
+    balise_fsm_state_t next_state = balise_state;
+
+    switch (balise_state) {
+        case BALISE_FSM_EVEN_HOUR:
+            if (fsm_in.hour_is_even == 0) {
+                next_state = BALISE_FSM_ODD_HOUR;
+            }
+            break;
+        case BALISE_FSM_ODD_HOUR:
+            if (fsm_in.hour_is_even == 1) {
+                if (timestamp_now() > 1000 * 60) { // Does not start the balise at startup
+                    next_state = BALISE_FSM_PENDING;
+                }
+                else {
+                    next_state = BALISE_FSM_EVEN_HOUR;
+                }
+            }
+            break;
+        case BALISE_FSM_PENDING:
+            if (current_state == FSM_BALISE_SPECIALE ||
+                    current_state == FSM_BALISE_LONGUE) {
+                next_state = BALISE_FSM_EVEN_HOUR;
+            }
+            break;
+
+        default:
+            // Should never happen
+            next_state = BALISE_FSM_EVEN_HOUR;
+            break;
+    }
+
+    if (next_state != balise_state) {
+        fsm_state_switched(balise_state_name(next_state));
+    }
+
+    balise_state = next_state;
+
+}
diff --git a/src/common/src/Core/main.c b/src/common/src/Core/main.c
index 2be9e0c..6dbe697 100644
--- a/src/common/src/Core/main.c
+++ b/src/common/src/Core/main.c
@@ -49,7 +49,8 @@
 #include "vc.h"
 
 static int tm_trigger_button = 0;
-static int tm_trigger = 0;
+
+static struct fsm_input_signals_t fsm_input;
 
 /* Threshold for SWR measurement */
 const int swr_refl_threshold = 10; // mV
@@ -371,8 +372,7 @@ static void gps_monit_task(void __attribute__ ((unused))*pvParameters) {
         }
 
         if (time_valid) {
-            // Even hours: tm_trigger=1, odd hours: tm_trigger=0
-            tm_trigger = (time.tm_hour + 1) % 2;
+            fsm_input.hour_is_even = (time.tm_hour + 1) % 2;
         }
 
         gps_utctime(&gps_time);
@@ -409,7 +409,6 @@ static void gps_monit_task(void __attribute__ ((unused))*pvParameters) {
             const float temp = temperature_get();
             usart_debug("TEMP %d.%02d\r\n", (int)temp, (int)(temp * 100.0f - (int)(temp) * 100.0f));
 
-            usart_debug("TM_TRIGGER %d\r\n", tm_trigger);
         }
 
         if (time.tm_sec % 30 > 0) {
@@ -449,11 +448,9 @@ static void gps_monit_task(void __attribute__ ((unused))*pvParameters) {
     }
 }
 
-static struct fsm_input_signals_t fsm_input;
 static void exercise_fsm(void __attribute__ ((unused))*pvParameters)
 {
     int cw_last_trigger = 0;
-    int last_tm_trigger = 0;
     int last_tm_trigger_button = 0;
 
     int last_sq = 0;
@@ -495,23 +492,11 @@ static void exercise_fsm(void __attribute__ ((unused))*pvParameters)
             usart_debug("In U %d\r\n", last_discrim_u);
         }
 
-
         if (tm_trigger_button == 1 && last_tm_trigger_button == 0) {
-            fsm_input.start_tm = 1;
+            // Do something if you want. This currently does nothing.
         }
         last_tm_trigger_button = tm_trigger_button;
 
-        /* Do not time-trigger BALISE if
-         * the trigger occurs in the first minute,
-         * or if we happen to start up in an even hour
-         */
-        if (    timestamp_now() > 60 * 1000 &&
-                tm_trigger == 1 && last_tm_trigger == 0) {
-            fsm_input.start_tm = 1;
-            usart_debug("START_TM set\r\n");
-        }
-        last_tm_trigger = tm_trigger;
-
         int cw_done = !cw_psk31_busy();
         if (last_cw_done != cw_done) {
 
@@ -538,6 +523,7 @@ static void exercise_fsm(void __attribute__ ((unused))*pvParameters)
 
         fsm_update_inputs(&fsm_input);
         fsm_update();
+        fsm_balise_update();
 
         struct fsm_output_signals_t fsm_out;
         fsm_get_outputs(&fsm_out);
@@ -553,9 +539,5 @@ static void exercise_fsm(void __attribute__ ((unused))*pvParameters)
         }
         cw_last_trigger = fsm_out.cw_psk31_trigger;
 
-        if (fsm_out.ack_start_tm) {
-            fsm_input.start_tm = 0;
-            usart_debug("START_TM reset\r\n");
-        }
     }
 }
diff --git a/src/glutt-o-logique/fsm.c b/src/glutt-o-logique/fsm.c
index bc39030..916a1fc 100644
--- a/src/glutt-o-logique/fsm.c
+++ b/src/glutt-o-logique/fsm.c
@@ -28,4 +28,3 @@
 void fsm_state_switched(const char *new_state) {
     usart_debug_puts_header("FSM: ", new_state);
 }
-