← Back to branch summary

~toykeeper/flashlight-firmware/fsm

« back to all changes in this revision

Viewing changes to ToyKeeper/spaghetti-monster/fireflies-ui/fireflies-ui.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/fireflies-ui/fireflies-ui.c
460
460
        #endif
461
461
        // sleep while off  (lower power use)
462
462
        go_to_standby = 1;
463
 
        return MISCHIEF_MANAGED;
 
463
        return EVENT_HANDLED;
464
464
    }
465
465
    // go back to sleep eventually if we got bumped but didn't leave "off" state
466
466
    else if (event == EV_tick) {
470
470
            indicator_led(indicator_led_mode & 0x03);
471
471
            #endif
472
472
        }
473
 
        return MISCHIEF_MANAGED;
 
473
        return EVENT_HANDLED;
474
474
    }
475
475
    #if defined(TICK_DURING_STANDBY) && defined(USE_INDICATOR_LED)
476
476
    // blink the indicator LED, maybe
478
478
        if ((indicator_led_mode & 0b00000011) == 0b00000011) {
479
479
            indicator_blink(arg);
480
480
        }
481
 
        return MISCHIEF_MANAGED;
 
481
        return EVENT_HANDLED;
482
482
    }
483
483
    #endif
484
484
    // hold (initially): go to lowest level (floor), but allow abort for regular click
485
485
    else if (event == EV_click1_press) {
486
486
        set_level(nearest_level(1));
487
 
        return MISCHIEF_MANAGED;
 
487
        return EVENT_HANDLED;
488
488
    }
489
489
    // hold: go to lowest level
490
490
    else if (event == EV_click1_hold) {
500
500
        if (arg >= (!ramp_style) * HOLD_TIMEOUT) {  // more consistent
501
501
            set_state(steady_state, 1);
502
502
        }
503
 
        return MISCHIEF_MANAGED;
 
503
        return EVENT_HANDLED;
504
504
    }
505
505
    // hold, release quickly: go to lowest level (floor)
506
506
    else if (event == EV_click1_hold_release) {
507
507
        set_state(steady_state, 1);
508
 
        return MISCHIEF_MANAGED;
 
508
        return EVENT_HANDLED;
509
509
    }
510
510
    // 1 click (before timeout): go to memorized level, but allow abort for double click
511
511
    else if (event == EV_click1_release) {
512
512
        set_level(nearest_level(memorized_level));
513
 
        return MISCHIEF_MANAGED;
 
513
        return EVENT_HANDLED;
514
514
    }
515
515
    // 1 click: regular mode
516
516
    else if (event == EV_1click) {
517
517
        set_state(steady_state, memorized_level);
518
 
        return MISCHIEF_MANAGED;
 
518
        return EVENT_HANDLED;
519
519
    }
520
520
    // click, hold: go to highest level (ceiling) (for ramping down)
521
521
    else if (event == EV_click2_hold) {
522
522
        set_state(steady_state, MAX_LEVEL);
523
 
        return MISCHIEF_MANAGED;
 
523
        return EVENT_HANDLED;
524
524
    }
525
525
    // 2 clicks: highest mode (ceiling)
526
526
    else if (event == EV_2clicks) {
527
527
        set_state(steady_state, MAX_LEVEL);
528
 
        return MISCHIEF_MANAGED;
 
528
        return EVENT_HANDLED;
529
529
    }
530
530
    // 3 clicks (initial press): off, to prep for later events
531
531
    else if (event == EV_click3_press) {
532
532
        set_level(0);
533
 
        return MISCHIEF_MANAGED;
 
533
        return EVENT_HANDLED;
534
534
    }
535
535
    #ifdef USE_BATTCHECK
536
536
    // 3 clicks: battcheck mode / blinky mode group 1
537
537
    else if (event == EV_3clicks) {
538
538
        set_state(battcheck_state, 0);
539
 
        return MISCHIEF_MANAGED;
 
539
        return EVENT_HANDLED;
540
540
    }
541
541
    #endif
