Improved digit state tracking

Nixie_Firmware_Mbed/main.cpp

@@ -14,21 +14,25 @@ bool RtcTick, RefreshTick, RngTick;
 bool StartupFlag, RuntimeFlag;
 
 typedef struct {
-    char PrevDigit;     // Previous digit to fade out
-    ushort PrevValue;   // Brightness of previous digit
-    char NextDigit;     // Next digit to fade in
-    ushort NextValue;   // Brightness of next digit
+    char DigitA;
+    ushort DigitAValue;
+    char DigitB;
+    ushort DigitBValue;
+    bool DigitBActive;
+    bool Updated;
     bool RefreshActive;
-} Digit;
+} TUBE;
 
-Digit Digits[NUM_DIGITS] = {0};  // Active per-tube digit setting
+TUBE Display[NUM_TUBES] = {0};  // Active per-tube digit setting
 
-int DotNextValue, DotPrevValue;
+int DotValue;
+bool DotUpdated = false;;
 bool DotIncrement = false;
 
 Ticker StartupUpdateTicker, RuntimeUpdateTicker, RngUpdateTicker;
 int StartupTickerIter, RuntimeTickerIter, RngTickerIter;
 
+
 void RtcTickCallback(void) {
     RtcTick = true;
 }
@@ -43,18 +47,18 @@ void RngTickCallback(void) {
 
 void StartupTickerUpdate(void) {
 
-    for (int i = 0; i < NUM_DIGITS; i++) {
-        if (!Digits[i].RefreshActive) {
-            Digits[i].NextValue = (i == 0 && Digits[i].NextDigit == 0) ? 0 : Digits[i].NextValue + FADE_TICK_STEP;
-        }
+    for (int i = 0; i < NUM_TUBES; i++) {
+        Display[i].DigitAValue = (i == 0 && Display[i].DigitA == 0) ? 0 : Display[i].DigitAValue + FADE_TICK_STEP;
+        Display[i].Updated = true;
     }
 
-    DotNextValue += FADE_TICK_STEP;
+    DotValue += FADE_TICK_STEP;
+    DotUpdated = true;
 
     if (--StartupTickerIter == 0) {
         StartupUpdateTicker.detach();
-        for (int i = 0; i < NUM_DIGITS; i++) {
-            Digits[i].PrevDigit = Digits[i].NextDigit;
+        for (int i = 0; i < NUM_TUBES; i++) {
+            Display[i].DigitBActive = !Display[i].DigitBActive;
         }
 
         // Switch to runtime mode once startup sequence has completed
@@ -64,19 +68,33 @@ void StartupTickerUpdate(void) {
 
 void RuntimeTickerUpdate(void) {
 
-    for (int i = 0; i < NUM_DIGITS; i++) {
-        if(!Digits[i].RefreshActive && Digits[i].PrevDigit != Digits[i].NextDigit) {
-            Digits[i].PrevValue -= FADE_TICK_STEP;
-            Digits[i].NextValue = (i == 0 && Digits[i].NextDigit == 0) ? 0 : Digits[i].NextValue + FADE_TICK_STEP;
+    for (int i = 0; i < NUM_TUBES; i++) {
+        if(!Display[i].RefreshActive) {
+
+            if (Display[i].DigitA != Display[i].DigitB) {
+
+                if (Display[i].DigitBActive) {
+                    Display[i].DigitAValue -= FADE_TICK_STEP;
+                    Display[i].DigitBValue = (i == 0 && Display[i].DigitB == 0) ? 0 : Display[i].DigitBValue + FADE_TICK_STEP;
+                } else {
+                    Display[i].DigitBValue -= FADE_TICK_STEP;
+                    Display[i].DigitAValue = (i == 0 && Display[i].DigitA == 0) ? 0 : Display[i].DigitAValue + FADE_TICK_STEP;
+                }
+
+                Display[i].Updated = true;
+            } 
         }
     }
 
-    DotNextValue = DotIncrement ? DotNextValue + FADE_TICK_STEP: DotNextValue - FADE_TICK_STEP;
+    DotValue = DotIncrement ? DotValue + FADE_TICK_STEP: DotValue - FADE_TICK_STEP;
+    DotUpdated = true;
 
     if (--RuntimeTickerIter == 0) {
         RuntimeUpdateTicker.detach();
-        for (int i = 0; i < NUM_DIGITS; i++) {
-            Digits[i].PrevDigit = Digits[i].NextDigit;
+        for (int i = 0; i < NUM_TUBES; i++) {
+            if (Display[i].DigitA != Display[i].DigitB) {
+                Display[i].DigitBActive = !Display[i].DigitBActive;
+            }
         }
         DotIncrement = !DotIncrement;
     }
@@ -124,8 +142,8 @@ int main() {
     refreshTicker.attach_us(RefreshTickCallback, DIGIT_REFRESH_RATE_US);
 
     // Kick off the RNG ticker at 0.1Hz
-    Ticker rngTicker;
-    rngTicker.attach(RngTickCallback, DIGIT_RNG_REFRESH_RATE_S);
+    // Ticker rngTicker;
+    // rngTicker.attach(RngTickCallback, DIGIT_RNG_REFRESH_RATE_S);
 
     // DS3231_SetTime(0, 55, 6, true);
     // DS3231_SetDate(0, 2, 12, 18, 0);
@@ -142,50 +160,61 @@ int main() {
         // Animate_Cycle_Fast_Random();
 
         if (RefreshTick) {
-
             RefreshTick = false;
 
             // On refresh, update the display with new values
 
-            // If brightness has changed, update both prevous and next digits with new values
-            for (int i = 0; i < NUM_DIGITS; i++) {
-                if (Digits[i].NextValue != Digits[i].PrevValue) {
-                    PCA9685_SetDigit(i, Digits[i].PrevDigit, Digits[i].PrevValue);
-                    PCA9685_SetDigit(i, Digits[i].NextDigit, Digits[i].NextValue);
+            // If values has changed, update both prevous and next digits with new values
+            for (int i = 0; i < NUM_TUBES; i++) {
+                if (Display[i].Updated) {
+                    PCA9685_SetDigit(i, Display[i].DigitA, Display[i].DigitAValue);
+                    PCA9685_SetDigit(i, Display[i].DigitB, Display[i].DigitBValue);
+                    Display[i].Updated = false;
                 }
             }
 
-            if (DotNextValue != DotPrevValue) {
-                PCA9685_SetDot(DotNextValue);
-            }
-
-            // Update previous values to what was just set
-
-            for (int i = 0; i < NUM_DIGITS; i++) {
-                Digits[i].PrevValue = Digits[i].NextValue;
+            if (DotUpdated) {
+                PCA9685_SetDot(DotValue);
+                DotUpdated = false;
             }
-            DotPrevValue = DotNextValue;
         }
 
         if (RtcTick) {
-            
             RtcTick = false;
 
             // On RTC 1Hz ticks, get the time and begin update
-
             int nextSecond, nextMinute, nextHour;
             DS3231_GetTime(&nextSecond, &nextMinute, &nextHour);
 
-            Digits[3].NextDigit = nextMinute % 10;
-            Digits[2].NextDigit = nextMinute / 10;
-            Digits[1].NextDigit = nextHour % 10;
-            Digits[0].NextDigit = nextHour / 10;
+            if (Display[3].DigitBActive) {
+                Display[3].DigitB = nextMinute % 10;
+            } else {
+                Display[3].DigitA = nextMinute % 10;
+            }
+
+            if (Display[2].DigitBActive) {
+                Display[2].DigitB = nextMinute / 10;
+            } else {
+                Display[2].DigitA = nextMinute / 10;
+            }
+
+            if (Display[1].DigitBActive) {
+                Display[1].DigitB = nextHour % 10;
+            } else {
+                Display[1].DigitA = nextHour % 10;
+            }
+
+            if (Display[0].DigitBActive) {
+                Display[0].DigitB = nextHour / 10;
+            } else {
+                Display[0].DigitA = nextHour / 10;
+            }
 
             if (StartupFlag) {
 
                 // Fade in the current time
                 StartupTickerIter = FADE_TICKS;
-                StartupUpdateTicker.attach(StartupTickerUpdate, (DIGIT_REFRESH_RATE_US/1000)/StartupTickerIter);
+                StartupUpdateTicker.attach(StartupTickerUpdate, (float)(DIGIT_REFRESH_RATE_US / 1000) / StartupTickerIter);
                 StartupFlag = false;
             } 
 
@@ -193,14 +222,14 @@ int main() {
 
                 // Fade in the new time
                 RuntimeTickerIter = FADE_TICKS;
-                RuntimeUpdateTicker.attach(RuntimeTickerUpdate, (DIGIT_REFRESH_RATE_US/1000)/RuntimeTickerIter);
+                RuntimeUpdateTicker.attach(RuntimeTickerUpdate, (float)(DIGIT_REFRESH_RATE_US / 1000) / RuntimeTickerIter);
             }
         }
 
         if (RngTick) {
 
             // Choose a random tube to refresh
-            Digits[rand() % 4].RefreshActive = true;
+            Display[rand() % 4].RefreshActive = true;
 
             RngTickerIter = DIGIT_RNG_REFRESH_ITER * FADE_TICKS;
             RngUpdateTicker.attach(RngTickerUpdate, (DIGIT_REFRESH_RATE_US/1000)/FADE_TICKS);

Nixie_Firmware_Mbed/main.h

@@ -13,7 +13,7 @@
 
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
 
-#define NUM_DIGITS 4
+#define NUM_TUBES 4
 
 #define I2C_MAX_BUFFER 20