← Back to branch summary

~toykeeper/flashlight-firmware/fsm

« back to all changes in this revision

Viewing changes to ToyKeeper/spaghetti-monster/ramping-ui/ramping-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/ramping-ui/ramping-ui.c
59
59
        set_level(0);
60
60
        // sleep while off  (lower power use)
61
61
        go_to_standby = 1;
62
 
        return MISCHIEF_MANAGED;
 
62
        return EVENT_HANDLED;
63
63
    }
64
64
    // hold (initially): go to lowest level, but allow abort for regular click
65
65
    else if (event == EV_click1_press) {
66
66
        set_level(1);
67
 
        return MISCHIEF_MANAGED;
 
67
        return EVENT_HANDLED;
68
68
    }
69
69
    // 1 click (before timeout): go to memorized level, but allow abort for double click
70
70
    else if (event == EV_click1_release) {
71
71
        set_level(memorized_level);
72
 
        return MISCHIEF_MANAGED;
 
72
        return EVENT_HANDLED;
73
73
    }
74
74
    // 1 click: regular mode
75
75
    else if (event == EV_1click) {
76
76
        set_state(steady_state, memorized_level);
77
 
        return MISCHIEF_MANAGED;
 
77
        return EVENT_HANDLED;
78
78
    }
79
79
    // 2 clicks (initial press): off, to prep for later events
80
80
    else if (event == EV_click2_press) {
81
81
        set_level(0);
82
 
        return MISCHIEF_MANAGED;
 
82
        return EVENT_HANDLED;
83
83
    }
84
84
    // 2 clicks: highest mode
85
85
    else if (event == EV_2clicks) {
86
86
        set_state(steady_state, MAX_LEVEL);
87
 
        return MISCHIEF_MANAGED;
 
87
        return EVENT_HANDLED;
88
88
    }
89
89
    // 3 clicks: strobe mode
90
90
    else if (event == EV_3clicks) {
91
91
        set_state(strobe_state, 0);
92
 
        return MISCHIEF_MANAGED;
 
92
        return EVENT_HANDLED;
93
93
    }
94
94
    #ifdef USE_BATTCHECK
95
95
    // 4 clicks: battcheck mode
96
96
    else if (event == EV_4clicks) {
97
97
        set_state(battcheck_state, 0);
98
 
        return MISCHIEF_MANAGED;
 
98
        return EVENT_HANDLED;
99
99
    }
100
100
    #endif
101
101
    // hold: go to lowest level
104
104
        // give the user time to release at moon level
105
105
        if (arg >= HOLD_TIMEOUT)
106
106
            set_state(steady_state, 1);
107
 
        return MISCHIEF_MANAGED;
 
107
        return EVENT_HANDLED;
108
108
    }
109
109
    // hold, release quickly: go to lowest level
110
110
    else if (event == EV_click1_hold_release) {
111
111
        set_state(steady_state, 1);
112
 
        return MISCHIEF_MANAGED;
 
112
        return EVENT_HANDLED;
113
113
    }
114
114
    // click, hold: go to highest level (for ramping down)
115
115
    else if (event == EV_click2_hold) {
116
116
        set_state(steady_state, MAX_LEVEL);
117
 
        return MISCHIEF_MANAGED;
 
117
        return EVENT_HANDLED;
118
118
    }
119
119
    return EVENT_NOT_HANDLED;
120
120
}
131
131
        target_level = arg;
132
132
        #endif
133
133
        set_level(arg);
134
 
        return MISCHIEF_MANAGED;
 
134
        return EVENT_HANDLED;
135
135
    }
136
136
    // 1 click: off
137
137
    else if (event == EV_1click) {
138
138
        set_state(off_state, 0);
139
 
        return MISCHIEF_MANAGED;
 
139
        return EVENT_HANDLED;
140
140
    }
141
141
    // 2 clicks: go to/from highest level
142
142
    else if (event == EV_2clicks) {
153
153
            #endif
154
154
            set_level(memorized_level);
155
155
        }
156
 
        return MISCHIEF_MANAGED;
 
156
        return EVENT_HANDLED;
157
157
    }
158
158
    // 3 clicks: go to strobe modes
159
159
    else if (event == EV_3clicks) {
160
160
        set_state(strobe_state, 0);
161
 
        return MISCHIEF_MANAGED;
 
161
        return EVENT_HANDLED;
162
162
    }
163
163
    // 4 clicks: toggle smooth vs discrete ramping
164
164
    else if (event == EV_4clicks) {
167
167
        set_level(0);
168
168
        delay_4ms(20/4);
169
169
        set_level(memorized_level);
170
 
        return MISCHIEF_MANAGED;
 
170
        return EVENT_HANDLED;
171
171
    }
172
172
    // hold: change brightness (brighter)
