diff options
Diffstat (limited to 'drivers/haptic')
-rw-r--r-- | drivers/haptic/haptic.c | 355 | ||||
-rw-r--r-- | drivers/haptic/haptic.h | 81 | ||||
-rw-r--r-- | drivers/haptic/solenoid.c | 1 |
3 files changed, 1 insertions, 436 deletions
diff --git a/drivers/haptic/haptic.c b/drivers/haptic/haptic.c deleted file mode 100644 index de3f40052..000000000 --- a/drivers/haptic/haptic.c +++ /dev/null | |||
@@ -1,355 +0,0 @@ | |||
1 | /* Copyright 2019 ishtob | ||
2 | * Driver for haptic feedback written for QMK | ||
3 | * | ||
4 | * This program is free software: you can redistribute it and/or modify | ||
5 | * it under the terms of the GNU General Public License as published by | ||
6 | * the Free Software Foundation, either version 2 of the License, or | ||
7 | * (at your option) any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | * GNU General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License | ||
15 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
16 | */ | ||
17 | #include "haptic.h" | ||
18 | #include "eeconfig.h" | ||
19 | #include "progmem.h" | ||
20 | #include "debug.h" | ||
21 | #ifdef DRV2605L | ||
22 | # include "DRV2605L.h" | ||
23 | #endif | ||
24 | #ifdef SOLENOID_ENABLE | ||
25 | # include "solenoid.h" | ||
26 | #endif | ||
27 | |||
28 | haptic_config_t haptic_config; | ||
29 | |||
30 | void haptic_init(void) { | ||
31 | debug_enable = 1; // Debug is ON! | ||
32 | if (!eeconfig_is_enabled()) { | ||
33 | eeconfig_init(); | ||
34 | } | ||
35 | haptic_config.raw = eeconfig_read_haptic(); | ||
36 | #ifdef SOLENOID_ENABLE | ||
37 | solenoid_set_dwell(haptic_config.dwell); | ||
38 | #endif | ||
39 | if ((haptic_config.raw == 0) | ||
40 | #ifdef SOLENOID_ENABLE | ||
41 | || (haptic_config.dwell == 0) | ||
42 | #endif | ||
43 | ) { | ||
44 | // this will be called, if the eeprom is not corrupt, | ||
45 | // but the previous firmware didn't have haptic enabled, | ||
46 | // or the previous firmware didn't have solenoid enabled, | ||
47 | // and the current one has solenoid enabled. | ||
48 | haptic_reset(); | ||
49 | } | ||
50 | #ifdef SOLENOID_ENABLE | ||
51 | solenoid_setup(); | ||
52 | dprintf("Solenoid driver initialized\n"); | ||
53 | #endif | ||
54 | #ifdef DRV2605L | ||
55 | DRV_init(); | ||
56 | dprintf("DRV2605 driver initialized\n"); | ||
57 | #endif | ||
58 | eeconfig_debug_haptic(); | ||
59 | } | ||
60 | |||
61 | void haptic_task(void) { | ||
62 | #ifdef SOLENOID_ENABLE | ||
63 | solenoid_check(); | ||
64 | #endif | ||
65 | } | ||
66 | |||
67 | void eeconfig_debug_haptic(void) { | ||
68 | dprintf("haptic_config eprom\n"); | ||
69 | dprintf("haptic_config.enable = %d\n", haptic_config.enable); | ||
70 | dprintf("haptic_config.mode = %d\n", haptic_config.mode); | ||
71 | } | ||
72 | |||
73 | void haptic_enable(void) { | ||
74 | haptic_config.enable = 1; | ||
75 | xprintf("haptic_config.enable = %u\n", haptic_config.enable); | ||
76 | eeconfig_update_haptic(haptic_config.raw); | ||
77 | } | ||
78 | |||
79 | void haptic_disable(void) { | ||
80 | haptic_config.enable = 0; | ||
81 | xprintf("haptic_config.enable = %u\n", haptic_config.enable); | ||
82 | eeconfig_update_haptic(haptic_config.raw); | ||
83 | } | ||
84 | |||
85 | void haptic_toggle(void) { | ||
86 | if (haptic_config.enable) { | ||
87 | haptic_disable(); | ||
88 | } else { | ||
89 | haptic_enable(); | ||
90 | } | ||
91 | eeconfig_update_haptic(haptic_config.raw); | ||
92 | } | ||
93 | |||
94 | void haptic_feedback_toggle(void) { | ||
95 | haptic_config.feedback++; | ||
96 | if (haptic_config.feedback >= HAPTIC_FEEDBACK_MAX) haptic_config.feedback = KEY_PRESS; | ||
97 | xprintf("haptic_config.feedback = %u\n", !haptic_config.feedback); | ||
98 | eeconfig_update_haptic(haptic_config.raw); | ||
99 | } | ||
100 | |||
101 | void haptic_buzz_toggle(void) { | ||
102 | bool buzz_stat = !haptic_config.buzz; | ||
103 | haptic_config.buzz = buzz_stat; | ||
104 | haptic_set_buzz(buzz_stat); | ||
105 | } | ||
106 | |||
107 | void haptic_mode_increase(void) { | ||
108 | uint8_t mode = haptic_config.mode + 1; | ||
109 | #ifdef DRV2605L | ||
110 | if (haptic_config.mode >= drv_effect_max) { | ||
111 | mode = 1; | ||
112 | } | ||
113 | #endif | ||
114 | haptic_set_mode(mode); | ||
115 | } | ||
116 | |||
117 | void haptic_mode_decrease(void) { | ||
118 | uint8_t mode = haptic_config.mode - 1; | ||
119 | #ifdef DRV2605L | ||
120 | if (haptic_config.mode < 1) { | ||
121 | mode = (drv_effect_max - 1); | ||
122 | } | ||
123 | #endif | ||
124 | haptic_set_mode(mode); | ||
125 | } | ||
126 | |||
127 | void haptic_dwell_increase(void) { | ||
128 | #ifdef SOLENOID_ENABLE | ||
129 | int16_t next_dwell = ((int16_t)haptic_config.dwell) + SOLENOID_DWELL_STEP_SIZE; | ||
130 | if (haptic_config.dwell >= SOLENOID_MAX_DWELL) { | ||
131 | // if it's already at max, we wrap back to min | ||
132 | next_dwell = SOLENOID_MIN_DWELL; | ||
133 | } else if (next_dwell > SOLENOID_MAX_DWELL) { | ||
134 | // if we overshoot the max, then cap at max | ||
135 | next_dwell = SOLENOID_MAX_DWELL; | ||
136 | } | ||
137 | solenoid_set_dwell(next_dwell); | ||
138 | #else | ||
139 | int16_t next_dwell = ((int16_t)haptic_config.dwell) + 1; | ||
140 | #endif | ||
141 | haptic_set_dwell(next_dwell); | ||
142 | } | ||
143 | |||
144 | void haptic_dwell_decrease(void) { | ||
145 | #ifdef SOLENOID_ENABLE | ||
146 | int16_t next_dwell = ((int16_t)haptic_config.dwell) - SOLENOID_DWELL_STEP_SIZE; | ||
147 | if (haptic_config.dwell <= SOLENOID_MIN_DWELL) { | ||
148 | // if it's already at min, we wrap to max | ||
149 | next_dwell = SOLENOID_MAX_DWELL; | ||
150 | } else if (next_dwell < SOLENOID_MIN_DWELL) { | ||
151 | // if we go below min, then we cap to min | ||
152 | next_dwell = SOLENOID_MIN_DWELL; | ||
153 | } | ||
154 | solenoid_set_dwell(next_dwell); | ||
155 | #else | ||
156 | int16_t next_dwell = ((int16_t)haptic_config.dwell) - 1; | ||
157 | #endif | ||
158 | haptic_set_dwell(next_dwell); | ||
159 | } | ||
160 | |||
161 | void haptic_reset(void) { | ||
162 | haptic_config.enable = true; | ||
163 | uint8_t feedback = HAPTIC_FEEDBACK_DEFAULT; | ||
164 | haptic_config.feedback = feedback; | ||
165 | #ifdef DRV2605L | ||
166 | uint8_t mode = HAPTIC_MODE_DEFAULT; | ||
167 | haptic_config.mode = mode; | ||
168 | #endif | ||
169 | #ifdef SOLENOID_ENABLE | ||
170 | uint8_t dwell = SOLENOID_DEFAULT_DWELL; | ||
171 | haptic_config.dwell = dwell; | ||
172 | haptic_config.buzz = SOLENOID_DEFAULT_BUZZ; | ||
173 | solenoid_set_dwell(dwell); | ||
174 | #else | ||
175 | // This is to trigger haptic_reset again, if solenoid is enabled in the future. | ||
176 | haptic_config.dwell = 0; | ||
177 | haptic_config.buzz = 0; | ||
178 | #endif | ||
179 | eeconfig_update_haptic(haptic_config.raw); | ||
180 | xprintf("haptic_config.feedback = %u\n", haptic_config.feedback); | ||
181 | xprintf("haptic_config.mode = %u\n", haptic_config.mode); | ||
182 | } | ||
183 | |||
184 | void haptic_set_feedback(uint8_t feedback) { | ||
185 | haptic_config.feedback = feedback; | ||
186 | eeconfig_update_haptic(haptic_config.raw); | ||
187 | xprintf("haptic_config.feedback = %u\n", haptic_config.feedback); | ||
188 | } | ||
189 | |||
190 | void haptic_set_mode(uint8_t mode) { | ||
191 | haptic_config.mode = mode; | ||
192 | eeconfig_update_haptic(haptic_config.raw); | ||
193 | xprintf("haptic_config.mode = %u\n", haptic_config.mode); | ||
194 | } | ||
195 | |||
196 | void haptic_set_amplitude(uint8_t amp) { | ||
197 | haptic_config.amplitude = amp; | ||
198 | eeconfig_update_haptic(haptic_config.raw); | ||
199 | xprintf("haptic_config.amplitude = %u\n", haptic_config.amplitude); | ||
200 | #ifdef DRV2605L | ||
201 | DRV_amplitude(amp); | ||
202 | #endif | ||
203 | } | ||
204 | |||
205 | void haptic_set_buzz(uint8_t buzz) { | ||
206 | haptic_config.buzz = buzz; | ||
207 | eeconfig_update_haptic(haptic_config.raw); | ||
208 | xprintf("haptic_config.buzz = %u\n", haptic_config.buzz); | ||
209 | } | ||
210 | |||
211 | void haptic_set_dwell(uint8_t dwell) { | ||
212 | haptic_config.dwell = dwell; | ||
213 | eeconfig_update_haptic(haptic_config.raw); | ||
214 | xprintf("haptic_config.dwell = %u\n", haptic_config.dwell); | ||
215 | } | ||
216 | |||
217 | uint8_t haptic_get_mode(void) { | ||
218 | if (!haptic_config.enable) { | ||
219 | return false; | ||
220 | } | ||
221 | return haptic_config.mode; | ||
222 | } | ||
223 | |||
224 | uint8_t haptic_get_feedback(void) { | ||
225 | if (!haptic_config.enable) { | ||
226 | return false; | ||
227 | } | ||
228 | return haptic_config.feedback; | ||
229 | } | ||
230 | |||
231 | uint8_t haptic_get_dwell(void) { | ||
232 | if (!haptic_config.enable) { | ||
233 | return false; | ||
234 | } | ||
235 | return haptic_config.dwell; | ||
236 | } | ||
237 | |||
238 | void haptic_enable_continuous(void) { | ||
239 | haptic_config.cont = 1; | ||
240 | xprintf("haptic_config.cont = %u\n", haptic_config.cont); | ||
241 | eeconfig_update_haptic(haptic_config.raw); | ||
242 | #ifdef DRV2605L | ||
243 | DRV_rtp_init(); | ||
244 | #endif | ||
245 | } | ||
246 | |||
247 | void haptic_disable_continuous(void) { | ||
248 | haptic_config.cont = 0; | ||
249 | xprintf("haptic_config.cont = %u\n", haptic_config.cont); | ||
250 | eeconfig_update_haptic(haptic_config.raw); | ||
251 | #ifdef DRV2605L | ||
252 | DRV_write(DRV_MODE, 0x00); | ||
253 | #endif | ||
254 | } | ||
255 | |||
256 | void haptic_toggle_continuous(void) { | ||
257 | #ifdef DRV2605L | ||
258 | if (haptic_config.cont) { | ||
259 | haptic_disable_continuous(); | ||
260 | } else { | ||
261 | haptic_enable_continuous(); | ||
262 | } | ||
263 | eeconfig_update_haptic(haptic_config.raw); | ||
264 | #endif | ||
265 | } | ||
266 | |||
267 | void haptic_cont_increase(void) { | ||
268 | uint8_t amp = haptic_config.amplitude + 10; | ||
269 | if (haptic_config.amplitude >= 120) { | ||
270 | amp = 120; | ||
271 | } | ||
272 | haptic_set_amplitude(amp); | ||
273 | } | ||
274 | |||
275 | void haptic_cont_decrease(void) { | ||
276 | uint8_t amp = haptic_config.amplitude - 10; | ||
277 | if (haptic_config.amplitude < 20) { | ||
278 | amp = 20; | ||
279 | } | ||
280 | haptic_set_amplitude(amp); | ||
281 | } | ||
282 | |||
283 | void haptic_play(void) { | ||
284 | #ifdef DRV2605L | ||
285 | uint8_t play_eff = 0; | ||
286 | play_eff = haptic_config.mode; | ||
287 | DRV_pulse(play_eff); | ||
288 | #endif | ||
289 | #ifdef SOLENOID_ENABLE | ||
290 | solenoid_fire(); | ||
291 | #endif | ||
292 | } | ||
293 | |||
294 | bool process_haptic(uint16_t keycode, keyrecord_t *record) { | ||
295 | if (keycode == HPT_ON && record->event.pressed) { | ||
296 | haptic_enable(); | ||
297 | } | ||
298 | if (keycode == HPT_OFF && record->event.pressed) { | ||
299 | haptic_disable(); | ||
300 | } | ||
301 | if (keycode == HPT_TOG && record->event.pressed) { | ||
302 | haptic_toggle(); | ||
303 | } | ||
304 | if (keycode == HPT_RST && record->event.pressed) { | ||
305 | haptic_reset(); | ||
306 | } | ||
307 | if (keycode == HPT_FBK && record->event.pressed) { | ||
308 | haptic_feedback_toggle(); | ||
309 | } | ||
310 | if (keycode == HPT_BUZ && record->event.pressed) { | ||
311 | haptic_buzz_toggle(); | ||
312 | } | ||
313 | if (keycode == HPT_MODI && record->event.pressed) { | ||
314 | haptic_mode_increase(); | ||
315 | } | ||
316 | if (keycode == HPT_MODD && record->event.pressed) { | ||
317 | haptic_mode_decrease(); | ||
318 | } | ||
319 | if (keycode == HPT_DWLI && record->event.pressed) { | ||
320 | haptic_dwell_increase(); | ||
321 | } | ||
322 | if (keycode == HPT_DWLD && record->event.pressed) { | ||
323 | haptic_dwell_decrease(); | ||
324 | } | ||
325 | if (keycode == HPT_CONT && record->event.pressed) { | ||
326 | haptic_toggle_continuous(); | ||
327 | } | ||
328 | if (keycode == HPT_CONI && record->event.pressed) { | ||
329 | haptic_cont_increase(); | ||
330 | } | ||
331 | if (keycode == HPT_COND && record->event.pressed) { | ||
332 | haptic_cont_decrease(); | ||
333 | } | ||
334 | |||
335 | if (haptic_config.enable) { | ||
336 | if (record->event.pressed) { | ||
337 | // keypress | ||
338 | if (haptic_config.feedback < 2) { | ||
339 | haptic_play(); | ||
340 | } | ||
341 | } else { | ||
342 | // keyrelease | ||
343 | if (haptic_config.feedback > 0) { | ||
344 | haptic_play(); | ||
345 | } | ||
346 | } | ||
347 | } | ||
348 | return true; | ||
349 | } | ||
350 | |||
351 | void haptic_shutdown(void) { | ||
352 | #ifdef SOLENOID_ENABLE | ||
353 | solenoid_shutdown(); | ||
354 | #endif | ||
355 | } | ||
diff --git a/drivers/haptic/haptic.h b/drivers/haptic/haptic.h deleted file mode 100644 index ba8e0d20b..000000000 --- a/drivers/haptic/haptic.h +++ /dev/null | |||
@@ -1,81 +0,0 @@ | |||
1 | /* Copyright 2019 ishtob | ||
2 | * Driver for haptic feedback written for QMK | ||
3 | * | ||
4 | * This program is free software: you can redistribute it and/or modify | ||
5 | * it under the terms of the GNU General Public License as published by | ||
6 | * the Free Software Foundation, either version 2 of the License, or | ||
7 | * (at your option) any later version. | ||
8 | * | ||
9 | * This program is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | * GNU General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU General Public License | ||
15 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
16 | */ | ||
17 | |||
18 | #pragma once | ||
19 | #include <stdint.h> | ||
20 | #include <stdbool.h> | ||
21 | #include "quantum.h" | ||
22 | #ifdef DRV2605L | ||
23 | # include "DRV2605L.h" | ||
24 | #endif | ||
25 | |||
26 | #ifndef HAPTIC_FEEDBACK_DEFAULT | ||
27 | # define HAPTIC_FEEDBACK_DEFAULT 0 | ||
28 | #endif | ||
29 | #ifndef HAPTIC_MODE_DEFAULT | ||
30 | # define HAPTIC_MODE_DEFAULT DRV_MODE_DEFAULT | ||
31 | #endif | ||
32 | |||
33 | /* EEPROM config settings */ | ||
34 | typedef union { | ||
35 | uint32_t raw; | ||
36 | struct { | ||
37 | bool enable : 1; | ||
38 | uint8_t feedback : 2; | ||
39 | uint8_t mode : 7; | ||
40 | bool buzz : 1; | ||
41 | uint8_t dwell : 7; | ||
42 | bool cont : 1; | ||
43 | uint8_t amplitude : 8; | ||
44 | uint8_t reserved : 5; | ||
45 | }; | ||
46 | } haptic_config_t; | ||
47 | |||
48 | typedef enum HAPTIC_FEEDBACK { | ||
49 | KEY_PRESS, | ||
50 | KEY_PRESS_RELEASE, | ||
51 | KEY_RELEASE, | ||
52 | HAPTIC_FEEDBACK_MAX, | ||
53 | } HAPTIC_FEEDBACK; | ||
54 | |||
55 | bool process_haptic(uint16_t keycode, keyrecord_t *record); | ||
56 | void haptic_init(void); | ||
57 | void haptic_task(void); | ||
58 | void eeconfig_debug_haptic(void); | ||
59 | void haptic_enable(void); | ||
60 | void haptic_disable(void); | ||
61 | void haptic_toggle(void); | ||
62 | void haptic_feedback_toggle(void); | ||
63 | void haptic_mode_increase(void); | ||
64 | void haptic_mode_decrease(void); | ||
65 | void haptic_mode(uint8_t mode); | ||
66 | void haptic_reset(void); | ||
67 | void haptic_set_feedback(uint8_t feedback); | ||
68 | void haptic_set_mode(uint8_t mode); | ||
69 | void haptic_set_dwell(uint8_t dwell); | ||
70 | void haptic_set_buzz(uint8_t buzz); | ||
71 | void haptic_buzz_toggle(void); | ||
72 | uint8_t haptic_get_mode(void); | ||
73 | uint8_t haptic_get_feedback(void); | ||
74 | void haptic_dwell_increase(void); | ||
75 | void haptic_dwell_decrease(void); | ||
76 | void haptic_toggle_continuous(void); | ||
77 | void haptic_cont_increase(void); | ||
78 | void haptic_cont_decrease(void); | ||
79 | |||
80 | void haptic_play(void); | ||
81 | void haptic_shutdown(void); | ||
diff --git a/drivers/haptic/solenoid.c b/drivers/haptic/solenoid.c index 3e61d5a17..25cf34465 100644 --- a/drivers/haptic/solenoid.c +++ b/drivers/haptic/solenoid.c | |||
@@ -18,6 +18,7 @@ | |||
18 | #include "timer.h" | 18 | #include "timer.h" |
19 | #include "solenoid.h" | 19 | #include "solenoid.h" |
20 | #include "haptic.h" | 20 | #include "haptic.h" |
21 | #include "gpio.h" | ||
21 | 22 | ||
22 | bool solenoid_on = false; | 23 | bool solenoid_on = false; |
23 | bool solenoid_buzzing = false; | 24 | bool solenoid_buzzing = false; |