1 files changed, 59 insertions, 59 deletions

diff --git a/spaghetti-monster/fsm-events.c b/spaghetti-monster/fsm-events.c
index ad869a6..3279c14 100644
--- a/spaghetti-monster/fsm-events.c
+++ b/spaghetti-monster/fsm-events.c
@@ -23,8 +23,60 @@
 #include <util/delay_basic.h>
 
 
+void append_emission(Event event, uint16_t arg) {
+    uint8_t i;
+    // find last entry
+    for(i=0;
+        (i<EMISSION_QUEUE_LEN) && (emissions[i].event != EV_none);
+        i++) { }
+    // add new entry
+    if (i < EMISSION_QUEUE_LEN) {
+        emissions[i].event = event;
+        emissions[i].arg = arg;
+    } else {
+        // TODO: if queue full, what should we do?
+    }
+}
+
+void delete_first_emission() {
+    uint8_t i;
+    for(i=0; i<EMISSION_QUEUE_LEN-1; i++) {
+        emissions[i].event = emissions[i+1].event;
+        emissions[i].arg = emissions[i+1].arg;
+    }
+    emissions[i].event = EV_none;
+    emissions[i].arg = 0;
+}
+
+void process_emissions() {
+    while (emissions[0].event != EV_none) {
+        emit_now(emissions[0].event, emissions[0].arg);
+        delete_first_emission();
+    }
+}
+
+// Call stacked callbacks for the given event until one handles it.
+uint8_t emit_now(Event event, uint16_t arg) {
+    for(int8_t i=state_stack_len-1; i>=0; i--) {
+        uint8_t err = state_stack[i](event, arg);
+        if (! err) return 0;
+    }
+    return 1;  // event not handled
+}
+
+void emit(Event event, uint16_t arg) {
+    // add this event to the queue for later,
+    // so we won't use too much time during an interrupt
+    append_emission(event, arg);
+}
+
+void emit_current_event(uint16_t arg) {
+    emit(current_event, arg);
+}
+
 void empty_event_sequence() {
     current_event = EV_none;
+    ticks_since_last_event = 0;
     // when the user completes an input sequence, interrupt any running timers
     // to cancel any delays currently in progress
     // This eliminates a whole bunch of extra code:
@@ -33,8 +85,9 @@ void empty_event_sequence() {
     interrupt_nice_delays();
 }
 
-uint8_t push_event(uint8_t ev_type) {
-    ticks_since_last_event = 0;  // something happened
+uint8_t push_event(uint8_t ev_type) {  // only for use by PCINT_inner()
+    // don't do this here; do it in PCINT_inner() instead
+    //ticks_since_last_event = 0;  // something happened
 
     // only click events are sent to this function
     current_event |= B_CLICK;
@@ -61,41 +114,8 @@ uint8_t push_event(uint8_t ev_type) {
     }
 
     return 0;  // unexpected event type
-
-}
-
-
-void append_emission(Event event, uint16_t arg) {
-    uint8_t i;
-    // find last entry
-    for(i=0;
-        (i<EMISSION_QUEUE_LEN) && (emissions[i].event != EV_none);
-        i++) { }
-    // add new entry
-    if (i < EMISSION_QUEUE_LEN) {
-        emissions[i].event = event;
-        emissions[i].arg = arg;
-    } else {
-        // TODO: if queue full, what should we do?
-    }
 }
 
-void delete_first_emission() {
-    uint8_t i;
-    for(i=0; i<EMISSION_QUEUE_LEN-1; i++) {
-        emissions[i].event = emissions[i+1].event;
-        emissions[i].arg = emissions[i+1].arg;
-    }
-    emissions[i].event = EV_none;
-    emissions[i].arg = 0;
-}
-
-void process_emissions() {
-    while (emissions[0].event != EV_none) {
-        emit_now(emissions[0].event, emissions[0].arg);
-        delete_first_emission();
-    }
-}
 
 // explicitly interrupt these "nice" delays
 volatile uint8_t nice_delay_interrupt = 0;
@@ -106,7 +126,6 @@ inline void interrupt_nice_delays() { nice_delay_interrupt = 1; }
 //   0: state changed
 //   1: normal completion
 uint8_t nice_delay_ms(uint16_t ms) {
-    StatePtr old_state = current_state;
     /*  // delay_zero() implementation
     if (ms == 0) {
         CLKPR = 1<<CLKPCE; CLKPR = 0;  // full speed
@@ -115,6 +134,10 @@ uint8_t nice_delay_ms(uint16_t ms) {
     }
     */
     while(ms-- > 0) {
+        if (nice_delay_interrupt) {
+            return 0;
+        }
+
         #ifdef USE_DYNAMIC_UNDERCLOCKING
         #ifdef USE_RAMPING
         uint8_t level = actual_level;  // volatile, avoid repeat access
@@ -148,9 +171,6 @@ uint8_t nice_delay_ms(uint16_t ms) {
         // run pending system processes while we wait
         handle_deferred_interrupts();
 
-        if ((nice_delay_interrupt) || (old_state != current_state)) {
-            return 0;  // state changed; abort
-        }
         // handle events only afterward, so that any collapsed delays will
         // finish running the UI's loop() code before taking any further actions
         // (this helps make sure code runs in the correct order)
@@ -192,24 +212,4 @@ uint8_t nice_delay_s() {
 }
 */
 
-// Call stacked callbacks for the given event until one handles it.
-uint8_t emit_now(Event event, uint16_t arg) {
-    for(int8_t i=state_stack_len-1; i>=0; i--) {
-        uint8_t err = state_stack[i](event, arg);
-        if (! err) return 0;
-    }
-    return 1;  // event not handled
-}
-
-void emit(Event event, uint16_t arg) {
-    // add this event to the queue for later,
-    // so we won't use too much time during an interrupt
-    append_emission(event, arg);
-}
-
-void emit_current_event(uint16_t arg) {
-    ticks_since_last_event = arg;
-    emit(current_event, arg);
-}
-
 #endif