542
542
    // click, click, long-click: strobe mode
543
543
    #ifdef USE_STROBE_STATE
544
544
    else if (event == EV_click3_hold) {
545
545
        set_state(strobe_state, 0);
546
 
        return MISCHIEF_MANAGED;
 
546
        return EVENT_HANDLED;
547
547
    }
548
548
    #elif defined(USE_BORING_STROBE_STATE)
549
549
    else if (event == EV_click3_hold) {
550
550
        set_state(boring_strobe_state, 0);
551
 
        return MISCHIEF_MANAGED;
 
551
        return EVENT_HANDLED;
552
552
    }
553
553
    #endif
554
554
    // 4 clicks: soft lockout
555
555
    else if (event == EV_4clicks) {
556
556
        blink_confirm(2);
557
557
        set_state(lockout_state, 0);
558
 
        return MISCHIEF_MANAGED;
 
558
        return EVENT_HANDLED;
559
559
    }
560
560
    // 5 clicks: momentary mode
561
561
    else if (event == EV_5clicks) {
562
562
        blink_confirm(1);
563
563
        set_state(momentary_state, 0);
564
 
        return MISCHIEF_MANAGED;
 
564
        return EVENT_HANDLED;
565
565
    }
566
566
    #ifdef USE_MUGGLE_MODE
567
567
    // 6 clicks: muggle mode
568
568
    else if (event == EV_6clicks) {
569
569
        blink_confirm(1);
570
570
        set_state(muggle_state, 0);
571
 
        return MISCHIEF_MANAGED;
 
571
        return EVENT_HANDLED;
572
572
    }
573
573
    #endif
574
574
    #ifdef USE_INDICATOR_LED
586
586
        indicator_led_mode = (indicator_led_mode & 0b11111100) | mode;
587
587
        indicator_led(mode);
588
588
        save_config();
589
 
        return MISCHIEF_MANAGED;
 
589
        return EVENT_HANDLED;
590
590
    }
591
591
    #endif
592
592
    // 8 clicks: temperature check
593
593
    else if (event == EV_8clicks) {
594
594
        set_state(tempcheck_state, 0);
595
 
        return MISCHIEF_MANAGED;
 
595
        return EVENT_HANDLED;
596
596
    }
597
597
    #ifdef USE_TENCLICK_THERMAL_CONFIG
598
598
    // 10 clicks: thermal config mode
599
599
    else if (event == EV_10clicks) {
600
600
        push_state(thermal_config_state, 0);
601
 
        return MISCHIEF_MANAGED;
 
601
        return EVENT_HANDLED;
602
602
    }
603
603
    #endif
604
604
    return EVENT_NOT_HANDLED;
637
637
        #ifdef USE_REVERSING
638
638
        ramp_direction = 1;
639
639
        #endif
640
 
        return MISCHIEF_MANAGED;
 
640
        return EVENT_HANDLED;
641
641
    }
642
642
    // 1 click: off
643
643
    else if (event == EV_1click) {
644
644
        set_state(off_state, 0);
645
 
        return MISCHIEF_MANAGED;
 
645
        return EVENT_HANDLED;
646
646
    }
647
647
    // 2 clicks: go to/from highest level
648
648
    else if (event == EV_2clicks) {
659
659
            #endif
660
660
            set_level(memorized_level);
661
661
        }
662
 
        return MISCHIEF_MANAGED;
 
662
        return EVENT_HANDLED;
663
663
    }
664
664
    // 3 clicks: toggle smooth vs discrete ramping
665
665
    else if (event == EV_3clicks) {
677
677
        #endif
678
678
        blip();
679
679
        set_level(memorized_level);
680
 
        return MISCHIEF_MANAGED;
 
680
        return EVENT_HANDLED;
681
681
    }
682
682
    #ifdef USE_RAMP_CONFIG
683
683
    // 4 clicks: configure this ramp mode
684
684
    else if (event == EV_4clicks) {
685
685
        push_state(ramp_config_state, 0);
686
 
        return MISCHIEF_MANAGED;
 
686
        return EVENT_HANDLED;
687
687
    }
