From 3895b4b86867c6323f4e595b9726d02158bca612 Mon Sep 17 00:00:00 2001 From: fauxpark Date: Wed, 17 Jul 2019 14:58:29 +1000 Subject: Extend maximum number of backlight levels to 31 (#6351) --- docs/feature_backlight.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'docs/feature_backlight.md') diff --git a/docs/feature_backlight.md b/docs/feature_backlight.md index b06db89e4..26a5078ca 100644 --- a/docs/feature_backlight.md +++ b/docs/feature_backlight.md @@ -65,7 +65,7 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`: |---------------------|-------------|-------------------------------------------------------------------------------------------------------------| |`BACKLIGHT_PIN` |`B7` |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this| |`BACKLIGHT_PINS` |*Not defined*|experimental: see below for more information | -|`BACKLIGHT_LEVELS` |`3` |The number of brightness levels (maximum 15 excluding off) | +|`BACKLIGHT_LEVELS` |`3` |The number of brightness levels (maximum 31 excluding off) | |`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED) | |`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if supported | |`BREATHING_PERIOD` |`6` |The length of one backlight "breath" in seconds | -- cgit v1.2.3-70-g09d2 From 5b4187ad1bdad6ec40d4f98c5342a22ab68cfabd Mon Sep 17 00:00:00 2001 From: fauxpark Date: Fri, 19 Jul 2019 00:45:00 +1000 Subject: Correct backlight on state docs (#6358) * Correct backlight on state docs * Reword to make it less confusing --- docs/feature_backlight.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'docs/feature_backlight.md') diff --git a/docs/feature_backlight.md b/docs/feature_backlight.md index 26a5078ca..64c663076 100644 --- a/docs/feature_backlight.md +++ b/docs/feature_backlight.md @@ -73,8 +73,10 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`: ## Backlight On State -Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *low*. -Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case you must `#define BACKLIGHT_ON_STATE 1`, so that when the transistor is on, the pin is driven *high* instead. +Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*. +Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead. + +This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define. ## Multiple backlight pins -- cgit v1.2.3-70-g09d2 From 4d72aa428fb8dc72634bded428f78ffba2284fdc Mon Sep 17 00:00:00 2001 From: fauxpark Date: Fri, 9 Aug 2019 06:12:12 +1000 Subject: Improve backlight PWM pin support (#6202) * Improve backlight PWM pin support * I accidentally an equals sign * Another typo * Order by pin number * Throw an error if backlight pin is C4 or C5 on 16/32U4 * Use else for clarity * Minor alignment adjustments --- docs/config_options.md | 2 +- docs/feature_backlight.md | 47 ++-- docs/getting_started_make_guide.md | 2 +- docs/hardware_avr.md | 4 +- ...keyboard_to_qmk_(arm_and_other_chibios_cpus).md | 2 +- quantum/quantum.c | 239 ++++++++++++--------- 6 files changed, 168 insertions(+), 128 deletions(-) (limited to 'docs/feature_backlight.md') diff --git a/docs/config_options.md b/docs/config_options.md index 3be294db8..d2ae56179 100644 --- a/docs/config_options.md +++ b/docs/config_options.md @@ -76,7 +76,7 @@ This is a C header file that is one of the first things included, and will persi * `#define B7_AUDIO` * enables audio on pin B7 (duophony is enables if one of B[5-7]\_AUDIO is enabled along with one of C[4-6]\_AUDIO) * `#define BACKLIGHT_PIN B7` - * pin of the backlight - `B5`, `B6`, `B7` and `C6` (and `D4` on ATmega32A) use hardware PWM, others use software implementation + * pin of the backlight * `#define BACKLIGHT_LEVELS 3` * number of levels your backlight will have (maximum 15 excluding off) * `#define BACKLIGHT_BREATHING` diff --git a/docs/feature_backlight.md b/docs/feature_backlight.md index 64c663076..2d9eea67b 100644 --- a/docs/feature_backlight.md +++ b/docs/feature_backlight.md @@ -30,32 +30,31 @@ You should then be able to use the keycodes below to change the backlight level. This feature is distinct from both the [RGB underglow](feature_rgblight.md) and [RGB matrix](feature_rgb_matrix.md) features as it usually allows for only a single colour per switch, though you can obviously use multiple different coloured LEDs on a keyboard. -Hardware PWM is only supported on certain pins of the MCU, so if the backlighting is not connected to one of them, a software PWM implementation triggered by hardware timer interrupts will be used. - Hardware PWM is supported according to the following table: -| Backlight Pin | Hardware timer | -|---------------|-------------------------| -|`B5` | Timer 1 | -|`B6` | Timer 1 | -|`B7` | Timer 1 | -|`C6` | Timer 3 | -|`D4` | Timer 1 (ATmega32A only)| -| other | Software PWM | - -The [audio feature](feature_audio.md) also uses hardware timers. Please refer to the following table to know what hardware timer the software PWM will use depending on the audio configuration: - -| Audio Pin(s) | Audio Timer | Software PWM Timer | -|--------------|-------------|--------------------| -| `C4` | Timer 3 | Timer 1 | -| `C5` | Timer 3 | Timer 1 | -| `C6` | Timer 3 | Timer 1 | -| `B5` | Timer 1 | Timer 3 | -| `B6` | Timer 1 | Timer 3 | -| `B7` | Timer 1 | Timer 3 | -| `Bx` & `Cx` | Timer 1 & 3 | None | - -When all timers are in use for [audio](feature_audio.md), the backlight software PWM will not use a hardware timer, but instead will be triggered during the matrix scan. In this case the backlight doesn't support breathing and might show lighting artifacts (for instance flickering), because the PWM computation might not be called with enough timing precision. +|Backlight Pin|AT90USB64/128|ATmega16/32U4|ATmega16/32U2|ATmega32A| +|-------------|-------------|-------------|-------------|---------| +|`B5` |Timer 1 |Timer 1 | | | +|`B6` |Timer 1 |Timer 1 | | | +|`B7` |Timer 1 |Timer 1 |Timer 1 | | +|`C4` |Timer 3 | | | | +|`C5` |Timer 3 | |Timer 1 | | +|`C6` |Timer 3 |Timer 3 |Timer 1 | | +|`D4` | | | |Timer 1 | +|`D5` | | | |Timer 1 | + +All other pins will use software PWM. If the [Audio](feature_audio.md) feature is disabled or only using one timer, the backlight PWM can be triggered by a hardware timer: + +|Audio Pin|Audio Timer|Software PWM Timer| +|---------|-----------|------------------| +|`C4` |Timer 3 |Timer 1 | +|`C5` |Timer 3 |Timer 1 | +|`C6` |Timer 3 |Timer 1 | +|`B5` |Timer 1 |Timer 3 | +|`B6` |Timer 1 |Timer 3 | +|`B7` |Timer 1 |Timer 3 | + +When both timers are in use for Audio, the backlight PWM will not use a hardware timer, but will instead be triggered during the matrix scan. In this case, breathing is not supported, and the backlight might flicker, because the PWM computation may not be called with enough timing precision. ## Configuration diff --git a/docs/getting_started_make_guide.md b/docs/getting_started_make_guide.md index 75eafd42c..4fe3f184d 100644 --- a/docs/getting_started_make_guide.md +++ b/docs/getting_started_make_guide.md @@ -83,7 +83,7 @@ This allows the keyboard to tell the host OS that up to 248 keys are held down a `BACKLIGHT_ENABLE` -This enables your backlight on Timer1 and ports B5, B6, or B7 (for now). You can specify your port by putting this in your `config.h`: +This enables the in-switch LED backlighting. You can specify the backlight pin by putting this in your `config.h`: #define BACKLIGHT_PIN B7 diff --git a/docs/hardware_avr.md b/docs/hardware_avr.md index 7c28ab6db..c6987d1bd 100644 --- a/docs/hardware_avr.md +++ b/docs/hardware_avr.md @@ -125,7 +125,7 @@ To configure a keyboard where each switch is connected to a separate pin and gro ### Backlight Configuration -By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are using one of those you can simply enable it here. For more details see the [Backlight Documentation](feature_backlight.md). +QMK supports backlighting on most GPIO pins. A select few of these can be driven by the MCU in hardware. For more details see the [Backlight Documentation](feature_backlight.md). ```c #define BACKLIGHT_PIN B7 @@ -134,8 +134,6 @@ By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are us #define BREATHING_PERIOD 6 ``` -?> You can use backlighting on any pin you like, but you will have to do more work to support that. See the [Backlight Documentation](feature_backlight.md) for more details. - ### Other Configuration Options There are a lot of features that can be configured or tuned in `config.h`. You should see the [Config Options](config_options.md) page for more details. diff --git a/docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md b/docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md index 979eafbc8..bce9f9dc9 100644 --- a/docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md +++ b/docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md @@ -34,7 +34,7 @@ For the `DIODE_DIRECTION`, most hand-wiring guides will instruct you to wire the To configure a keyboard where each switch is connected to a separate pin and ground instead of sharing row and column pins, use `DIRECT_PINS`. The mapping defines the pins of each switch in rows and columns, from left to right. Must conform to the sizes within `MATRIX_ROWS` and `MATRIX_COLS`, use `NO_PIN` to fill in blank spaces. Overrides the behaviour of `DIODE_DIRECTION`, `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`. -`BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to. Currently only B5, B6, and B7 are supported. +`BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to. `BACKLIGHT_BREATHING` is a fancier backlight feature that adds breathing/pulsing/fading effects to the backlight. It uses the same timer as the normal backlight. These breathing effects must be called by code in your keymap. diff --git a/quantum/quantum.c b/quantum/quantum.c index d98c601d9..77cbbb2e7 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -1034,104 +1034,147 @@ void matrix_scan_quantum() { } #if defined(BACKLIGHT_ENABLE) && (defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS)) -// The logic is a bit complex, we support 3 setups: -// 1. hardware PWM when backlight is wired to a PWM pin -// depending on this pin, we use a different output compare unit -// 2. software PWM with hardware timers, but the used timer depends -// on the audio setup (audio wins other backlight) -// 3. full software PWM - -#if BACKLIGHT_PIN == B7 -# define HARDWARE_PWM -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define COMxx1 COM1C1 -# define OCRxx OCR1C -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define TOIEx TOIE1 -# define ICRx ICR1 -# define TIMSKx TIMSK1 -#elif BACKLIGHT_PIN == B6 -# define HARDWARE_PWM -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define COMxx1 COM1B1 -# define OCRxx OCR1B -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define TOIEx TOIE1 -# define ICRx ICR1 -# define TIMSKx TIMSK1 -#elif BACKLIGHT_PIN == B5 -# define HARDWARE_PWM -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define COMxx1 COM1A1 -# define OCRxx OCR1A -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define TOIEx TOIE1 -# define ICRx ICR1 -# define TIMSKx TIMSK1 -#elif BACKLIGHT_PIN == C6 -# define HARDWARE_PWM -# define TCCRxA TCCR3A -# define TCCRxB TCCR3B -# define COMxx1 COM3A1 -# define OCRxx OCR3A -# define TIMERx_OVF_vect TIMER3_OVF_vect -# define TOIEx TOIE3 -# define ICRx ICR3 -# define TIMSKx TIMSK3 -#elif defined(__AVR_ATmega32A__) && BACKLIGHT_PIN == D4 -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define COMxx1 COM1B1 -# define OCRxx OCR1B -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define TOIEx TOIE1 -# define ICRx ICR1 -# define TIMSKx TIMSK1 +// This logic is a bit complex, we support 3 setups: +// +// 1. Hardware PWM when backlight is wired to a PWM pin. +// Depending on this pin, we use a different output compare unit. +// 2. Software PWM with hardware timers, but the used timer +// depends on the Audio setup (Audio wins over Backlight). +// 3. Full software PWM, driven by the matrix scan, if both timers are used by Audio. + +#if (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) \ + || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) \ + || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) \ + && (BACKLIGHT_PIN == B5 || BACKLIGHT_PIN == B6 || BACKLIGHT_PIN == B7) + #define HARDWARE_PWM + #define ICRx ICR1 + #define TCCRxA TCCR1A + #define TCCRxB TCCR1B + #define TIMERx_OVF_vect TIMER1_OVF_vect + #define TIMSKx TIMSK1 + #define TOIEx TOIE1 + + #if BACKLIGHT_PIN == B5 + #define COMxx1 COM1A1 + #define OCRxx OCR1A + #elif BACKLIGHT_PIN == B6 + #define COMxx1 COM1B1 + #define OCRxx OCR1B + #elif BACKLIGHT_PIN == B7 + #define COMxx1 COM1C1 + #define OCRxx OCR1C + #endif +#elif (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) \ + || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) \ + || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) \ + && (BACKLIGHT_PIN == C4 || BACKLIGHT_PIN == C5 || BACKLIGHT_PIN == C6) + #define HARDWARE_PWM + #define ICRx ICR3 + #define TCCRxA TCCR3A + #define TCCRxB TCCR3B + #define TIMERx_OVF_vect TIMER3_OVF_vect + #define TIMSKx TIMSK3 + #define TOIEx TOIE3 + + #if BACKLIGHT_PIN == C4 + #if (defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) + #error This MCU has no C4 pin! + #else + #define COMxx1 COM3C1 + #define OCRxx OCR3C + #endif + #elif BACKLIGHT_PIN == C5 + #if (defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) + #error This MCU has no C5 pin! + #else + #define COMxx1 COM3B1 + #define OCRxx OCR3B + #endif + #elif BACKLIGHT_PIN == C6 + #define COMxx1 COM3A1 + #define OCRxx OCR3A + #endif +#elif (defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__)) \ + && (BACKLIGHT_PIN == B7 || BACKLIGHT_PIN == C5 || BACKLIGHT_PIN == C6) + #define HARDWARE_PWM + #define ICRx ICR1 + #define TCCRxA TCCR1A + #define TCCRxB TCCR1B + #define TIMERx_OVF_vect TIMER1_OVF_vect + #define TIMSKx TIMSK1 + #define TOIEx TOIE1 + + #if BACKLIGHT_PIN == B7 + #define COMxx1 COM1C1 + #define OCRxx OCR1C + #elif BACKLIGHT_PIN == C5 + #define COMxx1 COM1B1 + #define OCRxx OCR1B + #elif BACKLIGHT_PIN == C6 + #define COMxx1 COM1A1 + #define OCRxx OCR1A + #endif +#elif defined(__AVR_ATmega32A__) \ + && (BACKLIGHT_PIN == D4 || BACKLIGHT_PIN == D5) + #define HARDWARE_PWM + #define ICRx ICR1 + #define TCCRxA TCCR1A + #define TCCRxB TCCR1B + #define TIMERx_OVF_vect TIMER1_OVF_vect + #define TIMSKx TIMSK + #define TOIEx TOIE1 + + #if BACKLIGHT_PIN == D4 + #define COMxx1 COM1B1 + #define OCRxx OCR1B + #elif BACKLIGHT_PIN == D5 + #define COMxx1 COM1A1 + #define OCRxx OCR1A + #endif #else -# if !defined(BACKLIGHT_CUSTOM_DRIVER) -# if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO) - // timer 1 is not used by audio , backlight can use it -#pragma message "Using hardware timer 1 with software PWM" -# define HARDWARE_PWM -# define BACKLIGHT_PWM_TIMER -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define OCRxx OCR1A -# define TIMERx_COMPA_vect TIMER1_COMPA_vect -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define OCIExA OCIE1A -# define TOIEx TOIE1 -# define ICRx ICR1 -# if defined(__AVR_ATmega32A__) // This MCU has only one TIMSK register -# define TIMSKx TIMSK -# else -# define TIMSKx TIMSK1 -# endif -# elif !defined(C6_AUDIO) && !defined(C5_AUDIO) && !defined(C4_AUDIO) -#pragma message "Using hardware timer 3 with software PWM" -// timer 3 is not used by audio, backlight can use it -# define HARDWARE_PWM -# define BACKLIGHT_PWM_TIMER -# define TCCRxA TCCR3A -# define TCCRxB TCCR3B -# define OCRxx OCR3A -# define TIMERx_COMPA_vect TIMER3_COMPA_vect -# define TIMERx_OVF_vect TIMER3_OVF_vect -# define OCIExA OCIE3A -# define TOIEx TOIE3 -# define ICRx ICR1 -# define TIMSKx TIMSK3 -# else -#pragma message "Audio in use - using pure software PWM" -#define NO_HARDWARE_PWM -# endif -# else -#pragma message "Custom driver defined - using pure software PWM" -#define NO_HARDWARE_PWM -# endif + #if !defined(BACKLIGHT_CUSTOM_DRIVER) + #if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO) + // Timer 1 is not in use by Audio feature, Backlight can use it + #pragma message "Using hardware timer 1 with software PWM" + #define HARDWARE_PWM + #define BACKLIGHT_PWM_TIMER + #define ICRx ICR1 + #define TCCRxA TCCR1A + #define TCCRxB TCCR1B + #define TIMERx_COMPA_vect TIMER1_COMPA_vect + #define TIMERx_OVF_vect TIMER1_OVF_vect + #if defined(__AVR_ATmega32A__) // This MCU has only one TIMSK register + #define TIMSKx TIMSK + #else + #define TIMSKx TIMSK1 + #endif + #define TOIEx TOIE1 + + #define OCIExA OCIE1A + #define OCRxx OCR1A + #elif !defined(C6_AUDIO) && !defined(C5_AUDIO) && !defined(C4_AUDIO) + #pragma message "Using hardware timer 3 with software PWM" + // Timer 3 is not in use by Audio feature, Backlight can use it + #define HARDWARE_PWM + #define BACKLIGHT_PWM_TIMER + #define ICRx ICR1 + #define TCCRxA TCCR3A + #define TCCRxB TCCR3B + #define TIMERx_COMPA_vect TIMER3_COMPA_vect + #define TIMERx_OVF_vect TIMER3_OVF_vect + #define TIMSKx TIMSK3 + #define TOIEx TOIE3 + + #define OCIExA OCIE3A + #define OCRxx OCR3A + #else + #pragma message "Audio in use - using pure software PWM" + #define NO_HARDWARE_PWM + #endif + #else + #pragma message "Custom driver defined - using pure software PWM" + #define NO_HARDWARE_PWM + #endif #endif #ifndef BACKLIGHT_ON_STATE @@ -1300,7 +1343,7 @@ static uint16_t cie_lightness(uint16_t v) { // range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val. static inline void set_pwm(uint16_t val) { - OCRxx = val; + OCRxx = val; } #ifndef BACKLIGHT_CUSTOM_DRIVER -- cgit v1.2.3-70-g09d2 From 3b4b54f6ed0361e41bd1fb9463539e7b871e6b68 Mon Sep 17 00:00:00 2001 From: xster Date: Sun, 15 Sep 2019 02:22:02 -0700 Subject: Clarify the backlight_level API doc slightly (#6733) * Clarify the backlight_level API doc slightly * review --- docs/feature_backlight.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'docs/feature_backlight.md') diff --git a/docs/feature_backlight.md b/docs/feature_backlight.md index 2d9eea67b..690eb8215 100644 --- a/docs/feature_backlight.md +++ b/docs/feature_backlight.md @@ -119,7 +119,8 @@ The breathing effect is the same as in the hardware PWM implementation. |`backlight_step()` |Cycle through backlight levels | |`backlight_increase()` |Increase the backlight level | |`backlight_decrease()` |Decrease the backlight level | -|`backlight_level(x)` |Sets the backlight level to specified level | +|`backlight_level(x)` |Sets the backlight level, from 0 to | +| |`BACKLIGHT_LEVELS` | |`get_backlight_level()` |Return the current backlight level | |`is_backlight_enabled()`|Return whether the backlight is currently on | -- cgit v1.2.3-70-g09d2 From 3642a82d37e8c4fb34b9ee60606ab831d642c9ec Mon Sep 17 00:00:00 2001 From: fauxpark Date: Sat, 21 Sep 2019 15:11:15 +1000 Subject: Add support for 328P hardware backlight on B1/B2 (#6776) --- docs/feature_backlight.md | 22 ++++++++++++---------- quantum/quantum.c | 16 ++++++++++++++++ 2 files changed, 28 insertions(+), 10 deletions(-) (limited to 'docs/feature_backlight.md') diff --git a/docs/feature_backlight.md b/docs/feature_backlight.md index 690eb8215..556da7385 100644 --- a/docs/feature_backlight.md +++ b/docs/feature_backlight.md @@ -32,16 +32,18 @@ This feature is distinct from both the [RGB underglow](feature_rgblight.md) and Hardware PWM is supported according to the following table: -|Backlight Pin|AT90USB64/128|ATmega16/32U4|ATmega16/32U2|ATmega32A| -|-------------|-------------|-------------|-------------|---------| -|`B5` |Timer 1 |Timer 1 | | | -|`B6` |Timer 1 |Timer 1 | | | -|`B7` |Timer 1 |Timer 1 |Timer 1 | | -|`C4` |Timer 3 | | | | -|`C5` |Timer 3 | |Timer 1 | | -|`C6` |Timer 3 |Timer 3 |Timer 1 | | -|`D4` | | | |Timer 1 | -|`D5` | | | |Timer 1 | +|Backlight Pin|AT90USB64/128|ATmega16/32U4|ATmega16/32U2|ATmega32A|ATmega328P| +|-------------|-------------|-------------|-------------|---------|----------| +|`B1` | | | | |Timer 1 | +|`B2` | | | | |Timer 1 | +|`B5` |Timer 1 |Timer 1 | | | | +|`B6` |Timer 1 |Timer 1 | | | | +|`B7` |Timer 1 |Timer 1 |Timer 1 | | | +|`C4` |Timer 3 | | | | | +|`C5` |Timer 3 | |Timer 1 | | | +|`C6` |Timer 3 |Timer 3 |Timer 1 | | | +|`D4` | | | |Timer 1 | | +|`D5` | | | |Timer 1 | | All other pins will use software PWM. If the [Audio](feature_audio.md) feature is disabled or only using one timer, the backlight PWM can be triggered by a hardware timer: diff --git a/quantum/quantum.c b/quantum/quantum.c index 85a03377f..ec80fa557 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -1104,6 +1104,22 @@ void matrix_scan_quantum() { # define COMxx1 COM1A1 # define OCRxx OCR1A # endif +# elif defined(__AVR_ATmega328P__) && (BACKLIGHT_PIN == B1 || BACKLIGHT_PIN == B2) +# define HARDWARE_PWM +# define ICRx ICR1 +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TIMSKx TIMSK1 +# define TOIEx TOIE1 + +# if BACKLIGHT_PIN == B1 +# define COMxx1 COM1A1 +# define OCRxx OCR1A +# elif BACKLIGHT_PIN == B2 +# define COMxx1 COM1B1 +# define OCRxx OCR1B +# endif # else # if !defined(BACKLIGHT_CUSTOM_DRIVER) # if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO) -- cgit v1.2.3-70-g09d2 From 38aefaf78e3d9f17ef561f031679a02c9fba869c Mon Sep 17 00:00:00 2001 From: Joel Challis Date: Sat, 5 Oct 2019 16:57:00 +0100 Subject: ARM - Initial backlight support (#6487) * Move AVR backlight to own file, add borrowed ARM implementation * Tiny fix for backlight custom logic * Remove duplicate board from rebase * Fix f303 onekey example * clang-format * clang-format * Remove backlight keymap debug * Initial pass of ARM backlight docs * Initial pass of ARM backlight docs - resolve todos * fix rules validation logic * Add f072 warning * Add f072 warning * tidy up breathing in backlight keymap * tidy up breathing in backlight keymap * add missing break to backlight keymap --- common_features.mk | 23 +- docs/feature_backlight.md | 50 +- keyboards/handwired/onekey/bluepill/config.h | 4 + keyboards/handwired/onekey/bluepill/halconf.h | 2 +- keyboards/handwired/onekey/bluepill/mcuconf.h | 6 +- keyboards/handwired/onekey/bluepill/rules.mk | 6 +- keyboards/handwired/onekey/config.h | 2 + .../handwired/onekey/keymaps/backlight/config.h | 3 + .../handwired/onekey/keymaps/backlight/keymap.c | 40 ++ .../handwired/onekey/keymaps/backlight/rules.mk | 2 + keyboards/handwired/onekey/proton_c/config.h | 5 + keyboards/handwired/onekey/stm32f0_disco/config.h | 5 + quantum/backlight/backlight.c | 1 + quantum/backlight/backlight_arm.c | 218 +++++++++ quantum/backlight/backlight_avr.c | 509 +++++++++++++++++++++ quantum/quantum.c | 509 --------------------- tmk_core/common/backlight.h | 4 + 17 files changed, 860 insertions(+), 529 deletions(-) create mode 100644 keyboards/handwired/onekey/keymaps/backlight/config.h create mode 100644 keyboards/handwired/onekey/keymaps/backlight/keymap.c create mode 100644 keyboards/handwired/onekey/keymaps/backlight/rules.mk create mode 100644 quantum/backlight/backlight.c create mode 100644 quantum/backlight/backlight_arm.c create mode 100644 quantum/backlight/backlight_avr.c (limited to 'docs/feature_backlight.md') diff --git a/common_features.mk b/common_features.mk index 79af8a225..05a99fc63 100644 --- a/common_features.mk +++ b/common_features.mk @@ -229,13 +229,32 @@ ifeq ($(strip $(LCD_ENABLE)), yes) CIE1931_CURVE = yes endif -ifeq ($(strip $(BACKLIGHT_ENABLE)), yes) +# backward compat +ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes) + BACKLIGHT_ENABLE = custom +endif + +VALID_BACKLIGHT_TYPES := yes custom + +BACKLIGHT_ENABLE ?= no +ifneq ($(strip $(BACKLIGHT_ENABLE)), no) + ifeq ($(filter $(BACKLIGHT_ENABLE),$(VALID_BACKLIGHT_TYPES)),) + $(error BACKLIGHT_ENABLE="$(BACKLIGHT_ENABLE)" is not a valid backlight type) + endif + ifeq ($(strip $(VISUALIZER_ENABLE)), yes) CIE1931_CURVE = yes endif - ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes) + + ifeq ($(strip $(BACKLIGHT_ENABLE)), custom) OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER endif + + ifeq ($(PLATFORM),AVR) + SRC += $(QUANTUM_DIR)/backlight/backlight_avr.c + else + SRC += $(QUANTUM_DIR)/backlight/backlight_arm.c + endif endif ifeq ($(strip $(CIE1931_CURVE)), yes) diff --git a/docs/feature_backlight.md b/docs/feature_backlight.md index 556da7385..6a2946fd6 100644 --- a/docs/feature_backlight.md +++ b/docs/feature_backlight.md @@ -1,6 +1,8 @@ # Backlighting -Many keyboards support backlit keys by way of individual LEDs placed through or underneath the keyswitches. QMK is able to control the brightness of these LEDs by switching them on and off rapidly in a certain ratio, a technique known as *Pulse Width Modulation*, or PWM. By altering the duty cycle of the PWM signal, it creates the illusion of dimming. +Many keyboards support backlit keys by way of individual LEDs placed through or underneath the keyswitches. This feature is distinct from both the [RGB underglow](feature_rgblight.md) and [RGB matrix](feature_rgb_matrix.md) features as it usually allows for only a single colour per switch, though you can obviously install multiple different single coloured LEDs on a keyboard. + +QMK is able to control the brightness of these LEDs by switching them on and off rapidly in a certain ratio, a technique known as *Pulse Width Modulation*, or PWM. By altering the duty cycle of the PWM signal, it creates the illusion of dimming. The MCU can only supply so much current to its GPIO pins. Instead of powering the backlight directly from the MCU, the backlight pin is connected to a transistor or MOSFET that switches the power to the LEDs. @@ -12,9 +14,8 @@ Most keyboards have backlighting enabled by default if they support it, but if i BACKLIGHT_ENABLE = yes ``` -You should then be able to use the keycodes below to change the backlight level. - ## Keycodes +Once enabled the following keycodes below can be used to change the backlight level. |Key |Description | |---------|------------------------------------------| @@ -26,9 +27,9 @@ You should then be able to use the keycodes below to change the backlight level. |`BL_DEC` |Decrease the backlight level | |`BL_BRTG`|Toggle backlight breathing | -## Caveats +## AVR driver -This feature is distinct from both the [RGB underglow](feature_rgblight.md) and [RGB matrix](feature_rgb_matrix.md) features as it usually allows for only a single colour per switch, though you can obviously use multiple different coloured LEDs on a keyboard. +### Caveats Hardware PWM is supported according to the following table: @@ -58,9 +59,9 @@ All other pins will use software PWM. If the [Audio](feature_audio.md) feature i When both timers are in use for Audio, the backlight PWM will not use a hardware timer, but will instead be triggered during the matrix scan. In this case, breathing is not supported, and the backlight might flicker, because the PWM computation may not be called with enough timing precision. -## Configuration +### AVR Configuration -To change the behaviour of the backlighting, `#define` these in your `config.h`: +To change the behavior of the backlighting, `#define` these in your `config.h`: |Define |Default |Description | |---------------------|-------------|-------------------------------------------------------------------------------------------------------------| @@ -72,14 +73,14 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`: |`BREATHING_PERIOD` |`6` |The length of one backlight "breath" in seconds | |`BACKLIGHT_ON_STATE` |`0` |The state of the backlight pin when the backlight is "on" - `1` for high, `0` for low | -## Backlight On State +### Backlight On State Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*. Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead. This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define. -## Multiple backlight pins +### Multiple backlight pins Most keyboards have only one backlight pin which control all backlight LEDs (especially if the backlight is connected to an hardware PWM pin). In software PWM, it is possible to define multiple backlight pins. All those pins will be turned on and off at the same time during the PWM duty cycle. @@ -87,13 +88,13 @@ This feature allows to set for instance the Caps Lock LED (or any other controll To activate multiple backlight pins, you need to add something like this to your user `config.h`: -~~~c +```c #define BACKLIGHT_LED_COUNT 2 #undef BACKLIGHT_PIN #define BACKLIGHT_PINS { F5, B2 } -~~~ +``` -## Hardware PWM Implementation +### Hardware PWM Implementation When using the supported pins for backlighting, QMK will use a hardware timer configured to output a PWM signal. This timer will count up to `ICRx` (by default `0xFFFF`) before resetting to 0. The desired brightness is calculated and stored in the `OCRxx` register. When the counter reaches this value, the backlight pin will go low, and is pulled high again when the counter resets. @@ -102,7 +103,7 @@ In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus th The breathing effect is achieved by registering an interrupt handler for `TIMER1_OVF_vect` that is called whenever the counter resets, roughly 244 times per second. In this handler, the value of an incrementing counter is mapped onto a precomputed brightness curve. To turn off breathing, the interrupt handler is simply disabled, and the brightness reset to the level stored in EEPROM. -## Software PWM Implementation +### Software PWM Implementation When `BACKLIGHT_PIN` is not set to a hardware backlight pin, QMK will use a hardware timer configured to trigger software interrupts. This time will count up to `ICRx` (by default `0xFFFF`) before resetting to 0. When resetting to 0, the CPU will fire an OVF (overflow) interrupt that will turn the LEDs on, starting the duty cycle. @@ -111,6 +112,29 @@ In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus th The breathing effect is the same as in the hardware PWM implementation. +## ARM Driver + +### Caveats + +Currently only hardware PWM is supported, and does not provide automatic configuration. + +?> STMF072 support is being investigated. + +### ARM Configuration + +To change the behavior of the backlighting, `#define` these in your `config.h`: + +|Define |Default |Description | +|------------------------|-------------|-------------------------------------------------------------------------------------------------------------| +|`BACKLIGHT_PIN` |`B7` |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this| +|`BACKLIGHT_PWM_DRIVER` |`PWMD4` |The PWM driver to use, see ST datasheets for pin to PWM timer mapping. Unless you are designing your own keyboard, you shouldn't need to change this| +|`BACKLIGHT_PWM_CHANNEL` |`3` |The PWM channel to use, see ST datasheets for pin to PWM channel mapping. Unless you are designing your own keyboard, you shouldn't need to change this| +|`BACKLIGHT_PAL_MODE` |`2` |The pin alternative function to use, see ST datasheets for pin AF mapping. Unless you are designing your own keyboard, you shouldn't need to change this| +|`BACKLIGHT_LEVELS` |`3` |The number of brightness levels (maximum 31 excluding off) | +|`BACKLIGHT_CAPS_LOCK` |*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED) | +|`BACKLIGHT_BREATHING` |*Not defined*|Enable backlight breathing, if supported | +|`BREATHING_PERIOD` |`6` |The length of one backlight "breath" in seconds | + ## Backlight Functions |Function |Description | diff --git a/keyboards/handwired/onekey/bluepill/config.h b/keyboards/handwired/onekey/bluepill/config.h index 3d88ee00e..81282ae1f 100644 --- a/keyboards/handwired/onekey/bluepill/config.h +++ b/keyboards/handwired/onekey/bluepill/config.h @@ -21,3 +21,7 @@ #define MATRIX_COL_PINS { B0 } #define MATRIX_ROW_PINS { A7 } #define UNUSED_PINS + +#define BACKLIGHT_PIN A0 +#define BACKLIGHT_PWM_DRIVER PWMD2 +#define BACKLIGHT_PWM_CHANNEL 1 diff --git a/keyboards/handwired/onekey/bluepill/halconf.h b/keyboards/handwired/onekey/bluepill/halconf.h index 72879a575..53b2f91e3 100644 --- a/keyboards/handwired/onekey/bluepill/halconf.h +++ b/keyboards/handwired/onekey/bluepill/halconf.h @@ -146,7 +146,7 @@ * @brief Enables the SPI subsystem. */ #if !defined(HAL_USE_SPI) || defined(__DOXYGEN__) -#define HAL_USE_SPI TRUE +#define HAL_USE_SPI FALSE #endif /** diff --git a/keyboards/handwired/onekey/bluepill/mcuconf.h b/keyboards/handwired/onekey/bluepill/mcuconf.h index fced27289..a645d3c5d 100644 --- a/keyboards/handwired/onekey/bluepill/mcuconf.h +++ b/keyboards/handwired/onekey/bluepill/mcuconf.h @@ -132,8 +132,8 @@ * PWM driver system settings. */ #define STM32_PWM_USE_ADVANCED FALSE -#define STM32_PWM_USE_TIM1 TRUE -#define STM32_PWM_USE_TIM2 FALSE +#define STM32_PWM_USE_TIM1 FALSE +#define STM32_PWM_USE_TIM2 TRUE #define STM32_PWM_USE_TIM3 FALSE #define STM32_PWM_USE_TIM4 FALSE #define STM32_PWM_USE_TIM5 FALSE @@ -168,7 +168,7 @@ * SPI driver system settings. */ #define STM32_SPI_USE_SPI1 FALSE -#define STM32_SPI_USE_SPI2 TRUE +#define STM32_SPI_USE_SPI2 FALSE #define STM32_SPI_USE_SPI3 FALSE #define STM32_SPI_SPI1_DMA_PRIORITY 1 #define STM32_SPI_SPI2_DMA_PRIORITY 1 diff --git a/keyboards/handwired/onekey/bluepill/rules.mk b/keyboards/handwired/onekey/bluepill/rules.mk index 46274066d..aeda2782b 100644 --- a/keyboards/handwired/onekey/bluepill/rules.mk +++ b/keyboards/handwired/onekey/bluepill/rules.mk @@ -1,7 +1,11 @@ # GENERIC STM32F103C8T6 board - stm32duino bootloader +BOARD = GENERIC_STM32_F103 + OPT_DEFS = -DCORTEX_VTOR_INIT=0x2000 MCU_LDSCRIPT = STM32F103x8_stm32duino_bootloader -BOARD = GENERIC_STM32_F103 + +DFU_ARGS = -d 1eaf:0003 -a2 -R +DFU_SUFFIX_ARGS ?= -v 1eaf -p 0003 # OPT_DEFS = # MCU_LDSCRIPT = STM32F103x8 diff --git a/keyboards/handwired/onekey/config.h b/keyboards/handwired/onekey/config.h index 6f7ec1289..64a447481 100644 --- a/keyboards/handwired/onekey/config.h +++ b/keyboards/handwired/onekey/config.h @@ -35,6 +35,8 @@ along with this program. If not, see . /* Set 0 if debouncing isn't needed */ #define DEBOUNCE 5 +#define TAPPING_TERM 500 + /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ #define LOCKING_SUPPORT_ENABLE /* Locking resynchronize hack */ diff --git a/keyboards/handwired/onekey/keymaps/backlight/config.h b/keyboards/handwired/onekey/keymaps/backlight/config.h new file mode 100644 index 000000000..af01528b4 --- /dev/null +++ b/keyboards/handwired/onekey/keymaps/backlight/config.h @@ -0,0 +1,3 @@ +#pragma once + +#define BACKLIGHT_BREATHING diff --git a/keyboards/handwired/onekey/keymaps/backlight/keymap.c b/keyboards/handwired/onekey/keymaps/backlight/keymap.c new file mode 100644 index 000000000..1f4be16a6 --- /dev/null +++ b/keyboards/handwired/onekey/keymaps/backlight/keymap.c @@ -0,0 +1,40 @@ +#include QMK_KEYBOARD_H + +//Tap Dance Declarations +enum { + TD_BL = 0 +}; + +void dance_cln_finished (qk_tap_dance_state_t *state, void *user_data) { + // noop +} + +void dance_cln_reset (qk_tap_dance_state_t *state, void *user_data) { + switch (state->count) { + case 1: + // single tap - step through backlight + backlight_step(); + break; +#ifdef BACKLIGHT_BREATHING + case 2: + // double tap - toggle breathing + breathing_toggle(); + break; + case 3: + //tripple tap - do some pulse stuff + breathing_pulse(); + break; +#endif + default: + // more - nothing + break; + } +} + +qk_tap_dance_action_t tap_dance_actions[] = { + [TD_BL] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset) +}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + LAYOUT( TD(TD_BL) ) +}; diff --git a/keyboards/handwired/onekey/keymaps/backlight/rules.mk b/keyboards/handwired/onekey/keymaps/backlight/rules.mk new file mode 100644 index 000000000..176e09977 --- /dev/null +++ b/keyboards/handwired/onekey/keymaps/backlight/rules.mk @@ -0,0 +1,2 @@ +BACKLIGHT_ENABLE = yes +TAP_DANCE_ENABLE = yes diff --git a/keyboards/handwired/onekey/proton_c/config.h b/keyboards/handwired/onekey/proton_c/config.h index f6bedcfe6..d4fb9c829 100644 --- a/keyboards/handwired/onekey/proton_c/config.h +++ b/keyboards/handwired/onekey/proton_c/config.h @@ -21,3 +21,8 @@ #define MATRIX_COL_PINS { A3 } #define MATRIX_ROW_PINS { A2 } #define UNUSED_PINS + +#define BACKLIGHT_PIN B8 +#define BACKLIGHT_PWM_DRIVER PWMD4 +#define BACKLIGHT_PWM_CHANNEL 3 +#define BACKLIGHT_PAL_MODE 2 diff --git a/keyboards/handwired/onekey/stm32f0_disco/config.h b/keyboards/handwired/onekey/stm32f0_disco/config.h index 039a1beff..4024ee1ca 100644 --- a/keyboards/handwired/onekey/stm32f0_disco/config.h +++ b/keyboards/handwired/onekey/stm32f0_disco/config.h @@ -21,3 +21,8 @@ #define MATRIX_COL_PINS { B4 } #define MATRIX_ROW_PINS { B5 } #define UNUSED_PINS + +#define BACKLIGHT_PIN C8 +#define BACKLIGHT_PWM_DRIVER PWMD3 +#define BACKLIGHT_PWM_CHANNEL 3 +#define BACKLIGHT_PAL_MODE 0 diff --git a/quantum/backlight/backlight.c b/quantum/backlight/backlight.c new file mode 100644 index 000000000..e26de86bf --- /dev/null +++ b/quantum/backlight/backlight.c @@ -0,0 +1 @@ +// TODO: Add common code here, for example cie_lightness implementation diff --git a/quantum/backlight/backlight_arm.c b/quantum/backlight/backlight_arm.c new file mode 100644 index 000000000..3f94ccef8 --- /dev/null +++ b/quantum/backlight/backlight_arm.c @@ -0,0 +1,218 @@ +#include "quantum.h" +#include "backlight.h" +#include +#include "debug.h" + +// TODO: remove short term bodge when refactoring BACKLIGHT_CUSTOM_DRIVER out +#ifdef BACKLIGHT_PIN + +# if defined(STM32F0XX) || defined(STM32F0xx) +# error "Backlight support for STMF072 is not available. Please disable." +# endif + +# if defined(STM32F1XX) || defined(STM32F1xx) +# define USE_GPIOV1 +# endif + +// GPIOV2 && GPIOV3 +# ifndef BACKLIGHT_PAL_MODE +# define BACKLIGHT_PAL_MODE 2 +# endif + +// GENERIC +# ifndef BACKLIGHT_PWM_DRIVER +# define BACKLIGHT_PWM_DRIVER PWMD4 +# endif +# ifndef BACKLIGHT_PWM_CHANNEL +# define BACKLIGHT_PWM_CHANNEL 3 +# endif + +static void breathing_callback(PWMDriver *pwmp); + +static PWMConfig pwmCFG = {0xFFFF, /* PWM clock frequency */ + 256, /* PWM period (in ticks) 1S (1/10kHz=0.1mS 0.1ms*10000 ticks=1S) */ + NULL, /* No Callback */ + { /* Default all channels to disabled - Channels will be configured durring init */ + {PWM_OUTPUT_DISABLED, NULL}, + {PWM_OUTPUT_DISABLED, NULL}, + {PWM_OUTPUT_DISABLED, NULL}, + {PWM_OUTPUT_DISABLED, NULL}}, + 0, /* HW dependent part.*/ + 0}; + +static PWMConfig pwmCFG_breathing = {0xFFFF, /** PWM clock frequency */ + 256, /* PWM period (in ticks) 1S (1/10kHz=0.1mS 0.1ms*10000 ticks=1S) */ + breathing_callback, /* Breathing Callback */ + { /* Default all channels to disabled - Channels will be configured durring init */ + {PWM_OUTPUT_DISABLED, NULL}, + {PWM_OUTPUT_DISABLED, NULL}, + {PWM_OUTPUT_DISABLED, NULL}, + {PWM_OUTPUT_DISABLED, NULL}}, + 0, /* HW dependent part.*/ + 0}; + +// See http://jared.geek.nz/2013/feb/linear-led-pwm +static uint16_t cie_lightness(uint16_t v) { + if (v <= 5243) // if below 8% of max + return v / 9; // same as dividing by 900% + else { + uint32_t y = (((uint32_t)v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare + // to get a useful result with integer division, we shift left in the expression above + // and revert what we've done again after squaring. + y = y * y * y >> 8; + if (y > 0xFFFFUL) // prevent overflow + return 0xFFFFU; + else + return (uint16_t)y; + } +} + +void backlight_init_ports(void) { + // printf("backlight_init_ports()\n"); + +# ifdef USE_GPIOV1 + palSetPadMode(PAL_PORT(BACKLIGHT_PIN), PAL_PAD(BACKLIGHT_PIN), PAL_MODE_STM32_ALTERNATE_PUSHPULL); +# else + palSetPadMode(PAL_PORT(BACKLIGHT_PIN), PAL_PAD(BACKLIGHT_PIN), PAL_MODE_ALTERNATE(BACKLIGHT_PAL_MODE)); +# endif + + pwmCFG.channels[BACKLIGHT_PWM_CHANNEL - 1].mode = PWM_OUTPUT_ACTIVE_HIGH; + pwmCFG_breathing.channels[BACKLIGHT_PWM_CHANNEL - 1].mode = PWM_OUTPUT_ACTIVE_HIGH; + pwmStart(&BACKLIGHT_PWM_DRIVER, &pwmCFG); + + backlight_set(get_backlight_level()); + if (is_backlight_breathing()) { + breathing_enable(); + } +} + +void backlight_set(uint8_t level) { + // printf("backlight_set(%d)\n", level); + if (level == 0) { + // Turn backlight off + pwmDisableChannel(&BACKLIGHT_PWM_DRIVER, BACKLIGHT_PWM_CHANNEL - 1); + } else { + // Turn backlight on + if (!is_breathing()) { + uint32_t duty = (uint32_t)(cie_lightness(0xFFFF * (uint32_t)level / BACKLIGHT_LEVELS)); + // printf("duty: (%d)\n", duty); + pwmEnableChannel(&BACKLIGHT_PWM_DRIVER, BACKLIGHT_PWM_CHANNEL - 1, PWM_FRACTION_TO_WIDTH(&BACKLIGHT_PWM_DRIVER, 0xFFFF, duty)); + } + } +} + +uint8_t backlight_tick = 0; + +void backlight_task(void) {} + +# define BREATHING_NO_HALT 0 +# define BREATHING_HALT_OFF 1 +# define BREATHING_HALT_ON 2 +# define BREATHING_STEPS 128 + +static uint8_t breathing_period = BREATHING_PERIOD; +static uint8_t breathing_halt = BREATHING_NO_HALT; +static uint16_t breathing_counter = 0; + +bool is_breathing(void) { return BACKLIGHT_PWM_DRIVER.config == &pwmCFG_breathing; } + +static inline void breathing_min(void) { breathing_counter = 0; } + +static inline void breathing_max(void) { breathing_counter = breathing_period * 256 / 2; } + +void breathing_interrupt_enable(void) { + pwmStop(&BACKLIGHT_PWM_DRIVER); + pwmStart(&BACKLIGHT_PWM_DRIVER, &pwmCFG_breathing); + chSysLockFromISR(); + pwmEnablePeriodicNotification(&BACKLIGHT_PWM_DRIVER); + pwmEnableChannelI(&BACKLIGHT_PWM_DRIVER, BACKLIGHT_PWM_CHANNEL - 1, PWM_FRACTION_TO_WIDTH(&BACKLIGHT_PWM_DRIVER, 0xFFFF, 0xFFFF)); + chSysUnlockFromISR(); +} + +void breathing_interrupt_disable(void) { + pwmStop(&BACKLIGHT_PWM_DRIVER); + pwmStart(&BACKLIGHT_PWM_DRIVER, &pwmCFG); +} + +void breathing_enable(void) { + breathing_counter = 0; + breathing_halt = BREATHING_NO_HALT; + breathing_interrupt_enable(); +} + +void breathing_pulse(void) { + if (get_backlight_level() == 0) + breathing_min(); + else + breathing_max(); + breathing_halt = BREATHING_HALT_ON; + breathing_interrupt_enable(); +} + +void breathing_disable(void) { + // printf("breathing_disable()\n"); + breathing_interrupt_disable(); + // Restore backlight level + backlight_set(get_backlight_level()); +} + +void breathing_self_disable(void) { + if (get_backlight_level() == 0) + breathing_halt = BREATHING_HALT_OFF; + else + breathing_halt = BREATHING_HALT_ON; +} + +void breathing_toggle(void) { + if (is_breathing()) + breathing_disable(); + else + breathing_enable(); +} + +void breathing_period_set(uint8_t value) { + if (!value) value = 1; + breathing_period = value; +} + +void breathing_period_default(void) { breathing_period_set(BREATHING_PERIOD); } + +void breathing_period_inc(void) { breathing_period_set(breathing_period + 1); } + +void breathing_period_dec(void) { breathing_period_set(breathing_period - 1); } + +/* To generate breathing curve in python: + * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)] + */ +static const uint8_t breathing_table[BREATHING_STEPS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + +// Use this before the cie_lightness function. +static inline uint16_t scale_backlight(uint16_t v) { return v / BACKLIGHT_LEVELS * get_backlight_level(); } + +static void breathing_callback(PWMDriver *pwmp) { + (void)pwmp; + uint16_t interval = (uint16_t)breathing_period * 256 / BREATHING_STEPS; + // resetting after one period to prevent ugly reset at overflow. + breathing_counter = (breathing_counter + 1) % (breathing_period * 256); + uint8_t index = breathing_counter / interval % BREATHING_STEPS; + + if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) || ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1))) { + breathing_interrupt_disable(); + } + + uint32_t duty = cie_lightness(scale_backlight(breathing_table[index] * 256)); + + chSysLockFromISR(); + pwmEnableChannelI(&BACKLIGHT_PWM_DRIVER, BACKLIGHT_PWM_CHANNEL - 1, PWM_FRACTION_TO_WIDTH(&BACKLIGHT_PWM_DRIVER, 0xFFFF, duty)); + chSysUnlockFromISR(); +} + +#else + +__attribute__((weak)) void backlight_init_ports(void) {} + +__attribute__((weak)) void backlight_set(uint8_t level) {} + +__attribute__((weak)) void backlight_task(void) {} + +#endif diff --git a/quantum/backlight/backlight_avr.c b/quantum/backlight/backlight_avr.c new file mode 100644 index 000000000..445698f47 --- /dev/null +++ b/quantum/backlight/backlight_avr.c @@ -0,0 +1,509 @@ +#include "quantum.h" +#include "backlight.h" +#include "debug.h" + +#if defined(BACKLIGHT_ENABLE) && (defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS)) + +// This logic is a bit complex, we support 3 setups: +// +// 1. Hardware PWM when backlight is wired to a PWM pin. +// Depending on this pin, we use a different output compare unit. +// 2. Software PWM with hardware timers, but the used timer +// depends on the Audio setup (Audio wins over Backlight). +// 3. Full software PWM, driven by the matrix scan, if both timers are used by Audio. + +# if (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) && (BACKLIGHT_PIN == B5 || BACKLIGHT_PIN == B6 || BACKLIGHT_PIN == B7) +# define HARDWARE_PWM +# define ICRx ICR1 +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TIMSKx TIMSK1 +# define TOIEx TOIE1 + +# if BACKLIGHT_PIN == B5 +# define COMxx1 COM1A1 +# define OCRxx OCR1A +# elif BACKLIGHT_PIN == B6 +# define COMxx1 COM1B1 +# define OCRxx OCR1B +# elif BACKLIGHT_PIN == B7 +# define COMxx1 COM1C1 +# define OCRxx OCR1C +# endif +# elif (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) && (BACKLIGHT_PIN == C4 || BACKLIGHT_PIN == C5 || BACKLIGHT_PIN == C6) +# define HARDWARE_PWM +# define ICRx ICR3 +# define TCCRxA TCCR3A +# define TCCRxB TCCR3B +# define TIMERx_OVF_vect TIMER3_OVF_vect +# define TIMSKx TIMSK3 +# define TOIEx TOIE3 + +# if BACKLIGHT_PIN == C4 +# if (defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) +# error This MCU has no C4 pin! +# else +# define COMxx1 COM3C1 +# define OCRxx OCR3C +# endif +# elif BACKLIGHT_PIN == C5 +# if (defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) +# error This MCU has no C5 pin! +# else +# define COMxx1 COM3B1 +# define OCRxx OCR3B +# endif +# elif BACKLIGHT_PIN == C6 +# define COMxx1 COM3A1 +# define OCRxx OCR3A +# endif +# elif (defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__)) && (BACKLIGHT_PIN == B7 || BACKLIGHT_PIN == C5 || BACKLIGHT_PIN == C6) +# define HARDWARE_PWM +# define ICRx ICR1 +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TIMSKx TIMSK1 +# define TOIEx TOIE1 + +# if BACKLIGHT_PIN == B7 +# define COMxx1 COM1C1 +# define OCRxx OCR1C +# elif BACKLIGHT_PIN == C5 +# define COMxx1 COM1B1 +# define OCRxx OCR1B +# elif BACKLIGHT_PIN == C6 +# define COMxx1 COM1A1 +# define OCRxx OCR1A +# endif +# elif defined(__AVR_ATmega32A__) && (BACKLIGHT_PIN == D4 || BACKLIGHT_PIN == D5) +# define HARDWARE_PWM +# define ICRx ICR1 +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TIMSKx TIMSK +# define TOIEx TOIE1 + +# if BACKLIGHT_PIN == D4 +# define COMxx1 COM1B1 +# define OCRxx OCR1B +# elif BACKLIGHT_PIN == D5 +# define COMxx1 COM1A1 +# define OCRxx OCR1A +# endif +# elif defined(__AVR_ATmega328P__) && (BACKLIGHT_PIN == B1 || BACKLIGHT_PIN == B2) +# define HARDWARE_PWM +# define ICRx ICR1 +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define TIMERx_OVF_vect TIMER1_OVF_vect +# define TIMSKx TIMSK1 +# define TOIEx TOIE1 + +# if BACKLIGHT_PIN == B1 +# define COMxx1 COM1A1 +# define OCRxx OCR1A +# elif BACKLIGHT_PIN == B2 +# define COMxx1 COM1B1 +# define OCRxx OCR1B +# endif +# else +# if !defined(BACKLIGHT_CUSTOM_DRIVER) +# if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO) +// Timer 1 is not in use by Audio feature, Backlight can use it +# pragma message "Using hardware timer 1 with software PWM" +# define HARDWARE_PWM +# define BACKLIGHT_PWM_TIMER +# define ICRx ICR1 +# define TCCRxA TCCR1A +# define TCCRxB TCCR1B +# define TIMERx_COMPA_vect TIMER1_COMPA_vect +# define TIMERx_OVF_vect TIMER1_OVF_vect +# if defined(__AVR_ATmega32A__) // This MCU has only one TIMSK register +# define TIMSKx TIMSK +# else +# define TIMSKx TIMSK1 +# endif +# define TOIEx TOIE1 + +# define OCIExA OCIE1A +# define OCRxx OCR1A +# elif !defined(C6_AUDIO) && !defined(C5_AUDIO) && !defined(C4_AUDIO) +# pragma message "Using hardware timer 3 with software PWM" +// Timer 3 is not in use by Audio feature, Backlight can use it +# define HARDWARE_PWM +# define BACKLIGHT_PWM_TIMER +# define ICRx ICR1 +# define TCCRxA TCCR3A +# define TCCRxB TCCR3B +# define TIMERx_COMPA_vect TIMER3_COMPA_vect +# define TIMERx_OVF_vect TIMER3_OVF_vect +# define TIMSKx TIMSK3 +# define TOIEx TOIE3 + +# define OCIExA OCIE3A +# define OCRxx OCR3A +# else +# pragma message "Audio in use - using pure software PWM" +# define NO_HARDWARE_PWM +# endif +# else +# pragma message "Custom driver defined - using pure software PWM" +# define NO_HARDWARE_PWM +# endif +# endif + +# ifndef BACKLIGHT_ON_STATE +# define BACKLIGHT_ON_STATE 0 +# endif + +void backlight_on(uint8_t backlight_pin) { +# if BACKLIGHT_ON_STATE == 0 + writePinLow(backlight_pin); +# else + writePinHigh(backlight_pin); +# endif +} + +void backlight_off(uint8_t backlight_pin) { +# if BACKLIGHT_ON_STATE == 0 + writePinHigh(backlight_pin); +# else + writePinLow(backlight_pin); +# endif +} + +# if defined(NO_HARDWARE_PWM) || defined(BACKLIGHT_PWM_TIMER) // pwm through software + +// we support multiple backlight pins +# ifndef BACKLIGHT_LED_COUNT +# define BACKLIGHT_LED_COUNT 1 +# endif + +# if BACKLIGHT_LED_COUNT == 1 +# define BACKLIGHT_PIN_INIT \ + { BACKLIGHT_PIN } +# else +# define BACKLIGHT_PIN_INIT BACKLIGHT_PINS +# endif + +# define FOR_EACH_LED(x) \ + for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) { \ + uint8_t backlight_pin = backlight_pins[i]; \ + { x } \ + } + +static const uint8_t backlight_pins[BACKLIGHT_LED_COUNT] = BACKLIGHT_PIN_INIT; + +# else // full hardware PWM + +// we support only one backlight pin +static const uint8_t backlight_pin = BACKLIGHT_PIN; +# define FOR_EACH_LED(x) x + +# endif + +# ifdef NO_HARDWARE_PWM +__attribute__((weak)) void backlight_init_ports(void) { + // Setup backlight pin as output and output to on state. + FOR_EACH_LED(setPinOutput(backlight_pin); backlight_on(backlight_pin);) + +# ifdef BACKLIGHT_BREATHING + if (is_backlight_breathing()) { + breathing_enable(); + } +# endif +} + +__attribute__((weak)) void backlight_set(uint8_t level) {} + +uint8_t backlight_tick = 0; + +# ifndef BACKLIGHT_CUSTOM_DRIVER +void backlight_task(void) { + if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) { + FOR_EACH_LED(backlight_on(backlight_pin);) + } else { + FOR_EACH_LED(backlight_off(backlight_pin);) + } + backlight_tick = (backlight_tick + 1) % 16; +} +# endif + +# ifdef BACKLIGHT_BREATHING +# ifndef BACKLIGHT_CUSTOM_DRIVER +# error "Backlight breathing only available with hardware PWM. Please disable." +# endif +# endif + +# else // hardware pwm through timer + +# ifdef BACKLIGHT_PWM_TIMER + +// The idea of software PWM assisted by hardware timers is the following +// we use the hardware timer in fast PWM mode like for hardware PWM, but +// instead of letting the Output Match Comparator control the led pin +// (which is not possible since the backlight is not wired to PWM pins on the +// CPU), we do the LED on/off by oursleves. +// The timer is setup to count up to 0xFFFF, and we set the Output Compare +// register to the current 16bits backlight level (after CIE correction). +// This means the CPU will trigger a compare match interrupt when the counter +// reaches the backlight level, where we turn off the LEDs, +// but also an overflow interrupt when the counter rolls back to 0, +// in which we're going to turn on the LEDs. +// The LED will then be on for OCRxx/0xFFFF time, adjusted every 244Hz. + +// Triggered when the counter reaches the OCRx value +ISR(TIMERx_COMPA_vect) { FOR_EACH_LED(backlight_off(backlight_pin);) } + +// Triggered when the counter reaches the TOP value +// this one triggers at F_CPU/65536 =~ 244 Hz +ISR(TIMERx_OVF_vect) { +# ifdef BACKLIGHT_BREATHING + if (is_breathing()) { + breathing_task(); + } +# endif + // for very small values of OCRxx (or backlight level) + // we can't guarantee this whole code won't execute + // at the same time as the compare match interrupt + // which means that we might turn on the leds while + // trying to turn them off, leading to flickering + // artifacts (especially while breathing, because breathing_task + // takes many computation cycles). + // so better not turn them on while the counter TOP is very low. + if (OCRxx > 256) { + FOR_EACH_LED(backlight_on(backlight_pin);) + } +} + +# endif + +# define TIMER_TOP 0xFFFFU + +// See http://jared.geek.nz/2013/feb/linear-led-pwm +static uint16_t cie_lightness(uint16_t v) { + if (v <= 5243) // if below 8% of max + return v / 9; // same as dividing by 900% + else { + uint32_t y = (((uint32_t)v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare + // to get a useful result with integer division, we shift left in the expression above + // and revert what we've done again after squaring. + y = y * y * y >> 8; + if (y > 0xFFFFUL) // prevent overflow + return 0xFFFFU; + else + return (uint16_t)y; + } +} + +// range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val. +static inline void set_pwm(uint16_t val) { OCRxx = val; } + +# ifndef BACKLIGHT_CUSTOM_DRIVER +__attribute__((weak)) void backlight_set(uint8_t level) { + if (level > BACKLIGHT_LEVELS) level = BACKLIGHT_LEVELS; + + if (level == 0) { +# ifdef BACKLIGHT_PWM_TIMER + if (OCRxx) { + TIMSKx &= ~(_BV(OCIExA)); + TIMSKx &= ~(_BV(TOIEx)); + FOR_EACH_LED(backlight_off(backlight_pin);) + } +# else + // Turn off PWM control on backlight pin + TCCRxA &= ~(_BV(COMxx1)); +# endif + } else { +# ifdef BACKLIGHT_PWM_TIMER + if (!OCRxx) { + TIMSKx |= _BV(OCIExA); + TIMSKx |= _BV(TOIEx); + } +# else + // Turn on PWM control of backlight pin + TCCRxA |= _BV(COMxx1); +# endif + } + // Set the brightness + set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS)); +} + +void backlight_task(void) {} +# endif // BACKLIGHT_CUSTOM_DRIVER + +# ifdef BACKLIGHT_BREATHING + +# define BREATHING_NO_HALT 0 +# define BREATHING_HALT_OFF 1 +# define BREATHING_HALT_ON 2 +# define BREATHING_STEPS 128 + +static uint8_t breathing_period = BREATHING_PERIOD; +static uint8_t breathing_halt = BREATHING_NO_HALT; +static uint16_t breathing_counter = 0; + +# ifdef BACKLIGHT_PWM_TIMER +static bool breathing = false; + +bool is_breathing(void) { return breathing; } + +# define breathing_interrupt_enable() \ + do { \ + breathing = true; \ + } while (0) +# define breathing_interrupt_disable() \ + do { \ + breathing = false; \ + } while (0) +# else + +bool is_breathing(void) { return !!(TIMSKx & _BV(TOIEx)); } + +# define breathing_interrupt_enable() \ + do { \ + TIMSKx |= _BV(TOIEx); \ + } while (0) +# define breathing_interrupt_disable() \ + do { \ + TIMSKx &= ~_BV(TOIEx); \ + } while (0) +# endif + +# define breathing_min() \ + do { \ + breathing_counter = 0; \ + } while (0) +# define breathing_max() \ + do { \ + breathing_counter = breathing_period * 244 / 2; \ + } while (0) + +void breathing_enable(void) { + breathing_counter = 0; + breathing_halt = BREATHING_NO_HALT; + breathing_interrupt_enable(); +} + +void breathing_pulse(void) { + if (get_backlight_level() == 0) + breathing_min(); + else + breathing_max(); + breathing_halt = BREATHING_HALT_ON; + breathing_interrupt_enable(); +} + +void breathing_disable(void) { + breathing_interrupt_disable(); + // Restore backlight level + backlight_set(get_backlight_level()); +} + +void breathing_self_disable(void) { + if (get_backlight_level() == 0) + breathing_halt = BREATHING_HALT_OFF; + else + breathing_halt = BREATHING_HALT_ON; +} + +void breathing_toggle(void) { + if (is_breathing()) + breathing_disable(); + else + breathing_enable(); +} + +void breathing_period_set(uint8_t value) { + if (!value) value = 1; + breathing_period = value; +} + +void breathing_period_default(void) { breathing_period_set(BREATHING_PERIOD); } + +void breathing_period_inc(void) { breathing_period_set(breathing_period + 1); } + +void breathing_period_dec(void) { breathing_period_set(breathing_period - 1); } + +/* To generate breathing curve in python: + * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)] + */ +static const uint8_t breathing_table[BREATHING_STEPS] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + +// Use this before the cie_lightness function. +static inline uint16_t scale_backlight(uint16_t v) { return v / BACKLIGHT_LEVELS * get_backlight_level(); } + +# ifdef BACKLIGHT_PWM_TIMER +void breathing_task(void) +# else +/* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run + * about 244 times per second. + */ +ISR(TIMERx_OVF_vect) +# endif +{ + uint16_t interval = (uint16_t)breathing_period * 244 / BREATHING_STEPS; + // resetting after one period to prevent ugly reset at overflow. + breathing_counter = (breathing_counter + 1) % (breathing_period * 244); + uint8_t index = breathing_counter / interval % BREATHING_STEPS; + + if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) || ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1))) { + breathing_interrupt_disable(); + } + + set_pwm(cie_lightness(scale_backlight((uint16_t)pgm_read_byte(&breathing_table[index]) * 0x0101U))); +} + +# endif // BACKLIGHT_BREATHING + +__attribute__((weak)) void backlight_init_ports(void) { + // Setup backlight pin as output and output to on state. + FOR_EACH_LED(setPinOutput(backlight_pin); backlight_on(backlight_pin);) + + // I could write a wall of text here to explain... but TL;DW + // Go read the ATmega32u4 datasheet. + // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on + +# ifdef BACKLIGHT_PWM_TIMER + // TimerX setup, Fast PWM mode count to TOP set in ICRx + TCCRxA = _BV(WGM11); // = 0b00000010; + // clock select clk/1 + TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001; +# else // hardware PWM + // Pin PB7 = OCR1C (Timer 1, Channel C) + // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0 + // (i.e. start high, go low when counter matches.) + // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0 + // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1 + + /* + 14.8.3: + "In fast PWM mode, the compare units allow generation of PWM waveforms on the OCnx pins. Setting the COMnx1:0 bits to two will produce a non-inverted PWM [..]." + "In fast PWM mode the counter is incremented until the counter value matches either one of the fixed values 0x00FF, 0x01FF, or 0x03FF (WGMn3:0 = 5, 6, or 7), the value in ICRn (WGMn3:0 = 14), or the value in OCRnA (WGMn3:0 = 15)." + */ + TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010; + TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001; +# endif + // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0. + ICRx = TIMER_TOP; + + backlight_init(); +# ifdef BACKLIGHT_BREATHING + if (is_backlight_breathing()) { + breathing_enable(); + } +# endif +} + +# endif // hardware backlight + +#else // no backlight + +__attribute__((weak)) void backlight_init_ports(void) {} + +__attribute__((weak)) void backlight_set(uint8_t level) {} + +#endif // backlight \ No newline at end of file diff --git a/quantum/quantum.c b/quantum/quantum.c index 16922dd01..f4999456e 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -24,10 +24,6 @@ # include "outputselect.h" #endif -#ifndef BREATHING_PERIOD -# define BREATHING_PERIOD 6 -#endif - #include "backlight.h" extern backlight_config_t backlight_config; @@ -1019,511 +1015,6 @@ void matrix_scan_quantum() { matrix_scan_kb(); } -#if defined(BACKLIGHT_ENABLE) && (defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS)) - -// This logic is a bit complex, we support 3 setups: -// -// 1. Hardware PWM when backlight is wired to a PWM pin. -// Depending on this pin, we use a different output compare unit. -// 2. Software PWM with hardware timers, but the used timer -// depends on the Audio setup (Audio wins over Backlight). -// 3. Full software PWM, driven by the matrix scan, if both timers are used by Audio. - -# if (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) && (BACKLIGHT_PIN == B5 || BACKLIGHT_PIN == B6 || BACKLIGHT_PIN == B7) -# define HARDWARE_PWM -# define ICRx ICR1 -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define TIMSKx TIMSK1 -# define TOIEx TOIE1 - -# if BACKLIGHT_PIN == B5 -# define COMxx1 COM1A1 -# define OCRxx OCR1A -# elif BACKLIGHT_PIN == B6 -# define COMxx1 COM1B1 -# define OCRxx OCR1B -# elif BACKLIGHT_PIN == B7 -# define COMxx1 COM1C1 -# define OCRxx OCR1C -# endif -# elif (defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) && (BACKLIGHT_PIN == C4 || BACKLIGHT_PIN == C5 || BACKLIGHT_PIN == C6) -# define HARDWARE_PWM -# define ICRx ICR3 -# define TCCRxA TCCR3A -# define TCCRxB TCCR3B -# define TIMERx_OVF_vect TIMER3_OVF_vect -# define TIMSKx TIMSK3 -# define TOIEx TOIE3 - -# if BACKLIGHT_PIN == C4 -# if (defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) -# error This MCU has no C4 pin! -# else -# define COMxx1 COM3C1 -# define OCRxx OCR3C -# endif -# elif BACKLIGHT_PIN == C5 -# if (defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) -# error This MCU has no C5 pin! -# else -# define COMxx1 COM3B1 -# define OCRxx OCR3B -# endif -# elif BACKLIGHT_PIN == C6 -# define COMxx1 COM3A1 -# define OCRxx OCR3A -# endif -# elif (defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__)) && (BACKLIGHT_PIN == B7 || BACKLIGHT_PIN == C5 || BACKLIGHT_PIN == C6) -# define HARDWARE_PWM -# define ICRx ICR1 -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define TIMSKx TIMSK1 -# define TOIEx TOIE1 - -# if BACKLIGHT_PIN == B7 -# define COMxx1 COM1C1 -# define OCRxx OCR1C -# elif BACKLIGHT_PIN == C5 -# define COMxx1 COM1B1 -# define OCRxx OCR1B -# elif BACKLIGHT_PIN == C6 -# define COMxx1 COM1A1 -# define OCRxx OCR1A -# endif -# elif defined(__AVR_ATmega32A__) && (BACKLIGHT_PIN == D4 || BACKLIGHT_PIN == D5) -# define HARDWARE_PWM -# define ICRx ICR1 -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define TIMSKx TIMSK -# define TOIEx TOIE1 - -# if BACKLIGHT_PIN == D4 -# define COMxx1 COM1B1 -# define OCRxx OCR1B -# elif BACKLIGHT_PIN == D5 -# define COMxx1 COM1A1 -# define OCRxx OCR1A -# endif -# elif defined(__AVR_ATmega328P__) && (BACKLIGHT_PIN == B1 || BACKLIGHT_PIN == B2) -# define HARDWARE_PWM -# define ICRx ICR1 -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define TIMERx_OVF_vect TIMER1_OVF_vect -# define TIMSKx TIMSK1 -# define TOIEx TOIE1 - -# if BACKLIGHT_PIN == B1 -# define COMxx1 COM1A1 -# define OCRxx OCR1A -# elif BACKLIGHT_PIN == B2 -# define COMxx1 COM1B1 -# define OCRxx OCR1B -# endif -# else -# if !defined(BACKLIGHT_CUSTOM_DRIVER) -# if !defined(B5_AUDIO) && !defined(B6_AUDIO) && !defined(B7_AUDIO) -// Timer 1 is not in use by Audio feature, Backlight can use it -# pragma message "Using hardware timer 1 with software PWM" -# define HARDWARE_PWM -# define BACKLIGHT_PWM_TIMER -# define ICRx ICR1 -# define TCCRxA TCCR1A -# define TCCRxB TCCR1B -# define TIMERx_COMPA_vect TIMER1_COMPA_vect -# define TIMERx_OVF_vect TIMER1_OVF_vect -# if defined(__AVR_ATmega32A__) // This MCU has only one TIMSK register -# define TIMSKx TIMSK -# else -# define TIMSKx TIMSK1 -# endif -# define TOIEx TOIE1 - -# define OCIExA OCIE1A -# define OCRxx OCR1A -# elif !defined(C6_AUDIO) && !defined(C5_AUDIO) && !defined(C4_AUDIO) -# pragma message "Using hardware timer 3 with software PWM" -// Timer 3 is not in use by Audio feature, Backlight can use it -# define HARDWARE_PWM -# define BACKLIGHT_PWM_TIMER -# define ICRx ICR1 -# define TCCRxA TCCR3A -# define TCCRxB TCCR3B -# define TIMERx_COMPA_vect TIMER3_COMPA_vect -# define TIMERx_OVF_vect TIMER3_OVF_vect -# define TIMSKx TIMSK3 -# define TOIEx TOIE3 - -# define OCIExA OCIE3A -# define OCRxx OCR3A -# else -# pragma message "Audio in use - using pure software PWM" -# define NO_HARDWARE_PWM -# endif -# else -# pragma message "Custom driver defined - using pure software PWM" -# define NO_HARDWARE_PWM -# endif -# endif - -# ifndef BACKLIGHT_ON_STATE -# define BACKLIGHT_ON_STATE 0 -# endif - -void backlight_on(uint8_t backlight_pin) { -# if BACKLIGHT_ON_STATE == 0 - writePinLow(backlight_pin); -# else - writePinHigh(backlight_pin); -# endif -} - -void backlight_off(uint8_t backlight_pin) { -# if BACKLIGHT_ON_STATE == 0 - writePinHigh(backlight_pin); -# else - writePinLow(backlight_pin); -# endif -} - -# if defined(NO_HARDWARE_PWM) || defined(BACKLIGHT_PWM_TIMER) // pwm through software - -// we support multiple backlight pins -# ifndef BACKLIGHT_LED_COUNT -# define BACKLIGHT_LED_COUNT 1 -# endif - -# if BACKLIGHT_LED_COUNT == 1 -# define BACKLIGHT_PIN_INIT \ - { BACKLIGHT_PIN } -# else -# define BACKLIGHT_PIN_INIT BACKLIGHT_PINS -# endif - -# define FOR_EACH_LED(x) \ - for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) { \ - uint8_t backlight_pin = backlight_pins[i]; \ - { x } \ - } - -static const uint8_t backlight_pins[BACKLIGHT_LED_COUNT] = BACKLIGHT_PIN_INIT; - -# else // full hardware PWM - -// we support only one backlight pin -static const uint8_t backlight_pin = BACKLIGHT_PIN; -# define FOR_EACH_LED(x) x - -# endif - -# ifdef NO_HARDWARE_PWM -__attribute__((weak)) void backlight_init_ports(void) { - // Setup backlight pin as output and output to on state. - FOR_EACH_LED(setPinOutput(backlight_pin); backlight_on(backlight_pin);) - -# ifdef BACKLIGHT_BREATHING - if (is_backlight_breathing()) { - breathing_enable(); - } -# endif -} - -__attribute__((weak)) void backlight_set(uint8_t level) {} - -uint8_t backlight_tick = 0; - -# ifndef BACKLIGHT_CUSTOM_DRIVER -void backlight_task(void) { - if ((0xFFFF >> ((BACKLIGHT_LEVELS - get_backlight_level()) * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) { - FOR_EACH_LED(backlight_on(backlight_pin);) - } else { - FOR_EACH_LED(backlight_off(backlight_pin);) - } - backlight_tick = (backlight_tick + 1) % 16; -} -# endif - -# ifdef BACKLIGHT_BREATHING -# ifndef BACKLIGHT_CUSTOM_DRIVER -# error "Backlight breathing only available with hardware PWM. Please disable." -# endif -# endif - -# else // hardware pwm through timer - -# ifdef BACKLIGHT_PWM_TIMER - -// The idea of software PWM assisted by hardware timers is the following -// we use the hardware timer in fast PWM mode like for hardware PWM, but -// instead of letting the Output Match Comparator control the led pin -// (which is not possible since the backlight is not wired to PWM pins on the -// CPU), we do the LED on/off by oursleves. -// The timer is setup to count up to 0xFFFF, and we set the Output Compare -// register to the current 16bits backlight level (after CIE correction). -// This means the CPU will trigger a compare match interrupt when the counter -// reaches the backlight level, where we turn off the LEDs, -// but also an overflow interrupt when the counter rolls back to 0, -// in which we're going to turn on the LEDs. -// The LED will then be on for OCRxx/0xFFFF time, adjusted every 244Hz. - -// Triggered when the counter reaches the OCRx value -ISR(TIMERx_COMPA_vect) { FOR_EACH_LED(backlight_off(backlight_pin);) } - -// Triggered when the counter reaches the TOP value -// this one triggers at F_CPU/65536 =~ 244 Hz -ISR(TIMERx_OVF_vect) { -# ifdef BACKLIGHT_BREATHING - if (is_breathing()) { - breathing_task(); - } -# endif - // for very small values of OCRxx (or backlight level) - // we can't guarantee this whole code won't execute - // at the same time as the compare match interrupt - // which means that we might turn on the leds while - // trying to turn them off, leading to flickering - // artifacts (especially while breathing, because breathing_task - // takes many computation cycles). - // so better not turn them on while the counter TOP is very low. - if (OCRxx > 256) { - FOR_EACH_LED(backlight_on(backlight_pin);) - } -} - -# endif - -# define TIMER_TOP 0xFFFFU - -// See http://jared.geek.nz/2013/feb/linear-led-pwm -static uint16_t cie_lightness(uint16_t v) { - if (v <= 5243) // if below 8% of max - return v / 9; // same as dividing by 900% - else { - uint32_t y = (((uint32_t)v + 10486) << 8) / (10486 + 0xFFFFUL); // add 16% of max and compare - // to get a useful result with integer division, we shift left in the expression above - // and revert what we've done again after squaring. - y = y * y * y >> 8; - if (y > 0xFFFFUL) // prevent overflow - return 0xFFFFU; - else - return (uint16_t)y; - } -} - -// range for val is [0..TIMER_TOP]. PWM pin is high while the timer count is below val. -static inline void set_pwm(uint16_t val) { OCRxx = val; } - -# ifndef BACKLIGHT_CUSTOM_DRIVER -__attribute__((weak)) void backlight_set(uint8_t level) { - if (level > BACKLIGHT_LEVELS) level = BACKLIGHT_LEVELS; - - if (level == 0) { -# ifdef BACKLIGHT_PWM_TIMER - if (OCRxx) { - TIMSKx &= ~(_BV(OCIExA)); - TIMSKx &= ~(_BV(TOIEx)); - FOR_EACH_LED(backlight_off(backlight_pin);) - } -# else - // Turn off PWM control on backlight pin - TCCRxA &= ~(_BV(COMxx1)); -# endif - } else { -# ifdef BACKLIGHT_PWM_TIMER - if (!OCRxx) { - TIMSKx |= _BV(OCIExA); - TIMSKx |= _BV(TOIEx); - } -# else - // Turn on PWM control of backlight pin - TCCRxA |= _BV(COMxx1); -# endif - } - // Set the brightness - set_pwm(cie_lightness(TIMER_TOP * (uint32_t)level / BACKLIGHT_LEVELS)); -} - -void backlight_task(void) {} -# endif // BACKLIGHT_CUSTOM_DRIVER - -# ifdef BACKLIGHT_BREATHING - -# define BREATHING_NO_HALT 0 -# define BREATHING_HALT_OFF 1 -# define BREATHING_HALT_ON 2 -# define BREATHING_STEPS 128 - -static uint8_t breathing_period = BREATHING_PERIOD; -static uint8_t breathing_halt = BREATHING_NO_HALT; -static uint16_t breathing_counter = 0; - -# ifdef BACKLIGHT_PWM_TIMER -static bool breathing = false; - -bool is_breathing(void) { return breathing; } - -# define breathing_interrupt_enable() \ - do { \ - breathing = true; \ - } while (0) -# define breathing_interrupt_disable() \ - do { \ - breathing = false; \ - } while (0) -# else - -bool is_breathing(void) { return !!(TIMSKx & _BV(TOIEx)); } - -# define breathing_interrupt_enable() \ - do { \ - TIMSKx |= _BV(TOIEx); \ - } while (0) -# define breathing_interrupt_disable() \ - do { \ - TIMSKx &= ~_BV(TOIEx); \ - } while (0) -# endif - -# define breathing_min() \ - do { \ - breathing_counter = 0; \ - } while (0) -# define breathing_max() \ - do { \ - breathing_counter = breathing_period * 244 / 2; \ - } while (0) - -void breathing_enable(void) { - breathing_counter = 0; - breathing_halt = BREATHING_NO_HALT; - breathing_interrupt_enable(); -} - -void breathing_pulse(void) { - if (get_backlight_level() == 0) - breathing_min(); - else - breathing_max(); - breathing_halt = BREATHING_HALT_ON; - breathing_interrupt_enable(); -} - -void breathing_disable(void) { - breathing_interrupt_disable(); - // Restore backlight level - backlight_set(get_backlight_level()); -} - -void breathing_self_disable(void) { - if (get_backlight_level() == 0) - breathing_halt = BREATHING_HALT_OFF; - else - breathing_halt = BREATHING_HALT_ON; -} - -void breathing_toggle(void) { - if (is_breathing()) - breathing_disable(); - else - breathing_enable(); -} - -void breathing_period_set(uint8_t value) { - if (!value) value = 1; - breathing_period = value; -} - -void breathing_period_default(void) { breathing_period_set(BREATHING_PERIOD); } - -void breathing_period_inc(void) { breathing_period_set(breathing_period + 1); } - -void breathing_period_dec(void) { breathing_period_set(breathing_period - 1); } - -/* To generate breathing curve in python: - * from math import sin, pi; [int(sin(x/128.0*pi)**4*255) for x in range(128)] - */ -static const uint8_t breathing_table[BREATHING_STEPS] PROGMEM = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 17, 20, 24, 28, 32, 36, 41, 46, 51, 57, 63, 70, 76, 83, 91, 98, 106, 113, 121, 129, 138, 146, 154, 162, 170, 178, 185, 193, 200, 207, 213, 220, 225, 231, 235, 240, 244, 247, 250, 252, 253, 254, 255, 254, 253, 252, 250, 247, 244, 240, 235, 231, 225, 220, 213, 207, 200, 193, 185, 178, 170, 162, 154, 146, 138, 129, 121, 113, 106, 98, 91, 83, 76, 70, 63, 57, 51, 46, 41, 36, 32, 28, 24, 20, 17, 15, 12, 10, 8, 6, 5, 4, 3, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; - -// Use this before the cie_lightness function. -static inline uint16_t scale_backlight(uint16_t v) { return v / BACKLIGHT_LEVELS * get_backlight_level(); } - -# ifdef BACKLIGHT_PWM_TIMER -void breathing_task(void) -# else -/* Assuming a 16MHz CPU clock and a timer that resets at 64k (ICR1), the following interrupt handler will run - * about 244 times per second. - */ -ISR(TIMERx_OVF_vect) -# endif -{ - uint16_t interval = (uint16_t)breathing_period * 244 / BREATHING_STEPS; - // resetting after one period to prevent ugly reset at overflow. - breathing_counter = (breathing_counter + 1) % (breathing_period * 244); - uint8_t index = breathing_counter / interval % BREATHING_STEPS; - - if (((breathing_halt == BREATHING_HALT_ON) && (index == BREATHING_STEPS / 2)) || ((breathing_halt == BREATHING_HALT_OFF) && (index == BREATHING_STEPS - 1))) { - breathing_interrupt_disable(); - } - - set_pwm(cie_lightness(scale_backlight((uint16_t)pgm_read_byte(&breathing_table[index]) * 0x0101U))); -} - -# endif // BACKLIGHT_BREATHING - -__attribute__((weak)) void backlight_init_ports(void) { - // Setup backlight pin as output and output to on state. - FOR_EACH_LED(setPinOutput(backlight_pin); backlight_on(backlight_pin);) - - // I could write a wall of text here to explain... but TL;DW - // Go read the ATmega32u4 datasheet. - // And this: http://blog.saikoled.com/post/43165849837/secret-konami-cheat-code-to-high-resolution-pwm-on - -# ifdef BACKLIGHT_PWM_TIMER - // TimerX setup, Fast PWM mode count to TOP set in ICRx - TCCRxA = _BV(WGM11); // = 0b00000010; - // clock select clk/1 - TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001; -# else // hardware PWM - // Pin PB7 = OCR1C (Timer 1, Channel C) - // Compare Output Mode = Clear on compare match, Channel C = COM1C1=1 COM1C0=0 - // (i.e. start high, go low when counter matches.) - // WGM Mode 14 (Fast PWM) = WGM13=1 WGM12=1 WGM11=1 WGM10=0 - // Clock Select = clk/1 (no prescaling) = CS12=0 CS11=0 CS10=1 - - /* - 14.8.3: - "In fast PWM mode, the compare units allow generation of PWM waveforms on the OCnx pins. Setting the COMnx1:0 bits to two will produce a non-inverted PWM [..]." - "In fast PWM mode the counter is incremented until the counter value matches either one of the fixed values 0x00FF, 0x01FF, or 0x03FF (WGMn3:0 = 5, 6, or 7), the value in ICRn (WGMn3:0 = 14), or the value in OCRnA (WGMn3:0 = 15)." - */ - TCCRxA = _BV(COMxx1) | _BV(WGM11); // = 0b00001010; - TCCRxB = _BV(WGM13) | _BV(WGM12) | _BV(CS10); // = 0b00011001; -# endif - // Use full 16-bit resolution. Counter counts to ICR1 before reset to 0. - ICRx = TIMER_TOP; - - backlight_init(); -# ifdef BACKLIGHT_BREATHING - if (is_backlight_breathing()) { - breathing_enable(); - } -# endif -} - -# endif // hardware backlight - -#else // no backlight - -__attribute__((weak)) void backlight_init_ports(void) {} - -__attribute__((weak)) void backlight_set(uint8_t level) {} - -#endif // backlight #ifdef HD44780_ENABLED # include "hd44780.h" diff --git a/tmk_core/common/backlight.h b/tmk_core/common/backlight.h index bb1f897ee..1e581055d 100644 --- a/tmk_core/common/backlight.h +++ b/tmk_core/common/backlight.h @@ -26,6 +26,10 @@ along with this program. If not, see . # error "Maximum value of BACKLIGHT_LEVELS is 31" #endif +#ifndef BREATHING_PERIOD +# define BREATHING_PERIOD 6 +#endif + typedef union { uint8_t raw; struct { -- cgit v1.2.3-70-g09d2 From 4531cc874e1bb8602fede9dc038b692673521590 Mon Sep 17 00:00:00 2001 From: Joel Challis Date: Sat, 2 Nov 2019 21:20:03 +0000 Subject: Initial migration of software PWM backlight (#6709) * Initial migration of software PWM backlight * First pass at backlight driver docs * Correct driver name in docs * Run backlight_task when using BACKLIGHT_PINS * Resolve backlight docs TODOs --- common_features.mk | 21 +++--- docs/feature_backlight.md | 131 ++++++++++++++++++++++++------------- quantum/backlight/backlight_avr.c | 10 +-- quantum/backlight/backlight_soft.c | 66 +++++++++++++++++++ quantum/quantum.c | 2 +- quantum/quantum.h | 4 +- 6 files changed, 173 insertions(+), 61 deletions(-) create mode 100644 quantum/backlight/backlight_soft.c (limited to 'docs/feature_backlight.md') diff --git a/common_features.mk b/common_features.mk index 7bb9187bb..a1f95955a 100644 --- a/common_features.mk +++ b/common_features.mk @@ -234,7 +234,7 @@ ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes) BACKLIGHT_ENABLE = custom endif -VALID_BACKLIGHT_TYPES := yes custom +VALID_BACKLIGHT_TYPES := yes software custom BACKLIGHT_ENABLE ?= no ifneq ($(strip $(BACKLIGHT_ENABLE)), no) @@ -246,19 +246,22 @@ ifneq ($(strip $(BACKLIGHT_ENABLE)), no) CIE1931_CURVE = yes endif - COMMON_VPATH += $(QUANTUM_DIR)/backlight SRC += $(QUANTUM_DIR)/backlight/backlight.c OPT_DEFS += -DBACKLIGHT_ENABLE - ifeq ($(strip $(BACKLIGHT_ENABLE)), custom) - OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER - endif - - ifeq ($(PLATFORM),AVR) - SRC += $(QUANTUM_DIR)/backlight/backlight_avr.c + ifeq ($(strip $(BACKLIGHT_ENABLE)), software) + SRC += $(QUANTUM_DIR)/backlight/backlight_soft.c else - SRC += $(QUANTUM_DIR)/backlight/backlight_arm.c + ifeq ($(strip $(BACKLIGHT_ENABLE)), custom) + OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER + endif + + ifeq ($(PLATFORM),AVR) + SRC += $(QUANTUM_DIR)/backlight/backlight_avr.c + else + SRC += $(QUANTUM_DIR)/backlight/backlight_arm.c + endif endif endif diff --git a/docs/feature_backlight.md b/docs/feature_backlight.md index 6a2946fd6..71f375594 100644 --- a/docs/feature_backlight.md +++ b/docs/feature_backlight.md @@ -6,14 +6,16 @@ QMK is able to control the brightness of these LEDs by switching them on and off The MCU can only supply so much current to its GPIO pins. Instead of powering the backlight directly from the MCU, the backlight pin is connected to a transistor or MOSFET that switches the power to the LEDs. -## Usage +## Driver configuration Most keyboards have backlighting enabled by default if they support it, but if it is not working for you, check that your `rules.mk` includes the following: -```make -BACKLIGHT_ENABLE = yes +```makefile +BACKLIGHT_ENABLE = software # Valid driver values are 'yes,software,no' ``` +See below for help on individual drivers. + ## Keycodes Once enabled the following keycodes below can be used to change the backlight level. @@ -27,8 +29,54 @@ Once enabled the following keycodes below can be used to change the backlight le |`BL_DEC` |Decrease the backlight level | |`BL_BRTG`|Toggle backlight breathing | +## Backlight Functions + +|Function |Description | +|----------|-----------------------------------------------------------| +|`backlight_toggle()` |Turn the backlight on or off | +|`backlight_enable()` |Turn the backlight on | +|`backlight_disable()` |Turn the backlight off | +|`backlight_step()` |Cycle through backlight levels | +|`backlight_increase()` |Increase the backlight level | +|`backlight_decrease()` |Decrease the backlight level | +|`backlight_level(x)` |Sets the backlight level to specified level | +|`get_backlight_level()` |Return the current backlight level | +|`is_backlight_enabled()`|Return whether the backlight is currently on | + +### Backlight Breathing Functions + +|Function |Description | +|----------|---------------------------------------------------| +|`breathing_toggle()` |Turn the backlight breathing on or off | +|`breathing_enable()` |Turns on backlight breathing | +|`breathing_disable()` |Turns off backlight breathing | + +## Common Driver Configuration + +To change the behavior of the backlighting, `#define` these in your `config.h`: + +|Define |Default |Description | +|---------------------|-------------|--------------------------------------------------------------------------------------| +|`BACKLIGHT_LEVELS` |`3` |The number of brightness levels (maximum 31 excluding off) | +|`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED) | +|`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if supported | +|`BREATHING_PERIOD` |`6` |The length of one backlight "breath" in seconds | +|`BACKLIGHT_ON_STATE` |`0` |The state of the backlight pin when the backlight is "on" - `1` for high, `0` for low | + +### Backlight On State + +Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*. +Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead. + +This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define. + ## AVR driver +On AVR boards, the default driver currently sniffs the configuration to pick the best scenario. To enable it, add this to your rules.mk: +```makefile +BACKLIGHT_ENABLE = yes +``` + ### Caveats Hardware PWM is supported according to the following table: @@ -63,22 +111,10 @@ When both timers are in use for Audio, the backlight PWM will not use a hardware To change the behavior of the backlighting, `#define` these in your `config.h`: -|Define |Default |Description | -|---------------------|-------------|-------------------------------------------------------------------------------------------------------------| -|`BACKLIGHT_PIN` |`B7` |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this| -|`BACKLIGHT_PINS` |*Not defined*|experimental: see below for more information | -|`BACKLIGHT_LEVELS` |`3` |The number of brightness levels (maximum 31 excluding off) | -|`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED) | -|`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if supported | -|`BREATHING_PERIOD` |`6` |The length of one backlight "breath" in seconds | -|`BACKLIGHT_ON_STATE` |`0` |The state of the backlight pin when the backlight is "on" - `1` for high, `0` for low | - -### Backlight On State - -Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*. -Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead. - -This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define. +|Define |Default |Description | +|---------------------|-------------|--------------------------------------------------------------------------------------------------------------| +|`BACKLIGHT_PIN` |`B7` |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this | +|`BACKLIGHT_PINS` |*Not defined*|experimental: see below for more information | ### Multiple backlight pins @@ -103,7 +139,7 @@ In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus th The breathing effect is achieved by registering an interrupt handler for `TIMER1_OVF_vect` that is called whenever the counter resets, roughly 244 times per second. In this handler, the value of an incrementing counter is mapped onto a precomputed brightness curve. To turn off breathing, the interrupt handler is simply disabled, and the brightness reset to the level stored in EEPROM. -### Software PWM Implementation +### Timer Assisted PWM Implementation When `BACKLIGHT_PIN` is not set to a hardware backlight pin, QMK will use a hardware timer configured to trigger software interrupts. This time will count up to `ICRx` (by default `0xFFFF`) before resetting to 0. When resetting to 0, the CPU will fire an OVF (overflow) interrupt that will turn the LEDs on, starting the duty cycle. @@ -114,9 +150,14 @@ The breathing effect is the same as in the hardware PWM implementation. ## ARM Driver +While still in its early stages, ARM backlight support aims to eventually have feature parity with AVR. To enable it, add this to your rules.mk: +```makefile +BACKLIGHT_ENABLE = yes +``` + ### Caveats -Currently only hardware PWM is supported, and does not provide automatic configuration. +Currently only hardware PWM is supported, not timer assisted, and does not provide automatic configuration. ?> STMF072 support is being investigated. @@ -130,30 +171,32 @@ To change the behavior of the backlighting, `#define` these in your `config.h`: |`BACKLIGHT_PWM_DRIVER` |`PWMD4` |The PWM driver to use, see ST datasheets for pin to PWM timer mapping. Unless you are designing your own keyboard, you shouldn't need to change this| |`BACKLIGHT_PWM_CHANNEL` |`3` |The PWM channel to use, see ST datasheets for pin to PWM channel mapping. Unless you are designing your own keyboard, you shouldn't need to change this| |`BACKLIGHT_PAL_MODE` |`2` |The pin alternative function to use, see ST datasheets for pin AF mapping. Unless you are designing your own keyboard, you shouldn't need to change this| -|`BACKLIGHT_LEVELS` |`3` |The number of brightness levels (maximum 31 excluding off) | -|`BACKLIGHT_CAPS_LOCK` |*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED) | -|`BACKLIGHT_BREATHING` |*Not defined*|Enable backlight breathing, if supported | -|`BREATHING_PERIOD` |`6` |The length of one backlight "breath" in seconds | -## Backlight Functions +## Software PWM Driver -|Function |Description | -|----------|-----------------------------------------------------------| -|`backlight_toggle()` |Turn the backlight on or off | -|`backlight_enable()` |Turn the backlight on | -|`backlight_disable()` |Turn the backlight off | -|`backlight_step()` |Cycle through backlight levels | -|`backlight_increase()` |Increase the backlight level | -|`backlight_decrease()` |Decrease the backlight level | -|`backlight_level(x)` |Sets the backlight level, from 0 to | -| |`BACKLIGHT_LEVELS` | -|`get_backlight_level()` |Return the current backlight level | -|`is_backlight_enabled()`|Return whether the backlight is currently on | +Emulation of PWM while running other keyboard tasks, it offers maximum hardware compatibility without extra platform configuration. The tradeoff is the backlight might jitter when the keyboard is busy. To enable, add this to your rules.mk: +```makefile +BACKLIGHT_ENABLE = software +``` -### Backlight Breathing Functions +### Software PWM Configuration + +To change the behavior of the backlighting, `#define` these in your `config.h`: + +|Define |Default |Description | +|-----------------|-------------|-------------------------------------------------------------------------------------------------------------| +|`BACKLIGHT_PIN` |`B7` |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this| +|`BACKLIGHT_PINS` |*Not defined*|experimental: see below for more information | -|Function |Description | -|----------|----------------------------------------------------------| -|`breathing_toggle()` |Turn the backlight breathing on or off | -|`breathing_enable()` |Turns on backlight breathing | -|`breathing_disable()` |Turns off backlight breathing | +### Multiple backlight pins + +Most keyboards have only one backlight pin which control all backlight LEDs (especially if the backlight is connected to an hardware PWM pin). +In software PWM, it is possible to define multiple backlight pins. All those pins will be turned on and off at the same time during the PWM duty cycle. +This feature allows to set for instance the Caps Lock LED (or any other controllable LED) brightness at the same level as the other LEDs of the backlight. This is useful if you have mapped LCTRL in place of Caps Lock and you need the Caps Lock LED to be part of the backlight instead of being activated when Caps Lock is on. + +To activate multiple backlight pins, you need to add something like this to your user `config.h`: + +```c +#undef BACKLIGHT_PIN +#define BACKLIGHT_PINS { F5, B2 } +``` diff --git a/quantum/backlight/backlight_avr.c b/quantum/backlight/backlight_avr.c index 445698f47..648a37adf 100644 --- a/quantum/backlight/backlight_avr.c +++ b/quantum/backlight/backlight_avr.c @@ -159,7 +159,7 @@ # define BACKLIGHT_ON_STATE 0 # endif -void backlight_on(uint8_t backlight_pin) { +void backlight_on(pin_t backlight_pin) { # if BACKLIGHT_ON_STATE == 0 writePinLow(backlight_pin); # else @@ -167,7 +167,7 @@ void backlight_on(uint8_t backlight_pin) { # endif } -void backlight_off(uint8_t backlight_pin) { +void backlight_off(pin_t backlight_pin) { # if BACKLIGHT_ON_STATE == 0 writePinHigh(backlight_pin); # else @@ -191,16 +191,16 @@ void backlight_off(uint8_t backlight_pin) { # define FOR_EACH_LED(x) \ for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) { \ - uint8_t backlight_pin = backlight_pins[i]; \ + pin_t backlight_pin = backlight_pins[i]; \ { x } \ } -static const uint8_t backlight_pins[BACKLIGHT_LED_COUNT] = BACKLIGHT_PIN_INIT; +static const pin_t backlight_pins[BACKLIGHT_LED_COUNT] = BACKLIGHT_PIN_INIT; # else // full hardware PWM // we support only one backlight pin -static const uint8_t backlight_pin = BACKLIGHT_PIN; +static const pin_t backlight_pin = BACKLIGHT_PIN; # define FOR_EACH_LED(x) x # endif diff --git a/quantum/backlight/backlight_soft.c b/quantum/backlight/backlight_soft.c new file mode 100644 index 000000000..a6aba7782 --- /dev/null +++ b/quantum/backlight/backlight_soft.c @@ -0,0 +1,66 @@ +#include "quantum.h" +#include "backlight.h" + +#if !defined(BACKLIGHT_PIN) && !defined(BACKLIGHT_PINS) +# error "Backlight pin/pins not defined. Please configure." +#endif + +#ifdef BACKLIGHT_BREATHING +# error "Backlight breathing is not available for software PWM. Please disable." +#endif + +#ifndef BACKLIGHT_ON_STATE +# define BACKLIGHT_ON_STATE 0 +#endif + +#ifdef BACKLIGHT_PINS +# define BACKLIGHT_PIN_INIT BACKLIGHT_PINS +#else +# define BACKLIGHT_PIN_INIT \ + { BACKLIGHT_PIN } +#endif + +static const pin_t backlight_pins[] = BACKLIGHT_PIN_INIT; +#define BACKLIGHT_LED_COUNT (sizeof(backlight_pins) / sizeof(pin_t)) + +#define FOR_EACH_LED(x) \ + for (uint8_t i = 0; i < BACKLIGHT_LED_COUNT; i++) { \ + pin_t backlight_pin = backlight_pins[i]; \ + { x } \ + } + +void backlight_on(pin_t backlight_pin) { +#if BACKLIGHT_ON_STATE == 0 + writePinLow(backlight_pin); +#else + writePinHigh(backlight_pin); +#endif +} + +void backlight_off(pin_t backlight_pin) { +#if BACKLIGHT_ON_STATE == 0 + writePinHigh(backlight_pin); +#else + writePinLow(backlight_pin); +#endif +} + +void backlight_init_ports(void) { + // Setup backlight pin as output and output to on state. + FOR_EACH_LED(setPinOutput(backlight_pin); backlight_on(backlight_pin);) +} + +void backlight_task(void) { + static uint8_t backlight_tick = 0; + + if ((0xFFFF >> (get_backlight_level() * ((BACKLIGHT_LEVELS + 1) / 2))) & (1 << backlight_tick)) { + FOR_EACH_LED(backlight_on(backlight_pin);) + } else { + FOR_EACH_LED(backlight_off(backlight_pin);) + } + backlight_tick = (backlight_tick + 1) % 16; +} + +void backlight_set(uint8_t level) { + // noop as backlight_task uses get_backlight_level() +} diff --git a/quantum/quantum.c b/quantum/quantum.c index d689a9fbf..571dda4c5 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -981,7 +981,7 @@ void matrix_scan_quantum() { #if defined(BACKLIGHT_ENABLE) # if defined(LED_MATRIX_ENABLE) led_matrix_task(); -# elif defined(BACKLIGHT_PIN) +# elif defined(BACKLIGHT_PIN) || defined(BACKLIGHT_PINS) backlight_task(); # endif #endif diff --git a/quantum/quantum.h b/quantum/quantum.h index f5ac97379..01abe1c0a 100644 --- a/quantum/quantum.h +++ b/quantum/quantum.h @@ -257,8 +257,8 @@ void tap_code16(uint16_t code); void backlight_init_ports(void); void backlight_task(void); void backlight_task_internal(void); -void backlight_on(uint8_t backlight_pin); -void backlight_off(uint8_t backlight_pin); +void backlight_on(pin_t backlight_pin); +void backlight_off(pin_t backlight_pin); # ifdef BACKLIGHT_BREATHING void breathing_task(void); -- cgit v1.2.3-70-g09d2