Merge lp:~i-dan-3/flashlight-firmware/pwm-strobe into lp:flashlight-firmware

[Dan Stahlke]

Added accurate 16-bit PWM strobe modes

Disabled by default. Only supported on CPUs having a 16-bit PWM, which means only attiny1634, which means only Emisar D4v2 and D4Sv2. I don't have a D4Sv2 to test, so currently it's only implemented on D4v2. The relevant functions could probably be directly copied from hwdef-Emisar_D4v2.h to hwdef-Emisar_D4Sv2.h.

Strobe rate can be continuously varied from 1Hz to 500Hz. Theoretically it could run faster, but this is already enough to freeze something that's spinning at 30000 RPM. Uses full brightness (1x7135 plus FET) with a 1:256 duty cycle (party strobe) or 1:4 duty cycle (tactical strobe). Rate adjustment has acceleration, going twice as fast after 1 second and 4x as fast after 2 seconds. It still takes about 10 seconds to traverse the whole range from 1Hz to 500Hz.

With this I was able to freeze my Proxon drill (similar to Dremel) running at 20000 RPM. Unfortunately the flash rate fluctuates by about 0.1%, probably due to the CPU's RC oscillator.

Unmerged revisions

238. By Dan Stahlke <dstahlke@psi> on 2019-11-13

Added accurate 16-bit PWM strobe modes

Disabled by default. Only supported on CPUs having a 16-bit PWM, which means only attiny1634, which means only Emisar D4v2 and D4Sv2. I don't have a D4Sv2 to test, so currently it's only implemented on D4v2. The relevant functions could probably be directly copied from hwdef-Emisar_D4v2.h to hwdef-Emisar_D4Sv2.h.

Strobe rate can be continuously varied from 1Hz to 500Hz. Theoretically it could run faster, but this is already enough to freeze something that's spinning at 30000 RPM. Uses full brightness (1x7135 plus FET) with a 1:256 duty cycle (party strobe) or 1:4 duty cycle (tactical strobe). Rate adjustment has acceleration, going twice as fast after 1 second and 4x as fast after 2 seconds. It still takes about 10 seconds to traverse the whole range from 1Hz to 500Hz.

With this I was able to freeze my Proxon drill (similar to Dremel) running at 20000 RPM. Unfortunately the flash rate fluctuates by about 0.1%, probably due to the CPU's RC oscillator.

=== modified file 'ToyKeeper/hwdef-Emisar_D4v2.h'
--- ToyKeeper/hwdef-Emisar_D4v2.h	2019-08-05 07:40:20 +0000
+++ ToyKeeper/hwdef-Emisar_D4v2.h	2019-11-13 06:37:16 +0000
@@ -95,6 +95,62 @@
   SWITCH_PCMSK = (1 << SWITCH_PCINT);  // enable pin change interrupt
 }
 