173
173
    else if (event == EV_click1_hold) {
174
174
        // ramp slower in discrete mode
175
175
        if (arg % ramp_step_size != 0) {
176
 
            return MISCHIEF_MANAGED;
 
176
            return EVENT_HANDLED;
177
177
        }
178
178
        // FIXME: make it ramp down instead, if already at max
179
179
        if (actual_level + ramp_step_size < MAX_LEVEL)
190
190
            delay_4ms(8/4);
191
191
        }
192
192
        set_level(memorized_level);
193
 
        return MISCHIEF_MANAGED;
 
193
        return EVENT_HANDLED;
194
194
    }
195
195
    // click, hold: change brightness (dimmer)
196
196
    else if (event == EV_click2_hold) {
197
197
        // ramp slower in discrete mode
198
198
        if (arg % ramp_step_size != 0) {
199
 
            return MISCHIEF_MANAGED;
 
199
            return EVENT_HANDLED;
200
200
        }
201
201
        // FIXME: make it ramp up instead, if already at min
202
202
        if (actual_level > ramp_step_size)
214
214
            delay_4ms(8/4);
215
215
        }
216
216
        set_level(memorized_level);
217
 
        return MISCHIEF_MANAGED;
 
217
        return EVENT_HANDLED;
218
218
    }
219
219
    #ifdef USE_THERMAL_REGULATION
220
220
    // TODO: test this on a real light
225
225
            if (stepdown < MAX_LEVEL/4) stepdown = MAX_LEVEL/4;
226
226
            set_level(stepdown);
227
227
        }
228
 
        return MISCHIEF_MANAGED;
 
228
        return EVENT_HANDLED;
229
229
    }
230
230
    // underheating: increase slowly if we're lower than the target
231
231
    //               (proportional to how low we are)
235
235
            if (stepup > target_level) stepup = target_level;
236
236
            set_level(stepup);
237
237
        }
238
 
        return MISCHIEF_MANAGED;
 
238
        return EVENT_HANDLED;
239
239
    }
240
240
    #endif
241
241
    return EVENT_NOT_HANDLED;
244
244
 
245
245
uint8_t strobe_state(Event event, uint16_t arg) {
246
246
    if (event == EV_enter_state) {
247
 
        return MISCHIEF_MANAGED;
 
247
        return EVENT_HANDLED;
248
248
    }
249
249
    // 1 click: off
250
250
    else if (event == EV_1click) {
251
251
        set_state(off_state, 0);
252
 
        return MISCHIEF_MANAGED;
 
252
        return EVENT_HANDLED;
253
253
    }
254
254
    // 2 clicks: toggle party strobe vs tactical strobe
255
255
    else if (event == EV_2clicks) {
256
256
        strobe_type ^= 1;
257
 
        return MISCHIEF_MANAGED;
 
257
        return EVENT_HANDLED;
258
258
    }
259
259
    // 3 clicks: go back to regular modes
260
260
    else if (event == EV_3clicks) {
261
261
        set_state(steady_state, memorized_level);
262
 
        return MISCHIEF_MANAGED;
 
262
        return EVENT_HANDLED;
263
263
    }
264
264
    // hold: change speed (go faster)
265
265
    else if (event == EV_click1_hold) {
266
266
        if ((arg & 1) == 0) {
267
267
            if (strobe_delay > 8) strobe_delay --;
268
268
        }
269
 
        return MISCHIEF_MANAGED;
 
269
        return EVENT_HANDLED;
270
270
    }
271
271
    // click, hold: change speed (go slower)
272
272
    else if (event == EV_click2_hold) {
273
273
        if ((arg & 1) == 0) {
274
274
            if (strobe_delay < 255) strobe_delay ++;
275
275
        }
276
 
        return MISCHIEF_MANAGED;
 
276
        return EVENT_HANDLED;
277
277
    }
278
278
    return EVENT_NOT_HANDLED;
279
279
}
284
284
    // 1 click: off
285
285
    if (event == EV_1click) {
286
286
        set_state(off_state, 0);
287
 
        return MISCHIEF_MANAGED;
 
287
        return EVENT_HANDLED;
288
288
    }
289
289
    // 2 clicks: tempcheck mode
290
290
    else if (event == EV_2clicks) {
291
291
        set_state(tempcheck_state, 0);
292
 
        return MISCHIEF_MANAGED;
 
292
        return EVENT_HANDLED;
293
293
    }
294
294
    return EVENT_NOT_HANDLED;
295
295
}
298
298
    // 1 click: off
299
299
    if (event == EV_1click) {
300
300
        set_state(off_state, 0);
301
 
        return MISCHIEF_MANAGED;
 
301
        return EVENT_HANDLED;
302
302
    }
303
303
    return EVENT_NOT_HANDLED;
304
304
}