← Back to branch summary

~toykeeper/flashlight-firmware/trunk

« back to all changes in this revision

Viewing changes to ToyKeeper/spaghetti-monster/ramping-ui.c

  • Committer: Selene Scriven
  • Date: 2017-08-25 01:22:10 UTC
  • mto: (188.9.1 emisar-d18)
  • mto: This revision was merged to the branch mainline in revision 206.
  • Revision ID: ubuntu@toykeeper.net-20170825012210-oudmztbdsus3bic2
Started on some documentation, spaghetti-monster.txt.
Added #defines for State return values: EVENT_HANDLED, EVENT_NOT_HANDLED
Improved handling of delay includes.
Managed mischief.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ToyKeeper/spaghetti-monster/ramping-ui.c
21
21
#define USE_LVP
22
22
#define USE_THERMAL_REGULATION
23
23
#define DEFAULT_THERM_CEIL 32
24
 
#define USE_DEBUG_BLINK
25
24
#define USE_DELAY_MS
 
25
#define USE_DELAY_4MS
26
26
#define USE_DELAY_ZERO
27
27
#define USE_RAMPING
28
28
#define RAMP_LENGTH 150
55
55
        // sleep while off  (lower power use)
56
56
        //empty_event_sequence();  // just in case (but shouldn't be needed)
57
57
        standby_mode();
58
 
        return 0;
 
58
        return MISCHIEF_MANAGED;
59
59
    }
60
60
    // hold (initially): go to lowest level, but allow abort for regular click
61
61
    else if (event == EV_click1_press) {
62
62
        set_level(1);
63
 
        return 0;
 
63
        return MISCHIEF_MANAGED;
64
64
    }
65
65
    // 1 click (before timeout): go to memorized level, but allow abort for double click
66
66
    else if (event == EV_click1_release) {
67
67
        set_level(memorized_level);
68
 
        return 0;
 
68
        return MISCHIEF_MANAGED;
69
69
    }
70
70
    // 1 click: regular mode
71
71
    else if (event == EV_1click) {
72
72
        set_state(steady_state, memorized_level);
73
 
        return 0;
 
73
        return MISCHIEF_MANAGED;
74
74
    }
75
75
    // 2 clicks: highest mode
76
76
    else if (event == EV_2clicks) {
77
77
        set_state(steady_state, MAX_LEVEL);
78
 
        return 0;
 
78
        return MISCHIEF_MANAGED;
79
79
    }
80
80
    // 3 clicks: strobe mode
81
81
    else if (event == EV_3clicks) {
82
82
        set_state(strobe_state, 0);
83
 
        return 0;
 
83
        return MISCHIEF_MANAGED;
84
84
    }
85
85
    // hold: go to lowest level
86
86
    else if (event == EV_click1_hold) {
88
88
        // give the user time to release at moon level
89
89
        if (arg >= HOLD_TIMEOUT)
90
90
            set_state(steady_state, 1);
91
 
        return 0;
 
91
        return MISCHIEF_MANAGED;
92
92
    }
93
93
    // hold, release quickly: go to lowest level
94
94
    else if (event == EV_click1_hold_release) {
95
95
        set_state(steady_state, 1);
96
 
        return 0;
 
96
        return MISCHIEF_MANAGED;
97
97
    }
98
98
    // click, hold: go to highest level (for ramping down)
99
99
    else if (event == EV_click2_hold) {
100
100
        set_state(steady_state, MAX_LEVEL);
101
 
        return 0;
 
101
        return MISCHIEF_MANAGED;
102
102
    }
103
 
    return 1;
 
103
    return EVENT_NOT_HANDLED;
104
104
}
105
105
 
106
106
 
115
115
        target_level = arg;
116
116
        #endif
117
117
        set_level(arg);
118
 
        return 0;
 
118
        return MISCHIEF_MANAGED;
119
119
    }
120
120
    // 1 click: off
121
121
    else if (event == EV_1click) {
122
122
        set_state(off_state, 0);
123
 
        return 0;
 
123
        return MISCHIEF_MANAGED;
124
124
    }
125
125
    // 2 clicks: go to/from highest level
126
126
    else if (event == EV_2clicks) {
137
137
            #endif
138
138
            set_level(memorized_level);
139
139
        }
140
 
        return 0;
 
140
        return MISCHIEF_MANAGED;
141
141
    }