688
688
    #endif
689
689
    // hold: change brightness (brighter)
690
690
    else if (event == EV_click1_hold) {
691
691
        // ramp slower in discrete mode
692
692
        if (ramp_style  &&  (arg % HOLD_TIMEOUT != 0)) {
693
 
            return MISCHIEF_MANAGED;
 
693
            return EVENT_HANDLED;
694
694
        }
695
695
        #ifdef USE_REVERSING
696
696
        // fix ramp direction on first frame if necessary
744
744
        }
745
745
        #endif
746
746
        set_level(memorized_level);
747
 
        return MISCHIEF_MANAGED;
 
747
        return EVENT_HANDLED;
748
748
    }
749
749
    #if defined(USE_REVERSING) || defined(START_AT_MEMORIZED_LEVEL)
750
750
    // reverse ramp direction on hold release
755
755
        #ifdef START_AT_MEMORIZED_LEVEL
756
756
        save_config_wl();
757
757
        #endif
758
 
        return MISCHIEF_MANAGED;
 
758
        return EVENT_HANDLED;
759
759
    }
760
760
    #endif
761
761
    // click, hold: change brightness (dimmer)
765
765
        #endif
766
766
        // ramp slower in discrete mode
767
767
        if (ramp_style  &&  (arg % HOLD_TIMEOUT != 0)) {
768
 
            return MISCHIEF_MANAGED;
 
768
            return EVENT_HANDLED;
769
769
        }
770
770
        // TODO? make it ramp up instead, if already at min?
771
771
        memorized_level = nearest_level((int16_t)actual_level - ramp_step_size);
804
804
        }
805
805
        #endif
806
806
        set_level(memorized_level);
807
 
        return MISCHIEF_MANAGED;
 
807
        return EVENT_HANDLED;
808
808
    }
809
809
    #ifdef START_AT_MEMORIZED_LEVEL
810
810
    // click, release, hold, release: save new ramp level (if necessary)
811
811
    else if (event == EV_click2_hold_release) {
812
812
        save_config_wl();
813
 
        return MISCHIEF_MANAGED;
 
813
        return EVENT_HANDLED;
814
814
    }
815
815
    #endif
816
816
    #if defined(USE_SET_LEVEL_GRADUALLY) || defined(USE_REVERSING)
822
822
        #ifdef USE_SET_LEVEL_GRADUALLY
823
823
        // make thermal adjustment speed scale with magnitude
824
824
        if ((arg & 1) && (actual_level < THERM_FASTER_LEVEL)) {
825
 
            return MISCHIEF_MANAGED;  // adjust slower when not a high mode
 
825
            return EVENT_HANDLED;  // adjust slower when not a high mode
826
826
        }
827
827
        #ifdef THERM_HARD_TURBO_DROP
828
828
        else if ((! (actual_level < THERM_FASTER_LEVEL))
864
864
        }
865
865
        #endif
866
866
        #endif
867
 
        return MISCHIEF_MANAGED;
 
867
        return EVENT_HANDLED;
868
868
    }
869
869
    #endif
870
870
    #ifdef USE_THERMAL_REGULATION
893
893
            set_level(stepdown);
894
894
            #endif
895
895
        }
896
 
        return MISCHIEF_MANAGED;
 
896
        return EVENT_HANDLED;
897
897
    }
898
898
    // underheating: increase slowly if we're lower than the target
899
899
    //               (proportional to how low we are)
912
912
            set_level(stepup);
913
913
            #endif
914
914
        }
915
 
        return MISCHIEF_MANAGED;
 
915
        return EVENT_HANDLED;
916
916
    }
917
917
    #endif
918
918
    return EVENT_NOT_HANDLED;
1004
1004
    // init anything which needs to be initialized
1005
1005
    else if (event == EV_enter_state) {
1006
1006
        ramp_direction = 1;
1007
 
        return MISCHIEF_MANAGED;
 
1007
        return EVENT_HANDLED;
1008
1008
    }
