diff options
Diffstat (limited to 'drivers')
| -rw-r--r-- | drivers/apa102/apa102.c | 151 | ||||
| -rw-r--r-- | drivers/apa102/apa102.h (renamed from drivers/avr/apa102.h) | 32 | ||||
| -rw-r--r-- | drivers/avr/apa102.c | 96 | ||||
| -rw-r--r-- | drivers/chibios/serial_usart.c | 13 | ||||
| -rw-r--r-- | drivers/qwiic/qwiic.mk | 9 | 
5 files changed, 178 insertions, 123 deletions
| diff --git a/drivers/apa102/apa102.c b/drivers/apa102/apa102.c new file mode 100644 index 0000000000..7396dc3c55 --- /dev/null +++ b/drivers/apa102/apa102.c @@ -0,0 +1,151 @@ +/* Copyright 2020 Aldehir Rojas + * Copyright 2017 Mikkel (Duckle29) + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program.  If not, see <http://www.gnu.org/licenses/>. + */ + +#include "apa102.h" +#include "quantum.h" + +#ifndef APA102_NOPS +#    if defined(__AVR__) +#        define APA102_NOPS 0  // AVR at 16 MHz already spends 62.5 ns per clock, so no extra delay is needed +#    elif defined(PROTOCOL_CHIBIOS) + +#        include "hal.h" +#        if defined(STM32F0XX) || defined(STM32F1XX) || defined(STM32F3XX) || defined(STM32F4XX) || defined(STM32L0XX) +#            define APA102_NOPS (100 / (1000000000L / (STM32_SYSCLK / 4)))  // This calculates how many loops of 4 nops to run to delay 100 ns +#        else +#            error("APA102_NOPS configuration required") +#            define APA102_NOPS 0  // this just pleases the compile so the above error is easier to spot +#        endif +#    endif +#endif + +#define io_wait                                 \ +    do {                                        \ +        for (int i = 0; i < APA102_NOPS; i++) { \ +            __asm__ volatile("nop\n\t"          \ +                             "nop\n\t"          \ +                             "nop\n\t"          \ +                             "nop\n\t");        \ +        }                                       \ +    } while (0) + +#define APA102_SEND_BIT(byte, bit)               \ +    do {                                         \ +        writePin(RGB_DI_PIN, (byte >> bit) & 1); \ +        io_wait;                                 \ +        writePinHigh(RGB_CI_PIN);                \ +        io_wait;                                 \ +        writePinLow(RGB_CI_PIN);                 \ +        io_wait;                                 \ +    } while (0) + +uint8_t apa102_led_brightness = APA102_DEFAULT_BRIGHTNESS; + +void static apa102_start_frame(void); +void static apa102_end_frame(uint16_t num_leds); + +void static apa102_send_frame(uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness); +void static apa102_send_byte(uint8_t byte); + +void apa102_setleds(LED_TYPE *start_led, uint16_t num_leds) { +    LED_TYPE *end = start_led + num_leds; + +    apa102_start_frame(); +    for (LED_TYPE *led = start_led; led < end; led++) { +        apa102_send_frame(led->r, led->g, led->b, apa102_led_brightness); +    } +    apa102_end_frame(num_leds); +} + +// Overwrite the default rgblight_call_driver to use apa102 driver +void rgblight_call_driver(LED_TYPE *start_led, uint8_t num_leds) { apa102_setleds(start_led, num_leds); } + +void static apa102_init(void) { +    setPinOutput(RGB_DI_PIN); +    setPinOutput(RGB_CI_PIN); + +    writePinLow(RGB_DI_PIN); +    writePinLow(RGB_CI_PIN); +} + +void apa102_set_brightness(uint8_t brightness) { +    if (brightness > APA102_MAX_BRIGHTNESS) { +        apa102_led_brightness = APA102_MAX_BRIGHTNESS; +    } else if (brightness < 0) { +        apa102_led_brightness = 0; +    } else { +        apa102_led_brightness = brightness; +    } +} + +void static apa102_send_frame(uint8_t red, uint8_t green, uint8_t blue, uint8_t brightness) { +    apa102_send_byte(0b11100000 | brightness); +    apa102_send_byte(blue); +    apa102_send_byte(green); +    apa102_send_byte(red); +} + +void static apa102_start_frame(void) { +    apa102_init(); +    for (uint16_t i = 0; i < 4; i++) { +        apa102_send_byte(0); +    } +} + +void static apa102_end_frame(uint16_t num_leds) { +    // This function has been taken from: https://github.com/pololu/apa102-arduino/blob/master/APA102.h +    // and adapted. The code is MIT licensed. I think thats compatible? +    // +    // The data stream seen by the last LED in the chain will be delayed by +    // (count - 1) clock edges, because each LED before it inverts the clock +    // line and delays the data by one clock edge.  Therefore, to make sure +    // the last LED actually receives the data we wrote, the number of extra +    // edges we send at the end of the frame must be at least (count - 1). +    // +    // Assuming we only want to send these edges in groups of size K, the +    // C/C++ expression for the minimum number of groups to send is: +    // +    //   ((count - 1) + (K - 1)) / K +    // +    // The C/C++ expression above is just (count - 1) divided by K, +    // rounded up to the nearest whole number if there is a remainder. +    // +    // We set K to 16 and use the formula above as the number of frame-end +    // bytes to transfer.  Each byte has 16 clock edges. +    // +    // We are ignoring the specification for the end frame in the APA102 +    // datasheet, which says to send 0xFF four times, because it does not work +    // when you have 66 LEDs or more, and also it results in unwanted white +    // pixels if you try to update fewer LEDs than are on your LED strip. +    uint16_t iterations = (num_leds + 14) / 16; +    for (uint16_t i = 0; i < iterations; i++) { +        apa102_send_byte(0); +    } + +    apa102_init(); +} + +void static apa102_send_byte(uint8_t byte) { +    APA102_SEND_BIT(byte, 7); +    APA102_SEND_BIT(byte, 6); +    APA102_SEND_BIT(byte, 5); +    APA102_SEND_BIT(byte, 4); +    APA102_SEND_BIT(byte, 3); +    APA102_SEND_BIT(byte, 2); +    APA102_SEND_BIT(byte, 1); +    APA102_SEND_BIT(byte, 0); +} diff --git a/drivers/avr/apa102.h b/drivers/apa102/apa102.h index d4c1e18ee1..58cf020c1e 100644 --- a/drivers/avr/apa102.h +++ b/drivers/apa102/apa102.h @@ -1,10 +1,5 @@ -/* - * light weight WS2812 lib include - * - * Version 2.3  - Nev 29th 2015 - * Author: Tim ([email protected]) - * - * Please do not change this file! All configuration is handled in "ws2812_config.h" +/* Copyright 2020 Aldehir Rojas + * Copyright 2017 Mikkel (Duckle29)   *   * This program is free software: you can redistribute it and/or modify   * it under the terms of the GNU General Public License as published by @@ -22,24 +17,25 @@  #pragma once -#include <avr/io.h> -#include <avr/interrupt.h> -  #include "color.h" +#ifndef APA102_DEFAULT_BRIGHTNESS +#    define APA102_DEFAULT_BRIGHTNESS 31 +#endif + +#define APA102_MAX_BRIGHTNESS 31 + +extern uint8_t apa102_led_brightness; +  /* User Interface   *   * Input: - *         ledarray:           An array of GRB data describing the LED colors - *         number_of_leds:     The number of LEDs to write - *         pinmask (optional): Bitmask describing the output bin. e.g. _BV(PB0) + *         start_led:          An array of GRB data describing the LED colors + *         num_leds:           The number of LEDs to write   *   * The functions will perform the following actions:   *         - Set the data-out pin as output   *         - Send out the LED data - *         - Wait 50�s to reset the LEDs   */ - -void apa102_setleds(LED_TYPE *ledarray, uint16_t number_of_leds); -void apa102_setleds_pin(LED_TYPE *ledarray, uint16_t number_of_leds, uint8_t pinmask); -void apa102_setleds_rgbw(LED_TYPE *ledarray, uint16_t number_of_leds); +void apa102_setleds(LED_TYPE *start_led, uint16_t num_leds); +void apa102_set_brightness(uint8_t brightness); diff --git a/drivers/avr/apa102.c b/drivers/avr/apa102.c deleted file mode 100644 index 740acb5739..0000000000 --- a/drivers/avr/apa102.c +++ /dev/null @@ -1,96 +0,0 @@ -/* - * APA102 lib V1.0a - * - * Controls APA102 RGB-LEDs - * Author: Mikkel (Duckle29 on GitHub) - * - * Dec 22th, 2017  v1.0a Initial Version - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program.  If not, see <http://www.gnu.org/licenses/>. - */ - -#include "apa102.h" -#include <avr/interrupt.h> -#include <avr/io.h> -#include <util/delay.h> -#include "debug.h" - -// Setleds for standard RGB -void inline apa102_setleds(LED_TYPE *ledarray, uint16_t leds) { apa102_setleds_pin(ledarray, leds, _BV(RGB_DI_PIN & 0xF), _BV(RGB_CLK_PIN & 0xF)); } - -void static inline apa102_setleds_pin(LED_TYPE *ledarray, uint16_t leds, uint8_t pinmask_DI, uint8_t pinmask_CLK) { -    setPinOutput(RGB_DI_PIN); -    setPinOutput(RGB_CLK_PIN); - -    apa102_send_array((uint8_t *)ledarray, leds) -} - -void apa102_send_array(uint8_t *data, uint16_t leds) {  // Data is struct of 3 bytes. RGB - leds is number of leds in data -    apa102_start_frame(); -    while (leds--) { -        apa102_send_frame(0xFF000000 | (data->b << 16) | (data->g << 8) | data->r); -        data++; -    } -    apa102_end_frame(leds); -} - -void apa102_send_frame(uint32_t frame) { -    for (uint32_t i = 0xFF; i > 0;) { -        apa102_send_byte(frame & i); -        i = i << 8; -    } -} - -void apa102_start_frame() { apa102_send_frame(0); } - -void apa102_end_frame(uint16_t leds) { -    // This function has been taken from: https://github.com/pololu/apa102-arduino/blob/master/APA102.h -    // and adapted. The code is MIT licensed. I think thats compatible? - -    // We need to send some more bytes to ensure that all the LEDs in the -    // chain see their new color and start displaying it. -    // -    // The data stream seen by the last LED in the chain will be delayed by -    // (count - 1) clock edges, because each LED before it inverts the clock -    // line and delays the data by one clock edge.  Therefore, to make sure -    // the last LED actually receives the data we wrote, the number of extra -    // edges we send at the end of the frame must be at least (count - 1). -    // For the APA102C, that is sufficient. -    // -    // The SK9822 only updates after it sees 32 zero bits followed by one more -    // rising edge.  To avoid having the update time depend on the color of -    // the last LED, we send a dummy 0xFF byte.  (Unfortunately, this means -    // that partial updates of the beginning of an LED strip are not possible; -    // the LED after the last one you are trying to update will be black.) -    // After that, to ensure that the last LED in the chain sees 32 zero bits -    // and a rising edge, we need to send at least 65 + (count - 1) edges.  It -    // is sufficent and simpler to just send (5 + count/16) bytes of zeros. -    // -    // We are ignoring the specification for the end frame in the APA102/SK9822 -    // datasheets because it does not actually ensure that all the LEDs will -    // start displaying their new colors right away. - -    apa102_send_byte(0xFF); -    for (uint16_t i = 0; i < 5 + leds / 16; i++) { -        apa102_send_byte(0); -    } -} - -void apa102_send_byte(uint8_t byte) { -    uint8_t i; -    for (i = 0; i < 8; i++) { -        writePin(RGB_DI_PIN, !!(byte & (1 << (7 - i)))); -        writePinHigh(RGB_CLK_PIN); -    } -} diff --git a/drivers/chibios/serial_usart.c b/drivers/chibios/serial_usart.c index a3e21f90bc..7c81b16464 100644 --- a/drivers/chibios/serial_usart.c +++ b/drivers/chibios/serial_usart.c @@ -58,7 +58,10 @@  #    error invalid SELECT_SOFT_SERIAL_SPEED value  #endif -#define TIMEOUT 100 +#ifndef SERIAL_USART_TIMEOUT +#    define SERIAL_USART_TIMEOUT 100 +#endif +  #define HANDSHAKE_MAGIC 7  static inline msg_t sdWriteHalfDuplex(SerialDriver* driver, uint8_t* data, uint8_t size) { @@ -201,21 +204,21 @@ int soft_serial_transaction(int index) {      sdClear(&SERIAL_USART_DRIVER);      // First chunk is always transaction id -    sdWriteTimeout(&SERIAL_USART_DRIVER, &sstd_index, sizeof(sstd_index), TIME_MS2I(TIMEOUT)); +    sdWriteTimeout(&SERIAL_USART_DRIVER, &sstd_index, sizeof(sstd_index), TIME_MS2I(SERIAL_USART_TIMEOUT));      uint8_t sstd_index_shake = 0xFF;      // Which we always read back first so that we can error out correctly      //   - due to the half duplex limitations on return codes, we always have to read *something*      //   - without the read, write only transactions *always* succeed, even during the boot process where the slave is not ready -    res = sdReadTimeout(&SERIAL_USART_DRIVER, &sstd_index_shake, sizeof(sstd_index_shake), TIME_MS2I(TIMEOUT)); +    res = sdReadTimeout(&SERIAL_USART_DRIVER, &sstd_index_shake, sizeof(sstd_index_shake), TIME_MS2I(SERIAL_USART_TIMEOUT));      if (res < 0 || (sstd_index_shake != (sstd_index ^ HANDSHAKE_MAGIC))) {          dprintf("serial::usart_shake NO_RESPONSE\n");          return TRANSACTION_NO_RESPONSE;      }      if (trans->initiator2target_buffer_size) { -        res = sdWriteTimeout(&SERIAL_USART_DRIVER, trans->initiator2target_buffer, trans->initiator2target_buffer_size, TIME_MS2I(TIMEOUT)); +        res = sdWriteTimeout(&SERIAL_USART_DRIVER, trans->initiator2target_buffer, trans->initiator2target_buffer_size, TIME_MS2I(SERIAL_USART_TIMEOUT));          if (res < 0) {              dprintf("serial::usart_transmit NO_RESPONSE\n");              return TRANSACTION_NO_RESPONSE; @@ -223,7 +226,7 @@ int soft_serial_transaction(int index) {      }      if (trans->target2initiator_buffer_size) { -        res = sdReadTimeout(&SERIAL_USART_DRIVER, trans->target2initiator_buffer, trans->target2initiator_buffer_size, TIME_MS2I(TIMEOUT)); +        res = sdReadTimeout(&SERIAL_USART_DRIVER, trans->target2initiator_buffer, trans->target2initiator_buffer_size, TIME_MS2I(SERIAL_USART_TIMEOUT));          if (res < 0) {              dprintf("serial::usart_receive NO_RESPONSE\n");              return TRANSACTION_NO_RESPONSE; diff --git a/drivers/qwiic/qwiic.mk b/drivers/qwiic/qwiic.mk index b23c25657d..164bd72108 100644 --- a/drivers/qwiic/qwiic.mk +++ b/drivers/qwiic/qwiic.mk @@ -1,16 +1,17 @@ -ifneq ($(strip $(QWIIC_ENABLE)),) +ifeq ($(strip $(QWIIC_ENABLE)),yes)    COMMON_VPATH += $(DRIVER_PATH)/qwiic    OPT_DEFS += -DQWIIC_ENABLE    SRC += qwiic.c    QUANTUM_LIB_SRC += i2c_master.c -endif -ifneq ($(filter JOYSTIIC, $(QWIIC_ENABLE)),) +ifneq ($(filter JOYSTIIC, $(QWIIC_DRIVERS)),)    OPT_DEFS += -DQWIIC_JOYSTIIC_ENABLE    SRC += joystiic.c  endif -ifneq ($(filter MICRO_OLED, $(QWIIC_ENABLE)),) +ifneq ($(filter MICRO_OLED, $(QWIIC_DRIVERS)),)    OPT_DEFS += -DQWIIC_MICRO_OLED_ENABLE    SRC += micro_oled.c  endif + +endif | 