142
142
    // 3 clicks: go to strobe modes
143
143
    else if (event == EV_3clicks) {
144
144
        set_state(strobe_state, 0);
145
 
        return 0;
 
145
        return MISCHIEF_MANAGED;
146
146
    }
147
147
    // 4 clicks: toggle smooth vs discrete ramping
148
148
    else if (event == EV_4clicks) {
151
151
        set_level(0);
152
152
        delay_ms(20);
153
153
        set_level(memorized_level);
154
 
        return 0;
 
154
        return MISCHIEF_MANAGED;
155
155
    }
156
156
    // hold: change brightness (brighter)
157
157
    else if (event == EV_click1_hold) {
158
158
        // ramp slower in discrete mode
159
159
        if (arg % ramp_step_size != 0) {
160
 
            return 0;
 
160
            return MISCHIEF_MANAGED;
161
161
        }
162
162
        // FIXME: make it ramp down instead, if already at max
163
163
        if (actual_level + ramp_step_size < MAX_LEVEL)
174
174
            delay_ms(7);
175
175
        }
176
176
        set_level(memorized_level);
177
 
        return 0;
 
177
        return MISCHIEF_MANAGED;
178
178
    }
179
179
    // click, hold: change brightness (dimmer)
180
180
    else if (event == EV_click2_hold) {
181
181
        // ramp slower in discrete mode
182
182
        if (arg % ramp_step_size != 0) {
183
 
            return 0;
 
183
            return MISCHIEF_MANAGED;
184
184
        }
185
185
        // FIXME: make it ramp up instead, if already at min
186
186
        if (actual_level > ramp_step_size)
198
198
            delay_ms(7);
199
199
        }
200
200
        set_level(memorized_level);
201
 
        return 0;
 
201
        return MISCHIEF_MANAGED;
202
202
    }
203
203
    #ifdef USE_THERMAL_REGULATION
204
204
    // TODO: test this on a real light
209
209
            if (stepdown < MAX_LEVEL/4) stepdown = MAX_LEVEL/4;
210
210
            set_level(stepdown);
211
211
        }
212
 
        return 0;
 
212
        return MISCHIEF_MANAGED;
213
213
    }
214
214
    // underheating: increase slowly if we're lower than the target
215
215
    //               (proportional to how low we are)
219
219
            if (stepup > target_level) stepup = target_level;
220
220
            set_level(stepup);
221
221
        }
222
 
        return 0;
 
222
        return MISCHIEF_MANAGED;
223
223
    }
224
224
    #endif
225
 
    return 1;
 
225
    return EVENT_NOT_HANDLED;
226
226
}
227
227
 
228
228
 
229
229
uint8_t strobe_state(EventPtr event, uint16_t arg) {
230
230
    if (event == EV_enter_state) {
231
 
        return 0;
 
231
        return MISCHIEF_MANAGED;
232
232
    }
233
233
    // 1 click: off
234
234
    else if (event == EV_1click) {
235
235
        set_state(off_state, 0);
236
 
        return 0;
 
236
        return MISCHIEF_MANAGED;
237
237
    }
238
238
    // 2 clicks: toggle party strobe vs tactical strobe
239
239
    else if (event == EV_2clicks) {
240
240
        strobe_type ^= 1;
241
 
        return 0;
 
241
        return MISCHIEF_MANAGED;
242
242
    }
243
243
    // 3 clicks: go back to regular modes
244
244
    else if (event == EV_3clicks) {
245
245
        set_state(steady_state, memorized_level);
246
 
        return 0;
 
246
        return MISCHIEF_MANAGED;
247
247
    }
248
248
    // hold: change speed (go faster)
249
249
    else if (event == EV_click1_hold) {
250
250
        if ((arg & 1) == 0) {
251
251
            if (strobe_delay > 8) strobe_delay --;
252
252
        }
253
 
        return 0;
 
253
        return MISCHIEF_MANAGED;
254
254
    }
255
255
    // click, hold: change speed (go slower)
256
256
    else if (event == EV_click2_hold) {
257
257
        if ((arg & 1) == 0) {
258
258
            if (strobe_delay < 255) strobe_delay ++;
259
259
        }
260
 
        return 0;
 
260
        return MISCHIEF_MANAGED;
261
261
    }
262
 
    return 1;
 
262
    return EVENT_NOT_HANDLED;
263
263
}
264
264
 
265
265