1009
1009
    // 1 click: off
1010
1010
    else if (event == EV_1click) {
1011
1011
        set_state(off_state, 0);
1012
 
        return MISCHIEF_MANAGED;
 
1012
        return EVENT_HANDLED;
1013
1013
    }
1014
1014
    // 2 clicks: rotate through strobe/flasher modes
1015
1015
    else if (event == EV_2clicks) {
1016
1016
        strobe_type = (st + 1) % NUM_STROBES;
1017
1017
        save_config();
1018
 
        return MISCHIEF_MANAGED;
 
1018
        return EVENT_HANDLED;
1019
1019
    }
1020
1020
    // hold: change speed (go faster)
1021
1021
    //       or change brightness (brighter)
1052
1052
        }
1053
1053
        #endif
1054
1054
 
1055
 
        return MISCHIEF_MANAGED;
 
1055
        return EVENT_HANDLED;
1056
1056
    }
1057
1057
    // reverse ramp direction on hold release
1058
1058
    // ... and save new strobe settings
1059
1059
    else if (event == EV_click1_hold_release) {
1060
1060
        ramp_direction = -ramp_direction;
1061
1061
        save_config();
1062
 
        return MISCHIEF_MANAGED;
 
1062
        return EVENT_HANDLED;
1063
1063
    }
1064
1064
    // click, hold: change speed (go slower)
1065
1065
    //       or change brightness (dimmer)
1093
1093
        }
1094
1094
        #endif
1095
1095
 
1096
 
        return MISCHIEF_MANAGED;
 
1096
        return EVENT_HANDLED;
1097
1097
    }
1098
1098
    // release hold: save new strobe settings
1099
1099
    else if (event == EV_click2_hold_release) {
1100
1100
        save_config();
1101
 
        return MISCHIEF_MANAGED;
 
1101
        return EVENT_HANDLED;
1102
1102
    }
1103
1103
    #if defined(USE_LIGHTNING_MODE) || defined(USE_CANDLE_MODE)
1104
1104
    // clock tick: bump the random seed
1107
1107
        if (arg == TICKS_PER_SECOND) ramp_direction = 1;
1108
1108
 
1109
1109
        pseudo_rand_seed += arg;
1110
 
        return MISCHIEF_MANAGED;
 
1110
        return EVENT_HANDLED;
1111
1111
    }
1112
1112
    #endif
1113
1113
    return EVENT_NOT_HANDLED;
1223
1223
    if (event == EV_enter_state) {
1224
1224
        candle_mode_timer = 0;  // in case any time was left over from earlier
1225
1225
        ramp_direction = 1;
1226
 
        return MISCHIEF_MANAGED;
 
1226
        return EVENT_HANDLED;
1227
1227
    }
1228
1228
    // 2 clicks: cancel timer
1229
1229
    else if (event == EV_2clicks) {
1230
1230
        // parent state just rotated through strobe/flasher modes,
1231
1231
        // so cancel timer...  in case any time was left over from earlier
1232
1232
        candle_mode_timer = 0;
1233
 
        return MISCHIEF_MANAGED;
 
1233
        return EVENT_HANDLED;
1234
1234
    }
1235
1235
    // hold: change brightness (brighter)
1236
1236
    else if (event == EV_click1_hold) {
1243
1243
        candle_mode_brightness += ramp_direction;
1244
1244
        if (candle_mode_brightness < 1) candle_mode_brightness = 1;
1245
1245
        else if (candle_mode_brightness > MAX_CANDLE_LEVEL) candle_mode_brightness = MAX_CANDLE_LEVEL;
1246
 
        return MISCHIEF_MANAGED;
 
1246
        return EVENT_HANDLED;
1247
1247
    }
1248
1248
    // reverse ramp direction on hold release
1249
1249
    else if (event == EV_click1_hold_release) {
1250
1250
        ramp_direction = -ramp_direction;
1251
 
        return MISCHIEF_MANAGED;
 
1251
        return EVENT_HANDLED;
1252
1252
    }
1253
1253
    // click, hold: change brightness (dimmer)
1254
1254
    else if (event == EV_click2_hold) {
1255
1255
        ramp_direction = 1;
1256
1256
        if (candle_mode_brightness > 1)
1257
1257
            candle_mode_brightness --;
1258
 
        return MISCHIEF_MANAGED;
 
1258
        return EVENT_HANDLED;
1259
1259
    }
1260
1260
    // 3 clicks: add 30m to candle timer
1261
1261
    else if (event == EV_3clicks) {
1266
1266
            set_level(actual_level + 32);
1267
1267
            delay_4ms(2);
1268
1268
        }
1269
 
        return MISCHIEF_MANAGED;
 
1269
        return EVENT_HANDLED;
1270
1270
    }
1271
1271
    // clock tick: animate candle brightness
1272
1272
    else if (event == EV_tick) {
1328
1328
            // random amplitude
1329
1329
            //candle_wave3_depth = 2 + (pseudo_rand() % ((CANDLE_WAVE3_MAXDEPTH * CANDLE_AMPLITUDE / 100) - 2));
1330
1330
            candle_wave3_depth = pseudo_rand() % (CANDLE_WAVE3_MAXDEPTH * CANDLE_AMPLITUDE / 100);
1331
 
        return MISCHIEF_MANAGED;
 
1331
        return EVENT_HANDLED;
1332
1332
    }
1333
1333
    return EVENT_NOT_HANDLED;
1334
1334
}
1345
1345
    momentary_mode = 1;  // 0 = ramping, 1 = strobes
1346
1346
 
1347
1347
    if (event == EV_enter_state) {
1348
 
        return MISCHIEF_MANAGED;
 
1348
        return EVENT_HANDLED;
1349
1349
    }
1350
1350
    // 1 click: off
1351
1351
    else if (event == EV_1click) {
1352
1352
        // reset to police strobe for next time
1353
1353
        boring_strobe_type = 0;
1354
1354
        set_state(off_state, 0);
1355
 
        return MISCHIEF_MANAGED;
 
1355
        return EVENT_HANDLED;
1356
1356
    }
1357
1357
    // 2 clicks: rotate through strobe/flasher modes
1358
1358
    else if (event == EV_2clicks) {
1359
1359
        boring_strobe_type = (st + 1) % NUM_BORING_STROBES;
1360
 
        return MISCHIEF_MANAGED;
 
1360
        return EVENT_HANDLED;
1361
1361
    }
1362
1362
    return EVENT_NOT_HANDLED;
1363
1363
}
1411
1411
    // 1 click: off
1412
1412
    if (event == EV_1click) {
1413
1413
        set_state(off_state, 0);
1414
 
        return MISCHIEF_MANAGED;
 
1414
        return EVENT_HANDLED;
1415
1415
    }
1416
1416
    #if defined(USE_GOODNIGHT_MODE) || defined(USE_BEACON_MODE)
1417
1417
    // 2 clicks: next mode
1421
1421
        #elif defined(USE_BEACON_MODE)
1422
1422
        set_state(beacon_state, 0);
1423
1423
        #endif
1424
 
        return MISCHIEF_MANAGED;
 
1424
        return EVENT_HANDLED;
1425
1425
    }
1426
1426
    #endif
1427
1427
    return EVENT_NOT_HANDLED;
1434
1434
    // 1 click: off
1435
1435
    if (event == EV_1click) {
1436
1436
        set_state(off_state, 0);
1437
 
        return MISCHIEF_MANAGED;
 
1437
        return EVENT_HANDLED;
1438
1438
    }
1439
1439
    #if 0  // not part of a loop in this UI
1440
1440
    // 2 clicks: battcheck mode
1441
1441
    else if (event == EV_2clicks) {
1442
1442
        set_state(battcheck_state, 0);
1443
 
        return MISCHIEF_MANAGED;
 
1443
        return EVENT_HANDLED;
1444
1444
    }
1445
1445
    #endif
1446
1446
    // 4 clicks: thermal config mode
1447
1447
    else if (event == EV_4clicks) {
1448
1448
        push_state(thermal_config_state, 0);
1449
 
        return MISCHIEF_MANAGED;
 
1449
        return EVENT_HANDLED;
1450
1450
    }
1451
1451
    return EVENT_NOT_HANDLED;
1452
1452
}
1458
1458
    // 1 click: off
1459
1459
    if (event == EV_1click) {
1460
1460
        set_state(off_state, 0);
1461
 
        return MISCHIEF_MANAGED;
 
1461
        return EVENT_HANDLED;
1462
1462
    }
1463
1463
    // TODO: use sleep ticks to measure time between pulses,
1464
1464
    //       to save power
1469
1469
        #else
1470
1470
        set_state(battcheck_state, 0);
1471
1471
        #endif
1472
 
        return MISCHIEF_MANAGED;
 
1472
        return EVENT_HANDLED;
1473
1473
    }
1474
1474
    // 4 clicks: beacon config mode
1475
1475
    else if (event == EV_4clicks) {
1476
1476
        push_state(beacon_config_state, 0);
1477
 
        return MISCHIEF_MANAGED;
 
1477
        return EVENT_HANDLED;
1478
1478
    }
1479
1479
    return EVENT_NOT_HANDLED;
1480
1480
}
1490
1490
        ticks_since_stepdown = 0;
1491
1491
        blink_confirm(2);
1492
1492
        set_level(GOODNIGHT_LEVEL);
1493
 
        return MISCHIEF_MANAGED;
 
1493
        return EVENT_HANDLED;
1494
1494
    }
1495
1495
    // 1 click: off
1496
1496
    else if (event == EV_1click) {
1497
1497
        set_state(off_state, 0);
1498
 
        return MISCHIEF_MANAGED;
 
1498
        return EVENT_HANDLED;
1499
1499
    }
1500
1500
    // 2 clicks: beacon mode
1501
1501
    else if (event == EV_2clicks) {
1504
1504
        #elif defined(USE_TEMPCHECK_MODE)
1505
1505
        set_state(tempcheck_state, 0);
1506
1506
        #endif
1507
 
        return MISCHIEF_MANAGED;
 
1507
        return EVENT_HANDLED;
1508
1508
    }
1509
1509
    // tick: step down (maybe) or off (maybe)
1510
1510
    else if (event == EV_tick) {
1520
1520
                set_state(off_state, 0);
1521
1521
            }
1522
1522
        }
1523
 
        return MISCHIEF_MANAGED;
 
1523
        return EVENT_HANDLED;
1524
1524
    }
1525
1525
    return EVENT_NOT_HANDLED;
1526
1526
}
1572
1572
            indicator_led(indicator_led_mode >> 2);
1573
1573
            #endif
1574
1574
        }
1575
 
        return MISCHIEF_MANAGED;
 
1575
        return EVENT_HANDLED;
1576
1576
    }
1577
1577
    #if defined(TICK_DURING_STANDBY) && defined(USE_INDICATOR_LED)
1578
1578
    else if (event == EV_sleep_tick) {
1579
1579
        if ((indicator_led_mode & 0b00001100) == 0b00001100) {
1580
1580
            indicator_blink(arg);
1581
1581
        }
1582
 
        return MISCHIEF_MANAGED;
 
1582
        return EVENT_HANDLED;
1583
1583
    }
1584
1584
    #endif
1585
1585
    #ifdef USE_INDICATOR_LED
1597
1597
        indicator_led_mode = (mode << 2) + (indicator_led_mode & 0x03);
1598
1598
        indicator_led(mode);
1599
1599
        save_config();
1600
 
        return MISCHIEF_MANAGED;
 
1600
        return EVENT_HANDLED;
1601
1601
    }
1602
1602
    #if 0  // old method, deprecated in favor of "7 clicks from off"
1603
1603
    // click, click, hold: rotate through indicator LED modes (off mode)
1624
1624
        indicator_led(mode);
1625
1625
        #endif
1626
1626
        //save_config();
1627
 
        return MISCHIEF_MANAGED;
 
1627
        return EVENT_HANDLED;
1628
1628
    }
1629
1629
    // click, click, hold, release: save indicator LED mode (off mode)
1630
1630
    else if (event == EV_click3_hold_release) {
1631
1631
        save_config();
1632
 
        return MISCHIEF_MANAGED;
 
1632
        return EVENT_HANDLED;
1633
1633
    }
1634
1634
    #endif
1635
1635
    #endif
1637
1637
    else if (event == EV_4clicks) {
1638
1638
        blink_confirm(1);
1639
1639
        set_state(off_state, 0);
1640
 
        return MISCHIEF_MANAGED;
 
1640
        return EVENT_HANDLED;
1641
1641
    }
1642
1642
 
1643
1643
    return EVENT_NOT_HANDLED;
1660
1660
        if (momentary_mode == 0) {
1661
1661
            set_level(memorized_level);
1662
1662
        }
1663
 
        return MISCHIEF_MANAGED;
 
1663
        return EVENT_HANDLED;
1664
1664
    }
1665
1665
    // button was released
1666
1666
    else if ((event & (B_CLICK | B_PRESS)) == (B_CLICK)) {
1667
1667
        momentary_active = 0;
1668
1668
        set_level(0);
1669
1669
        //go_to_standby = 1;  // sleep while light is off
1670
 
        return MISCHIEF_MANAGED;
 
1670
        return EVENT_HANDLED;
1671
1671
    }
1672
1672
 
1673
1673
    // Sleep, dammit!  (but wait a few seconds first)
1688
1688
                // TODO: lighted button should use lockout config?
1689
1689
            }
1690
1690
        }
1691
 
        return MISCHIEF_MANAGED;
 
1691
        return EVENT_HANDLED;
1692
1692
    }
1693
1693
 
1694
1694
    return EVENT_NOT_HANDLED;
1721
1721
            //memorized_level = MAX_1x7135;
1722
1722
            memorized_level = (MUGGLE_FLOOR + MUGGLE_CEILING) / 2;
1723
1723
        #endif
1724
 
        return MISCHIEF_MANAGED;
 
1724
        return EVENT_HANDLED;
1725
1725
    }
1726
1726
    // initial press: moon hint
1727
1727
    else if (event == EV_click1_press) {
1749
1749
            set_level(memorized_level);
1750
1750
        }
1751
1751
        */
1752
 
        return MISCHIEF_MANAGED;
 
1752
        return EVENT_HANDLED;
1753
1753
    }
1754
1754
    // hold: change brightness
1755
1755
    else if (event == EV_click1_hold) {
1756
1756
        // ramp at half speed
1757
 
        if (arg & 1) return MISCHIEF_MANAGED;
 
1757
        if (arg & 1) return EVENT_HANDLED;
1758
1758
 
1759
1759
        // if off, start at bottom
1760
1760
        if (muggle_off_mode) {
1776
1776
            memorized_level = m;
1777
1777
            set_level(m);
1778
1778
        }
1779
 
        return MISCHIEF_MANAGED;
 
1779
        return EVENT_HANDLED;
1780
1780
    }
1781
1781
    // reverse ramp direction on hold release
1782
1782
    else if (event == EV_click1_hold_release) {
1784
1784
        #ifdef START_AT_MEMORIZED_LEVEL
1785
1785
        save_config_wl();  // momentary use should retain brightness level
1786
1786
        #endif
1787
 
        return MISCHIEF_MANAGED;
 
1787
        return EVENT_HANDLED;
1788
1788
    }
1789
1789
    /*
1790
1790
    // click, hold: change brightness (dimmer)
1793
1793
        if (memorized_level > MUGGLE_FLOOR)
1794
1794
            memorized_level = actual_level - 1;
1795
1795
        set_level(memorized_level);
1796
 
        return MISCHIEF_MANAGED;
 
1796
        return EVENT_HANDLED;
1797
1797
    }
1798
1798
    */
1799
1799
    // 6 clicks: exit muggle mode
1802
1802
        muggle_mode_active = 0;
1803
1803
        save_config();
1804
1804
        set_state(off_state, 0);
1805
 
        return MISCHIEF_MANAGED;
 
1805
        return EVENT_HANDLED;
1806
1806
    }
1807
1807
    // tick: housekeeping
1808
1808
    else if (event == EV_tick) {
1815
1815
                go_to_standby = 1;  // sleep while light is off
1816
1816
            }
1817
1817
        }
1818
 
        return MISCHIEF_MANAGED;
 
1818
        return EVENT_HANDLED;
1819
1819
    }
1820
1820
    #ifdef USE_THERMAL_REGULATION
1821
1821
    // overheating is handled specially in muggle mode
1827
1827
        uint8_t new = actual_level - arg;
1828
1828
        if (new < MUGGLE_FLOOR) { new = MUGGLE_FLOOR; }
1829
1829
        set_level(new);
1830
 
        return MISCHIEF_MANAGED;
 
1830
        return EVENT_HANDLED;
1831
1831
    }
1832
1832
    #endif
1833
1833
    // low voltage is handled specially in muggle mode
1838
1838
        } else {
1839
1839
            muggle_off_mode = 1;
1840
1840
        }
1841
 
        return MISCHIEF_MANAGED;
 
1841
        return EVENT_HANDLED;
1842
1842
    }
1843
1843
 
1844
1844
    return EVENT_NOT_HANDLED;
1854
1854
    if (event == EV_enter_state) {
1855
1855
        config_step = 0;
1856
1856
        set_level(0);
1857
 
        return MISCHIEF_MANAGED;
 
1857
        return EVENT_HANDLED;
1858
1858
    }
1859
1859
    // advance forward through config steps
1860
1860
    else if (event == EV_tick) {
1868
1868
            //set_state(retstate, retval);
1869
1869
            pop_state();
1870
1870
        }
1871
 
        return MISCHIEF_MANAGED;
 
1871
        return EVENT_HANDLED;
1872
1872
    }
1873
1873
    // an option was set (return from number_entry_state)
1874
1874
    else if (event == EV_reenter_state) {
1875
1875
        config_state_values[config_step] = number_entry_value;
1876
1876
        config_step ++;
1877
 
        return MISCHIEF_MANAGED;
 
1877
        return EVENT_HANDLED;
1878
1878
    }
1879
1879
    //return EVENT_NOT_HANDLED;
1880
1880
    // eat all other events; don't pass any through to parent
1978
1978
        blinks_left = arg;
1979
1979
        entry_step = 0;
1980
1980
        wait_ticks = 0;
1981
 
        return MISCHIEF_MANAGED;
 
1981
        return EVENT_HANDLED;
1982
1982
    }
1983
1983
    // advance through the process:
1984
1984
    // 0: wait a moment
2035
2035
            number_entry_value = value;
2036
2036
            pop_state();
2037
2037
        }
2038
 
        return MISCHIEF_MANAGED;
 
2038
        return EVENT_HANDLED;
2039
2039
    }
2040
2040
    // count clicks
2041
2041
    else if (event == EV_click1_release) {
2048
2048
            delay_4ms(8/2);
2049
2049
            set_level(0);
2050
2050
        }
2051
 
        return MISCHIEF_MANAGED;
 
2051
        return EVENT_HANDLED;
2052
2052
    }
2053
2053
    return EVENT_NOT_HANDLED;
2054
2054
}
2107
2107
#if defined(USE_INDICATOR_LED) && defined(TICK_DURING_STANDBY)
2108
2108
// beacon-like mode for the indicator LED
2109
2109
void indicator_blink(uint8_t arg) {
 
2110
    #define USE_FANCIER_BLINKING_INDICATOR
2110
2111
    #ifdef USE_FANCIER_BLINKING_INDICATOR
2111
2112
 
2112
2113
    // fancy blink, set off/low/high levels here: