← Back to branch summary

~toykeeper/flashlight-firmware/fsm

« back to all changes in this revision

Viewing changes to ToyKeeper/spaghetti-monster/werner/werner.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/werner/werner.c
152
152
        set_level(0);
153
153
        // sleep while off  (lower power use)
154
154
        go_to_standby = 1;
155
 
        return MISCHIEF_MANAGED;
 
155
        return EVENT_HANDLED;
156
156
    }
157
157
    // go back to sleep eventually if we got bumped but didn't leave "off" state
158
158
    else if (event == EV_tick) {
159
159
        if (arg > TICKS_PER_SECOND*2) {
160
160
            go_to_standby = 1;
161
161
        }
162
 
        return MISCHIEF_MANAGED;
 
162
        return EVENT_HANDLED;
163
163
    }
164
164
    // hold (initially): go to lowest level, but allow abort for regular click
165
165
    else if (event == EV_click1_press) {
166
166
        set_level(nearest_level(1));
167
 
        return MISCHIEF_MANAGED;
 
167
        return EVENT_HANDLED;
168
168
    }
169
169
    // hold: go to lowest level
170
170
    else if (event == EV_click1_hold) {
173
173
        if (arg >= HOLD_TIMEOUT) {
174
174
            set_state(steady_state, 1);
175
175
        }
176
 
        return MISCHIEF_MANAGED;
 
176
        return EVENT_HANDLED;
177
177
    }
178
178
    // hold, release quickly: go to lowest level
179
179
    else if (event == EV_click1_hold_release) {
180
180
        set_state(steady_state, 1);
181
 
        return MISCHIEF_MANAGED;
 
181
        return EVENT_HANDLED;
182
182
    }
183
183
    // 1 click (before timeout): go to memorized level, but allow abort for double click
184
184
    else if (event == EV_click1_release) {
185
185
        set_level(nearest_level(memorized_level));
186
 
        return MISCHIEF_MANAGED;
 
186
        return EVENT_HANDLED;
187
187
    }
188
188
    // 1 click: regular mode
189
189
    else if (event == EV_1click) {
190
190
        set_state(steady_state, memorized_level);
191
 
        return MISCHIEF_MANAGED;
 
191
        return EVENT_HANDLED;
192
192
    }
193
193
    // 2 clicks (initial press): off, to prep for later events
194
194
    else if (event == EV_click2_press) {
195
195
        set_level(0);
196
 
        return MISCHIEF_MANAGED;
 
196
        return EVENT_HANDLED;
197
197
    }
198
198
    // click, hold: go to highest level (for ramping down)
199
199
    else if (event == EV_click2_hold) {
200
200
        set_state(steady_state, MAX_LEVEL);
201
 
        return MISCHIEF_MANAGED;
 
201
        return EVENT_HANDLED;
202
202
    }
203
203
    // 2 clicks: highest mode
204
204
    else if (event == EV_2clicks) {
205
205
        set_state(steady_state, nearest_level(MAX_LEVEL));
206
 
        return MISCHIEF_MANAGED;
 
206
        return EVENT_HANDLED;
207
207
    }
208
208
    #ifdef USE_BATTCHECK
209
209
    // 3 clicks: battcheck mode / blinky mode group
210
210
    else if (event == EV_3clicks) {
211
211
        set_state(battcheck_state, 0);
212
 
        return MISCHIEF_MANAGED;
 
212
        return EVENT_HANDLED;
213
213
    }
214
214
    #endif
215
215
    // 4 clicks: configure ramp
216
216
    else if (event == EV_4clicks) {
217
217
        push_state(ramp_config_state, 0);
218
 
        return MISCHIEF_MANAGED;
 
218
        return EVENT_HANDLED;
219
219
    }
220
220
    return EVENT_NOT_HANDLED;
221
221
}
240
240
        target_level = arg;
241
241
        #endif
242
242
        set_level(nearest_level(arg));
243
 
        return MISCHIEF_MANAGED;
 
243
        return EVENT_HANDLED;
244
244
    }
245
245
    // click: brighter
246
246
    else if (event == EV_click1_release) {
253
253
        empty_event_sequence();
254
254
        // remember mode for later
255
255
        save_config_wl();
256
 
        return MISCHIEF_MANAGED;
 
256
        return EVENT_HANDLED;
257
257
    }
258
258
    // hold: dimmer
259
259
    else if (event == EV_click1_hold) {
260
260
        // ramp slower in discrete mode
261
261
        if (arg % HOLD_TIMEOUT != 0) {
262
 
            return MISCHIEF_MANAGED;
 
262
            return EVENT_HANDLED;
263
263
        }
264
264
        memorized_level = nearest_level((int16_t)actual_level - ramp_step_size);
265
265
        #ifdef USE_THERMAL_REGULATION
266
266
        target_level = memorized_level;
267
267
        #endif
268
268
        set_level(memorized_level);
269
 
        return MISCHIEF_MANAGED;
 
269
        return EVENT_HANDLED;
270
270
    }
271
271
    // reverse ramp direction on hold release
