From b624f32f944acdc59dcb130674c09090c5c404cb Mon Sep 17 00:00:00 2001 From: skullY Date: Fri, 30 Aug 2019 11:19:03 -0700 Subject: clang-format changes --- drivers/haptic/DRV2605L.c | 150 ++++++------ drivers/haptic/DRV2605L.h | 574 +++++++++++++++++++++++----------------------- drivers/haptic/haptic.c | 316 +++++++++++++------------ drivers/haptic/haptic.h | 78 +++---- drivers/haptic/solenoid.c | 100 ++++---- drivers/haptic/solenoid.h | 10 +- 6 files changed, 609 insertions(+), 619 deletions(-) (limited to 'drivers/haptic') diff --git a/drivers/haptic/DRV2605L.c b/drivers/haptic/DRV2605L.c index 215e6be3e..f74c96525 100644 --- a/drivers/haptic/DRV2605L.c +++ b/drivers/haptic/DRV2605L.c @@ -20,110 +20,102 @@ #include #include - uint8_t DRV2605L_transfer_buffer[2]; uint8_t DRV2605L_tx_register[0]; uint8_t DRV2605L_read_buffer[0]; uint8_t DRV2605L_read_register; - void DRV_write(uint8_t drv_register, uint8_t settings) { - DRV2605L_transfer_buffer[0] = drv_register; - DRV2605L_transfer_buffer[1] = settings; - i2c_transmit(DRV2605L_BASE_ADDRESS << 1, DRV2605L_transfer_buffer, 2, 100); + DRV2605L_transfer_buffer[0] = drv_register; + DRV2605L_transfer_buffer[1] = settings; + i2c_transmit(DRV2605L_BASE_ADDRESS << 1, DRV2605L_transfer_buffer, 2, 100); } uint8_t DRV_read(uint8_t regaddress) { #ifdef __AVR__ - i2c_readReg(DRV2605L_BASE_ADDRESS << 1, - regaddress, DRV2605L_read_buffer, 1, 100); - DRV2605L_read_register = (uint8_t)DRV2605L_read_buffer[0]; + i2c_readReg(DRV2605L_BASE_ADDRESS << 1, regaddress, DRV2605L_read_buffer, 1, 100); + DRV2605L_read_register = (uint8_t)DRV2605L_read_buffer[0]; #else - DRV2605L_tx_register[0] = regaddress; - if (MSG_OK != i2c_transmit_receive(DRV2605L_BASE_ADDRESS << 1, - DRV2605L_tx_register, 1, - DRV2605L_read_buffer, 1 -)){ - printf("err reading reg \n"); - } - DRV2605L_read_register = (uint8_t)DRV2605L_read_buffer[0]; + DRV2605L_tx_register[0] = regaddress; + if (MSG_OK != i2c_transmit_receive(DRV2605L_BASE_ADDRESS << 1, DRV2605L_tx_register, 1, DRV2605L_read_buffer, 1)) { + printf("err reading reg \n"); + } + DRV2605L_read_register = (uint8_t)DRV2605L_read_buffer[0]; #endif -return DRV2605L_read_register; + return DRV2605L_read_register; } -void DRV_init(void) -{ - i2c_init(); - /* 0x07 sets DRV2605 into calibration mode */ - DRV_write(DRV_MODE,0x07); +void DRV_init(void) { + i2c_init(); + /* 0x07 sets DRV2605 into calibration mode */ + DRV_write(DRV_MODE, 0x07); + + // DRV_write(DRV_FEEDBACK_CTRL,0xB6); -// DRV_write(DRV_FEEDBACK_CTRL,0xB6); - - #if FB_ERM_LRA == 0 +#if FB_ERM_LRA == 0 /* ERM settings */ - DRV_write(DRV_RATED_VOLT, (RATED_VOLTAGE/21.33)*1000); - #if ERM_OPEN_LOOP == 0 - DRV_write(DRV_OVERDRIVE_CLAMP_VOLT, (((V_PEAK*(DRIVE_TIME+BLANKING_TIME+IDISS_TIME))/0.02133)/(DRIVE_TIME-0.0003))); - #elif ERM_OPEN_LOOP == 1 - DRV_write(DRV_OVERDRIVE_CLAMP_VOLT, (V_PEAK/0.02196)); - #endif - #elif FB_ERM_LRA == 1 - DRV_write(DRV_RATED_VOLT, ((V_RMS * sqrt(1 - ((4 * ((150+(SAMPLE_TIME*50))*0.000001)) + 0.0003)* F_LRA)/0.02071))); - #if LRA_OPEN_LOOP == 0 - DRV_write(DRV_OVERDRIVE_CLAMP_VOLT, ((V_PEAK/sqrt(1-(F_LRA*0.0008))/0.02133))); - #elif LRA_OPEN_LOOP == 1 - DRV_write(DRV_OVERDRIVE_CLAMP_VOLT, (V_PEAK/0.02196)); - #endif - #endif - - DRVREG_FBR FB_SET; - FB_SET.Bits.ERM_LRA = FB_ERM_LRA; + DRV_write(DRV_RATED_VOLT, (RATED_VOLTAGE / 21.33) * 1000); +# if ERM_OPEN_LOOP == 0 + DRV_write(DRV_OVERDRIVE_CLAMP_VOLT, (((V_PEAK * (DRIVE_TIME + BLANKING_TIME + IDISS_TIME)) / 0.02133) / (DRIVE_TIME - 0.0003))); +# elif ERM_OPEN_LOOP == 1 + DRV_write(DRV_OVERDRIVE_CLAMP_VOLT, (V_PEAK / 0.02196)); +# endif +#elif FB_ERM_LRA == 1 + DRV_write(DRV_RATED_VOLT, ((V_RMS * sqrt(1 - ((4 * ((150 + (SAMPLE_TIME * 50)) * 0.000001)) + 0.0003) * F_LRA) / 0.02071))); +# if LRA_OPEN_LOOP == 0 + DRV_write(DRV_OVERDRIVE_CLAMP_VOLT, ((V_PEAK / sqrt(1 - (F_LRA * 0.0008)) / 0.02133))); +# elif LRA_OPEN_LOOP == 1 + DRV_write(DRV_OVERDRIVE_CLAMP_VOLT, (V_PEAK / 0.02196)); +# endif +#endif + + DRVREG_FBR FB_SET; + FB_SET.Bits.ERM_LRA = FB_ERM_LRA; FB_SET.Bits.BRAKE_FACTOR = FB_BRAKEFACTOR; - FB_SET.Bits.LOOP_GAIN =FB_LOOPGAIN; - FB_SET.Bits.BEMF_GAIN = 0; /* auto-calibration populates this field*/ - DRV_write(DRV_FEEDBACK_CTRL, (uint8_t) FB_SET.Byte); - DRVREG_CTRL1 C1_SET; - C1_SET.Bits.C1_DRIVE_TIME = DRIVE_TIME; - C1_SET.Bits.C1_AC_COUPLE = AC_COUPLE; + FB_SET.Bits.LOOP_GAIN = FB_LOOPGAIN; + FB_SET.Bits.BEMF_GAIN = 0; /* auto-calibration populates this field*/ + DRV_write(DRV_FEEDBACK_CTRL, (uint8_t)FB_SET.Byte); + DRVREG_CTRL1 C1_SET; + C1_SET.Bits.C1_DRIVE_TIME = DRIVE_TIME; + C1_SET.Bits.C1_AC_COUPLE = AC_COUPLE; C1_SET.Bits.C1_STARTUP_BOOST = STARTUP_BOOST; - DRV_write(DRV_CTRL_1, (uint8_t) C1_SET.Byte); - DRVREG_CTRL2 C2_SET; - C2_SET.Bits.C2_BIDIR_INPUT = BIDIR_INPUT; - C2_SET.Bits.C2_BRAKE_STAB = BRAKE_STAB; - C2_SET.Bits.C2_SAMPLE_TIME = SAMPLE_TIME; + DRV_write(DRV_CTRL_1, (uint8_t)C1_SET.Byte); + DRVREG_CTRL2 C2_SET; + C2_SET.Bits.C2_BIDIR_INPUT = BIDIR_INPUT; + C2_SET.Bits.C2_BRAKE_STAB = BRAKE_STAB; + C2_SET.Bits.C2_SAMPLE_TIME = SAMPLE_TIME; C2_SET.Bits.C2_BLANKING_TIME = BLANKING_TIME; - C2_SET.Bits.C2_IDISS_TIME = IDISS_TIME; - DRV_write(DRV_CTRL_2, (uint8_t) C2_SET.Byte); - DRVREG_CTRL3 C3_SET; - C3_SET.Bits.C3_LRA_OPEN_LOOP = LRA_OPEN_LOOP; - C3_SET.Bits.C3_N_PWM_ANALOG = N_PWM_ANALOG; - C3_SET.Bits.C3_LRA_DRIVE_MODE = LRA_DRIVE_MODE; + C2_SET.Bits.C2_IDISS_TIME = IDISS_TIME; + DRV_write(DRV_CTRL_2, (uint8_t)C2_SET.Byte); + DRVREG_CTRL3 C3_SET; + C3_SET.Bits.C3_LRA_OPEN_LOOP = LRA_OPEN_LOOP; + C3_SET.Bits.C3_N_PWM_ANALOG = N_PWM_ANALOG; + C3_SET.Bits.C3_LRA_DRIVE_MODE = LRA_DRIVE_MODE; C3_SET.Bits.C3_DATA_FORMAT_RTO = DATA_FORMAT_RTO; C3_SET.Bits.C3_SUPPLY_COMP_DIS = SUPPLY_COMP_DIS; - C3_SET.Bits.C3_ERM_OPEN_LOOP = ERM_OPEN_LOOP; - C3_SET.Bits.C3_NG_THRESH = NG_THRESH; - DRV_write(DRV_CTRL_3, (uint8_t) C3_SET.Byte); - DRVREG_CTRL4 C4_SET; - C4_SET.Bits.C4_ZC_DET_TIME = ZC_DET_TIME; + C3_SET.Bits.C3_ERM_OPEN_LOOP = ERM_OPEN_LOOP; + C3_SET.Bits.C3_NG_THRESH = NG_THRESH; + DRV_write(DRV_CTRL_3, (uint8_t)C3_SET.Byte); + DRVREG_CTRL4 C4_SET; + C4_SET.Bits.C4_ZC_DET_TIME = ZC_DET_TIME; C4_SET.Bits.C4_AUTO_CAL_TIME = AUTO_CAL_TIME; - DRV_write(DRV_CTRL_4, (uint8_t) C4_SET.Byte); - DRV_write(DRV_LIB_SELECTION,LIB_SELECTION); + DRV_write(DRV_CTRL_4, (uint8_t)C4_SET.Byte); + DRV_write(DRV_LIB_SELECTION, LIB_SELECTION); - DRV_write(DRV_GO, 0x01); + DRV_write(DRV_GO, 0x01); - /* 0x00 sets DRV2605 out of standby and to use internal trigger - * 0x01 sets DRV2605 out of standby and to use external trigger */ - DRV_write(DRV_MODE,0x00); + /* 0x00 sets DRV2605 out of standby and to use internal trigger + * 0x01 sets DRV2605 out of standby and to use external trigger */ + DRV_write(DRV_MODE, 0x00); -//Play greeting sequence - DRV_write(DRV_GO, 0x00); - DRV_write(DRV_WAVEFORM_SEQ_1, DRV_GREETING); - DRV_write(DRV_GO, 0x01); + // Play greeting sequence + DRV_write(DRV_GO, 0x00); + DRV_write(DRV_WAVEFORM_SEQ_1, DRV_GREETING); + DRV_write(DRV_GO, 0x01); } -void DRV_pulse(uint8_t sequence) -{ - DRV_write(DRV_GO, 0x00); - DRV_write(DRV_WAVEFORM_SEQ_1, sequence); - DRV_write(DRV_GO, 0x01); +void DRV_pulse(uint8_t sequence) { + DRV_write(DRV_GO, 0x00); + DRV_write(DRV_WAVEFORM_SEQ_1, sequence); + DRV_write(DRV_GO, 0x01); } \ No newline at end of file diff --git a/drivers/haptic/DRV2605L.h b/drivers/haptic/DRV2605L.h index 836e9cbcd..f550b859f 100644 --- a/drivers/haptic/DRV2605L.h +++ b/drivers/haptic/DRV2605L.h @@ -22,383 +22,383 @@ * Feedback Control Settings */ #ifndef FB_ERM_LRA -#define FB_ERM_LRA 1 /* For ERM:0 or LRA:1*/ +# define FB_ERM_LRA 1 /* For ERM:0 or LRA:1*/ #endif #ifndef FB_BRAKEFACTOR -#define FB_BRAKEFACTOR 3 /* For 1x:0, 2x:1, 3x:2, 4x:3, 6x:4, 8x:5, 16x:6, Disable Braking:7 */ +# define FB_BRAKEFACTOR 3 /* For 1x:0, 2x:1, 3x:2, 4x:3, 6x:4, 8x:5, 16x:6, Disable Braking:7 */ #endif #ifndef FB_LOOPGAIN -#define FB_LOOPGAIN 1 /* For Low:0, Medium:1, High:2, Very High:3 */ +# define FB_LOOPGAIN 1 /* For Low:0, Medium:1, High:2, Very High:3 */ #endif /* LRA specific settings */ #if FB_ERM_LRA == 1 -#ifndef V_RMS -#define V_RMS 2.0 -#endif -#ifndef V_PEAK -#define V_PEAK 2.1 -#endif -#ifndef F_LRA -#define F_LRA 205 -#endif -#ifndef RATED_VOLTAGE -#define RATED_VOLTAGE 2 /* 2v as safe range in case device voltage is not set */ -#endif +# ifndef V_RMS +# define V_RMS 2.0 +# endif +# ifndef V_PEAK +# define V_PEAK 2.1 +# endif +# ifndef F_LRA +# define F_LRA 205 +# endif +# ifndef RATED_VOLTAGE +# define RATED_VOLTAGE 2 /* 2v as safe range in case device voltage is not set */ +# endif #endif #ifndef RATED_VOLTAGE -#define RATED_VOLTAGE 2 /* 2v as safe range in case device voltage is not set */ +# define RATED_VOLTAGE 2 /* 2v as safe range in case device voltage is not set */ #endif #ifndef V_PEAK -#define V_PEAK 2.8 +# define V_PEAK 2.8 #endif /* Library Selection */ #ifndef LIB_SELECTION -#if FB_ERM_LRA == 1 -#define LIB_SELECTION 6 /* For Empty:0' TS2200 library A to D:1-5, LRA Library: 6 */ -#else -#define LIB_SELECTION 1 -#endif +# if FB_ERM_LRA == 1 +# define LIB_SELECTION 6 /* For Empty:0' TS2200 library A to D:1-5, LRA Library: 6 */ +# else +# define LIB_SELECTION 1 +# endif #endif #ifndef DRV_GREETING -#define DRV_GREETING alert_750ms +# define DRV_GREETING alert_750ms #endif #ifndef DRV_MODE_DEFAULT -#define DRV_MODE_DEFAULT strong_click1 +# define DRV_MODE_DEFAULT strong_click1 #endif /* Control 1 register settings */ #ifndef DRIVE_TIME -#define DRIVE_TIME 25 +# define DRIVE_TIME 25 #endif #ifndef AC_COUPLE -#define AC_COUPLE 0 +# define AC_COUPLE 0 #endif #ifndef STARTUP_BOOST -#define STARTUP_BOOST 1 +# define STARTUP_BOOST 1 #endif /* Control 2 Settings */ #ifndef BIDIR_INPUT -#define BIDIR_INPUT 1 +# define BIDIR_INPUT 1 #endif #ifndef BRAKE_STAB -#define BRAKE_STAB 1 /* Loopgain is reduced when braking is almost complete to improve stability */ +# define BRAKE_STAB 1 /* Loopgain is reduced when braking is almost complete to improve stability */ #endif -#ifndef SAMPLE_TIME -#define SAMPLE_TIME 3 +#ifndef SAMPLE_TIME +# define SAMPLE_TIME 3 #endif #ifndef BLANKING_TIME -#define BLANKING_TIME 1 +# define BLANKING_TIME 1 #endif #ifndef IDISS_TIME -#define IDISS_TIME 1 +# define IDISS_TIME 1 #endif /* Control 3 settings */ #ifndef NG_THRESH -#define NG_THRESH 2 +# define NG_THRESH 2 #endif #ifndef ERM_OPEN_LOOP -#define ERM_OPEN_LOOP 1 +# define ERM_OPEN_LOOP 1 #endif #ifndef SUPPLY_COMP_DIS -#define SUPPLY_COMP_DIS 0 +# define SUPPLY_COMP_DIS 0 #endif #ifndef DATA_FORMAT_RTO -#define DATA_FORMAT_RTO 0 +# define DATA_FORMAT_RTO 0 #endif #ifndef LRA_DRIVE_MODE -#define LRA_DRIVE_MODE 0 +# define LRA_DRIVE_MODE 0 #endif #ifndef N_PWM_ANALOG -#define N_PWM_ANALOG 0 +# define N_PWM_ANALOG 0 #endif #ifndef LRA_OPEN_LOOP -#define LRA_OPEN_LOOP 0 +# define LRA_OPEN_LOOP 0 #endif /* Control 4 settings */ #ifndef ZC_DET_TIME -#define ZC_DET_TIME 0 +# define ZC_DET_TIME 0 #endif #ifndef AUTO_CAL_TIME -#define AUTO_CAL_TIME 3 +# define AUTO_CAL_TIME 3 #endif /* register defines -------------------------------------------------------- */ -#define DRV2605L_BASE_ADDRESS 0x5A /* DRV2605L Base address */ -#define DRV_STATUS 0x00 -#define DRV_MODE 0x01 -#define DRV_RTP_INPUT 0x02 -#define DRV_LIB_SELECTION 0x03 -#define DRV_WAVEFORM_SEQ_1 0x04 -#define DRV_WAVEFORM_SEQ_2 0x05 -#define DRV_WAVEFORM_SEQ_3 0x06 -#define DRV_WAVEFORM_SEQ_4 0x07 -#define DRV_WAVEFORM_SEQ_5 0x08 -#define DRV_WAVEFORM_SEQ_6 0x09 -#define DRV_WAVEFORM_SEQ_7 0x0A -#define DRV_WAVEFORM_SEQ_8 0x0B -#define DRV_GO 0x0C -#define DRV_OVERDRIVE_TIME_OFFSET 0x0D -#define DRV_SUSTAIN_TIME_OFFSET_P 0x0E -#define DRV_SUSTAIN_TIME_OFFSET_N 0x0F -#define DRV_BRAKE_TIME_OFFSET 0x10 -#define DRV_AUDIO_2_VIBE_CTRL 0x11 -#define DRV_AUDIO_2_VIBE_MIN_IN 0x12 -#define DRV_AUDIO_2_VIBE_MAX_IN 0x13 -#define DRV_AUDIO_2_VIBE_MIN_OUTDRV 0x14 -#define DRV_AUDIO_2_VIBE_MAX_OUTDRV 0x15 -#define DRV_RATED_VOLT 0x16 -#define DRV_OVERDRIVE_CLAMP_VOLT 0x17 -#define DRV_AUTO_CALIB_COMP_RESULT 0x18 -#define DRV_AUTO_CALIB_BEMF_RESULT 0x19 -#define DRV_FEEDBACK_CTRL 0x1A -#define DRV_CTRL_1 0x1B -#define DRV_CTRL_2 0x1C -#define DRV_CTRL_3 0x1D -#define DRV_CTRL_4 0x1E -#define DRV_CTRL_5 0x1F -#define DRV_OPEN_LOOP_PERIOD 0x20 -#define DRV_VBAT_VOLT_MONITOR 0x21 -#define DRV_LRA_RESONANCE_PERIOD 0x22 +#define DRV2605L_BASE_ADDRESS 0x5A /* DRV2605L Base address */ +#define DRV_STATUS 0x00 +#define DRV_MODE 0x01 +#define DRV_RTP_INPUT 0x02 +#define DRV_LIB_SELECTION 0x03 +#define DRV_WAVEFORM_SEQ_1 0x04 +#define DRV_WAVEFORM_SEQ_2 0x05 +#define DRV_WAVEFORM_SEQ_3 0x06 +#define DRV_WAVEFORM_SEQ_4 0x07 +#define DRV_WAVEFORM_SEQ_5 0x08 +#define DRV_WAVEFORM_SEQ_6 0x09 +#define DRV_WAVEFORM_SEQ_7 0x0A +#define DRV_WAVEFORM_SEQ_8 0x0B +#define DRV_GO 0x0C +#define DRV_OVERDRIVE_TIME_OFFSET 0x0D +#define DRV_SUSTAIN_TIME_OFFSET_P 0x0E +#define DRV_SUSTAIN_TIME_OFFSET_N 0x0F +#define DRV_BRAKE_TIME_OFFSET 0x10 +#define DRV_AUDIO_2_VIBE_CTRL 0x11 +#define DRV_AUDIO_2_VIBE_MIN_IN 0x12 +#define DRV_AUDIO_2_VIBE_MAX_IN 0x13 +#define DRV_AUDIO_2_VIBE_MIN_OUTDRV 0x14 +#define DRV_AUDIO_2_VIBE_MAX_OUTDRV 0x15 +#define DRV_RATED_VOLT 0x16 +#define DRV_OVERDRIVE_CLAMP_VOLT 0x17 +#define DRV_AUTO_CALIB_COMP_RESULT 0x18 +#define DRV_AUTO_CALIB_BEMF_RESULT 0x19 +#define DRV_FEEDBACK_CTRL 0x1A +#define DRV_CTRL_1 0x1B +#define DRV_CTRL_2 0x1C +#define DRV_CTRL_3 0x1D +#define DRV_CTRL_4 0x1E +#define DRV_CTRL_5 0x1F +#define DRV_OPEN_LOOP_PERIOD 0x20 +#define DRV_VBAT_VOLT_MONITOR 0x21 +#define DRV_LRA_RESONANCE_PERIOD 0x22 -void DRV_init(void); -void DRV_write(const uint8_t drv_register, const uint8_t settings); +void DRV_init(void); +void DRV_write(const uint8_t drv_register, const uint8_t settings); uint8_t DRV_read(const uint8_t regaddress); -void DRV_pulse(const uint8_t sequence); +void DRV_pulse(const uint8_t sequence); -typedef enum DRV_EFFECT{ - clear_sequence = 0, - strong_click = 1, - strong_click_60 = 2, - strong_click_30 = 3, - sharp_click = 4, - sharp_click_60 = 5, - sharp_click_30 = 6, - soft_bump = 7, - soft_bump_60 = 8, - soft_bump_30 = 9, - dbl_click = 10, - dbl_click_60 = 11, - trp_click = 12, - soft_fuzz = 13, - strong_buzz = 14, - alert_750ms = 15, - alert_1000ms = 16, - strong_click1 = 17, - strong_click2_80 = 18, - strong_click3_60 = 19, - strong_click4_30 = 20, - medium_click1 = 21, - medium_click2_80 = 22, - medium_click3_60 = 23, - sharp_tick1 = 24, - sharp_tick2_80 = 25, - sharp_tick3_60 = 26, - sh_dblclick_str = 27, - sh_dblclick_str_80 = 28, - sh_dblclick_str_60 = 29, - sh_dblclick_str_30 = 30, - sh_dblclick_med = 31, - sh_dblclick_med_80 = 32, - sh_dblclick_med_60 = 33, - sh_dblsharp_tick = 34, - sh_dblsharp_tick_80 = 35, - sh_dblsharp_tick_60 = 36, - lg_dblclick_str = 37, - lg_dblclick_str_80 = 38, - lg_dblclick_str_60 = 39, - lg_dblclick_str_30 = 40, - lg_dblclick_med = 41, - lg_dblclick_med_80 = 42, - lg_dblclick_med_60 = 43, - lg_dblsharp_tick = 44, - lg_dblsharp_tick_80 = 45, - lg_dblsharp_tick_60 = 46, - buzz = 47, - buzz_80 = 48, - buzz_60 = 49, - buzz_40 = 50, - buzz_20 = 51, - pulsing_strong = 52, - pulsing_strong_80 = 53, - pulsing_medium = 54, - pulsing_medium_80 = 55, - pulsing_sharp = 56, - pulsing_sharp_80 = 57, - transition_click = 58, - transition_click_80 = 59, - transition_click_60 = 60, - transition_click_40 = 61, - transition_click_20 = 62, - transition_click_10 = 63, - transition_hum = 64, - transition_hum_80 = 65, - transition_hum_60 = 66, - transition_hum_40 = 67, - transition_hum_20 = 68, - transition_hum_10 = 69, - transition_rampdown_long_smooth1 = 70, - transition_rampdown_long_smooth2 = 71, - transition_rampdown_med_smooth1 = 72, - transition_rampdown_med_smooth2 = 73, - transition_rampdown_short_smooth1 = 74, - transition_rampdown_short_smooth2 = 75, - transition_rampdown_long_sharp1 = 76, - transition_rampdown_long_sharp2 = 77, - transition_rampdown_med_sharp1 = 78, - transition_rampdown_med_sharp2 = 79, - transition_rampdown_short_sharp1 = 80, - transition_rampdown_short_sharp2 = 81, - transition_rampup_long_smooth1 = 82, - transition_rampup_long_smooth2 = 83, - transition_rampup_med_smooth1 = 84, - transition_rampup_med_smooth2 = 85, - transition_rampup_short_smooth1 = 86, - transition_rampup_short_smooth2 = 87, - transition_rampup_long_sharp1 = 88, - transition_rampup_long_sharp2 = 89, - transition_rampup_med_sharp1 = 90, - transition_rampup_med_sharp2 = 91, - transition_rampup_short_sharp1 = 92, - transition_rampup_short_sharp2 = 93, - transition_rampdown_long_smooth1_50 = 94, - transition_rampdown_long_smooth2_50 = 95, - transition_rampdown_med_smooth1_50 = 96, - transition_rampdown_med_smooth2_50 = 97, - transition_rampdown_short_smooth1_50 = 98, - transition_rampdown_short_smooth2_50 = 99, - transition_rampdown_long_sharp1_50 = 100, - transition_rampdown_long_sharp2_50 = 101, - transition_rampdown_med_sharp1_50 = 102, - transition_rampdown_med_sharp2_50 = 103, - transition_rampdown_short_sharp1_50 = 104, - transition_rampdown_short_sharp2_50 = 105, - transition_rampup_long_smooth1_50 = 106, - transition_rampup_long_smooth2_50 = 107, - transition_rampup_med_smooth1_50 = 108, - transition_rampup_med_smooth2_50 = 109, - transition_rampup_short_smooth1_50 = 110, - transition_rampup_short_smooth2_50 = 111, - transition_rampup_long_sharp1_50 = 112, - transition_rampup_long_sharp2_50 = 113, - transition_rampup_med_sharp1_50 = 114, - transition_rampup_med_sharp2_50 = 115, - transition_rampup_short_sharp1_50 = 116, - transition_rampup_short_sharp2_50 = 117, - long_buzz_for_programmatic_stopping = 118, - smooth_hum1_50 = 119, - smooth_hum2_40 = 120, - smooth_hum3_30 = 121, - smooth_hum4_20 = 122, - smooth_hum5_10 = 123, - drv_effect_max = 124, +typedef enum DRV_EFFECT { + clear_sequence = 0, + strong_click = 1, + strong_click_60 = 2, + strong_click_30 = 3, + sharp_click = 4, + sharp_click_60 = 5, + sharp_click_30 = 6, + soft_bump = 7, + soft_bump_60 = 8, + soft_bump_30 = 9, + dbl_click = 10, + dbl_click_60 = 11, + trp_click = 12, + soft_fuzz = 13, + strong_buzz = 14, + alert_750ms = 15, + alert_1000ms = 16, + strong_click1 = 17, + strong_click2_80 = 18, + strong_click3_60 = 19, + strong_click4_30 = 20, + medium_click1 = 21, + medium_click2_80 = 22, + medium_click3_60 = 23, + sharp_tick1 = 24, + sharp_tick2_80 = 25, + sharp_tick3_60 = 26, + sh_dblclick_str = 27, + sh_dblclick_str_80 = 28, + sh_dblclick_str_60 = 29, + sh_dblclick_str_30 = 30, + sh_dblclick_med = 31, + sh_dblclick_med_80 = 32, + sh_dblclick_med_60 = 33, + sh_dblsharp_tick = 34, + sh_dblsharp_tick_80 = 35, + sh_dblsharp_tick_60 = 36, + lg_dblclick_str = 37, + lg_dblclick_str_80 = 38, + lg_dblclick_str_60 = 39, + lg_dblclick_str_30 = 40, + lg_dblclick_med = 41, + lg_dblclick_med_80 = 42, + lg_dblclick_med_60 = 43, + lg_dblsharp_tick = 44, + lg_dblsharp_tick_80 = 45, + lg_dblsharp_tick_60 = 46, + buzz = 47, + buzz_80 = 48, + buzz_60 = 49, + buzz_40 = 50, + buzz_20 = 51, + pulsing_strong = 52, + pulsing_strong_80 = 53, + pulsing_medium = 54, + pulsing_medium_80 = 55, + pulsing_sharp = 56, + pulsing_sharp_80 = 57, + transition_click = 58, + transition_click_80 = 59, + transition_click_60 = 60, + transition_click_40 = 61, + transition_click_20 = 62, + transition_click_10 = 63, + transition_hum = 64, + transition_hum_80 = 65, + transition_hum_60 = 66, + transition_hum_40 = 67, + transition_hum_20 = 68, + transition_hum_10 = 69, + transition_rampdown_long_smooth1 = 70, + transition_rampdown_long_smooth2 = 71, + transition_rampdown_med_smooth1 = 72, + transition_rampdown_med_smooth2 = 73, + transition_rampdown_short_smooth1 = 74, + transition_rampdown_short_smooth2 = 75, + transition_rampdown_long_sharp1 = 76, + transition_rampdown_long_sharp2 = 77, + transition_rampdown_med_sharp1 = 78, + transition_rampdown_med_sharp2 = 79, + transition_rampdown_short_sharp1 = 80, + transition_rampdown_short_sharp2 = 81, + transition_rampup_long_smooth1 = 82, + transition_rampup_long_smooth2 = 83, + transition_rampup_med_smooth1 = 84, + transition_rampup_med_smooth2 = 85, + transition_rampup_short_smooth1 = 86, + transition_rampup_short_smooth2 = 87, + transition_rampup_long_sharp1 = 88, + transition_rampup_long_sharp2 = 89, + transition_rampup_med_sharp1 = 90, + transition_rampup_med_sharp2 = 91, + transition_rampup_short_sharp1 = 92, + transition_rampup_short_sharp2 = 93, + transition_rampdown_long_smooth1_50 = 94, + transition_rampdown_long_smooth2_50 = 95, + transition_rampdown_med_smooth1_50 = 96, + transition_rampdown_med_smooth2_50 = 97, + transition_rampdown_short_smooth1_50 = 98, + transition_rampdown_short_smooth2_50 = 99, + transition_rampdown_long_sharp1_50 = 100, + transition_rampdown_long_sharp2_50 = 101, + transition_rampdown_med_sharp1_50 = 102, + transition_rampdown_med_sharp2_50 = 103, + transition_rampdown_short_sharp1_50 = 104, + transition_rampdown_short_sharp2_50 = 105, + transition_rampup_long_smooth1_50 = 106, + transition_rampup_long_smooth2_50 = 107, + transition_rampup_med_smooth1_50 = 108, + transition_rampup_med_smooth2_50 = 109, + transition_rampup_short_smooth1_50 = 110, + transition_rampup_short_smooth2_50 = 111, + transition_rampup_long_sharp1_50 = 112, + transition_rampup_long_sharp2_50 = 113, + transition_rampup_med_sharp1_50 = 114, + transition_rampup_med_sharp2_50 = 115, + transition_rampup_short_sharp1_50 = 116, + transition_rampup_short_sharp2_50 = 117, + long_buzz_for_programmatic_stopping = 118, + smooth_hum1_50 = 119, + smooth_hum2_40 = 120, + smooth_hum3_30 = 121, + smooth_hum4_20 = 122, + smooth_hum5_10 = 123, + drv_effect_max = 124, } DRV_EFFECT; /* Register bit array unions */ typedef union DRVREG_STATUS { /* register 0x00 */ - uint8_t Byte; - struct { - uint8_t OC_DETECT :1; /* set to 1 when overcurrent event is detected */ - uint8_t OVER_TEMP :1; /* set to 1 when device exceeds temp threshold */ - uint8_t FB_STS :1; /* set to 1 when feedback controller has timed out */ - /* auto-calibration routine and diagnostic result - * result | auto-calibation | diagnostic | - * 0 | passed | actuator func normal | - * 1 | failed | actuator func fault* | - * * actuator is not present or is shorted, timing out, or giving out–of-range back-EMF */ - uint8_t DIAG_RESULT :1; - uint8_t :1; - uint8_t DEVICE_ID :3; /* Device IDs 3: DRV2605 4: DRV2604 5: DRV2604L 6: DRV2605L */ - } Bits; + uint8_t Byte; + struct { + uint8_t OC_DETECT : 1; /* set to 1 when overcurrent event is detected */ + uint8_t OVER_TEMP : 1; /* set to 1 when device exceeds temp threshold */ + uint8_t FB_STS : 1; /* set to 1 when feedback controller has timed out */ + /* auto-calibration routine and diagnostic result + * result | auto-calibation | diagnostic | + * 0 | passed | actuator func normal | + * 1 | failed | actuator func fault* | + * * actuator is not present or is shorted, timing out, or giving out–of-range back-EMF */ + uint8_t DIAG_RESULT : 1; + uint8_t : 1; + uint8_t DEVICE_ID : 3; /* Device IDs 3: DRV2605 4: DRV2604 5: DRV2604L 6: DRV2605L */ + } Bits; } DRVREG_STATUS; typedef union DRVREG_MODE { /* register 0x01 */ - uint8_t Byte; - struct { - uint8_t MODE :3; /* Mode setting */ - uint8_t :3; - uint8_t STANDBY :1; /* 0:standby 1:ready */ - } Bits; + uint8_t Byte; + struct { + uint8_t MODE : 3; /* Mode setting */ + uint8_t : 3; + uint8_t STANDBY : 1; /* 0:standby 1:ready */ + } Bits; } DRVREG_MODE; typedef union DRVREG_WAIT { - uint8_t Byte; - struct { - uint8_t WAIT_MODE :1; /* Set to 1 to interpret as wait for next 7 bits x10ms */ - uint8_t WAIT_TIME :7; - } Bits; + uint8_t Byte; + struct { + uint8_t WAIT_MODE : 1; /* Set to 1 to interpret as wait for next 7 bits x10ms */ + uint8_t WAIT_TIME : 7; + } Bits; } DRVREG_WAIT; -typedef union DRVREG_FBR{ /* register 0x1A */ - uint8_t Byte; - struct { - uint8_t BEMF_GAIN :2; - uint8_t LOOP_GAIN :2; - uint8_t BRAKE_FACTOR :3; - uint8_t ERM_LRA :1; - } Bits; +typedef union DRVREG_FBR { /* register 0x1A */ + uint8_t Byte; + struct { + uint8_t BEMF_GAIN : 2; + uint8_t LOOP_GAIN : 2; + uint8_t BRAKE_FACTOR : 3; + uint8_t ERM_LRA : 1; + } Bits; } DRVREG_FBR; -typedef union DRVREG_CTRL1{ /* register 0x1B */ - uint8_t Byte; - struct { - uint8_t C1_DRIVE_TIME :5; - uint8_t C1_AC_COUPLE :1; - uint8_t :1; - uint8_t C1_STARTUP_BOOST :1; - } Bits; +typedef union DRVREG_CTRL1 { /* register 0x1B */ + uint8_t Byte; + struct { + uint8_t C1_DRIVE_TIME : 5; + uint8_t C1_AC_COUPLE : 1; + uint8_t : 1; + uint8_t C1_STARTUP_BOOST : 1; + } Bits; } DRVREG_CTRL1; -typedef union DRVREG_CTRL2{ /* register 0x1C */ - uint8_t Byte; - struct { - uint8_t C2_IDISS_TIME :2; - uint8_t C2_BLANKING_TIME :2; - uint8_t C2_SAMPLE_TIME :2; - uint8_t C2_BRAKE_STAB :1; - uint8_t C2_BIDIR_INPUT :1; - } Bits; +typedef union DRVREG_CTRL2 { /* register 0x1C */ + uint8_t Byte; + struct { + uint8_t C2_IDISS_TIME : 2; + uint8_t C2_BLANKING_TIME : 2; + uint8_t C2_SAMPLE_TIME : 2; + uint8_t C2_BRAKE_STAB : 1; + uint8_t C2_BIDIR_INPUT : 1; + } Bits; } DRVREG_CTRL2; -typedef union DRVREG_CTRL3{ /* register 0x1D */ - uint8_t Byte; - struct { - uint8_t C3_LRA_OPEN_LOOP :1; - uint8_t C3_N_PWM_ANALOG :1; - uint8_t C3_LRA_DRIVE_MODE :1; - uint8_t C3_DATA_FORMAT_RTO :1; - uint8_t C3_SUPPLY_COMP_DIS :1; - uint8_t C3_ERM_OPEN_LOOP :1; - uint8_t C3_NG_THRESH :2; - } Bits; +typedef union DRVREG_CTRL3 { /* register 0x1D */ + uint8_t Byte; + struct { + uint8_t C3_LRA_OPEN_LOOP : 1; + uint8_t C3_N_PWM_ANALOG : 1; + uint8_t C3_LRA_DRIVE_MODE : 1; + uint8_t C3_DATA_FORMAT_RTO : 1; + uint8_t C3_SUPPLY_COMP_DIS : 1; + uint8_t C3_ERM_OPEN_LOOP : 1; + uint8_t C3_NG_THRESH : 2; + } Bits; } DRVREG_CTRL3; -typedef union DRVREG_CTRL4{ /* register 0x1E */ - uint8_t Byte; - struct { - uint8_t C4_OTP_PROGRAM :1; - uint8_t :1; - uint8_t C4_OTP_STATUS :1; - uint8_t :1; - uint8_t C4_AUTO_CAL_TIME :2; - uint8_t C4_ZC_DET_TIME :2; - } Bits; +typedef union DRVREG_CTRL4 { /* register 0x1E */ + uint8_t Byte; + struct { + uint8_t C4_OTP_PROGRAM : 1; + uint8_t : 1; + uint8_t C4_OTP_STATUS : 1; + uint8_t : 1; + uint8_t C4_AUTO_CAL_TIME : 2; + uint8_t C4_ZC_DET_TIME : 2; + } Bits; } DRVREG_CTRL4; -typedef union DRVREG_CTRL5{ /* register 0x1F */ - uint8_t Byte; - struct { - uint8_t C5_IDISS_TIME :2; - uint8_t C5_BLANKING_TIME :2; - uint8_t C5_PLAYBACK_INTERVAL :1; - uint8_t C5_LRA_AUTO_OPEN_LOOP :1; - uint8_t C5_AUTO_OL_CNT :2; - } Bits; +typedef union DRVREG_CTRL5 { /* register 0x1F */ + uint8_t Byte; + struct { + uint8_t C5_IDISS_TIME : 2; + uint8_t C5_BLANKING_TIME : 2; + uint8_t C5_PLAYBACK_INTERVAL : 1; + uint8_t C5_LRA_AUTO_OPEN_LOOP : 1; + uint8_t C5_AUTO_OL_CNT : 2; + } Bits; } DRVREG_CTRL5; \ No newline at end of file diff --git a/drivers/haptic/haptic.c b/drivers/haptic/haptic.c index a94f05565..ded6d8a44 100644 --- a/drivers/haptic/haptic.c +++ b/drivers/haptic/haptic.c @@ -19,230 +19,248 @@ #include "progmem.h" #include "debug.h" #ifdef DRV2605L -#include "DRV2605L.h" +# include "DRV2605L.h" #endif #ifdef SOLENOID_ENABLE -#include "solenoid.h" +# include "solenoid.h" #endif haptic_config_t haptic_config; void haptic_init(void) { - debug_enable = 1; //Debug is ON! - if (!eeconfig_is_enabled()) { - eeconfig_init(); - } - haptic_config.raw = eeconfig_read_haptic(); - if (haptic_config.mode < 1){ - haptic_config.mode = 1; - } - if (!haptic_config.mode){ - dprintf("No haptic config found in eeprom, setting default configs\n"); - haptic_reset(); - } - #ifdef SOLENOID_ENABLE + debug_enable = 1; // Debug is ON! + if (!eeconfig_is_enabled()) { + eeconfig_init(); + } + haptic_config.raw = eeconfig_read_haptic(); + if (haptic_config.mode < 1) { + haptic_config.mode = 1; + } + if (!haptic_config.mode) { + dprintf("No haptic config found in eeprom, setting default configs\n"); + haptic_reset(); + } +#ifdef SOLENOID_ENABLE solenoid_setup(); dprintf("Solenoid driver initialized\n"); - #endif - #ifdef DRV2605L +#endif +#ifdef DRV2605L DRV_init(); dprintf("DRV2605 driver initialized\n"); - #endif - eeconfig_debug_haptic(); +#endif + eeconfig_debug_haptic(); } void haptic_task(void) { - #ifdef SOLENOID_ENABLE - solenoid_check(); - #endif +#ifdef SOLENOID_ENABLE + solenoid_check(); +#endif } void eeconfig_debug_haptic(void) { - dprintf("haptic_config eprom\n"); - dprintf("haptic_config.enable = %d\n", haptic_config.enable); - dprintf("haptic_config.mode = %d\n", haptic_config.mode); + dprintf("haptic_config eprom\n"); + dprintf("haptic_config.enable = %d\n", haptic_config.enable); + dprintf("haptic_config.mode = %d\n", haptic_config.mode); } void haptic_enable(void) { - haptic_config.enable = 1; - xprintf("haptic_config.enable = %u\n", haptic_config.enable); - eeconfig_update_haptic(haptic_config.raw); + haptic_config.enable = 1; + xprintf("haptic_config.enable = %u\n", haptic_config.enable); + eeconfig_update_haptic(haptic_config.raw); } void haptic_disable(void) { - haptic_config.enable = 0; - xprintf("haptic_config.enable = %u\n", haptic_config.enable); - eeconfig_update_haptic(haptic_config.raw); + haptic_config.enable = 0; + xprintf("haptic_config.enable = %u\n", haptic_config.enable); + eeconfig_update_haptic(haptic_config.raw); } void haptic_toggle(void) { -if (haptic_config.enable) { - haptic_disable(); - } else { - haptic_enable(); - } - eeconfig_update_haptic(haptic_config.raw); + if (haptic_config.enable) { + haptic_disable(); + } else { + haptic_enable(); + } + eeconfig_update_haptic(haptic_config.raw); } -void haptic_feedback_toggle(void){ - haptic_config.feedback++; - if (haptic_config.feedback >= HAPTIC_FEEDBACK_MAX) - haptic_config.feedback = KEY_PRESS; - xprintf("haptic_config.feedback = %u\n", !haptic_config.feedback); - eeconfig_update_haptic(haptic_config.raw); +void haptic_feedback_toggle(void) { + haptic_config.feedback++; + if (haptic_config.feedback >= HAPTIC_FEEDBACK_MAX) haptic_config.feedback = KEY_PRESS; + xprintf("haptic_config.feedback = %u\n", !haptic_config.feedback); + eeconfig_update_haptic(haptic_config.raw); } void haptic_buzz_toggle(void) { - bool buzz_stat = !haptic_config.buzz; - haptic_config.buzz = buzz_stat; - haptic_set_buzz(buzz_stat); + bool buzz_stat = !haptic_config.buzz; + haptic_config.buzz = buzz_stat; + haptic_set_buzz(buzz_stat); } void haptic_mode_increase(void) { - uint8_t mode = haptic_config.mode + 1; - #ifdef DRV2605L - if (haptic_config.mode >= drv_effect_max) { - mode = 1; - } - #endif + uint8_t mode = haptic_config.mode + 1; +#ifdef DRV2605L + if (haptic_config.mode >= drv_effect_max) { + mode = 1; + } +#endif haptic_set_mode(mode); } void haptic_mode_decrease(void) { - uint8_t mode = haptic_config.mode -1; - #ifdef DRV2605L - if (haptic_config.mode < 1) { - mode = (drv_effect_max - 1); - } - #endif - haptic_set_mode(mode); + uint8_t mode = haptic_config.mode - 1; +#ifdef DRV2605L + if (haptic_config.mode < 1) { + mode = (drv_effect_max - 1); + } +#endif + haptic_set_mode(mode); } void haptic_dwell_increase(void) { - uint8_t dwell = haptic_config.dwell + 1; - #ifdef SOLENOID_ENABLE - if (haptic_config.dwell >= SOLENOID_MAX_DWELL) { - dwell = 1; - } - solenoid_set_dwell(dwell); - #endif - haptic_set_dwell(dwell); + uint8_t dwell = haptic_config.dwell + 1; +#ifdef SOLENOID_ENABLE + if (haptic_config.dwell >= SOLENOID_MAX_DWELL) { + dwell = 1; + } + solenoid_set_dwell(dwell); +#endif + haptic_set_dwell(dwell); } void haptic_dwell_decrease(void) { - uint8_t dwell = haptic_config.dwell -1; - #ifdef SOLENOID_ENABLE - if (haptic_config.dwell < SOLENOID_MIN_DWELL) { - dwell = SOLENOID_MAX_DWELL; - } - solenoid_set_dwell(dwell); - #endif - haptic_set_dwell(dwell); -} - -void haptic_reset(void){ - haptic_config.enable = true; - uint8_t feedback = HAPTIC_FEEDBACK_DEFAULT; - haptic_config.feedback = feedback; - #ifdef DRV2605L - uint8_t mode = HAPTIC_MODE_DEFAULT; + uint8_t dwell = haptic_config.dwell - 1; +#ifdef SOLENOID_ENABLE + if (haptic_config.dwell < SOLENOID_MIN_DWELL) { + dwell = SOLENOID_MAX_DWELL; + } + solenoid_set_dwell(dwell); +#endif + haptic_set_dwell(dwell); +} + +void haptic_reset(void) { + haptic_config.enable = true; + uint8_t feedback = HAPTIC_FEEDBACK_DEFAULT; + haptic_config.feedback = feedback; +#ifdef DRV2605L + uint8_t mode = HAPTIC_MODE_DEFAULT; haptic_config.mode = mode; - #endif - #ifdef SOLENOID_ENABLE - uint8_t dwell = SOLENOID_DEFAULT_DWELL; +#endif +#ifdef SOLENOID_ENABLE + uint8_t dwell = SOLENOID_DEFAULT_DWELL; haptic_config.dwell = dwell; - #endif - eeconfig_update_haptic(haptic_config.raw); - xprintf("haptic_config.feedback = %u\n", haptic_config.feedback); - xprintf("haptic_config.mode = %u\n", haptic_config.mode); +#endif + eeconfig_update_haptic(haptic_config.raw); + xprintf("haptic_config.feedback = %u\n", haptic_config.feedback); + xprintf("haptic_config.mode = %u\n", haptic_config.mode); } void haptic_set_feedback(uint8_t feedback) { - haptic_config.feedback = feedback; - eeconfig_update_haptic(haptic_config.raw); - xprintf("haptic_config.feedback = %u\n", haptic_config.feedback); + haptic_config.feedback = feedback; + eeconfig_update_haptic(haptic_config.raw); + xprintf("haptic_config.feedback = %u\n", haptic_config.feedback); } void haptic_set_mode(uint8_t mode) { - haptic_config.mode = mode; - eeconfig_update_haptic(haptic_config.raw); - xprintf("haptic_config.mode = %u\n", haptic_config.mode); + haptic_config.mode = mode; + eeconfig_update_haptic(haptic_config.raw); + xprintf("haptic_config.mode = %u\n", haptic_config.mode); } void haptic_set_buzz(uint8_t buzz) { - haptic_config.buzz = buzz; - eeconfig_update_haptic(haptic_config.raw); - xprintf("haptic_config.buzz = %u\n", haptic_config.buzz); + haptic_config.buzz = buzz; + eeconfig_update_haptic(haptic_config.raw); + xprintf("haptic_config.buzz = %u\n", haptic_config.buzz); } void haptic_set_dwell(uint8_t dwell) { - haptic_config.dwell = dwell; - eeconfig_update_haptic(haptic_config.raw); - xprintf("haptic_config.dwell = %u\n", haptic_config.dwell); + haptic_config.dwell = dwell; + eeconfig_update_haptic(haptic_config.raw); + xprintf("haptic_config.dwell = %u\n", haptic_config.dwell); } uint8_t haptic_get_mode(void) { - if (!haptic_config.enable){ - return false; - } - return haptic_config.mode; + if (!haptic_config.enable) { + return false; + } + return haptic_config.mode; } uint8_t haptic_get_feedback(void) { - if (!haptic_config.enable){ - return false; - } - return haptic_config.feedback; + if (!haptic_config.enable) { + return false; + } + return haptic_config.feedback; } uint8_t haptic_get_dwell(void) { - if (!haptic_config.enable){ - return false; - } - return haptic_config.dwell; + if (!haptic_config.enable) { + return false; + } + return haptic_config.dwell; } void haptic_play(void) { - #ifdef DRV2605L - uint8_t play_eff = 0; - play_eff = haptic_config.mode; - DRV_pulse(play_eff); - #endif - #ifdef SOLENOID_ENABLE - solenoid_fire(); - #endif +#ifdef DRV2605L + uint8_t play_eff = 0; + play_eff = haptic_config.mode; + DRV_pulse(play_eff); +#endif +#ifdef SOLENOID_ENABLE + solenoid_fire(); +#endif } bool process_haptic(uint16_t keycode, keyrecord_t *record) { - if (keycode == HPT_ON && record->event.pressed) { haptic_enable(); } - if (keycode == HPT_OFF && record->event.pressed) { haptic_disable(); } - if (keycode == HPT_TOG && record->event.pressed) { haptic_toggle(); } - if (keycode == HPT_RST && record->event.pressed) { haptic_reset(); } - if (keycode == HPT_FBK && record->event.pressed) { haptic_feedback_toggle(); } - if (keycode == HPT_BUZ && record->event.pressed) { haptic_buzz_toggle(); } - if (keycode == HPT_MODI && record->event.pressed) { haptic_mode_increase(); } - if (keycode == HPT_MODD && record->event.pressed) { haptic_mode_decrease(); } - if (keycode == HPT_DWLI && record->event.pressed) { haptic_dwell_increase(); } - if (keycode == HPT_DWLD && record->event.pressed) { haptic_dwell_decrease(); } - if (haptic_config.enable) { - if ( record->event.pressed ) { - // keypress - if (haptic_config.feedback < 2) { - haptic_play(); - } - } else { - //keyrelease - if (haptic_config.feedback > 0) { - haptic_play(); - } + if (keycode == HPT_ON && record->event.pressed) { + haptic_enable(); } - } - return true; + if (keycode == HPT_OFF && record->event.pressed) { + haptic_disable(); + } + if (keycode == HPT_TOG && record->event.pressed) { + haptic_toggle(); + } + if (keycode == HPT_RST && record->event.pressed) { + haptic_reset(); + } + if (keycode == HPT_FBK && record->event.pressed) { + haptic_feedback_toggle(); + } + if (keycode == HPT_BUZ && record->event.pressed) { + haptic_buzz_toggle(); + } + if (keycode == HPT_MODI && record->event.pressed) { + haptic_mode_increase(); + } + if (keycode == HPT_MODD && record->event.pressed) { + haptic_mode_decrease(); + } + if (keycode == HPT_DWLI && record->event.pressed) { + haptic_dwell_increase(); + } + if (keycode == HPT_DWLD && record->event.pressed) { + haptic_dwell_decrease(); + } + if (haptic_config.enable) { + if (record->event.pressed) { + // keypress + if (haptic_config.feedback < 2) { + haptic_play(); + } + } else { + // keyrelease + if (haptic_config.feedback > 0) { + haptic_play(); + } + } + } + return true; } void haptic_shutdown(void) { - #ifdef SOLENOID_ENABLE - solenoid_shutdown(); - #endif - +#ifdef SOLENOID_ENABLE + solenoid_shutdown(); +#endif } diff --git a/drivers/haptic/haptic.h b/drivers/haptic/haptic.h index d39dc5c3b..8135d0d43 100644 --- a/drivers/haptic/haptic.h +++ b/drivers/haptic/haptic.h @@ -20,63 +20,57 @@ #include #include "quantum.h" #ifdef DRV2605L -#include "DRV2605L.h" +# include "DRV2605L.h" #endif - #ifndef HAPTIC_FEEDBACK_DEFAULT -#define HAPTIC_FEEDBACK_DEFAULT 0 +# define HAPTIC_FEEDBACK_DEFAULT 0 #endif #ifndef HAPTIC_MODE_DEFAULT -#define HAPTIC_MODE_DEFAULT DRV_MODE_DEFAULT +# define HAPTIC_MODE_DEFAULT DRV_MODE_DEFAULT #endif /* EEPROM config settings */ typedef union { - uint32_t raw; - struct { - bool enable :1; - uint8_t feedback :2; - uint8_t mode :7; - bool buzz :1; - uint8_t dwell :7; - uint16_t reserved :16; - }; + uint32_t raw; + struct { + bool enable : 1; + uint8_t feedback : 2; + uint8_t mode : 7; + bool buzz : 1; + uint8_t dwell : 7; + uint16_t reserved : 16; + }; } haptic_config_t; -typedef enum HAPTIC_FEEDBACK{ - KEY_PRESS, - KEY_PRESS_RELEASE, - KEY_RELEASE, - HAPTIC_FEEDBACK_MAX, +typedef enum HAPTIC_FEEDBACK { + KEY_PRESS, + KEY_PRESS_RELEASE, + KEY_RELEASE, + HAPTIC_FEEDBACK_MAX, } HAPTIC_FEEDBACK; -bool process_haptic(uint16_t keycode, keyrecord_t *record); -void haptic_init(void); -void haptic_task(void); -void eeconfig_debug_haptic(void); -void haptic_enable(void); -void haptic_disable(void); -void haptic_toggle(void); -void haptic_feedback_toggle(void); -void haptic_mode_increase(void); -void haptic_mode_decrease(void); -void haptic_mode(uint8_t mode); -void haptic_reset(void); -void haptic_set_feedback(uint8_t feedback); -void haptic_set_mode(uint8_t mode); -void haptic_set_dwell(uint8_t dwell); -void haptic_set_buzz(uint8_t buzz); -void haptic_buzz_toggle(void); +bool process_haptic(uint16_t keycode, keyrecord_t *record); +void haptic_init(void); +void haptic_task(void); +void eeconfig_debug_haptic(void); +void haptic_enable(void); +void haptic_disable(void); +void haptic_toggle(void); +void haptic_feedback_toggle(void); +void haptic_mode_increase(void); +void haptic_mode_decrease(void); +void haptic_mode(uint8_t mode); +void haptic_reset(void); +void haptic_set_feedback(uint8_t feedback); +void haptic_set_mode(uint8_t mode); +void haptic_set_dwell(uint8_t dwell); +void haptic_set_buzz(uint8_t buzz); +void haptic_buzz_toggle(void); uint8_t haptic_get_mode(void); uint8_t haptic_get_feedback(void); -void haptic_dwell_increase(void); -void haptic_dwell_decrease(void); +void haptic_dwell_increase(void); +void haptic_dwell_decrease(void); void haptic_play(void); void haptic_shutdown(void); - - - - - diff --git a/drivers/haptic/solenoid.c b/drivers/haptic/solenoid.c index 2d39dbc17..d645c379a 100644 --- a/drivers/haptic/solenoid.c +++ b/drivers/haptic/solenoid.c @@ -19,91 +19,77 @@ #include "solenoid.h" #include "haptic.h" -bool solenoid_on = false; -bool solenoid_buzzing = false; -uint16_t solenoid_start = 0; -uint8_t solenoid_dwell = SOLENOID_DEFAULT_DWELL; +bool solenoid_on = false; +bool solenoid_buzzing = false; +uint16_t solenoid_start = 0; +uint8_t solenoid_dwell = SOLENOID_DEFAULT_DWELL; extern haptic_config_t haptic_config; +void solenoid_buzz_on(void) { haptic_set_buzz(1); } -void solenoid_buzz_on(void) { - haptic_set_buzz(1); -} - -void solenoid_buzz_off(void) { - haptic_set_buzz(0); -} - -void solenoid_set_buzz(int buzz) { - haptic_set_buzz(buzz); -} +void solenoid_buzz_off(void) { haptic_set_buzz(0); } +void solenoid_set_buzz(int buzz) { haptic_set_buzz(buzz); } void solenoid_dwell_minus(uint8_t solenoid_dwell) { - if (solenoid_dwell > 0) solenoid_dwell--; + if (solenoid_dwell > 0) solenoid_dwell--; } void solenoid_dwell_plus(uint8_t solenoid_dwell) { - if (solenoid_dwell < SOLENOID_MAX_DWELL) solenoid_dwell++; + if (solenoid_dwell < SOLENOID_MAX_DWELL) solenoid_dwell++; } -void solenoid_set_dwell(uint8_t dwell) { - solenoid_dwell = dwell; -} +void solenoid_set_dwell(uint8_t dwell) { solenoid_dwell = dwell; } void solenoid_stop(void) { - writePinLow(SOLENOID_PIN); - solenoid_on = false; - solenoid_buzzing = false; + writePinLow(SOLENOID_PIN); + solenoid_on = false; + solenoid_buzzing = false; } void solenoid_fire(void) { - if (!haptic_config.buzz && solenoid_on) return; - if (haptic_config.buzz && solenoid_buzzing) return; + if (!haptic_config.buzz && solenoid_on) return; + if (haptic_config.buzz && solenoid_buzzing) return; - solenoid_on = true; - solenoid_buzzing = true; - solenoid_start = timer_read(); - writePinHigh(SOLENOID_PIN); + solenoid_on = true; + solenoid_buzzing = true; + solenoid_start = timer_read(); + writePinHigh(SOLENOID_PIN); } void solenoid_check(void) { - uint16_t elapsed = 0; - - if (!solenoid_on) return; + uint16_t elapsed = 0; - elapsed = timer_elapsed(solenoid_start); + if (!solenoid_on) return; - //Check if it's time to finish this solenoid click cycle - if (elapsed > solenoid_dwell) { - solenoid_stop(); - return; - } + elapsed = timer_elapsed(solenoid_start); - //Check whether to buzz the solenoid on and off - if (haptic_config.buzz) { - if (elapsed / SOLENOID_MIN_DWELL % 2 == 0){ - if (!solenoid_buzzing) { - solenoid_buzzing = true; - writePinHigh(SOLENOID_PIN); - } + // Check if it's time to finish this solenoid click cycle + if (elapsed > solenoid_dwell) { + solenoid_stop(); + return; } - else { - if (solenoid_buzzing) { - solenoid_buzzing = false; - writePinLow(SOLENOID_PIN); - } + + // Check whether to buzz the solenoid on and off + if (haptic_config.buzz) { + if (elapsed / SOLENOID_MIN_DWELL % 2 == 0) { + if (!solenoid_buzzing) { + solenoid_buzzing = true; + writePinHigh(SOLENOID_PIN); + } + } else { + if (solenoid_buzzing) { + solenoid_buzzing = false; + writePinLow(SOLENOID_PIN); + } + } } - } } void solenoid_setup(void) { - setPinOutput(SOLENOID_PIN); - solenoid_fire(); + setPinOutput(SOLENOID_PIN); + solenoid_fire(); } -void solenoid_shutdown(void) { - writePinLow(SOLENOID_PIN); - -} +void solenoid_shutdown(void) { writePinLow(SOLENOID_PIN); } diff --git a/drivers/haptic/solenoid.h b/drivers/haptic/solenoid.h index a08f62a11..53dc626e3 100644 --- a/drivers/haptic/solenoid.h +++ b/drivers/haptic/solenoid.h @@ -18,23 +18,23 @@ #pragma once #ifndef SOLENOID_DEFAULT_DWELL -#define SOLENOID_DEFAULT_DWELL 12 +# define SOLENOID_DEFAULT_DWELL 12 #endif #ifndef SOLENOID_MAX_DWELL -#define SOLENOID_MAX_DWELL 100 +# define SOLENOID_MAX_DWELL 100 #endif #ifndef SOLENOID_MIN_DWELL -#define SOLENOID_MIN_DWELL 4 +# define SOLENOID_MIN_DWELL 4 #endif #ifndef SOLENOID_ACTIVE -#define SOLENOID_ACTIVE false +# define SOLENOID_ACTIVE false #endif #ifndef SOLENOID_PIN -#define SOLENOID_PIN F6 +# define SOLENOID_PIN F6 #endif void solenoid_buzz_on(void); -- cgit v1.3.1 From 911b8915cc89c040db3c6075a1a547003b0ab37f Mon Sep 17 00:00:00 2001 From: MechMerlin <30334081+mechmerlin@users.noreply.github.com> Date: Thu, 19 Sep 2019 09:42:33 -0700 Subject: DRV2605L Continuous Haptic Feedback Support (#6461) * provide means to turn on RTP mode and set the amplitude * new keycode HPT_CONT to turn RTP off/on * introduce new keycodes HPT_CONI, and HPT_COND for Haptic Continuous Increase and Decrease * support for continuous mode amplitude increase and decrease * code cleanup * update docs to reference new keycodes and functionality * don't touch the keymaps * add function prototypes * add proper guards * cleanup guards * remove extra reserved --- docs/feature_haptic_feedback.md | 7 +++++ drivers/haptic/DRV2605L.c | 11 +++++++ drivers/haptic/DRV2605L.h | 2 ++ drivers/haptic/haptic.c | 67 +++++++++++++++++++++++++++++++++++++++++ drivers/haptic/haptic.h | 17 +++++++---- quantum/quantum_keycodes.h | 3 ++ 6 files changed, 101 insertions(+), 6 deletions(-) (limited to 'drivers/haptic') diff --git a/docs/feature_haptic_feedback.md b/docs/feature_haptic_feedback.md index 85fd43964..acd156a27 100644 --- a/docs/feature_haptic_feedback.md +++ b/docs/feature_haptic_feedback.md @@ -29,6 +29,9 @@ Not all keycodes below will work depending on which haptic mechanism you have ch |`HPT_BUZ` | Toggle solenoid buzz on/off | |`HPT_MODI` | Go to next DRV2605L waveform | |`HPT_MODD` | Go to previous DRV2605L waveform | +|`HPT_CONT` | Toggle continuous haptic mode on/off | +|`HPT_CONI` | Increase DRV2605L continous haptic strength | +|`HPT_COND` | Decrease DRV2605L continous haptic strength | |`HPT_DWLI` | Increase Solenoid dwell time | |`HPT_DWLD` | Decrease Solenoid dwell time | @@ -145,3 +148,7 @@ If haptic feedback is enabled, the keyboard will vibrate to a specific sqeuence #define DRV_MODE_DEFAULT *sequence name or number* ``` This will set what sequence HPT_RST will set as the active mode. If not defined, mode will be set to 1 when HPT_RST is pressed. + +### DRV2605L Continuous Haptic Mode + +This mode sets continuous haptic feedback with the option to increase or decrease strength. \ No newline at end of file diff --git a/drivers/haptic/DRV2605L.c b/drivers/haptic/DRV2605L.c index f74c96525..728554b01 100644 --- a/drivers/haptic/DRV2605L.c +++ b/drivers/haptic/DRV2605L.c @@ -114,6 +114,17 @@ void DRV_init(void) { DRV_write(DRV_GO, 0x01); } +void DRV_rtp_init(void) { + DRV_write(DRV_GO, 0x00); + DRV_write(DRV_RTP_INPUT, 20); //20 is the lowest value I've found where haptics can still be felt. + DRV_write(DRV_MODE, 0x05); + DRV_write(DRV_GO, 0x01); +} + +void DRV_amplitude(uint8_t amplitude) { + DRV_write(DRV_RTP_INPUT, amplitude); +} + void DRV_pulse(uint8_t sequence) { DRV_write(DRV_GO, 0x00); DRV_write(DRV_WAVEFORM_SEQ_1, sequence); diff --git a/drivers/haptic/DRV2605L.h b/drivers/haptic/DRV2605L.h index f550b859f..535c77765 100644 --- a/drivers/haptic/DRV2605L.h +++ b/drivers/haptic/DRV2605L.h @@ -170,6 +170,8 @@ void DRV_init(void); void DRV_write(const uint8_t drv_register, const uint8_t settings); uint8_t DRV_read(const uint8_t regaddress); +void DRV_rtp_init(void); +void DRV_amplitude(const uint8_t amplitude); void DRV_pulse(const uint8_t sequence); typedef enum DRV_EFFECT { diff --git a/drivers/haptic/haptic.c b/drivers/haptic/haptic.c index ded6d8a44..989970bee 100644 --- a/drivers/haptic/haptic.c +++ b/drivers/haptic/haptic.c @@ -168,6 +168,15 @@ void haptic_set_mode(uint8_t mode) { xprintf("haptic_config.mode = %u\n", haptic_config.mode); } +void haptic_set_amplitude(uint8_t amp) { + haptic_config.amplitude = amp; + eeconfig_update_haptic(haptic_config.raw); + xprintf("haptic_config.amplitude = %u\n", haptic_config.amplitude); + #ifdef DRV2605L + DRV_amplitude(amp); + #endif +} + void haptic_set_buzz(uint8_t buzz) { haptic_config.buzz = buzz; eeconfig_update_haptic(haptic_config.raw); @@ -201,6 +210,53 @@ uint8_t haptic_get_dwell(void) { return haptic_config.dwell; } +void haptic_enable_continuous(void) { + haptic_config.cont = 1; + xprintf("haptic_config.cont = %u\n", haptic_config.cont); + eeconfig_update_haptic(haptic_config.raw); + #ifdef DRV2605L + DRV_rtp_init(); + #endif +} + +void haptic_disable_continuous(void) { + haptic_config.cont = 0; + xprintf("haptic_config.cont = %u\n", haptic_config.cont); + eeconfig_update_haptic(haptic_config.raw); + #ifdef DRV2605L + DRV_write(DRV_MODE,0x00); + #endif +} + +void haptic_toggle_continuous(void) { +#ifdef DRV2605L +if (haptic_config.cont) { + haptic_disable_continuous(); + } else { + haptic_enable_continuous(); + } + eeconfig_update_haptic(haptic_config.raw); +#endif +} + + +void haptic_cont_increase(void) { + uint8_t amp = haptic_config.amplitude + 10; + if (haptic_config.amplitude >= 120) { + amp = 120; + } + haptic_set_amplitude(amp); +} + +void haptic_cont_decrease(void) { + uint8_t amp = haptic_config.amplitude - 10; + if (haptic_config.amplitude < 20) { + amp = 20; + } + haptic_set_amplitude(amp); +} + + void haptic_play(void) { #ifdef DRV2605L uint8_t play_eff = 0; @@ -213,6 +269,7 @@ void haptic_play(void) { } bool process_haptic(uint16_t keycode, keyrecord_t *record) { + if (keycode == HPT_ON && record->event.pressed) { haptic_enable(); } @@ -243,6 +300,16 @@ bool process_haptic(uint16_t keycode, keyrecord_t *record) { if (keycode == HPT_DWLD && record->event.pressed) { haptic_dwell_decrease(); } + if (keycode == HPT_CONT && record->event.pressed) { + haptic_toggle_continuous(); + } + if (keycode == HPT_CONI && record->event.pressed) { + haptic_cont_increase(); + } + if (keycode == HPT_COND && record->event.pressed) { + haptic_cont_decrease(); + } + if (haptic_config.enable) { if (record->event.pressed) { // keypress diff --git a/drivers/haptic/haptic.h b/drivers/haptic/haptic.h index 8135d0d43..2f6eb31fc 100644 --- a/drivers/haptic/haptic.h +++ b/drivers/haptic/haptic.h @@ -34,12 +34,14 @@ typedef union { uint32_t raw; struct { - bool enable : 1; - uint8_t feedback : 2; - uint8_t mode : 7; - bool buzz : 1; - uint8_t dwell : 7; - uint16_t reserved : 16; + bool enable :1; + uint8_t feedback :2; + uint8_t mode :7; + bool buzz :1; + uint8_t dwell :7; + bool cont :1; + uint8_t amplitude :8; + uint16_t reserved :7; }; } haptic_config_t; @@ -71,6 +73,9 @@ uint8_t haptic_get_mode(void); uint8_t haptic_get_feedback(void); void haptic_dwell_increase(void); void haptic_dwell_decrease(void); +void haptic_toggle_continuous(void); +void haptic_cont_increase(void); +void haptic_cont_decrease(void); void haptic_play(void); void haptic_shutdown(void); diff --git a/quantum/quantum_keycodes.h b/quantum/quantum_keycodes.h index f5dca02e6..af984a7cd 100644 --- a/quantum/quantum_keycodes.h +++ b/quantum/quantum_keycodes.h @@ -473,6 +473,9 @@ enum quantum_keycodes { HPT_BUZ, HPT_MODI, HPT_MODD, + HPT_CONT, + HPT_CONI, + HPT_COND, HPT_DWLI, HPT_DWLD, -- cgit v1.3.1 From f6b5f6db7665512cece0223ce4d19c5b17455ef4 Mon Sep 17 00:00:00 2001 From: Drashna Jaelre Date: Fri, 15 Nov 2019 14:27:46 -0800 Subject: Improvements to Solenoid feature (#7369) * Error out when Solenid pin is not defined Instead of defaulting to a (literally) random pin, error out instead. Because this pin may be used, or because that pin may not be exposed, or may not exist. * Remove 'SOLENOID_ACTIVE' setting since it's not used * Update documentation --- docs/feature_haptic_feedback.md | 14 +++++++++----- drivers/haptic/solenoid.h | 6 +----- 2 files changed, 10 insertions(+), 10 deletions(-) (limited to 'drivers/haptic') diff --git a/docs/feature_haptic_feedback.md b/docs/feature_haptic_feedback.md index d9e445de8..227363322 100644 --- a/docs/feature_haptic_feedback.md +++ b/docs/feature_haptic_feedback.md @@ -41,11 +41,15 @@ First you will need a build a circuit to drive the solenoid through a mosfet as [Wiring diagram provided by Adafruit](https://playground.arduino.cc/uploads/Learning/solenoid_driver.pdf) -Select a pin that has PWM for the signal pin -``` -#define SOLENOID_PIN *pin* -``` +| Settings | Default | Description | +|--------------------------|---------------|-------------------------------------------------------| +|`SOLENOID_PIN` | *Not defined* |Configures the pin that the Solenoid is connected to. | +|`SOLENOID_DEFAULT_DWELL` | `12` ms |Configures the default dwell time for the solenoid. | +|`SOLENOID_MIN_DWELL` | `4` ms |Sets the lower limit for the dwell. | +|`SOLENOID_MAX_DWELL` | `100` ms |Sets the upper limit for the dwell. | + +?> Dwell time is how long the "plunger" stays activated. The dwell time changes how the solenoid sounds. Beware that some pins may be powered during bootloader (ie. A13 on the STM32F303 chip) and will result in the solenoid kept in the on state through the whole flashing process. This may overheat and damage the solenoid. If you find that the pin the solenoid is connected to is triggering the solenoid during bootloader/DFU, select another pin. @@ -151,4 +155,4 @@ This will set what sequence HPT_RST will set as the active mode. If not defined, ### DRV2605L Continuous Haptic Mode -This mode sets continuous haptic feedback with the option to increase or decrease strength. \ No newline at end of file +This mode sets continuous haptic feedback with the option to increase or decrease strength. diff --git a/drivers/haptic/solenoid.h b/drivers/haptic/solenoid.h index 53dc626e3..dd6ececa6 100644 --- a/drivers/haptic/solenoid.h +++ b/drivers/haptic/solenoid.h @@ -29,12 +29,8 @@ # define SOLENOID_MIN_DWELL 4 #endif -#ifndef SOLENOID_ACTIVE -# define SOLENOID_ACTIVE false -#endif - #ifndef SOLENOID_PIN -# define SOLENOID_PIN F6 +# error SOLENOID_PIN not defined #endif void solenoid_buzz_on(void); -- cgit v1.3.1 From a91c0c476507cb8c12840abb59bff34ab0de3c03 Mon Sep 17 00:00:00 2001 From: zvecr Date: Sun, 17 Nov 2019 14:02:26 +0000 Subject: Run clang-format manually to fix recently changed files --- drivers/haptic/DRV2605L.c | 12 ++- drivers/haptic/haptic.c | 85 +++++++++++----------- drivers/haptic/haptic.h | 16 ++-- quantum/backlight/backlight_avr.c | 2 +- quantum/config_common.h | 39 +++++----- quantum/dip_switch.c | 37 ++++------ quantum/encoder.c | 8 +- quantum/keymap_extras/keymap_italian.h | 54 +++++++------- quantum/keymap_extras/keymap_italian_osx_ansi.h | 60 +++++++-------- quantum/keymap_extras/keymap_italian_osx_iso.h | 60 +++++++-------- quantum/process_keycode/process_tap_dance.h | 6 +- quantum/quantum.c | 2 +- quantum/quantum.h | 5 +- quantum/quantum_keycodes.h | 2 +- quantum/rgblight.c | 2 +- quantum/stm32/chconf.h | 39 ++++++---- tmk_core/common/arm_atsam/suspend.c | 3 +- tmk_core/common/eeconfig.c | 4 +- tmk_core/common/host.c | 2 +- tmk_core/common/led.h | 10 +-- tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h | 7 +- tmk_core/protocol/chibios/usb_main.c | 6 +- tmk_core/protocol/iwrap/iwrap.c | 3 +- tmk_core/protocol/lufa/adafruit_ble.cpp | 6 +- 24 files changed, 235 insertions(+), 235 deletions(-) (limited to 'drivers/haptic') diff --git a/drivers/haptic/DRV2605L.c b/drivers/haptic/DRV2605L.c index 728554b01..c40731913 100644 --- a/drivers/haptic/DRV2605L.c +++ b/drivers/haptic/DRV2605L.c @@ -115,15 +115,13 @@ void DRV_init(void) { } void DRV_rtp_init(void) { - DRV_write(DRV_GO, 0x00); - DRV_write(DRV_RTP_INPUT, 20); //20 is the lowest value I've found where haptics can still be felt. - DRV_write(DRV_MODE, 0x05); - DRV_write(DRV_GO, 0x01); + DRV_write(DRV_GO, 0x00); + DRV_write(DRV_RTP_INPUT, 20); // 20 is the lowest value I've found where haptics can still be felt. + DRV_write(DRV_MODE, 0x05); + DRV_write(DRV_GO, 0x01); } -void DRV_amplitude(uint8_t amplitude) { - DRV_write(DRV_RTP_INPUT, amplitude); -} +void DRV_amplitude(uint8_t amplitude) { DRV_write(DRV_RTP_INPUT, amplitude); } void DRV_pulse(uint8_t sequence) { DRV_write(DRV_GO, 0x00); diff --git a/drivers/haptic/haptic.c b/drivers/haptic/haptic.c index 989970bee..2ce279b75 100644 --- a/drivers/haptic/haptic.c +++ b/drivers/haptic/haptic.c @@ -169,12 +169,12 @@ void haptic_set_mode(uint8_t mode) { } void haptic_set_amplitude(uint8_t amp) { - haptic_config.amplitude = amp; - eeconfig_update_haptic(haptic_config.raw); - xprintf("haptic_config.amplitude = %u\n", haptic_config.amplitude); - #ifdef DRV2605L - DRV_amplitude(amp); - #endif + haptic_config.amplitude = amp; + eeconfig_update_haptic(haptic_config.raw); + xprintf("haptic_config.amplitude = %u\n", haptic_config.amplitude); +#ifdef DRV2605L + DRV_amplitude(amp); +#endif } void haptic_set_buzz(uint8_t buzz) { @@ -211,52 +211,50 @@ uint8_t haptic_get_dwell(void) { } void haptic_enable_continuous(void) { - haptic_config.cont = 1; - xprintf("haptic_config.cont = %u\n", haptic_config.cont); - eeconfig_update_haptic(haptic_config.raw); - #ifdef DRV2605L - DRV_rtp_init(); - #endif + haptic_config.cont = 1; + xprintf("haptic_config.cont = %u\n", haptic_config.cont); + eeconfig_update_haptic(haptic_config.raw); +#ifdef DRV2605L + DRV_rtp_init(); +#endif } void haptic_disable_continuous(void) { - haptic_config.cont = 0; - xprintf("haptic_config.cont = %u\n", haptic_config.cont); - eeconfig_update_haptic(haptic_config.raw); - #ifdef DRV2605L - DRV_write(DRV_MODE,0x00); - #endif + haptic_config.cont = 0; + xprintf("haptic_config.cont = %u\n", haptic_config.cont); + eeconfig_update_haptic(haptic_config.raw); +#ifdef DRV2605L + DRV_write(DRV_MODE, 0x00); +#endif } void haptic_toggle_continuous(void) { #ifdef DRV2605L -if (haptic_config.cont) { - haptic_disable_continuous(); - } else { - haptic_enable_continuous(); - } - eeconfig_update_haptic(haptic_config.raw); + if (haptic_config.cont) { + haptic_disable_continuous(); + } else { + haptic_enable_continuous(); + } + eeconfig_update_haptic(haptic_config.raw); #endif } - void haptic_cont_increase(void) { - uint8_t amp = haptic_config.amplitude + 10; - if (haptic_config.amplitude >= 120) { - amp = 120; - } - haptic_set_amplitude(amp); + uint8_t amp = haptic_config.amplitude + 10; + if (haptic_config.amplitude >= 120) { + amp = 120; + } + haptic_set_amplitude(amp); } void haptic_cont_decrease(void) { - uint8_t amp = haptic_config.amplitude - 10; - if (haptic_config.amplitude < 20) { - amp = 20; - } - haptic_set_amplitude(amp); + uint8_t amp = haptic_config.amplitude - 10; + if (haptic_config.amplitude < 20) { + amp = 20; + } + haptic_set_amplitude(amp); } - void haptic_play(void) { #ifdef DRV2605L uint8_t play_eff = 0; @@ -269,7 +267,6 @@ void haptic_play(void) { } bool process_haptic(uint16_t keycode, keyrecord_t *record) { - if (keycode == HPT_ON && record->event.pressed) { haptic_enable(); } @@ -300,16 +297,16 @@ bool process_haptic(uint16_t keycode, keyrecord_t *record) { if (keycode == HPT_DWLD && record->event.pressed) { haptic_dwell_decrease(); } - if (keycode == HPT_CONT && record->event.pressed) { - haptic_toggle_continuous(); + if (keycode == HPT_CONT && record->event.pressed) { + haptic_toggle_continuous(); } - if (keycode == HPT_CONI && record->event.pressed) { - haptic_cont_increase(); + if (keycode == HPT_CONI && record->event.pressed) { + haptic_cont_increase(); } - if (keycode == HPT_COND && record->event.pressed) { - haptic_cont_decrease(); + if (keycode == HPT_COND && record->event.pressed) { + haptic_cont_decrease(); } - + if (haptic_config.enable) { if (record->event.pressed) { // keypress diff --git a/drivers/haptic/haptic.h b/drivers/haptic/haptic.h index 2f6eb31fc..5d3bd1c31 100644 --- a/drivers/haptic/haptic.h +++ b/drivers/haptic/haptic.h @@ -34,14 +34,14 @@ typedef union { uint32_t raw; struct { - bool enable :1; - uint8_t feedback :2; - uint8_t mode :7; - bool buzz :1; - uint8_t dwell :7; - bool cont :1; - uint8_t amplitude :8; - uint16_t reserved :7; + bool enable : 1; + uint8_t feedback : 2; + uint8_t mode : 7; + bool buzz : 1; + uint8_t dwell : 7; + bool cont : 1; + uint8_t amplitude : 8; + uint16_t reserved : 7; }; } haptic_config_t; diff --git a/quantum/backlight/backlight_avr.c b/quantum/backlight/backlight_avr.c index 648a37adf..edda6ea0b 100644 --- a/quantum/backlight/backlight_avr.c +++ b/quantum/backlight/backlight_avr.c @@ -191,7 +191,7 @@ void backlight_off(pin_t backlight_pin) { # define FOR_EACH_LED(x) \ for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) { \ - pin_t backlight_pin = backlight_pins[i]; \ + pin_t backlight_pin = backlight_pins[i]; \ { x } \ } diff --git a/quantum/config_common.h b/quantum/config_common.h index f42df6357..c1c1d4bd4 100644 --- a/quantum/config_common.h +++ b/quantum/config_common.h @@ -303,25 +303,26 @@ UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \ sei(); \ } while (0) -# elif (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)) -# define SERIAL_UART_BAUD 115200 -# define SERIAL_UART_DATA UDR1 - /* UBRR should result in ~16 and set UCSR1A = _BV(U2X1) as per rn42 documentation. HC05 needs baudrate configured accordingly */ -# define SERIAL_UART_UBRR (F_CPU / (8UL * SERIAL_UART_BAUD) - 1) -# define SERIAL_UART_RXD_VECT USART1_RX_vect -# define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1)) -# define SERIAL_UART_INIT() do { \ - UCSR1A = _BV(U2X1); \ - /* baud rate */ \ - UBRR1L = SERIAL_UART_UBRR; \ - /* baud rate */ \ - UBRR1H = SERIAL_UART_UBRR >> 8; \ - /* enable TX */ \ - UCSR1B = _BV(TXEN1); \ - /* 8-bit data */ \ - UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \ - sei(); \ - } while(0) +# elif (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)) +# define SERIAL_UART_BAUD 115200 +# define SERIAL_UART_DATA UDR1 +/* UBRR should result in ~16 and set UCSR1A = _BV(U2X1) as per rn42 documentation. HC05 needs baudrate configured accordingly */ +# define SERIAL_UART_UBRR (F_CPU / (8UL * SERIAL_UART_BAUD) - 1) +# define SERIAL_UART_RXD_VECT USART1_RX_vect +# define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1)) +# define SERIAL_UART_INIT() \ + do { \ + UCSR1A = _BV(U2X1); \ + /* baud rate */ \ + UBRR1L = SERIAL_UART_UBRR; \ + /* baud rate */ \ + UBRR1H = SERIAL_UART_UBRR >> 8; \ + /* enable TX */ \ + UCSR1B = _BV(TXEN1); \ + /* 8-bit data */ \ + UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \ + sei(); \ + } while (0) # else # error "USART configuration is needed." # endif diff --git a/quantum/dip_switch.c b/quantum/dip_switch.c index 3b5a8dadc..ab74222d1 100644 --- a/quantum/dip_switch.c +++ b/quantum/dip_switch.c @@ -21,40 +21,33 @@ // for memcpy #include - #if !defined(DIP_SWITCH_PINS) -# error "No DIP switch pads defined by DIP_SWITCH_PINS" +# error "No DIP switch pads defined by DIP_SWITCH_PINS" #endif -#define NUMBER_OF_DIP_SWITCHES (sizeof(dip_switch_pad)/sizeof(pin_t)) -static pin_t dip_switch_pad[] = DIP_SWITCH_PINS; -static bool dip_switch_state[NUMBER_OF_DIP_SWITCHES] = { 0 }; -static bool last_dip_switch_state[NUMBER_OF_DIP_SWITCHES] = { 0 }; - +#define NUMBER_OF_DIP_SWITCHES (sizeof(dip_switch_pad) / sizeof(pin_t)) +static pin_t dip_switch_pad[] = DIP_SWITCH_PINS; +static bool dip_switch_state[NUMBER_OF_DIP_SWITCHES] = {0}; +static bool last_dip_switch_state[NUMBER_OF_DIP_SWITCHES] = {0}; -__attribute__((weak)) -void dip_switch_update_user(uint8_t index, bool active) {} +__attribute__((weak)) void dip_switch_update_user(uint8_t index, bool active) {} -__attribute__((weak)) -void dip_switch_update_kb(uint8_t index, bool active) { dip_switch_update_user(index, active); } +__attribute__((weak)) void dip_switch_update_kb(uint8_t index, bool active) { dip_switch_update_user(index, active); } -__attribute__((weak)) -void dip_switch_update_mask_user(uint32_t state) {} +__attribute__((weak)) void dip_switch_update_mask_user(uint32_t state) {} -__attribute__((weak)) -void dip_switch_update_mask_kb(uint32_t state) { dip_switch_update_mask_user(state); } +__attribute__((weak)) void dip_switch_update_mask_kb(uint32_t state) { dip_switch_update_mask_user(state); } void dip_switch_init(void) { - for (uint8_t i = 0; i < NUMBER_OF_DIP_SWITCHES; i++) { - setPinInputHigh(dip_switch_pad[i]); - } - dip_switch_read(true); + for (uint8_t i = 0; i < NUMBER_OF_DIP_SWITCHES; i++) { + setPinInputHigh(dip_switch_pad[i]); + } + dip_switch_read(true); } - void dip_switch_read(bool forced) { - bool has_dip_state_changed = false; - uint32_t dip_switch_mask = 0; + bool has_dip_state_changed = false; + uint32_t dip_switch_mask = 0; for (uint8_t i = 0; i < NUMBER_OF_DIP_SWITCHES; i++) { dip_switch_state[i] = !readPin(dip_switch_pad[i]); diff --git a/quantum/encoder.c b/quantum/encoder.c index e86a0045c..4aeb3d0cd 100644 --- a/quantum/encoder.c +++ b/quantum/encoder.c @@ -37,8 +37,8 @@ static pin_t encoders_pad_b[] = ENCODERS_PAD_B; static int8_t encoder_LUT[] = {0, -1, 1, 0, 1, 0, 0, -1, -1, 0, 0, 1, 0, 1, -1, 0}; -static uint8_t encoder_state[NUMBER_OF_ENCODERS] = {0}; -static int8_t encoder_pulses[NUMBER_OF_ENCODERS] = {0}; +static uint8_t encoder_state[NUMBER_OF_ENCODERS] = {0}; +static int8_t encoder_pulses[NUMBER_OF_ENCODERS] = {0}; #ifdef SPLIT_KEYBOARD // right half encoders come over as second set of encoders @@ -84,7 +84,7 @@ static void encoder_update(int8_t index, uint8_t state) { encoder_value[index]++; encoder_update_kb(index, true); } - if (encoder_pulses[index] <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise + if (encoder_pulses[index] <= -ENCODER_RESOLUTION) { // direction is arbitrary here, but this clockwise encoder_value[index]--; encoder_update_kb(index, false); } @@ -109,7 +109,7 @@ void encoder_state_raw(uint8_t* slave_state) { memcpy(slave_state, &encoder_valu void encoder_update_raw(uint8_t* slave_state) { for (int i = 0; i < NUMBER_OF_ENCODERS; i++) { uint8_t index = i + thatHand; - int8_t delta = slave_state[i] - encoder_value[index]; + int8_t delta = slave_state[i] - encoder_value[index]; while (delta > 0) { delta--; encoder_value[index]++; diff --git a/quantum/keymap_extras/keymap_italian.h b/quantum/keymap_extras/keymap_italian.h index a8c03b884..063700aa0 100644 --- a/quantum/keymap_extras/keymap_italian.h +++ b/quantum/keymap_extras/keymap_italian.h @@ -78,36 +78,36 @@ #define IT_MINS KC_SLSH // - and _ // shifted characters -#define IT_DEGR LSFT(IT_AACC) // ° -#define IT_EXLM LSFT(KC_1) // ! -#define IT_DQOT LSFT(KC_2) // " -#define IT_STRL LSFT(KC_3) // £ -#define IT_DLR LSFT(KC_4) // $ -#define IT_PERC LSFT(KC_5) // % -#define IT_AMPR LSFT(KC_6) // & -#define IT_SLSH LSFT(KC_7) // / -#define IT_LPRN LSFT(KC_8) // ( -#define IT_RPRN LSFT(KC_9) // ) -#define IT_EQL LSFT(KC_0) // = -#define IT_QST LSFT(IT_APOS) // ? -#define IT_CRC LSFT(IT_IACC) // ^ -#define IT_ASTR LSFT(IT_PLUS) // * -#define IT_MORE LSFT(IT_LESS) // > -#define IT_COLN LSFT(IT_DOT) // : -#define IT_SCLN LSFT(IT_COMM) // ; -#define IT_UNDS LSFT(IT_MINS) // _ +#define IT_DEGR LSFT(IT_AACC) // ° +#define IT_EXLM LSFT(KC_1) // ! +#define IT_DQOT LSFT(KC_2) // " +#define IT_STRL LSFT(KC_3) // £ +#define IT_DLR LSFT(KC_4) // $ +#define IT_PERC LSFT(KC_5) // % +#define IT_AMPR LSFT(KC_6) // & +#define IT_SLSH LSFT(KC_7) // / +#define IT_LPRN LSFT(KC_8) // ( +#define IT_RPRN LSFT(KC_9) // ) +#define IT_EQL LSFT(KC_0) // = +#define IT_QST LSFT(IT_APOS) // ? +#define IT_CRC LSFT(IT_IACC) // ^ +#define IT_ASTR LSFT(IT_PLUS) // * +#define IT_MORE LSFT(IT_LESS) // > +#define IT_COLN LSFT(IT_DOT) // : +#define IT_SCLN LSFT(IT_COMM) // ; +#define IT_UNDS LSFT(IT_MINS) // _ // Alt Gr-ed characters -#define IT_LCBR ALGR(KC_7) // { -#define IT_LBRC ALGR(IT_EACC) // [ -#define IT_RBRC ALGR(IT_PLUS) // ] -#define IT_RCBR ALGR(KC_0) // } -#define IT_AT ALGR(IT_OACC) // @ -#define IT_EURO ALGR(KC_E) // € -#define IT_PIPE LSFT(IT_BSLS) // | -#define IT_SHRP ALGR(IT_AACC) // # +#define IT_LCBR ALGR(KC_7) // { +#define IT_LBRC ALGR(IT_EACC) // [ +#define IT_RBRC ALGR(IT_PLUS) // ] +#define IT_RCBR ALGR(KC_0) // } +#define IT_AT ALGR(IT_OACC) // @ +#define IT_EURO ALGR(KC_E) // € +#define IT_PIPE LSFT(IT_BSLS) // | +#define IT_SHRP ALGR(IT_AACC) // # // Deprecated -#define IT_X_PLUS X_RBRACKET // # +#define IT_X_PLUS X_RBRACKET // # #endif diff --git a/quantum/keymap_extras/keymap_italian_osx_ansi.h b/quantum/keymap_extras/keymap_italian_osx_ansi.h index 2b7160ff3..fa12d05dc 100644 --- a/quantum/keymap_extras/keymap_italian_osx_ansi.h +++ b/quantum/keymap_extras/keymap_italian_osx_ansi.h @@ -65,7 +65,7 @@ #define IT_COMM KC_COMM // , and ; #define IT_APOS KC_MINS // ' and ? #define IT_BSLS KC_NUBS // \ and | -#define IT_LESS KC_GRV // < and > +#define IT_LESS KC_GRV // < and > #define IT_MINS KC_SLSH // - and _ // accented vowels (regular, with shift, with option, with option and shift) @@ -77,37 +77,37 @@ #define IT_IACC KC_EQL // ì, ^, ˆ, ± // shifted characters -#define IT_EXLM LSFT(KC_1) // ! -#define IT_DQOT LSFT(KC_2) // " -#define IT_STRL LSFT(KC_3) // £ -#define IT_DLR LSFT(KC_4) // $ -#define IT_PERC LSFT(KC_5) // % -#define IT_AMPR LSFT(KC_6) // & -#define IT_SLSH LSFT(KC_7) // / -#define IT_LPRN LSFT(KC_8) // ( -#define IT_RPRN LSFT(KC_9) // ) -#define IT_EQL LSFT(KC_0) // = -#define IT_DEGR LSFT(IT_AACC) // ° -#define IT_QST LSFT(IT_APOS) // ? -#define IT_CRC LSFT(IT_IACC) // ^ -#define IT_ASTR LSFT(IT_PLUS) // * -#define IT_MORE LSFT(IT_LESS) // > -#define IT_COLN LSFT(IT_DOT) // : -#define IT_SCLN LSFT(IT_COMM) // ; -#define IT_UNDS LSFT(IT_MINS) // _ -#define IT_LCBR LSFT(IT_LBRC) // { -#define IT_RCBR LSFT(IT_RBRC) // } -#define IT_PIPE LSFT(IT_BSLS) // | +#define IT_EXLM LSFT(KC_1) // ! +#define IT_DQOT LSFT(KC_2) // " +#define IT_STRL LSFT(KC_3) // £ +#define IT_DLR LSFT(KC_4) // $ +#define IT_PERC LSFT(KC_5) // % +#define IT_AMPR LSFT(KC_6) // & +#define IT_SLSH LSFT(KC_7) // / +#define IT_LPRN LSFT(KC_8) // ( +#define IT_RPRN LSFT(KC_9) // ) +#define IT_EQL LSFT(KC_0) // = +#define IT_DEGR LSFT(IT_AACC) // ° +#define IT_QST LSFT(IT_APOS) // ? +#define IT_CRC LSFT(IT_IACC) // ^ +#define IT_ASTR LSFT(IT_PLUS) // * +#define IT_MORE LSFT(IT_LESS) // > +#define IT_COLN LSFT(IT_DOT) // : +#define IT_SCLN LSFT(IT_COMM) // ; +#define IT_UNDS LSFT(IT_MINS) // _ +#define IT_LCBR LSFT(IT_LBRC) // { +#define IT_RCBR LSFT(IT_RBRC) // } +#define IT_PIPE LSFT(IT_BSLS) // | // Alt -ed characters -#define IT_LBRC LALT(IT_EACC) // [ -#define IT_RBRC LALT(IT_PLUS) // ] -#define IT_AT LALT(IT_OACC) // @ -#define IT_EURO LALT(KC_E) // € -#define IT_SHRP LALT(IT_AACC ) // # -#define IT_ACUT LALT(KC_8) // ´ -#define IT_GRAVE LALT(KC_9) // ` -#define IT_TILDE LALT(KC_5) // ~ +#define IT_LBRC LALT(IT_EACC) // [ +#define IT_RBRC LALT(IT_PLUS) // ] +#define IT_AT LALT(IT_OACC) // @ +#define IT_EURO LALT(KC_E) // € +#define IT_SHRP LALT(IT_AACC) // # +#define IT_ACUT LALT(KC_8) // ´ +#define IT_GRAVE LALT(KC_9) // ` +#define IT_TILDE LALT(KC_5) // ~ #define IT_PLMN LALT(LSFT(IT_IACC)) // ± #endif diff --git a/quantum/keymap_extras/keymap_italian_osx_iso.h b/quantum/keymap_extras/keymap_italian_osx_iso.h index 5c920014a..a9b36f16e 100644 --- a/quantum/keymap_extras/keymap_italian_osx_iso.h +++ b/quantum/keymap_extras/keymap_italian_osx_iso.h @@ -65,7 +65,7 @@ #define IT_COMM KC_COMM // , and ; #define IT_APOS KC_MINS // ' and ? #define IT_BSLS KC_GRV // \ and | -#define IT_LESS KC_NUBS// < and > +#define IT_LESS KC_NUBS // < and > #define IT_MINS KC_SLSH // - and _ // accented vowels (regular, with shift, with option, with option and shift) @@ -77,37 +77,37 @@ #define IT_IACC KC_EQL // ì, ^, ˆ, ± // shifted characters -#define IT_EXLM LSFT(KC_1) // ! -#define IT_DQOT LSFT(KC_2) // " -#define IT_STRL LSFT(KC_3) // £ -#define IT_DLR LSFT(KC_4) // $ -#define IT_PERC LSFT(KC_5) // % -#define IT_AMPR LSFT(KC_6) // & -#define IT_SLSH LSFT(KC_7) // / -#define IT_LPRN LSFT(KC_8) // ( -#define IT_RPRN LSFT(KC_9) // ) -#define IT_EQL LSFT(KC_0) // = -#define IT_DEGR LSFT(IT_AACC) // ° -#define IT_QST LSFT(IT_APOS) // ? -#define IT_CRC LSFT(IT_IACC) // ^ -#define IT_ASTR LSFT(IT_PLUS) // * -#define IT_MORE LSFT(IT_LESS) // > -#define IT_COLN LSFT(IT_DOT) // : -#define IT_SCLN LSFT(IT_COMM) // ; -#define IT_UNDS LSFT(IT_MINS) // _ -#define IT_LCBR LSFT(IT_LBRC) // { -#define IT_RCBR LSFT(IT_RBRC) // } -#define IT_PIPE LSFT(IT_BSLS) // | +#define IT_EXLM LSFT(KC_1) // ! +#define IT_DQOT LSFT(KC_2) // " +#define IT_STRL LSFT(KC_3) // £ +#define IT_DLR LSFT(KC_4) // $ +#define IT_PERC LSFT(KC_5) // % +#define IT_AMPR LSFT(KC_6) // & +#define IT_SLSH LSFT(KC_7) // / +#define IT_LPRN LSFT(KC_8) // ( +#define IT_RPRN LSFT(KC_9) // ) +#define IT_EQL LSFT(KC_0) // = +#define IT_DEGR LSFT(IT_AACC) // ° +#define IT_QST LSFT(IT_APOS) // ? +#define IT_CRC LSFT(IT_IACC) // ^ +#define IT_ASTR LSFT(IT_PLUS) // * +#define IT_MORE LSFT(IT_LESS) // > +#define IT_COLN LSFT(IT_DOT) // : +#define IT_SCLN LSFT(IT_COMM) // ; +#define IT_UNDS LSFT(IT_MINS) // _ +#define IT_LCBR LSFT(IT_LBRC) // { +#define IT_RCBR LSFT(IT_RBRC) // } +#define IT_PIPE LSFT(IT_BSLS) // | // Alt -ed characters -#define IT_LBRC LALT(IT_EACC) // [ -#define IT_RBRC LALT(IT_PLUS) // ] -#define IT_AT LALT(IT_OACC) // @ -#define IT_EURO LALT(KC_E) // € -#define IT_SHRP LALT(IT_AACC ) // # -#define IT_ACUT LALT(KC_8) // ´ -#define IT_GRAVE LALT(KC_9) // ` -#define IT_TILDE LALT(KC_5) // ~ +#define IT_LBRC LALT(IT_EACC) // [ +#define IT_RBRC LALT(IT_PLUS) // ] +#define IT_AT LALT(IT_OACC) // @ +#define IT_EURO LALT(KC_E) // € +#define IT_SHRP LALT(IT_AACC) // # +#define IT_ACUT LALT(KC_8) // ´ +#define IT_GRAVE LALT(KC_9) // ` +#define IT_TILDE LALT(KC_5) // ~ #define IT_PLMN LALT(LSFT(IT_IACC)) // ± #endif diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h index 8f3f3ff3c..09ceef74d 100644 --- a/quantum/process_keycode/process_tap_dance.h +++ b/quantum/process_keycode/process_tap_dance.h @@ -63,10 +63,10 @@ typedef struct { { .fn = {qk_tap_dance_pair_on_each_tap, qk_tap_dance_pair_finished, qk_tap_dance_pair_reset}, .user_data = (void *)&((qk_tap_dance_pair_t){kc1, kc2}), } # define ACTION_TAP_DANCE_DUAL_ROLE(kc, layer) \ - { .fn = { qk_tap_dance_dual_role_on_each_tap, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset }, .user_data = (void *)&((qk_tap_dance_dual_role_t) { kc, layer, layer_move }), } + { .fn = {qk_tap_dance_dual_role_on_each_tap, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset}, .user_data = (void *)&((qk_tap_dance_dual_role_t){kc, layer, layer_move}), } # define ACTION_TAP_DANCE_LAYER_TOGGLE(kc, layer) \ - { .fn = { NULL, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset }, .user_data = (void *)&((qk_tap_dance_dual_role_t) { kc, layer, layer_invert }), } + { .fn = {NULL, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset}, .user_data = (void *)&((qk_tap_dance_dual_role_t){kc, layer, layer_invert}), } # define ACTION_TAP_DANCE_LAYER_MOVE(kc, layer) ACTION_TAP_DANCE_DUAL_ROLE(kc, layer) @@ -79,8 +79,6 @@ typedef struct { # define ACTION_TAP_DANCE_FN_ADVANCED_TIME(user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset, tap_specific_tapping_term) \ { .fn = {user_fn_on_each_tap, user_fn_on_dance_finished, user_fn_on_dance_reset}, .user_data = NULL, .custom_tapping_term = tap_specific_tapping_term, } - - extern qk_tap_dance_action_t tap_dance_actions[]; /* To be used internally */ diff --git a/quantum/quantum.c b/quantum/quantum.c index c27c3aba6..2e5e6376b 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -1116,7 +1116,7 @@ __attribute__((weak)) void led_set(uint8_t usb_led) { #endif led_set_kb(usb_led); - led_update_kb((led_t) usb_led); + led_update_kb((led_t)usb_led); } //------------------------------------------------------------------------------ diff --git a/quantum/quantum.h b/quantum/quantum.h index 7988c5878..6beab65a3 100644 --- a/quantum/quantum.h +++ b/quantum/quantum.h @@ -146,14 +146,13 @@ extern layer_state_t layer_state; #endif #ifdef DIP_SWITCH_ENABLE - #include "dip_switch.h" +# include "dip_switch.h" #endif #ifdef DYNAMIC_MACRO_ENABLE - #include "process_dynamic_macro.h" +# include "process_dynamic_macro.h" #endif - // Function substitutions to ease GPIO manipulation #if defined(__AVR__) typedef uint8_t pin_t; diff --git a/quantum/quantum_keycodes.h b/quantum/quantum_keycodes.h index 51a7e290f..66a3c66e8 100644 --- a/quantum/quantum_keycodes.h +++ b/quantum/quantum_keycodes.h @@ -771,4 +771,4 @@ enum quantum_keycodes { #define DM_PLY1 DYN_MACRO_PLAY1 #define DM_PLY2 DYN_MACRO_PLAY2 -#endif // QUANTUM_KEYCODES_H +#endif // QUANTUM_KEYCODES_H diff --git a/quantum/rgblight.c b/quantum/rgblight.c index 80f276139..7949bb688 100644 --- a/quantum/rgblight.c +++ b/quantum/rgblight.c @@ -919,7 +919,7 @@ void rgblight_effect_snake(animation_status_t *anim) { ledp->g = 0; ledp->b = 0; # ifdef RGBW - ledp->w = 0; + ledp->w = 0; # endif for (j = 0; j < RGBLIGHT_EFFECT_SNAKE_LENGTH; j++) { k = pos + j * increment; diff --git a/quantum/stm32/chconf.h b/quantum/stm32/chconf.h index f7b1b077d..6b691950a 100644 --- a/quantum/stm32/chconf.h +++ b/quantum/stm32/chconf.h @@ -419,34 +419,39 @@ * @note It is invoked from within @p chThdInit() and implicitly from all * the threads creation APIs. */ -# define CH_CFG_THREAD_INIT_HOOK(tp) \ - { /* Add threads initialization code here.*/ } +# define CH_CFG_THREAD_INIT_HOOK(tp) \ + { /* Add threads initialization code here.*/ \ + } /** * @brief Threads finalization hook. * @details User finalization code added to the @p chThdExit() API. */ -# define CH_CFG_THREAD_EXIT_HOOK(tp) \ - { /* Add threads finalization code here.*/ } +# define CH_CFG_THREAD_EXIT_HOOK(tp) \ + { /* Add threads finalization code here.*/ \ + } /** * @brief Context switch hook. * @details This hook is invoked just before switching between threads. */ # define CH_CFG_CONTEXT_SWITCH_HOOK(ntp, otp) \ - { /* Context switch code here.*/ } + { /* Context switch code here.*/ \ + } /** * @brief ISR enter hook. */ # define CH_CFG_IRQ_PROLOGUE_HOOK() \ - { /* IRQ prologue code here.*/ } + { /* IRQ prologue code here.*/ \ + } /** * @brief ISR exit hook. */ # define CH_CFG_IRQ_EPILOGUE_HOOK() \ - { /* IRQ epilogue code here.*/ } + { /* IRQ epilogue code here.*/ \ + } /** * @brief Idle thread enter hook. @@ -455,7 +460,8 @@ * @note This macro can be used to activate a power saving mode. */ # define CH_CFG_IDLE_ENTER_HOOK() \ - { /* Idle-enter code here.*/ } + { /* Idle-enter code here.*/ \ + } /** * @brief Idle thread leave hook. @@ -464,22 +470,25 @@ * @note This macro can be used to deactivate a power saving mode. */ # define CH_CFG_IDLE_LEAVE_HOOK() \ - { /* Idle-leave code here.*/ } + { /* Idle-leave code here.*/ \ + } /** * @brief Idle Loop hook. * @details This hook is continuously invoked by the idle thread loop. */ # define CH_CFG_IDLE_LOOP_HOOK() \ - { /* Idle loop code here.*/ } + { /* Idle loop code here.*/ \ + } /** * @brief System tick event hook. * @details This hook is invoked in the system tick handler immediately * after processing the virtual timers queue. */ -# define CH_CFG_SYSTEM_TICK_HOOK() \ - { /* System tick event code here.*/ } +# define CH_CFG_SYSTEM_TICK_HOOK() \ + { /* System tick event code here.*/ \ + } /** * @brief System halt hook. @@ -487,7 +496,8 @@ * the system is halted. */ # define CH_CFG_SYSTEM_HALT_HOOK(reason) \ - { /* System halt code here.*/ } + { /* System halt code here.*/ \ + } /** * @brief Trace hook. @@ -495,7 +505,8 @@ * trace buffer. */ # define CH_CFG_TRACE_HOOK(tep) \ - { /* Trace code here.*/ } + { /* Trace code here.*/ \ + } /** @} */ diff --git a/tmk_core/common/arm_atsam/suspend.c b/tmk_core/common/arm_atsam/suspend.c index 2dad00570..d1077be4c 100644 --- a/tmk_core/common/arm_atsam/suspend.c +++ b/tmk_core/common/arm_atsam/suspend.c @@ -7,7 +7,8 @@ * * FIXME: needs doc */ -void suspend_idle(uint8_t time) { /* Note: Not used anywhere currently */ } +void suspend_idle(uint8_t time) { /* Note: Not used anywhere currently */ +} /** \brief Run user level Power down * diff --git a/tmk_core/common/eeconfig.c b/tmk_core/common/eeconfig.c index 72f198d6c..7cec4bd7d 100644 --- a/tmk_core/common/eeconfig.c +++ b/tmk_core/common/eeconfig.c @@ -51,10 +51,10 @@ void eeconfig_init_quantum(void) { // TODO: Remove once ARM has a way to configure EECONFIG_HANDEDNESS // within the emulated eeprom via dfu-util or another tool #if defined INIT_EE_HANDS_LEFT - #pragma message "Faking EE_HANDS for left hand" +# pragma message "Faking EE_HANDS for left hand" eeprom_update_byte(EECONFIG_HANDEDNESS, 1); #elif defined INIT_EE_HANDS_RIGHT - #pragma message "Faking EE_HANDS for right hand" +# pragma message "Faking EE_HANDS for right hand" eeprom_update_byte(EECONFIG_HANDEDNESS, 0); #endif diff --git a/tmk_core/common/host.c b/tmk_core/common/host.c index 713b0d945..e7d92cfac 100644 --- a/tmk_core/common/host.c +++ b/tmk_core/common/host.c @@ -41,7 +41,7 @@ uint8_t host_keyboard_leds(void) { } led_t host_keyboard_led_state(void) { - if (!driver) return (led_t) {0}; + if (!driver) return (led_t){0}; return (led_t)((*driver->keyboard_leds)()); } diff --git a/tmk_core/common/led.h b/tmk_core/common/led.h index daf974bed..990282862 100644 --- a/tmk_core/common/led.h +++ b/tmk_core/common/led.h @@ -36,11 +36,11 @@ extern "C" { typedef union { uint8_t raw; struct { - bool num_lock : 1; - bool caps_lock : 1; - bool scroll_lock : 1; - bool compose : 1; - bool kana : 1; + bool num_lock : 1; + bool caps_lock : 1; + bool scroll_lock : 1; + bool compose : 1; + bool kana : 1; uint8_t reserved : 3; }; } led_t; diff --git a/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h b/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h index 2f8a39bdd..fb97f63ce 100644 --- a/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h +++ b/tmk_core/protocol/arm_atsam/usb/usb_protocol_hid.h @@ -186,9 +186,10 @@ COMPILER_PACK_RESET() #define USB_HID_COUNTRY_UK 32 // UK #define USB_HID_COUNTRY_US 33 // US #define USB_HID_COUNTRY_YUGOSLAVIA 34 // Yugoslavia -#define USB_HID_COUNTRY_TURKISH_F 35 // Turkish-F - //! @} - //! @} +#define USB_HID_COUNTRY_TURKISH_F \ + 35 // Turkish-F + //! @} + //! @} //! @} //! \name HID KEYS values diff --git a/tmk_core/protocol/chibios/usb_main.c b/tmk_core/protocol/chibios/usb_main.c index f7bfa20b2..b90bcd037 100644 --- a/tmk_core/protocol/chibios/usb_main.c +++ b/tmk_core/protocol/chibios/usb_main.c @@ -310,7 +310,7 @@ static void usb_event_cb(USBDriver *usbp, usbevent_t event) { case USB_EVENT_SUSPEND: #ifdef SLEEP_LED_ENABLE sleep_led_enable(); -#endif /* SLEEP_LED_ENABLE */ +#endif /* SLEEP_LED_ENABLE */ /* Falls into.*/ case USB_EVENT_UNCONFIGURED: /* Falls into.*/ @@ -453,9 +453,9 @@ static bool usb_request_hook_cb(USBDriver *usbp) { #ifdef NKRO_ENABLE keymap_config.nkro = !!keyboard_protocol; if (!keymap_config.nkro && keyboard_idle) { -#else /* NKRO_ENABLE */ +#else /* NKRO_ENABLE */ if (keyboard_idle) { -#endif /* NKRO_ENABLE */ +#endif /* NKRO_ENABLE */ /* arm the idle timer if boot protocol & idle */ osalSysLockFromISR(); chVTSetI(&keyboard_idle_timer, 4 * MS2ST(keyboard_idle), keyboard_idle_timer_cb, (void *)usbp); diff --git a/tmk_core/protocol/iwrap/iwrap.c b/tmk_core/protocol/iwrap/iwrap.c index 05e632da3..4d0ca5756 100644 --- a/tmk_core/protocol/iwrap/iwrap.c +++ b/tmk_core/protocol/iwrap/iwrap.c @@ -320,7 +320,8 @@ static void send_mouse(report_mouse_t *report) { #endif } -static void send_system(uint16_t data) { /* not supported */ } +static void send_system(uint16_t data) { /* not supported */ +} static void send_consumer(uint16_t data) { #ifdef EXTRAKEY_ENABLE diff --git a/tmk_core/protocol/lufa/adafruit_ble.cpp b/tmk_core/protocol/lufa/adafruit_ble.cpp index 505794a80..7b3ffdef7 100644 --- a/tmk_core/protocol/lufa/adafruit_ble.cpp +++ b/tmk_core/protocol/lufa/adafruit_ble.cpp @@ -31,9 +31,9 @@ #define ConnectionUpdateInterval 1000 /* milliseconds */ #ifdef SAMPLE_BATTERY -#ifndef BATTERY_LEVEL_PIN -# define BATTERY_LEVEL_PIN 7 -#endif +# ifndef BATTERY_LEVEL_PIN +# define BATTERY_LEVEL_PIN 7 +# endif #endif static struct { -- cgit v1.3.1