+#if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+void exit_pwm_strobe() {
+  // copied from hwdef_setup
+  TCCR1A  = (0<<WGM11)  | (1<<WGM10)   // 8-bit (TOP=0xFF) (DS table 12-5)
+          | (1<<COM1A1) | (0<<COM1A0)  // PWM 1A in normal direction (DS table 12-4)
+          | (1<<COM1B1) | (0<<COM1B0)  // PWM 1B in normal direction (DS table 12-4)
+          ;
+  TCCR1B  = (0<<CS12)   | (0<<CS11) | (1<<CS10)  // clk/1 (no prescaling) (DS table 12-6)
+          | (0<<WGM13)  | (0<<WGM12)  // phase-correct PWM (DS table 12-5)
+          ;
+  PWM1_LVL = 0;
+  PWM2_LVL = 0;
+}
+
+void init_pwm_strobe(uint32_t delay32, uint8_t tactical) {
+    uint16_t delay16;
+    uint8_t cs;
+    if (delay32 <= 0xffff) {
+        delay16 = (uint16_t)delay32;
+        cs = (1<<CS10); // clk/1
+    } else if ((delay32 >> 3) <= 0xffff) {
+        delay16 = (uint16_t)(delay32 >> 3);
+        cs = (1<<CS11); // clk/8
+    } else if ((delay32 >> 6) <= 0xffff) {
+        delay16 = (uint16_t)(delay32 >> 6);
+        cs = (1<<CS11) | (1<<CS10); // clk/64
+    } else {
+        delay16 = (uint16_t)(delay32 >> 10);
+        cs = (1<<CS12) | (1<<CS10); // clk/1024
+    }
+
+    TCCR1A  = (1<<WGM11)  | (0<<WGM10)
+        | (1<<COM1A1) | (0<<COM1A0)  // PWM 1A in normal direction (DS table 12-4)
+        | (1<<COM1B1) | (0<<COM1B0)  // PWM 1B in normal direction (DS table 12-4)
+        ;
+    TCCR1B  = (0<<CS12)   | (0<<CS11) | (0<<CS10)  // clock turned off
+        | (1<<WGM13)  | (1<<WGM12)  // WGM=1110 (fast PWM, TOP=ICR1) (DS table 12-5)
+        ;
+
+    if (tactical) {
+        PWM1_LVL = delay16 >> 8;
+        PWM2_LVL = delay16 >> 8;
+    } else {
+        PWM1_LVL = delay16 >> 2;
+        PWM2_LVL = delay16 >> 2;
+    }
+    ICR1 = delay16;
+    if (TCNT1 >= delay16)
+        TCNT1 = delay16 - 1;
+
+    TCCR1B  = cs
+        | (1<<WGM13)  | (1<<WGM12)  // WGM=1110 (fast PWM, TOP=ICR1) (DS table 12-5)
+        ;
+}
+#endif
+
 #define LAYOUT_DEFINED
 
 #endif

=== modified file 'ToyKeeper/spaghetti-monster/anduril/anduril.c'
--- ToyKeeper/spaghetti-monster/anduril/anduril.c	2019-08-05 07:40:20 +0000
+++ ToyKeeper/spaghetti-monster/anduril/anduril.c	2019-11-13 06:37:16 +0000
@@ -66,6 +66,9 @@
 #define USE_BIKE_FLASHER_MODE
 #define USE_PARTY_STROBE_MODE
 #define USE_TACTICAL_STROBE_MODE
+// PWM strobe modes require 16-bit timer, and only attiny1634 has that.
+//#define USE_PWM_PARTY_STROBE_MODE
+//#define USE_PWM_TACTICAL_STROBE_MODE
 #define USE_LIGHTNING_MODE
 #define USE_CANDLE_MODE
 
@@ -140,7 +143,7 @@
 #endif
 #endif
 
-#if defined(USE_CANDLE_MODE) || defined(USE_BIKE_FLASHER_MODE) || defined(USE_PARTY_STROBE_MODE) || defined(USE_TACTICAL_STROBE_MODE) || defined(USE_LIGHTNING_MODE)
+#if defined(USE_CANDLE_MODE) || defined(USE_BIKE_FLASHER_MODE) || defined(USE_PARTY_STROBE_MODE) || defined(USE_TACTICAL_STROBE_MODE) || defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE) || defined(USE_LIGHTNING_MODE)
 #define USE_STROBE_STATE
 #endif
 
@@ -172,6 +175,11 @@
     strobe_delays_0_e,
     strobe_delays_1_e,
     #endif
+    #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+    strobe_delays_l_e,
+    strobe_delays_m_e,
+    strobe_delays_h_e,
+    #endif
     #ifdef USE_BIKE_FLASHER_MODE
     bike_flasher_brightness_e,
     #endif
@@ -438,6 +446,12 @@
     #ifdef USE_TACTICAL_STROBE_MODE
     tactical_strobe_e,
     #endif
+    #ifdef USE_PWM_PARTY_STROBE_MODE
+    pwm_party_strobe_e,
+    #endif
+    #ifdef USE_PWM_TACTICAL_STROBE_MODE
+    pwm_tactical_strobe_e,
+    #endif
     #ifdef USE_LIGHTNING_MODE
     lightning_storm_e,
     #endif
@@ -465,6 +479,15 @@
 volatile uint8_t strobe_delays[] = { 40, 67 };  // party strobe, tactical strobe
 #endif
 
+#if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+// party / tactical strobe timing, using 16-bit pwm
+// Note: if pwm_strobe_delay_max is more than 24 bits, then load_config and
+// save_config will need to be modified (they only save the lower 24 bits).
+static const uint32_t pwm_strobe_delay_max = F_CPU; // min freq 1Hz
+static const uint32_t pwm_strobe_delay_min = F_CPU / 500; // max freq 500Hz
+volatile uint32_t pwm_strobe_delay = F_CPU / 10; // default freq 10Hz
+#endif
+
 // bike mode config options
 #ifdef USE_BIKE_FLASHER_MODE
 volatile uint8_t bike_flasher_brightness = MAX_1x7135;
@@ -1093,6 +1116,53 @@
 
 
 #ifdef USE_STROBE_STATE
+
+#if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+// Factoring out this common code saves 72 bytes.  Returning uint16_t instead of
+// uint32_t saves another 48 bytes, but that optimization is only valid if
+// pwm_strobe_delay_max >> 7 is a 16-bit value.  That's true (just barely) with
+// an 8MHz clock and 1Hz min blink rate, but the optimization probably isn't
+// worth the risk in case these numbers change.
+uint32_t pwm_strobe_step_size(uint16_t ticks) {
+    if (ticks >= TICKS_PER_SECOND*2) {
+        return pwm_strobe_delay >> 7;
+    } else if (ticks >= TICKS_PER_SECOND) {
+        return pwm_strobe_delay >> 8;
+    } else {
+        return pwm_strobe_delay >> 9;
+    }
+}
+
+void pwm_strobe_rate_faster(uint16_t ticks) {
+    pwm_strobe_delay -= pwm_strobe_step_size(ticks);
+    if (pwm_strobe_delay < pwm_strobe_delay_min)
+        pwm_strobe_delay = pwm_strobe_delay_min;
+}
+
+void pwm_strobe_rate_slower(uint16_t ticks) {
+    pwm_strobe_delay += pwm_strobe_step_size(ticks);
+    if (pwm_strobe_delay > pwm_strobe_delay_max)
+        pwm_strobe_delay = pwm_strobe_delay_max;
+}
+
+uint8_t is_pwm_strobe_mode(strobe_mode_te st) {
+    #ifdef USE_PWM_TACTICAL_STROBE_MODE
+    if (st == pwm_tactical_strobe_e) return 1;
+    #endif
+    #ifdef USE_PWM_PARTY_STROBE_MODE
+    if (st == pwm_party_strobe_e) return 1;
+    #endif
+    return 0;
+}
+
+uint8_t is_pwm_tactical_strobe_mode(strobe_mode_te st) {
+    #ifdef USE_PWM_TACTICAL_STROBE_MODE
+    if (st == pwm_tactical_strobe_e) return 1;
+    #endif
+    return 0;
+}
+#endif
+
 uint8_t strobe_state(Event event, uint16_t arg) {
     static int8_t ramp_direction = 1;
 
@@ -1114,17 +1184,43 @@
     // init anything which needs to be initialized
     else if (event == EV_enter_state) {
         ramp_direction = 1;
+        #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+        if (is_pwm_strobe_mode(st)) {
+            #ifdef USE_DYNAMIC_UNDERCLOCKING
+            clock_prescale_set(clock_div_1);
+            #endif  // ifdef USE_DYNAMIC_UNDERCLOCKING
+            init_pwm_strobe(pwm_strobe_delay, is_pwm_tactical_strobe_mode(st));
+        }
+        #endif
         return MISCHIEF_MANAGED;
     }
     // 1 click: off
     else if (event == EV_1click) {
+        #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+        if (is_pwm_strobe_mode(st)) {
+            exit_pwm_strobe();
+        }
+        #endif
         set_state(off_state, 0);
         return MISCHIEF_MANAGED;
     }
     // 2 clicks: rotate through strobe/flasher modes
     else if (event == EV_2clicks) {
-        strobe_type = (st + 1) % NUM_STROBES;
+        #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+        if (is_pwm_strobe_mode(st)) {
+            exit_pwm_strobe();
+        }
+        #endif
+        strobe_type = st = (st + 1) % NUM_STROBES;
         save_config();
+        #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+        if (is_pwm_strobe_mode(st)) {
+            #ifdef USE_DYNAMIC_UNDERCLOCKING
+            clock_prescale_set(clock_div_1);
+            #endif  // ifdef USE_DYNAMIC_UNDERCLOCKING
+            init_pwm_strobe(pwm_strobe_delay, is_pwm_tactical_strobe_mode(st));
+        }
+        #endif
         return MISCHIEF_MANAGED;
     }
     // hold: change speed (go faster)
@@ -1149,6 +1245,17 @@
         }
         #endif
 
+        // party / tactical strobe faster/slower
+        #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+        else if (is_pwm_strobe_mode(st)) {
+            if (ramp_direction > 0)
+                pwm_strobe_rate_faster(arg);
+            else
+                pwm_strobe_rate_slower(arg);
+            init_pwm_strobe(pwm_strobe_delay, is_pwm_tactical_strobe_mode(st));
+        }
+        #endif
+
         // lightning has no adjustments
         //else if (st == lightning_storm_e) {}
 
@@ -1191,6 +1298,14 @@
         }
         #endif
 
+        // party / tactical strobe faster
+        #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+        else if (is_pwm_strobe_mode(st)) {
+            pwm_strobe_rate_faster(arg);
+            init_pwm_strobe(pwm_strobe_delay, is_pwm_tactical_strobe_mode(st));
+        }
+        #endif
+
         // lightning has no adjustments
         //else if (st == lightning_storm_e) {}
 
@@ -2387,11 +2502,19 @@
         #ifdef USE_TINT_RAMPING
         tint = eeprom[tint_e];
         #endif
-        #if defined(USE_PARTY_STROBE_MODE) || defined(USE_TACTICAL_STROBE_MODE)
+        #ifdef USE_STROBE_STATE
         strobe_type = eeprom[strobe_type_e];  // TODO: move this to eeprom_wl?
+        #endif
+        #if defined(USE_PARTY_STROBE_MODE) || defined(USE_TACTICAL_STROBE_MODE)
         strobe_delays[0] = eeprom[strobe_delays_0_e];
         strobe_delays[1] = eeprom[strobe_delays_1_e];
         #endif
+        #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+        pwm_strobe_delay =
+            ((uint32_t)eeprom[strobe_delays_h_e] << 16) |
+            ((uint32_t)eeprom[strobe_delays_m_e] <<  8) |
+            ((uint32_t)eeprom[strobe_delays_l_e]);
+        #endif
         #ifdef USE_BIKE_FLASHER_MODE
         bike_flasher_brightness = eeprom[bike_flasher_brightness_e];
         #endif
@@ -2435,11 +2558,18 @@
     #ifdef USE_TINT_RAMPING
     eeprom[tint_e] = tint;
     #endif
-    #if defined(USE_PARTY_STROBE_MODE) || defined(USE_TACTICAL_STROBE_MODE)
+    #ifdef USE_STROBE_STATE
     eeprom[strobe_type_e] = strobe_type;  // TODO: move this to eeprom_wl?
+    #endif
+    #if defined(USE_PARTY_STROBE_MODE) || defined(USE_TACTICAL_STROBE_MODE)
     eeprom[strobe_delays_0_e] = strobe_delays[0];
     eeprom[strobe_delays_1_e] = strobe_delays[1];
     #endif
+    #if defined(USE_PWM_PARTY_STROBE_MODE) || defined(USE_PWM_TACTICAL_STROBE_MODE)
+    eeprom[strobe_delays_h_e] = (uint8_t)(pwm_strobe_delay >> 16);
+    eeprom[strobe_delays_m_e] = (uint8_t)(pwm_strobe_delay >> 8);
+    eeprom[strobe_delays_l_e] = (uint8_t)(pwm_strobe_delay);
+    #endif
     #ifdef USE_BIKE_FLASHER_MODE
     eeprom[bike_flasher_brightness_e] = bike_flasher_brightness;
     #endif