← Back to branch summary

~toykeeper/flashlight-firmware/fsm

« back to all changes in this revision

Viewing changes to ToyKeeper/spaghetti-monster/rampingios/rampingiosv3.c

  • Committer: Selene ToyKeeper
  • Date: 2023-11-04 15:09:10 UTC
  • mfrom: (483.1.175 anduril2)
  • Revision ID: bzr@toykeeper.net-20231104150910-ddd3afw4nhfvof2l
merged anduril2 branch -> fsm, with *years* of changes
(this also means this code is now Anduril 2 instead of Anduril 1)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ToyKeeper/spaghetti-monster/rampingios/rampingiosv3.c
247
247
        #endif
248
248
        // sleep while off  (lower power use)
249
249
        go_to_standby = 1;
250
 
        return MISCHIEF_MANAGED;
 
250
        return EVENT_HANDLED;
251
251
    }
252
252
    // go back to sleep eventually if we got bumped but didn't leave "off" state
253
253
    else if (event == EV_tick) {
257
257
            indicator_led(indicator_led_mode & 0x03);
258
258
            #endif
259
259
        }
260
 
        return MISCHIEF_MANAGED;
 
260
        return EVENT_HANDLED;
261
261
    }
262
262
    #if defined(TICK_DURING_STANDBY) && defined(USE_INDICATOR_LED)
263
263
    // blink the indicator LED, maybe
265
265
        if ((indicator_led_mode & 0b00000011) == 0b00000011) {
266
266
            indicator_blink(arg);
267
267
        }
268
 
        return MISCHIEF_MANAGED;
 
268
        return EVENT_HANDLED;
269
269
    }
270
270
    #endif
271
271
    // hold (initially): go to lowest level (floor), but allow abort for regular click
272
272
    else if (event == EV_click1_press) {
273
273
        set_level(nearest_level(1));
274
 
        return MISCHIEF_MANAGED;
 
274
        return EVENT_HANDLED;
275
275
    }
276
276
    // hold: go to lowest level
277
277
    else if (event == EV_click1_hold) {
290
290
        if (arg >= (!ramp_style) * HOLD_TIMEOUT) {  // more consistent
291
291
            set_state(steady_state, 1);
292
292
        }
293
 
        return MISCHIEF_MANAGED;
 
293
        return EVENT_HANDLED;
294
294
    }
295
295
    // hold, release quickly: go to lowest level (floor)
296
296
    else if (event == EV_click1_hold_release) {
297
297
        set_state(steady_state, 1);
298
 
        return MISCHIEF_MANAGED;
 
298
        return EVENT_HANDLED;
299
299
    }
300
300
    // 1 click (before timeout): go to memorized level, but allow abort for double click
301
301
    else if (event == EV_click1_release) {
302
302
        set_level(nearest_level(memorized_level));
303
 
        return MISCHIEF_MANAGED;
 
303
        return EVENT_HANDLED;
304
304
    }
305
305
    // 1 click: regular mode
306
306
    else if (event == EV_1click) {
307
307
        set_state(steady_state, memorized_level);
308
 
        return MISCHIEF_MANAGED;
 
308
        return EVENT_HANDLED;
309
309
    }
310
310
    // click, hold: go to highest level (ceiling) (for ramping down)
311
311
    else if (event == EV_click2_hold) {
312
312
        set_state(steady_state, MAX_LEVEL);
313
 
        return MISCHIEF_MANAGED;
 
313
        return EVENT_HANDLED;
314
314
    }
315
315
    // 2 clicks: highest mode (ceiling)
316
316
    else if (event == EV_2clicks) {
317
317
        set_state(steady_state, MAX_LEVEL);
318
 
        return MISCHIEF_MANAGED;
 
318
        return EVENT_HANDLED;
319
319
    }
320
320
    // 3 clicks (initial press): off, to prep for later events
321
321
    else if (event == EV_click3_press) {
322
322
        set_level(0);
323
 
        return MISCHIEF_MANAGED;
 
323
        return EVENT_HANDLED;
324
324
    }
325
325
    #ifdef USE_BATTCHECK
326
326
    // 3 clicks: battcheck mode / blinky mode group 1
327
327
    else if (event == EV_3clicks) {
328
328
        set_state(battcheck_state, 0);
329
 
        return MISCHIEF_MANAGED;
 
329
        return EVENT_HANDLED;
330
330
    }