272
272
    else if (event == EV_click1_hold_release) {
273
273
        save_config_wl();
274
 
        return MISCHIEF_MANAGED;
 
274
        return EVENT_HANDLED;
275
275
    }
276
276
    #if defined(USE_SET_LEVEL_GRADUALLY)
277
277
    // gradual thermal regulation
279
279
        #ifdef USE_SET_LEVEL_GRADUALLY
280
280
        // make thermal adjustment speed scale with magnitude
281
281
        if ((arg & 1) && (actual_level < THERM_FASTER_LEVEL)) {
282
 
            return MISCHIEF_MANAGED;  // adjust slower when not a high mode
 
282
            return EVENT_HANDLED;  // adjust slower when not a high mode
283
283
        }
284
284
        #ifdef THERM_HARD_TURBO_DROP
285
285
        else if ((! (actual_level < THERM_FASTER_LEVEL))
317
317
        }
318
318
        #endif
319
319
        #endif
320
 
        return MISCHIEF_MANAGED;
 
320
        return EVENT_HANDLED;
321
321
    }
322
322
    #endif
323
323
    #ifdef USE_THERMAL_REGULATION
342
342
            set_level(stepdown);
343
343
            #endif
344
344
        }
345
 
        return MISCHIEF_MANAGED;
 
345
        return EVENT_HANDLED;
346
346
    }
347
347
    // underheating: increase slowly if we're lower than the target
348
348
    //               (proportional to how low we are)
358
358
            set_level(stepup);
359
359
            #endif
360
360
        }
361
 
        return MISCHIEF_MANAGED;
 
361
        return EVENT_HANDLED;
362
362
    }
363
363
    #endif
364
364
    return EVENT_NOT_HANDLED;
370
370
    // 1 click: off
371
371
    if (event == EV_1click) {
372
372
        set_state(off_state, 0);
373
 
        return MISCHIEF_MANAGED;
 
373
        return EVENT_HANDLED;
374
374
    }
375
375
    #ifdef USE_THERMAL_REGULATION
376
376
    // 2 clicks: tempcheck mode
377
377
    else if (event == EV_2clicks) {
378
378
        blink_confirm(2);
379
379
        set_state(tempcheck_state, 0);
380
 
        return MISCHIEF_MANAGED;
 
380
        return EVENT_HANDLED;
381
381
    }
382
382
    #endif
383
383
    return EVENT_NOT_HANDLED;
389
389
    // 1 click: off
390
390
    if (event == EV_1click) {
391
391
        set_state(off_state, 0);
392
 
        return MISCHIEF_MANAGED;
 
392
        return EVENT_HANDLED;
393
393
    }
394
394
    // 2 clicks: battcheck mode
395
395
    else if (event == EV_2clicks) {
396
396
        blink_confirm(1);
397
397
        set_state(battcheck_state, 0);
398
 
        return MISCHIEF_MANAGED;
 
398
        return EVENT_HANDLED;
399
399
    }
400
400
    // 4 clicks: thermal config mode
401
401
    else if (event == EV_4clicks) {
402
402
        push_state(thermal_config_state, 0);
403
 
        return MISCHIEF_MANAGED;
 
403
        return EVENT_HANDLED;
404
404
    }
405
405
    return EVENT_NOT_HANDLED;
406
406
}
415
415
    if (event == EV_enter_state) {
416
416
        config_step = 0;
417
417
        set_level(0);
418
 
        return MISCHIEF_MANAGED;
 
418
        return EVENT_HANDLED;
419
419
    }
420
420
    // advance forward through config steps
421
421
    else if (event == EV_tick) {
429
429
            //set_state(retstate, retval);
430
430
            pop_state();
431
431
        }
432
 
        return MISCHIEF_MANAGED;
 
432
        return EVENT_HANDLED;
433
433
    }
434
434
    // an option was set (return from number_entry_state)
435
435
    else if (event == EV_reenter_state) {
436
436
        config_state_values[config_step] = number_entry_value;
437
437
        config_step ++;
438
 
        return MISCHIEF_MANAGED;
 
438
        return EVENT_HANDLED;
439
439
    }
440
440
    //return EVENT_NOT_HANDLED;
441
441
    // eat all other events; don't pass any through to parent
502
502
        blinks_left = arg;
503
503
        entry_step = 0;
504
504
        wait_ticks = 0;
505
 
        return MISCHIEF_MANAGED;
 
505
        return EVENT_HANDLED;
506
506
    }
507
507
    // advance through the process:
508
508
    // 0: wait a moment
559
559
            number_entry_value = value;
560
560
            pop_state();
561
561
        }
562
 
        return MISCHIEF_MANAGED;
 
562
        return EVENT_HANDLED;
563
563
    }
564
564
    // count clicks
565
565
    else if (event == EV_click1_release) {
572
572
            delay_4ms(8/2);
573
573
            set_level(0);
574
574
        }
575
 
        return MISCHIEF_MANAGED;
 
575
        return EVENT_HANDLED;
576
576
    }
577
577
    return EVENT_NOT_HANDLED;
578
578
}