331
331
    #endif
332
332
    // 4 clicks: momentary
333
333
    else if (event == EV_4clicks) {
334
334
        blink_confirm(1);
335
335
        set_state(momentary_state, 0);
336
 
        return MISCHIEF_MANAGED;
 
336
        return EVENT_HANDLED;
337
337
    }
338
338
    // 6 clicks: lockout mode
339
339
    else if (event == EV_6clicks) {
340
340
        blink_confirm(2);
341
341
        set_state(lockout_state, 0);
342
 
        return MISCHIEF_MANAGED;
 
342
        return EVENT_HANDLED;
343
343
    }
344
344
    #ifdef USE_INDICATOR_LED
345
345
    // 7 clicks: next aux LED mode
357
357
        indicator_led_mode = (indicator_led_mode & 0b11111100) | mode;
358
358
        indicator_led(mode);
359
359
        save_config();
360
 
        return MISCHIEF_MANAGED;
 
360
        return EVENT_HANDLED;
361
361
    }
362
362
    #endif
363
363
    // 8 clicks: beacon mode
364
364
    else if (event == EV_8clicks) {
365
365
        set_state(beacon_state, 0);
366
 
        return MISCHIEF_MANAGED;
 
366
        return EVENT_HANDLED;
367
367
    }
368
368
    #ifdef USE_TENCLICK_THERMAL_CONFIG
369
369
    // 10 clicks: thermal config mode
370
370
    else if (event == EV_10clicks) {
371
371
        push_state(thermal_config_state, 0);
372
 
        return MISCHIEF_MANAGED;
 
372
        return EVENT_HANDLED;
373
373
    }
374
374
    #endif
375
375
    return EVENT_NOT_HANDLED;
407
407
        #ifdef USE_REVERSING
408
408
        ramp_direction = 1;
409
409
        #endif
410
 
        return MISCHIEF_MANAGED;
 
410
        return EVENT_HANDLED;
411
411
    }
412
412
    // 1 click: off
413
413
    else if (event == EV_1click) {
414
414
        set_state(off_state, 0);
415
 
        return MISCHIEF_MANAGED;
 
415
        return EVENT_HANDLED;
416
416
    }
417
417
    // 2 clicks: go to/from highest level
418
418
    else if (event == EV_2clicks) {
429
429
            #endif
430
430
            set_level(memorized_level);
431
431
        }
432
 
        return MISCHIEF_MANAGED;
 
432
        return EVENT_HANDLED;
433
433
    }
434
434
    // 3 clicks: toggle smooth vs discrete ramping
435
435
    else if (event == EV_3clicks) {
445
445
        set_level(0);
446
446
        delay_4ms(20/4);
447
447
        set_level(memorized_level);
448
 
        return MISCHIEF_MANAGED;
 
448
        return EVENT_HANDLED;
449
449
    }
450
450
    #ifdef USE_RAMP_CONFIG
451
451
    // 4 clicks: configure this ramp mode
452
452
    else if (event == EV_4clicks) {
453
453
        push_state(ramp_config_state, 0);
454
 
        return MISCHIEF_MANAGED;
 
454
        return EVENT_HANDLED;
455
455
    }
456
456
    #endif
457
457
    // hold: change brightness (brighter)
458
458
    else if (event == EV_click1_hold) {
459
459
        // ramp slower in discrete mode
460
460
        if (ramp_style  &&  (arg % HOLD_TIMEOUT != 0)) {
461
 
            return MISCHIEF_MANAGED;
 
461
            return EVENT_HANDLED;
462
462
        }
463
463
        #ifdef USE_REVERSING
464
464
        // make it ramp down instead, if already at max
510
510
        }
511
511
        #endif
512
512
        set_level(memorized_level);
513
 
        return MISCHIEF_MANAGED;
 
513
        return EVENT_HANDLED;
514
514
    }
515
515
    #if defined(USE_REVERSING)
516
516
    // reverse ramp direction on hold release
518
518
        #ifdef USE_REVERSING
519
519
        ramp_direction = -ramp_direction;
520
520
        #endif
521
 
        return MISCHIEF_MANAGED;
 
521
        return EVENT_HANDLED;
522
522
    }
523
523
    #endif
524
524
    // click, hold: change brightness (dimmer)
528
528
        #endif
529
529
        // ramp slower in discrete mode
530
530
        if (ramp_style  &&  (arg % HOLD_TIMEOUT != 0)) {
531
 
            return MISCHIEF_MANAGED;
 
531
            return EVENT_HANDLED;
532
532
        }
533
533
        // TODO? make it ramp up instead, if already at min?
534
534
        memorized_level = nearest_level((int16_t)actual_level - ramp_step_size);
569
569
        }
570
570
        #endif
571
571
        set_level(memorized_level);
572
 
        return MISCHIEF_MANAGED;
 
572
        return EVENT_HANDLED;
573
573
    }
574
574
    #if defined(USE_SET_LEVEL_GRADUALLY) || defined(USE_REVERSING)
575
575
    else if (event == EV_tick) {
580
580
        #ifdef USE_SET_LEVEL_GRADUALLY
581
581
        // make thermal adjustment speed scale with magnitude
582
582
        if ((arg & 1) && (actual_level < THERM_FASTER_LEVEL)) {
583
 
            return MISCHIEF_MANAGED;  // adjust slower when not a high mode
 
583
            return EVENT_HANDLED;  // adjust slower when not a high mode
584
584
        }
585
585
        #ifdef THERM_HARD_TURBO_DROP
586
586
        else if ((! (actual_level < THERM_FASTER_LEVEL))
622
622
        }
623
623
        #endif
624
624
        #endif
625
 
        return MISCHIEF_MANAGED;
 
625
        return EVENT_HANDLED;
626
626
    }
627
627
    #endif
628
628
    #ifdef USE_THERMAL_REGULATION
654
654
            set_level(stepdown);
655
655
            #endif
656
656
        }
657
 
        return MISCHIEF_MANAGED;
 
657
        return EVENT_HANDLED;
658
658
    }
659
659
    // underheating: increase slowly if we're lower than the target
660
660
    //               (proportional to how low we are)
676
676
            set_level(stepup);
677
677
            #endif
678
678
        }
679
 
        return MISCHIEF_MANAGED;
 
679
        return EVENT_HANDLED;
680
680
    }
681
681
    #endif
682
682
    return EVENT_NOT_HANDLED;
688
688
    // 1 click: off
689
689
    if (event == EV_1click) {
690
690
        set_state(off_state, 0);
691
 
        return MISCHIEF_MANAGED;
 
691
        return EVENT_HANDLED;
692
692
    }
693
693
    // 2 clicks: tempcheck mode
694
694
    else if (event == EV_2clicks) {
695
695
        set_state(tempcheck_state, 0);
696
 
        return MISCHIEF_MANAGED;
 
696
        return EVENT_HANDLED;
697
697
    }
698
698
    return EVENT_NOT_HANDLED;
699
699
}
705
705
    // 1 click: off
706
706
    if (event == EV_1click) {
707
707
        set_state(off_state, 0);
708
 
        return MISCHIEF_MANAGED;
 
708
        return EVENT_HANDLED;
709
709
    }
710
710
    // 4 clicks: thermal config mode
711
711
    else if (event == EV_4clicks) {
712
712
        push_state(thermal_config_state, 0);
713
 
        return MISCHIEF_MANAGED;
 
713
        return EVENT_HANDLED;
714
714
    }
715
715
    return EVENT_NOT_HANDLED;
716
716
}
722
722
    // 1 click: off
723
723
    if (event == EV_1click) {
724
724
        set_state(off_state, 0);
725
 
        return MISCHIEF_MANAGED;
 
725
        return EVENT_HANDLED;
726
726
    }
727
727
    // TODO: use sleep ticks to measure time between pulses,
728
728
    //       to save power
729
729
    // 4 clicks: beacon config mode
730
730
    else if (event == EV_4clicks) {
731
731
        push_state(beacon_config_state, 0);
732
 
        return MISCHIEF_MANAGED;
 
732
        return EVENT_HANDLED;
733
733
    }
734
734
    return EVENT_NOT_HANDLED;
735
735
}
781
781
            indicator_led(indicator_led_mode >> 2);
782
782
            #endif
783
783
        }
784
 
        return MISCHIEF_MANAGED;
 
784
        return EVENT_HANDLED;
785
785
    }
786
786
    #if defined(TICK_DURING_STANDBY) && defined(USE_INDICATOR_LED)
787
787
    else if (event == EV_sleep_tick) {
788
788
        if ((indicator_led_mode & 0b00001100) == 0b00001100) {
789
789
            indicator_blink(arg);
790
790
        }
791
 
        return MISCHIEF_MANAGED;
 
791
        return EVENT_HANDLED;
792
792
    }
793
793
    #endif
794
794
    #ifdef USE_INDICATOR_LED
806
806
        indicator_led_mode = (mode << 2) + (indicator_led_mode & 0x03);
807
807
        indicator_led(mode);
808
808
        save_config();
809
 
        return MISCHIEF_MANAGED;
 
809
        return EVENT_HANDLED;
810
810
    }
811
811
    #endif
812
812
    // 6 clicks: exit
813
813
    else if (event == EV_6clicks) {
814
814
        blink_confirm(1);
815
815
        set_state(off_state, 0);
816
 
        return MISCHIEF_MANAGED;
 
816
        return EVENT_HANDLED;
817
817
    }
818
818
 
819
819
    return EVENT_NOT_HANDLED;
827
827
    // button is being held
828
828
    if ((event & (B_CLICK | B_PRESS)) == (B_CLICK | B_PRESS)) {
829
829
        set_level(memorized_level);
830
 
        return MISCHIEF_MANAGED;
 
830
        return EVENT_HANDLED;
831
831
    }
832
832
    // button was released
833
833
    else if ((event & (B_CLICK | B_PRESS)) == (B_CLICK)) {
834
834
        set_level(0);
835
835
        //go_to_standby = 1;  // sleep while light is off
836
 
        return MISCHIEF_MANAGED;
 
836
        return EVENT_HANDLED;
837
837
    }
838
838
 
839
839
    // Sleep, dammit!  (but wait a few seconds first)
846
846
            go_to_standby = 1;  // sleep while light is off
847
847
            // TODO: lighted button should use lockout config?
848
848
        }
849
 
        return MISCHIEF_MANAGED;
 
849
        return EVENT_HANDLED;
850
850
    }
851
851
 
852
852
    return EVENT_NOT_HANDLED;
861
861
    if (event == EV_enter_state) {
862
862
        config_step = 0;
863
863
        set_level(0);
864
 
        return MISCHIEF_MANAGED;
 
864
        return EVENT_HANDLED;
865
865
    }
866
866
    // advance forward through config steps
867
867
    else if (event == EV_tick) {
875
875
            //set_state(retstate, retval);
876
876
            pop_state();
877
877
        }
878
 
        return MISCHIEF_MANAGED;
 
878
        return EVENT_HANDLED;
879
879
    }
880
880
    // an option was set (return from number_entry_state)
881
881
    else if (event == EV_reenter_state) {
882
882
        config_state_values[config_step] = number_entry_value;
883
883
        config_step ++;
884
 
        return MISCHIEF_MANAGED;
 
884
        return EVENT_HANDLED;
885
885
    }
886
886
    //return EVENT_NOT_HANDLED;
887
887
    // eat all other events; don't pass any through to parent
985
985
        blinks_left = arg;
986
986
        entry_step = 0;
987
987
        wait_ticks = 0;
988
 
        return MISCHIEF_MANAGED;
 
988
        return EVENT_HANDLED;
989
989
    }
990
990
    // advance through the process:
991
991
    // 0: wait a moment
1042
1042
            number_entry_value = value;
1043
1043
            pop_state();
1044
1044
        }
1045
 
        return MISCHIEF_MANAGED;
 
1045
        return EVENT_HANDLED;
1046
1046
    }
1047
1047
    // count clicks
1048
1048
    else if (event == EV_click1_release) {
1055
1055
            delay_4ms(8/2);
1056
1056
            set_level(0);
1057
1057
        }
1058
 
        return MISCHIEF_MANAGED;
 
1058
        return EVENT_HANDLED;
1059
1059
    }
1060
1060
    return EVENT_NOT_HANDLED;
1061
1061
}
1106
1106
#if defined(USE_INDICATOR_LED) && defined(TICK_DURING_STANDBY)
1107
1107
// beacon-like mode for the indicator LED
1108
1108
void indicator_blink(uint8_t arg) {
 
1109
    #define USE_FANCIER_BLINKING_INDICATOR
1109
1110
    #ifdef USE_FANCIER_BLINKING_INDICATOR
1110
1111
 
1111
1112
    // fancy blink, set off/low/high levels here: