diff options
Diffstat (limited to 'platforms/avr/drivers')
| -rw-r--r-- | platforms/avr/drivers/analog.c | 138 | ||||
| -rw-r--r-- | platforms/avr/drivers/analog.h | 53 | ||||
| -rw-r--r-- | platforms/avr/drivers/glcdfont.c | 23 | ||||
| -rw-r--r-- | platforms/avr/drivers/hd44780.c | 536 | ||||
| -rw-r--r-- | platforms/avr/drivers/hd44780.h | 348 | ||||
| -rw-r--r-- | platforms/avr/drivers/i2c_master.c | 241 | ||||
| -rw-r--r-- | platforms/avr/drivers/i2c_master.h | 43 | ||||
| -rw-r--r-- | platforms/avr/drivers/i2c_slave.c | 111 | ||||
| -rw-r--r-- | platforms/avr/drivers/i2c_slave.h | 41 | ||||
| -rw-r--r-- | platforms/avr/drivers/serial.c | 529 | ||||
| -rw-r--r-- | platforms/avr/drivers/spi_master.c | 180 | ||||
| -rw-r--r-- | platforms/avr/drivers/spi_master.h | 59 | ||||
| -rw-r--r-- | platforms/avr/drivers/ssd1306.c | 319 | ||||
| -rw-r--r-- | platforms/avr/drivers/ssd1306.h | 87 | ||||
| -rw-r--r-- | platforms/avr/drivers/uart.c | 170 | ||||
| -rw-r--r-- | platforms/avr/drivers/uart.h | 35 | ||||
| -rw-r--r-- | platforms/avr/drivers/ws2812.c | 176 | ||||
| -rw-r--r-- | platforms/avr/drivers/ws2812_i2c.c | 27 | 
18 files changed, 3116 insertions, 0 deletions
| diff --git a/platforms/avr/drivers/analog.c b/platforms/avr/drivers/analog.c new file mode 100644 index 0000000000..8d299ffdb9 --- /dev/null +++ b/platforms/avr/drivers/analog.c @@ -0,0 +1,138 @@ +/* Copyright 2015 Jack Humbert + * + * 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 <avr/io.h> +#include <avr/pgmspace.h> +#include <stdint.h> +#include "analog.h" + +static uint8_t aref = ADC_REF_POWER; + +void analogReference(uint8_t mode) { aref = mode & (_BV(REFS1) | _BV(REFS0)); } + +// Arduino compatible pin input +int16_t analogRead(uint8_t pin) { +#if defined(__AVR_ATmega32U4__) +    // clang-format off +    static const uint8_t PROGMEM pin_to_mux[] = { +        //A0    A1    A2    A3    A4    A5 +        //F7    F6    F5    F4    F1    F0 +        0x07, 0x06, 0x05, 0x04, 0x01, 0x00, +        //A6    A7    A8    A9   A10   A11 +        //D4    D7    B4    B5    B6    D6 +        0x20, 0x22, 0x23, 0x24, 0x25, 0x21 +    }; +    // clang-format on +    if (pin >= 12) return 0; +    return adc_read(pgm_read_byte(pin_to_mux + pin)); +#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328__) +    if (pin >= 8) return 0; +    return adc_read(pin); +#else +    return 0; +#endif +} + +int16_t analogReadPin(pin_t pin) { return adc_read(pinToMux(pin)); } + +uint8_t pinToMux(pin_t pin) { +    switch (pin) { +        // clang-format off +#if defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) +        case F0: return 0;  // ADC0 +        case F1: return _BV(MUX0);  // ADC1 +        case F2: return _BV(MUX1);  // ADC2 +        case F3: return _BV(MUX1) | _BV(MUX0);  // ADC3 +        case F4: return _BV(MUX2);  // ADC4 +        case F5: return _BV(MUX2) | _BV(MUX0);  // ADC5 +        case F6: return _BV(MUX2) | _BV(MUX1);  // ADC6 +        case F7: return _BV(MUX2) | _BV(MUX1) | _BV(MUX0);  // ADC7 +        default: return _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1) | _BV(MUX0);  // 0V +#elif defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) +        case F0: return 0;  // ADC0 +        case F1: return _BV(MUX0);  // ADC1 +        case F4: return _BV(MUX2);  // ADC4 +        case F5: return _BV(MUX2) | _BV(MUX0);  // ADC5 +        case F6: return _BV(MUX2) | _BV(MUX1);  // ADC6 +        case F7: return _BV(MUX2) | _BV(MUX1) | _BV(MUX0);  // ADC7 +        case D4: return _BV(MUX5);  // ADC8 +        case D6: return _BV(MUX5) | _BV(MUX0);  // ADC9 +        case D7: return _BV(MUX5) | _BV(MUX1);  // ADC10 +        case B4: return _BV(MUX5) | _BV(MUX1) | _BV(MUX0);  // ADC11 +        case B5: return _BV(MUX5) | _BV(MUX2);  // ADC12 +        case B6: return _BV(MUX5) | _BV(MUX2) | _BV(MUX0);  // ADC13 +        default: return _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1) | _BV(MUX0);  // 0V +#elif defined(__AVR_ATmega32A__) +        case A0: return 0;  // ADC0 +        case A1: return _BV(MUX0);  // ADC1 +        case A2: return _BV(MUX1);  // ADC2 +        case A3: return _BV(MUX1) | _BV(MUX0);  // ADC3 +        case A4: return _BV(MUX2);  // ADC4 +        case A5: return _BV(MUX2) | _BV(MUX0);  // ADC5 +        case A6: return _BV(MUX2) | _BV(MUX1);  // ADC6 +        case A7: return _BV(MUX2) | _BV(MUX1) | _BV(MUX0);  // ADC7 +        default: return _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1) | _BV(MUX0);  // 0V +#elif defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328__) +        case C0: return 0;  // ADC0 +        case C1: return _BV(MUX0);  // ADC1 +        case C2: return _BV(MUX1);  // ADC2 +        case C3: return _BV(MUX1) | _BV(MUX0);  // ADC3 +        case C4: return _BV(MUX2);  // ADC4 +        case C5: return _BV(MUX2) | _BV(MUX0);  // ADC5 +        // ADC7:6 not present in DIP package and not shared by GPIO pins +        default: return _BV(MUX3) | _BV(MUX2) | _BV(MUX1) | _BV(MUX0);  // 0V +#endif +            // clang-format on +    } +    return 0; +} + +int16_t adc_read(uint8_t mux) { +    uint16_t low; + +    // Enable ADC and configure prescaler +    ADCSRA = _BV(ADEN) | ADC_PRESCALER; + +#if defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) +    // High speed mode and ADC8-13 +    ADCSRB = _BV(ADHSM) | (mux & _BV(MUX5)); +#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) +    // High speed mode only +    ADCSRB = _BV(ADHSM); +#endif + +    // Configure mux input +#if defined(MUX4) +    ADMUX = aref | (mux & (_BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1) | _BV(MUX0))); +#else +    ADMUX  = aref | (mux & (_BV(MUX3) | _BV(MUX2) | _BV(MUX1) | _BV(MUX0))); +#endif + +    // Start the conversion +    ADCSRA |= _BV(ADSC); +    // Wait for result +    while (ADCSRA & _BV(ADSC)) +        ; +    // Must read LSB first +    low = ADCL; +    // Must read MSB only once! +    low |= (ADCH << 8); + +    // turn off the ADC +    ADCSRA &= ~(1 << ADEN); + +    return low; +} diff --git a/platforms/avr/drivers/analog.h b/platforms/avr/drivers/analog.h new file mode 100644 index 0000000000..058882450d --- /dev/null +++ b/platforms/avr/drivers/analog.h @@ -0,0 +1,53 @@ +/* Copyright 2015 Jack Humbert + * + * 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/>. + */ + +#pragma once + +#include <stdint.h> +#include "quantum.h" + +#ifdef __cplusplus +extern "C" { +#endif +void    analogReference(uint8_t mode); +int16_t analogRead(uint8_t pin); + +int16_t analogReadPin(pin_t pin); +uint8_t pinToMux(pin_t pin); + +int16_t adc_read(uint8_t mux); +#ifdef __cplusplus +} +#endif + +#define ADC_REF_EXTERNAL 0                          // AREF, Internal Vref turned off +#define ADC_REF_POWER _BV(REFS0)                    // AVCC with external capacitor on AREF pin +#define ADC_REF_INTERNAL (_BV(REFS1) | _BV(REFS0))  // Internal 2.56V Voltage Reference with external capacitor on AREF pin (1.1V for 328P) + +// These prescaler values are for high speed mode, ADHSM = 1 +#if F_CPU == 16000000L || F_CPU == 12000000L +#    define ADC_PRESCALER (_BV(ADPS2) | _BV(ADPS1))  // /64 +#elif F_CPU == 8000000L +#    define ADC_PRESCALER (_BV(ADPS2) | _BV(ADPS0))  // /32 +#elif F_CPU == 4000000L +#    define ADC_PRESCALER (_BV(ADPS2))  // /16 +#elif F_CPU == 2000000L +#    define ADC_PRESCALER (_BV(ADPS1) | _BV(ADPS0))  // /8 +#elif F_CPU == 1000000L +#    define ADC_PRESCALER _BV(ADPS1)  // /4 +#else +#    define ADC_PRESCALER _BV(ADPS0)  // /2 +#endif diff --git a/platforms/avr/drivers/glcdfont.c b/platforms/avr/drivers/glcdfont.c new file mode 100644 index 0000000000..5e763b054f --- /dev/null +++ b/platforms/avr/drivers/glcdfont.c @@ -0,0 +1,23 @@ +// This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0. +// See gfxfont.h for newer custom bitmap font info. + +#include "progmem.h" + +// Standard ASCII 5x7 font + +static const unsigned char font[] PROGMEM = { +    0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00, 0x18, 0x3C, 0x18, 0x00, 0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00, 0x18, 0x24, 0x18, 0x00, 0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x30, 0x48, 0x3A, 0x06, 0x0E, 0x26, 0x29, 0x79, 0x29, 0x26, 0x40, 0x7F, 0x05, 0x05, 0x07, 0x40, 0x7F, 0x05, 0x25, 0x3F, 0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x14, 0x22, 0x7F, 0x22, 0x14, 0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00, 0x66, 0x89, 0x95, 0x6A, 0x60, 0x60, 0x60, 0x60, 0x60, 0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x08, 0x04, 0x7E, 0x04, 0x08, 0x10, 0x20, 0x7E, 0x20, 0x10, 0x08, 0x08, 0x2A, 0x1C, 0x08, 0x08, 0x1C, 0x2A, 0x08, 0x08, 0x1E, 0x10, 0x10, 0x10, 0x10, 0x0C, 0x1E, 0x0C, 0x1E, 0x0C, +    0x30, 0x38, 0x3E, 0x38, 0x30, 0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5F, 0x00, 0x00, 0x00, 0x07, 0x00, 0x07, 0x00, 0x14, 0x7F, 0x14, 0x7F, 0x14, 0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x23, 0x13, 0x08, 0x64, 0x62, 0x36, 0x49, 0x56, 0x20, 0x50, 0x00, 0x08, 0x07, 0x03, 0x00, 0x00, 0x1C, 0x22, 0x41, 0x00, 0x00, 0x41, 0x22, 0x1C, 0x00, 0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00, 0x80, 0x70, 0x30, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x60, 0x60, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02, 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x42, 0x7F, 0x40, 0x00, 0x72, 0x49, 0x49, 0x49, 0x46, 0x21, 0x41, 0x49, 0x4D, 0x33, 0x18, 0x14, 0x12, 0x7F, 0x10, 0x27, 0x45, 0x45, 0x45, 0x39, 0x3C, 0x4A, 0x49, 0x49, 0x31, 0x41, 0x21, 0x11, 0x09, 0x07, 0x36, 0x49, 0x49, 0x49, 0x36, 0x46, 0x49, 0x49, 0x29, 0x1E, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x40, 0x34, 0x00, 0x00, +    0x00, 0x08, 0x14, 0x22, 0x41, 0x14, 0x14, 0x14, 0x14, 0x14, 0x00, 0x41, 0x22, 0x14, 0x08, 0x02, 0x01, 0x59, 0x09, 0x06, 0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x7C, 0x12, 0x11, 0x12, 0x7C, 0x7F, 0x49, 0x49, 0x49, 0x36, 0x3E, 0x41, 0x41, 0x41, 0x22, 0x7F, 0x41, 0x41, 0x41, 0x3E, 0x7F, 0x49, 0x49, 0x49, 0x41, 0x7F, 0x09, 0x09, 0x09, 0x01, 0x3E, 0x41, 0x41, 0x51, 0x73, 0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00, 0x41, 0x7F, 0x41, 0x00, 0x20, 0x40, 0x41, 0x3F, 0x01, 0x7F, 0x08, 0x14, 0x22, 0x41, 0x7F, 0x40, 0x40, 0x40, 0x40, 0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x3E, 0x41, 0x41, 0x41, 0x3E, 0x7F, 0x09, 0x09, 0x09, 0x06, 0x3E, 0x41, 0x51, 0x21, 0x5E, 0x7F, 0x09, 0x19, 0x29, 0x46, 0x26, 0x49, 0x49, 0x49, 0x32, 0x03, 0x01, 0x7F, 0x01, 0x03, 0x3F, 0x40, 0x40, 0x40, 0x3F, 0x1F, 0x20, 0x40, 0x20, 0x1F, 0x3F, 0x40, 0x38, 0x40, 0x3F, 0x63, 0x14, 0x08, 0x14, 0x63, 0x03, 0x04, 0x78, 0x04, 0x03, +    0x61, 0x59, 0x49, 0x4D, 0x43, 0x00, 0x7F, 0x41, 0x41, 0x41, 0x02, 0x04, 0x08, 0x10, 0x20, 0x00, 0x41, 0x41, 0x41, 0x7F, 0x04, 0x02, 0x01, 0x02, 0x04, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x03, 0x07, 0x08, 0x00, 0x20, 0x54, 0x54, 0x78, 0x40, 0x7F, 0x28, 0x44, 0x44, 0x38, 0x38, 0x44, 0x44, 0x44, 0x28, 0x38, 0x44, 0x44, 0x28, 0x7F, 0x38, 0x54, 0x54, 0x54, 0x18, 0x00, 0x08, 0x7E, 0x09, 0x02, 0x18, 0xA4, 0xA4, 0x9C, 0x78, 0x7F, 0x08, 0x04, 0x04, 0x78, 0x00, 0x44, 0x7D, 0x40, 0x00, 0x20, 0x40, 0x40, 0x3D, 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00, 0x00, 0x41, 0x7F, 0x40, 0x00, 0x7C, 0x04, 0x78, 0x04, 0x78, 0x7C, 0x08, 0x04, 0x04, 0x78, 0x38, 0x44, 0x44, 0x44, 0x38, 0xFC, 0x18, 0x24, 0x24, 0x18, 0x18, 0x24, 0x24, 0x18, 0xFC, 0x7C, 0x08, 0x04, 0x04, 0x08, 0x48, 0x54, 0x54, 0x54, 0x24, 0x04, 0x04, 0x3F, 0x44, 0x24, 0x3C, 0x40, 0x40, 0x20, 0x7C, 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x3C, 0x40, 0x30, 0x40, 0x3C, +    0x44, 0x28, 0x10, 0x28, 0x44, 0x4C, 0x90, 0x90, 0x90, 0x7C, 0x44, 0x64, 0x54, 0x4C, 0x44, 0x00, 0x08, 0x36, 0x41, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00, 0x00, 0x41, 0x36, 0x08, 0x00, 0x02, 0x01, 0x02, 0x04, 0x02, 0x3C, 0x26, 0x23, 0x26, 0x3C, 0x1E, 0xA1, 0xA1, 0x61, 0x12, 0x3A, 0x40, 0x40, 0x20, 0x7A, 0x38, 0x54, 0x54, 0x55, 0x59, 0x21, 0x55, 0x55, 0x79, 0x41, 0x22, 0x54, 0x54, 0x78, 0x42,                                                                                                                                                                                                                                                                                                              // a-umlaut +    0x21, 0x55, 0x54, 0x78, 0x40, 0x20, 0x54, 0x55, 0x79, 0x40, 0x0C, 0x1E, 0x52, 0x72, 0x12, 0x39, 0x55, 0x55, 0x55, 0x59, 0x39, 0x54, 0x54, 0x54, 0x59, 0x39, 0x55, 0x54, 0x54, 0x58, 0x00, 0x00, 0x45, 0x7C, 0x41, 0x00, 0x02, 0x45, 0x7D, 0x42, 0x00, 0x01, 0x45, 0x7C, 0x40, 0x7D, 0x12, 0x11, 0x12, 0x7D,                                                                                                                                                                                                                                                                                                                                                                                                        // A-umlaut +    0xF0, 0x28, 0x25, 0x28, 0xF0, 0x7C, 0x54, 0x55, 0x45, 0x00, 0x20, 0x54, 0x54, 0x7C, 0x54, 0x7C, 0x0A, 0x09, 0x7F, 0x49, 0x32, 0x49, 0x49, 0x49, 0x32, 0x3A, 0x44, 0x44, 0x44, 0x3A,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // o-umlaut +    0x32, 0x4A, 0x48, 0x48, 0x30, 0x3A, 0x41, 0x41, 0x21, 0x7A, 0x3A, 0x42, 0x40, 0x20, 0x78, 0x00, 0x9D, 0xA0, 0xA0, 0x7D, 0x3D, 0x42, 0x42, 0x42, 0x3D,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              // O-umlaut +    0x3D, 0x40, 0x40, 0x40, 0x3D, 0x3C, 0x24, 0xFF, 0x24, 0x24, 0x48, 0x7E, 0x49, 0x43, 0x66, 0x2B, 0x2F, 0xFC, 0x2F, 0x2B, 0xFF, 0x09, 0x29, 0xF6, 0x20, 0xC0, 0x88, 0x7E, 0x09, 0x03, 0x20, 0x54, 0x54, 0x79, 0x41, 0x00, 0x00, 0x44, 0x7D, 0x41, 0x30, 0x48, 0x48, 0x4A, 0x32, 0x38, 0x40, 0x40, 0x22, 0x7A, 0x00, 0x7A, 0x0A, 0x0A, 0x72, 0x7D, 0x0D, 0x19, 0x31, 0x7D, 0x26, 0x29, 0x29, 0x2F, 0x28, 0x26, 0x29, 0x29, 0x29, 0x26, 0x30, 0x48, 0x4D, 0x40, 0x20, 0x38, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x38, 0x2F, 0x10, 0xC8, 0xAC, 0xBA, 0x2F, 0x10, 0x28, 0x34, 0xFA, 0x00, 0x00, 0x7B, 0x00, 0x00, 0x08, 0x14, 0x2A, 0x14, 0x22, 0x22, 0x14, 0x2A, 0x14, 0x08, 0x55, 0x00, 0x55, 0x00, 0x55,  // #176 (25% block) missing in old code +    0xAA, 0x55, 0xAA, 0x55, 0xAA,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // 50% block +    0xFF, 0x55, 0xFF, 0x55, 0xFF,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      // 75% block +    0x00, 0x00, 0x00, 0xFF, 0x00, 0x10, 0x10, 0x10, 0xFF, 0x00, 0x14, 0x14, 0x14, 0xFF, 0x00, 0x10, 0x10, 0xFF, 0x00, 0xFF, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x14, 0x14, 0x14, 0xFC, 0x00, 0x14, 0x14, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x14, 0x14, 0xF4, 0x04, 0xFC, 0x14, 0x14, 0x17, 0x10, 0x1F, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x14, 0x14, 0x14, 0x1F, 0x00, 0x10, 0x10, 0x10, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0x00, 0x00, 0x00, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0x00, 0x00, 0x00, 0xFF, 0x14, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x1F, 0x10, 0x17, 0x00, 0x00, 0xFC, 0x04, 0xF4, 0x14, 0x14, 0x17, 0x10, 0x17, 0x14, 0x14, 0xF4, 0x04, 0xF4, 0x00, 0x00, 0xFF, 0x00, 0xF7, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xF7, 0x00, 0xF7, 0x14, 0x14, 0x14, 0x17, 0x14, 0x10, 0x10, 0x1F, 0x10, 0x1F, +    0x14, 0x14, 0x14, 0xF4, 0x14, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00, 0x00, 0x1F, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x1F, 0x14, 0x00, 0x00, 0x00, 0xFC, 0x14, 0x00, 0x00, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0xFF, 0x10, 0xFF, 0x14, 0x14, 0x14, 0xFF, 0x14, 0x10, 0x10, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x38, 0x44, 0x44, 0x38, 0x44, 0xFC, 0x4A, 0x4A, 0x4A, 0x34,                                                                                                                                                                                                                                                                                                                                                                                                       // sharp-s or beta +    0x7E, 0x02, 0x02, 0x06, 0x06, 0x02, 0x7E, 0x02, 0x7E, 0x02, 0x63, 0x55, 0x49, 0x41, 0x63, 0x38, 0x44, 0x44, 0x3C, 0x04, 0x40, 0x7E, 0x20, 0x1E, 0x20, 0x06, 0x02, 0x7E, 0x02, 0x02, 0x99, 0xA5, 0xE7, 0xA5, 0x99, 0x1C, 0x2A, 0x49, 0x2A, 0x1C, 0x4C, 0x72, 0x01, 0x72, 0x4C, 0x30, 0x4A, 0x4D, 0x4D, 0x30, 0x30, 0x48, 0x78, 0x48, 0x30, 0xBC, 0x62, 0x5A, 0x46, 0x3D, 0x3E, 0x49, 0x49, 0x49, 0x00, 0x7E, 0x01, 0x01, 0x01, 0x7E, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x44, 0x44, 0x5F, 0x44, 0x44, 0x40, 0x51, 0x4A, 0x44, 0x40, 0x40, 0x44, 0x4A, 0x51, 0x40, 0x00, 0x00, 0xFF, 0x01, 0x03, 0xE0, 0x80, 0xFF, 0x00, 0x00, 0x08, 0x08, 0x6B, 0x6B, 0x08, 0x36, 0x12, 0x36, 0x24, 0x36, 0x06, 0x0F, 0x09, 0x0F, 0x06, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x30, 0x40, 0xFF, 0x01, 0x01, 0x00, 0x1F, 0x01, 0x01, 0x1E, 0x00, 0x19, 0x1D, 0x17, 0x12, 0x00, 0x3C, 0x3C, 0x3C, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00  // #255 NBSP +}; diff --git a/platforms/avr/drivers/hd44780.c b/platforms/avr/drivers/hd44780.c new file mode 100644 index 0000000000..f71069dece --- /dev/null +++ b/platforms/avr/drivers/hd44780.c @@ -0,0 +1,536 @@ +/**************************************************************************** + Title:     HD44780U LCD library + Author:    Peter Fleury <[email protected]>  http://tinyurl.com/peterfleury + License:   GNU General Public License Version 3 + File:	    $Id: lcd.c,v 1.15.2.2 2015/01/17 12:16:05 peter Exp $ + Software:  AVR-GCC 3.3 + Target:    any AVR device, memory mapped mode only for AT90S4414/8515/Mega + + DESCRIPTION +       Basic routines for interfacing a HD44780U-based text lcd display + +       Originally based on Volker Oth's lcd library, +       changed lcd_init(), added additional constants for lcd_command(), +       added 4-bit I/O mode, improved and optimized code. + +       Library can be operated in memory mapped mode (LCD_IO_MODE=0) or in +       4-bit IO port mode (LCD_IO_MODE=1). 8-bit IO port mode not supported. + +       Memory mapped mode compatible with Kanda STK200, but supports also +       generation of R/W signal through A8 address line. + + USAGE +       See the C include lcd.h file for a description of each function + +*****************************************************************************/ +#include <inttypes.h> +#include <avr/io.h> +#include <avr/pgmspace.h> +#include <util/delay.h> +#include "hd44780.h" + +/* +** constants/macros +*/ +#define DDR(x) (*(&x - 1)) /* address of data direction register of port x */ +#if defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) +/* on ATmega64/128 PINF is on port 0x00 and not 0x60 */ +#    define PIN(x) (&PORTF == &(x) ? _SFR_IO8(0x00) : (*(&x - 2))) +#else +#    define PIN(x) (*(&x - 2)) /* address of input register of port x          */ +#endif + +#if LCD_IO_MODE +#    define lcd_e_delay() _delay_us(LCD_DELAY_ENABLE_PULSE) +#    define lcd_e_high() LCD_E_PORT |= _BV(LCD_E_PIN); +#    define lcd_e_low() LCD_E_PORT &= ~_BV(LCD_E_PIN); +#    define lcd_e_toggle() toggle_e() +#    define lcd_rw_high() LCD_RW_PORT |= _BV(LCD_RW_PIN) +#    define lcd_rw_low() LCD_RW_PORT &= ~_BV(LCD_RW_PIN) +#    define lcd_rs_high() LCD_RS_PORT |= _BV(LCD_RS_PIN) +#    define lcd_rs_low() LCD_RS_PORT &= ~_BV(LCD_RS_PIN) +#endif + +#if LCD_IO_MODE +#    if LCD_LINES == 1 +#        define LCD_FUNCTION_DEFAULT LCD_FUNCTION_4BIT_1LINE +#    else +#        define LCD_FUNCTION_DEFAULT LCD_FUNCTION_4BIT_2LINES +#    endif +#else +#    if LCD_LINES == 1 +#        define LCD_FUNCTION_DEFAULT LCD_FUNCTION_8BIT_1LINE +#    else +#        define LCD_FUNCTION_DEFAULT LCD_FUNCTION_8BIT_2LINES +#    endif +#endif + +#if LCD_CONTROLLER_KS0073 +#    if LCD_LINES == 4 + +#        define KS0073_EXTENDED_FUNCTION_REGISTER_ON 0x2C  /* |0|010|1100 4-bit mode, extension-bit RE = 1 */ +#        define KS0073_EXTENDED_FUNCTION_REGISTER_OFF 0x28 /* |0|010|1000 4-bit mode, extension-bit RE = 0 */ +#        define KS0073_4LINES_MODE 0x09                    /* |0|000|1001 4 lines mode */ + +#    endif +#endif + +/* +** function prototypes +*/ +#if LCD_IO_MODE +static void toggle_e(void); +#endif + +/* +** local functions +*/ + +/************************************************************************* +delay for a minimum of <us> microseconds +the number of loops is calculated at compile-time from MCU clock frequency +*************************************************************************/ +#define delay(us) _delay_us(us) + +#if LCD_IO_MODE +/* toggle Enable Pin to initiate write */ +static void toggle_e(void) { +    lcd_e_high(); +    lcd_e_delay(); +    lcd_e_low(); +} +#endif + +/************************************************************************* +Low-level function to write byte to LCD controller +Input:    data   byte to write to LCD +          rs     1: write data +                 0: write instruction +Returns:  none +*************************************************************************/ +#if LCD_IO_MODE +static void lcd_write(uint8_t data, uint8_t rs) { +    unsigned char dataBits; + +    if (rs) { /* write data        (RS=1, RW=0) */ +        lcd_rs_high(); +    } else { /* write instruction (RS=0, RW=0) */ +        lcd_rs_low(); +    } +    lcd_rw_low(); /* RW=0  write mode      */ + +    if ((&LCD_DATA0_PORT == &LCD_DATA1_PORT) && (&LCD_DATA1_PORT == &LCD_DATA2_PORT) && (&LCD_DATA2_PORT == &LCD_DATA3_PORT) && (LCD_DATA0_PIN == 0) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3)) { +        /* configure data pins as output */ +        DDR(LCD_DATA0_PORT) |= 0x0F; + +        /* output high nibble first */ +        dataBits       = LCD_DATA0_PORT & 0xF0; +        LCD_DATA0_PORT = dataBits | ((data >> 4) & 0x0F); +        lcd_e_toggle(); + +        /* output low nibble */ +        LCD_DATA0_PORT = dataBits | (data & 0x0F); +        lcd_e_toggle(); + +        /* all data pins high (inactive) */ +        LCD_DATA0_PORT = dataBits | 0x0F; +    } else { +        /* configure data pins as output */ +        DDR(LCD_DATA0_PORT) |= _BV(LCD_DATA0_PIN); +        DDR(LCD_DATA1_PORT) |= _BV(LCD_DATA1_PIN); +        DDR(LCD_DATA2_PORT) |= _BV(LCD_DATA2_PIN); +        DDR(LCD_DATA3_PORT) |= _BV(LCD_DATA3_PIN); + +        /* output high nibble first */ +        LCD_DATA3_PORT &= ~_BV(LCD_DATA3_PIN); +        LCD_DATA2_PORT &= ~_BV(LCD_DATA2_PIN); +        LCD_DATA1_PORT &= ~_BV(LCD_DATA1_PIN); +        LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN); +        if (data & 0x80) LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN); +        if (data & 0x40) LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN); +        if (data & 0x20) LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN); +        if (data & 0x10) LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN); +        lcd_e_toggle(); + +        /* output low nibble */ +        LCD_DATA3_PORT &= ~_BV(LCD_DATA3_PIN); +        LCD_DATA2_PORT &= ~_BV(LCD_DATA2_PIN); +        LCD_DATA1_PORT &= ~_BV(LCD_DATA1_PIN); +        LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN); +        if (data & 0x08) LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN); +        if (data & 0x04) LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN); +        if (data & 0x02) LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN); +        if (data & 0x01) LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN); +        lcd_e_toggle(); + +        /* all data pins high (inactive) */ +        LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN); +        LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN); +        LCD_DATA2_PORT |= _BV(LCD_DATA2_PIN); +        LCD_DATA3_PORT |= _BV(LCD_DATA3_PIN); +    } +} +#else +#    define lcd_write(d, rs)                        \ +        if (rs)                                     \ +            *(volatile uint8_t *)(LCD_IO_DATA) = d; \ +        else                                        \ +            *(volatile uint8_t *)(LCD_IO_FUNCTION) = d; +/* rs==0 -> write instruction to LCD_IO_FUNCTION */ +/* rs==1 -> write data to LCD_IO_DATA */ +#endif + +/************************************************************************* +Low-level function to read byte from LCD controller +Input:    rs     1: read data +                 0: read busy flag / address counter +Returns:  byte read from LCD controller +*************************************************************************/ +#if LCD_IO_MODE +static uint8_t lcd_read(uint8_t rs) { +    uint8_t data; + +    if (rs) +        lcd_rs_high(); /* RS=1: read data      */ +    else +        lcd_rs_low(); /* RS=0: read busy flag */ +    lcd_rw_high();    /* RW=1  read mode      */ + +    if ((&LCD_DATA0_PORT == &LCD_DATA1_PORT) && (&LCD_DATA1_PORT == &LCD_DATA2_PORT) && (&LCD_DATA2_PORT == &LCD_DATA3_PORT) && (LCD_DATA0_PIN == 0) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3)) { +        DDR(LCD_DATA0_PORT) &= 0xF0; /* configure data pins as input */ + +        lcd_e_high(); +        lcd_e_delay(); +        data = PIN(LCD_DATA0_PORT) << 4; /* read high nibble first */ +        lcd_e_low(); + +        lcd_e_delay(); /* Enable 500ns low       */ + +        lcd_e_high(); +        lcd_e_delay(); +        data |= PIN(LCD_DATA0_PORT) & 0x0F; /* read low nibble        */ +        lcd_e_low(); +    } else { +        /* configure data pins as input */ +        DDR(LCD_DATA0_PORT) &= ~_BV(LCD_DATA0_PIN); +        DDR(LCD_DATA1_PORT) &= ~_BV(LCD_DATA1_PIN); +        DDR(LCD_DATA2_PORT) &= ~_BV(LCD_DATA2_PIN); +        DDR(LCD_DATA3_PORT) &= ~_BV(LCD_DATA3_PIN); + +        /* read high nibble first */ +        lcd_e_high(); +        lcd_e_delay(); +        data = 0; +        if (PIN(LCD_DATA0_PORT) & _BV(LCD_DATA0_PIN)) data |= 0x10; +        if (PIN(LCD_DATA1_PORT) & _BV(LCD_DATA1_PIN)) data |= 0x20; +        if (PIN(LCD_DATA2_PORT) & _BV(LCD_DATA2_PIN)) data |= 0x40; +        if (PIN(LCD_DATA3_PORT) & _BV(LCD_DATA3_PIN)) data |= 0x80; +        lcd_e_low(); + +        lcd_e_delay(); /* Enable 500ns low       */ + +        /* read low nibble */ +        lcd_e_high(); +        lcd_e_delay(); +        if (PIN(LCD_DATA0_PORT) & _BV(LCD_DATA0_PIN)) data |= 0x01; +        if (PIN(LCD_DATA1_PORT) & _BV(LCD_DATA1_PIN)) data |= 0x02; +        if (PIN(LCD_DATA2_PORT) & _BV(LCD_DATA2_PIN)) data |= 0x04; +        if (PIN(LCD_DATA3_PORT) & _BV(LCD_DATA3_PIN)) data |= 0x08; +        lcd_e_low(); +    } +    return data; +} +#else +#    define lcd_read(rs) (rs) ? *(volatile uint8_t *)(LCD_IO_DATA + LCD_IO_READ) : *(volatile uint8_t *)(LCD_IO_FUNCTION + LCD_IO_READ) +/* rs==0 -> read instruction from LCD_IO_FUNCTION */ +/* rs==1 -> read data from LCD_IO_DATA */ +#endif + +/************************************************************************* +loops while lcd is busy, returns address counter +*************************************************************************/ +static uint8_t lcd_waitbusy(void) + +{ +    register uint8_t c; + +    /* wait until busy flag is cleared */ +    while ((c = lcd_read(0)) & (1 << LCD_BUSY)) { +    } + +    /* the address counter is updated 4us after the busy flag is cleared */ +    delay(LCD_DELAY_BUSY_FLAG); + +    /* now read the address counter */ +    return (lcd_read(0));  // return address counter + +} /* lcd_waitbusy */ + +/************************************************************************* +Move cursor to the start of next line or to the first line if the cursor +is already on the last line. +*************************************************************************/ +static inline void lcd_newline(uint8_t pos) { +    register uint8_t addressCounter; + +#if LCD_LINES == 1 +    addressCounter = 0; +#endif +#if LCD_LINES == 2 +    if (pos < (LCD_START_LINE2)) +        addressCounter = LCD_START_LINE2; +    else +        addressCounter = LCD_START_LINE1; +#endif +#if LCD_LINES == 4 +#    if KS0073_4LINES_MODE +    if (pos < LCD_START_LINE2) +        addressCounter = LCD_START_LINE2; +    else if ((pos >= LCD_START_LINE2) && (pos < LCD_START_LINE3)) +        addressCounter = LCD_START_LINE3; +    else if ((pos >= LCD_START_LINE3) && (pos < LCD_START_LINE4)) +        addressCounter = LCD_START_LINE4; +    else +        addressCounter = LCD_START_LINE1; +#    else +    if (pos < LCD_START_LINE3) +        addressCounter = LCD_START_LINE2; +    else if ((pos >= LCD_START_LINE2) && (pos < LCD_START_LINE4)) +        addressCounter = LCD_START_LINE3; +    else if ((pos >= LCD_START_LINE3) && (pos < LCD_START_LINE2)) +        addressCounter = LCD_START_LINE4; +    else +        addressCounter = LCD_START_LINE1; +#    endif +#endif +    lcd_command((1 << LCD_DDRAM) + addressCounter); + +} /* lcd_newline */ + +/* +** PUBLIC FUNCTIONS +*/ + +/************************************************************************* +Send LCD controller instruction command +Input:   instruction to send to LCD controller, see HD44780 data sheet +Returns: none +*************************************************************************/ +void lcd_command(uint8_t cmd) { +    lcd_waitbusy(); +    lcd_write(cmd, 0); +} + +/************************************************************************* +Send data byte to LCD controller +Input:   data to send to LCD controller, see HD44780 data sheet +Returns: none +*************************************************************************/ +void lcd_data(uint8_t data) { +    lcd_waitbusy(); +    lcd_write(data, 1); +} + +/************************************************************************* +Set cursor to specified position +Input:    x  horizontal position  (0: left most position) +          y  vertical position    (0: first line) +Returns:  none +*************************************************************************/ +void lcd_gotoxy(uint8_t x, uint8_t y) { +#if LCD_LINES == 1 +    lcd_command((1 << LCD_DDRAM) + LCD_START_LINE1 + x); +#endif +#if LCD_LINES == 2 +    if (y == 0) +        lcd_command((1 << LCD_DDRAM) + LCD_START_LINE1 + x); +    else +        lcd_command((1 << LCD_DDRAM) + LCD_START_LINE2 + x); +#endif +#if LCD_LINES == 4 +    if (y == 0) +        lcd_command((1 << LCD_DDRAM) + LCD_START_LINE1 + x); +    else if (y == 1) +        lcd_command((1 << LCD_DDRAM) + LCD_START_LINE2 + x); +    else if (y == 2) +        lcd_command((1 << LCD_DDRAM) + LCD_START_LINE3 + x); +    else /* y==3 */ +        lcd_command((1 << LCD_DDRAM) + LCD_START_LINE4 + x); +#endif + +} /* lcd_gotoxy */ + +/************************************************************************* +*************************************************************************/ +int lcd_getxy(void) { return lcd_waitbusy(); } + +/************************************************************************* +Clear display and set cursor to home position +*************************************************************************/ +void lcd_clrscr(void) { lcd_command(1 << LCD_CLR); } + +/************************************************************************* +Set cursor to home position +*************************************************************************/ +void lcd_home(void) { lcd_command(1 << LCD_HOME); } + +/************************************************************************* +Display character at current cursor position +Input:    character to be displayed +Returns:  none +*************************************************************************/ +void lcd_putc(char c) { +    uint8_t pos; + +    pos = lcd_waitbusy();  // read busy-flag and address counter +    if (c == '\n') { +        lcd_newline(pos); +    } else { +#if LCD_WRAP_LINES == 1 +#    if LCD_LINES == 1 +        if (pos == LCD_START_LINE1 + LCD_DISP_LENGTH) { +            lcd_write((1 << LCD_DDRAM) + LCD_START_LINE1, 0); +        } +#    elif LCD_LINES == 2 +        if (pos == LCD_START_LINE1 + LCD_DISP_LENGTH) { +            lcd_write((1 << LCD_DDRAM) + LCD_START_LINE2, 0); +        } else if (pos == LCD_START_LINE2 + LCD_DISP_LENGTH) { +            lcd_write((1 << LCD_DDRAM) + LCD_START_LINE1, 0); +        } +#    elif LCD_LINES == 4 +        if (pos == LCD_START_LINE1 + LCD_DISP_LENGTH) { +            lcd_write((1 << LCD_DDRAM) + LCD_START_LINE2, 0); +        } else if (pos == LCD_START_LINE2 + LCD_DISP_LENGTH) { +            lcd_write((1 << LCD_DDRAM) + LCD_START_LINE3, 0); +        } else if (pos == LCD_START_LINE3 + LCD_DISP_LENGTH) { +            lcd_write((1 << LCD_DDRAM) + LCD_START_LINE4, 0); +        } else if (pos == LCD_START_LINE4 + LCD_DISP_LENGTH) { +            lcd_write((1 << LCD_DDRAM) + LCD_START_LINE1, 0); +        } +#    endif +        lcd_waitbusy(); +#endif +        lcd_write(c, 1); +    } + +} /* lcd_putc */ + +/************************************************************************* +Display string without auto linefeed +Input:    string to be displayed +Returns:  none +*************************************************************************/ +void lcd_puts(const char *s) +/* print string on lcd (no auto linefeed) */ +{ +    register char c; + +    while ((c = *s++)) { +        lcd_putc(c); +    } + +} /* lcd_puts */ + +/************************************************************************* +Display string from program memory without auto linefeed +Input:     string from program memory be be displayed +Returns:   none +*************************************************************************/ +void lcd_puts_p(const char *progmem_s) +/* print string from program memory on lcd (no auto linefeed) */ +{ +    register char c; + +    while ((c = pgm_read_byte(progmem_s++))) { +        lcd_putc(c); +    } + +} /* lcd_puts_p */ + +/************************************************************************* +Initialize display and select type of cursor +Input:    dispAttr LCD_DISP_OFF            display off +                   LCD_DISP_ON             display on, cursor off +                   LCD_DISP_ON_CURSOR      display on, cursor on +                   LCD_DISP_CURSOR_BLINK   display on, cursor on flashing +Returns:  none +*************************************************************************/ +void lcd_init(uint8_t dispAttr) { +#if LCD_IO_MODE +    /* +     *  Initialize LCD to 4 bit I/O mode +     */ + +    if ((&LCD_DATA0_PORT == &LCD_DATA1_PORT) && (&LCD_DATA1_PORT == &LCD_DATA2_PORT) && (&LCD_DATA2_PORT == &LCD_DATA3_PORT) && (&LCD_RS_PORT == &LCD_DATA0_PORT) && (&LCD_RW_PORT == &LCD_DATA0_PORT) && (&LCD_E_PORT == &LCD_DATA0_PORT) && (LCD_DATA0_PIN == 0) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3) && (LCD_RS_PIN == 4) && (LCD_RW_PIN == 5) && (LCD_E_PIN == 6)) { +        /* configure all port bits as output (all LCD lines on same port) */ +        DDR(LCD_DATA0_PORT) |= 0x7F; +    } else if ((&LCD_DATA0_PORT == &LCD_DATA1_PORT) && (&LCD_DATA1_PORT == &LCD_DATA2_PORT) && (&LCD_DATA2_PORT == &LCD_DATA3_PORT) && (LCD_DATA0_PIN == 0) && (LCD_DATA1_PIN == 1) && (LCD_DATA2_PIN == 2) && (LCD_DATA3_PIN == 3)) { +        /* configure all port bits as output (all LCD data lines on same port, but control lines on different ports) */ +        DDR(LCD_DATA0_PORT) |= 0x0F; +        DDR(LCD_RS_PORT) |= _BV(LCD_RS_PIN); +        DDR(LCD_RW_PORT) |= _BV(LCD_RW_PIN); +        DDR(LCD_E_PORT) |= _BV(LCD_E_PIN); +    } else { +        /* configure all port bits as output (LCD data and control lines on different ports */ +        DDR(LCD_RS_PORT) |= _BV(LCD_RS_PIN); +        DDR(LCD_RW_PORT) |= _BV(LCD_RW_PIN); +        DDR(LCD_E_PORT) |= _BV(LCD_E_PIN); +        DDR(LCD_DATA0_PORT) |= _BV(LCD_DATA0_PIN); +        DDR(LCD_DATA1_PORT) |= _BV(LCD_DATA1_PIN); +        DDR(LCD_DATA2_PORT) |= _BV(LCD_DATA2_PIN); +        DDR(LCD_DATA3_PORT) |= _BV(LCD_DATA3_PIN); +    } +    delay(LCD_DELAY_BOOTUP); /* wait 16ms or more after power-on       */ + +    /* initial write to lcd is 8bit */ +    LCD_DATA1_PORT |= _BV(LCD_DATA1_PIN);  // LCD_FUNCTION>>4; +    LCD_DATA0_PORT |= _BV(LCD_DATA0_PIN);  // LCD_FUNCTION_8BIT>>4; +    lcd_e_toggle(); +    delay(LCD_DELAY_INIT); /* delay, busy flag can't be checked here */ + +    /* repeat last command */ +    lcd_e_toggle(); +    delay(LCD_DELAY_INIT_REP); /* delay, busy flag can't be checked here */ + +    /* repeat last command a third time */ +    lcd_e_toggle(); +    delay(LCD_DELAY_INIT_REP); /* delay, busy flag can't be checked here */ + +    /* now configure for 4bit mode */ +    LCD_DATA0_PORT &= ~_BV(LCD_DATA0_PIN);  // LCD_FUNCTION_4BIT_1LINE>>4 +    lcd_e_toggle(); +    delay(LCD_DELAY_INIT_4BIT); /* some displays need this additional delay */ + +    /* from now the LCD only accepts 4 bit I/O, we can use lcd_command() */ +#else +    /* +     * Initialize LCD to 8 bit memory mapped mode +     */ + +    /* enable external SRAM (memory mapped lcd) and one wait state */ +    MCUCR = _BV(SRE) | _BV(SRW); + +    /* reset LCD */ +    delay(LCD_DELAY_BOOTUP);               /* wait 16ms after power-on     */ +    lcd_write(LCD_FUNCTION_8BIT_1LINE, 0); /* function set: 8bit interface */ +    delay(LCD_DELAY_INIT);                 /* wait 5ms                     */ +    lcd_write(LCD_FUNCTION_8BIT_1LINE, 0); /* function set: 8bit interface */ +    delay(LCD_DELAY_INIT_REP);             /* wait 64us                    */ +    lcd_write(LCD_FUNCTION_8BIT_1LINE, 0); /* function set: 8bit interface */ +    delay(LCD_DELAY_INIT_REP);             /* wait 64us                    */ +#endif + +#if KS0073_4LINES_MODE +    /* Display with KS0073 controller requires special commands for enabling 4 line mode */ +    lcd_command(KS0073_EXTENDED_FUNCTION_REGISTER_ON); +    lcd_command(KS0073_4LINES_MODE); +    lcd_command(KS0073_EXTENDED_FUNCTION_REGISTER_OFF); +#else +    lcd_command(LCD_FUNCTION_DEFAULT);     /* function set: display lines  */ +#endif +    lcd_command(LCD_DISP_OFF);     /* display off                  */ +    lcd_clrscr();                  /* display clear                */ +    lcd_command(LCD_MODE_DEFAULT); /* set entry mode               */ +    lcd_command(dispAttr);         /* display/cursor control       */ + +} /* lcd_init */ diff --git a/platforms/avr/drivers/hd44780.h b/platforms/avr/drivers/hd44780.h new file mode 100644 index 0000000000..08e60f8a44 --- /dev/null +++ b/platforms/avr/drivers/hd44780.h @@ -0,0 +1,348 @@ +/************************************************************************* + Title	:   C include file for the HD44780U LCD library (lcd.c) + Author:    Peter Fleury <[email protected]>  http://tinyurl.com/peterfleury + License:   GNU General Public License Version 3 + File:	    $Id: lcd.h,v 1.14.2.4 2015/01/20 17:16:07 peter Exp $ + Software:  AVR-GCC 4.x + Hardware:  any AVR device, memory mapped mode only for AVR with +            memory mapped interface (AT90S8515/ATmega8515/ATmega128) +***************************************************************************/ + +/** + @mainpage + Collection of libraries for AVR-GCC + @author Peter Fleury [email protected] http://tinyurl.com/peterfleury + @copyright (C) 2015 Peter Fleury, GNU General Public License Version 3 + + @file + @defgroup pfleury_lcd LCD library <lcd.h> + @code #include <lcd.h> @endcode + + @brief Basic routines for interfacing a HD44780U-based character LCD display + + LCD character displays can be found in many devices, like espresso machines, laser printers. + The Hitachi HD44780 controller and its compatible controllers like Samsung KS0066U have become an industry standard for these types of displays. + + This library allows easy interfacing with a HD44780 compatible display and can be + operated in memory mapped mode (LCD_IO_MODE defined as 0 in the include file lcd.h.) or in + 4-bit IO port mode (LCD_IO_MODE defined as 1). 8-bit IO port mode is not supported. + + Memory mapped mode is compatible with old Kanda STK200 starter kit, but also supports + generation of R/W signal through A8 address line. + + @see The chapter <a href=" http://homepage.hispeed.ch/peterfleury/avr-lcd44780.html" target="_blank">Interfacing a HD44780 Based LCD to an AVR</a> +      on my home page, which shows example circuits how to connect an LCD to an AVR controller. + + @author Peter Fleury [email protected] http://tinyurl.com/peterfleury + + @version   2.0 + + @copyright (C) 2015 Peter Fleury, GNU General Public License Version 3 + +*/ + +#pragma once + +#include <inttypes.h> +#include <avr/pgmspace.h> + +#if (__GNUC__ * 100 + __GNUC_MINOR__) < 405 +#    error "This library requires AVR-GCC 4.5 or later, update to newer AVR-GCC compiler !" +#endif + +/**@{*/ + +/* + * LCD and target specific definitions below can be defined in a separate include file with name lcd_definitions.h instead modifying this file + * by adding -D_LCD_DEFINITIONS_FILE to the CDEFS section in the Makefile + * All definitions added to the file lcd_definitions.h will override the default definitions from lcd.h + */ +#ifdef _LCD_DEFINITIONS_FILE +#    include "lcd_definitions.h" +#endif + +/** + * @name  Definition for LCD controller type + * Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller. + */ +#ifndef LCD_CONTROLLER_KS0073 +#    define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */ +#endif + +/** + * @name  Definitions for Display Size + * Change these definitions to adapt setting to your display + * + * These definitions can be defined in a separate include file \b lcd_definitions.h instead modifying this file by + * adding -D_LCD_DEFINITIONS_FILE to the CDEFS section in the Makefile. + * All definitions added to the file lcd_definitions.h will override the default definitions from lcd.h + * + */ +#ifndef LCD_LINES +#    define LCD_LINES 2 /**< number of visible lines of the display */ +#endif +#ifndef LCD_DISP_LENGTH +#    define LCD_DISP_LENGTH 16 /**< visibles characters per line of the display */ +#endif +#ifndef LCD_LINE_LENGTH +#    define LCD_LINE_LENGTH 0x40 /**< internal line length of the display    */ +#endif +#ifndef LCD_START_LINE1 +#    define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */ +#endif +#ifndef LCD_START_LINE2 +#    define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */ +#endif +#ifndef LCD_START_LINE3 +#    define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */ +#endif +#ifndef LCD_START_LINE4 +#    define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */ +#endif +#ifndef LCD_WRAP_LINES +#    define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */ +#endif + +/** + * @name Definitions for 4-bit IO mode + * + * The four LCD data lines and the three control lines RS, RW, E can be on the + * same port or on different ports. + * Change LCD_RS_PORT, LCD_RW_PORT, LCD_E_PORT if you want the control lines on + * different ports. + * + * Normally the four data lines should be mapped to bit 0..3 on one port, but it + * is possible to connect these data lines in different order or even on different + * ports by adapting the LCD_DATAx_PORT and LCD_DATAx_PIN definitions. + * + * Adjust these definitions to your target.\n + * These definitions can be defined in a separate include file \b lcd_definitions.h instead modifying this file by + * adding \b -D_LCD_DEFINITIONS_FILE to the \b CDEFS section in the Makefile. + * All definitions added to the file lcd_definitions.h will override the default definitions from lcd.h + * + */ +#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */ + +#if LCD_IO_MODE + +#    ifndef LCD_PORT +#        define LCD_PORT PORTA /**< port for the LCD lines   */ +#    endif +#    ifndef LCD_DATA0_PORT +#        define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */ +#    endif +#    ifndef LCD_DATA1_PORT +#        define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */ +#    endif +#    ifndef LCD_DATA2_PORT +#        define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */ +#    endif +#    ifndef LCD_DATA3_PORT +#        define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */ +#    endif +#    ifndef LCD_DATA0_PIN +#        define LCD_DATA0_PIN 4 /**< pin for 4bit data bit 0  */ +#    endif +#    ifndef LCD_DATA1_PIN +#        define LCD_DATA1_PIN 5 /**< pin for 4bit data bit 1  */ +#    endif +#    ifndef LCD_DATA2_PIN +#        define LCD_DATA2_PIN 6 /**< pin for 4bit data bit 2  */ +#    endif +#    ifndef LCD_DATA3_PIN +#        define LCD_DATA3_PIN 7 /**< pin for 4bit data bit 3  */ +#    endif +#    ifndef LCD_RS_PORT +#        define LCD_RS_PORT LCD_PORT /**< port for RS line         */ +#    endif +#    ifndef LCD_RS_PIN +#        define LCD_RS_PIN 3 /**< pin  for RS line         */ +#    endif +#    ifndef LCD_RW_PORT +#        define LCD_RW_PORT LCD_PORT /**< port for RW line         */ +#    endif +#    ifndef LCD_RW_PIN +#        define LCD_RW_PIN 2 /**< pin  for RW line         */ +#    endif +#    ifndef LCD_E_PORT +#        define LCD_E_PORT LCD_PORT /**< port for Enable line     */ +#    endif +#    ifndef LCD_E_PIN +#        define LCD_E_PIN 1 /**< pin  for Enable line     */ +#    endif + +#elif defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || defined(__AVR_ATmega64__) || defined(__AVR_ATmega8515__) || defined(__AVR_ATmega103__) || defined(__AVR_ATmega128__) || defined(__AVR_ATmega161__) || defined(__AVR_ATmega162__) +/* + * memory mapped mode is only supported when the device has an external data memory interface + */ +#    define LCD_IO_DATA 0xC000     /* A15=E=1, A14=RS=1                 */ +#    define LCD_IO_FUNCTION 0x8000 /* A15=E=1, A14=RS=0                 */ +#    define LCD_IO_READ 0x0100     /* A8 =R/W=1 (R/W: 1=Read, 0=Write   */ + +#else +#    error "external data memory interface not available for this device, use 4-bit IO port mode" + +#endif + +/** + * @name Definitions of delays + * Used to calculate delay timers. + * Adapt the F_CPU define in the Makefile to the clock frequency in Hz of your target + * + * These delay times can be adjusted, if some displays require different delays.\n + * These definitions can be defined in a separate include file \b lcd_definitions.h instead modifying this file by + * adding \b -D_LCD_DEFINITIONS_FILE to the \b CDEFS section in the Makefile. + * All definitions added to the file lcd_definitions.h will override the default definitions from lcd.h + */ +#ifndef LCD_DELAY_BOOTUP +#    define LCD_DELAY_BOOTUP 16000 /**< delay in micro seconds after power-on  */ +#endif +#ifndef LCD_DELAY_INIT +#    define LCD_DELAY_INIT 5000 /**< delay in micro seconds after initialization command sent  */ +#endif +#ifndef LCD_DELAY_INIT_REP +#    define LCD_DELAY_INIT_REP 64 /**< delay in micro seconds after initialization command repeated */ +#endif +#ifndef LCD_DELAY_INIT_4BIT +#    define LCD_DELAY_INIT_4BIT 64 /**< delay in micro seconds after setting 4-bit mode */ +#endif +#ifndef LCD_DELAY_BUSY_FLAG +#    define LCD_DELAY_BUSY_FLAG 4 /**< time in micro seconds the address counter is updated after busy flag is cleared */ +#endif +#ifndef LCD_DELAY_ENABLE_PULSE +#    define LCD_DELAY_ENABLE_PULSE 1 /**< enable signal pulse width in micro seconds */ +#endif + +/** + * @name Definitions for LCD command instructions + * The constants define the various LCD controller instructions which can be passed to the + * function lcd_command(), see HD44780 data sheet for a complete description. + */ + +/* instruction register bit positions, see HD44780U data sheet */ +#define LCD_CLR 0             /* DB0: clear display                  */ +#define LCD_HOME 1            /* DB1: return to home position        */ +#define LCD_ENTRY_MODE 2      /* DB2: set entry mode                 */ +#define LCD_ENTRY_INC 1       /*   DB1: 1=increment, 0=decrement     */ +#define LCD_ENTRY_SHIFT 0     /*   DB2: 1=display shift on           */ +#define LCD_ON 3              /* DB3: turn lcd/cursor on             */ +#define LCD_ON_DISPLAY 2      /*   DB2: turn display on              */ +#define LCD_ON_CURSOR 1       /*   DB1: turn cursor on               */ +#define LCD_ON_BLINK 0        /*     DB0: blinking cursor ?          */ +#define LCD_MOVE 4            /* DB4: move cursor/display            */ +#define LCD_MOVE_DISP 3       /*   DB3: move display (0-> cursor) ?  */ +#define LCD_MOVE_RIGHT 2      /*   DB2: move right (0-> left) ?      */ +#define LCD_FUNCTION 5        /* DB5: function set                   */ +#define LCD_FUNCTION_8BIT 4   /*   DB4: set 8BIT mode (0->4BIT mode) */ +#define LCD_FUNCTION_2LINES 3 /*   DB3: two lines (0->one line)      */ +#define LCD_FUNCTION_10DOTS 2 /*   DB2: 5x10 font (0->5x7 font)      */ +#define LCD_CGRAM 6           /* DB6: set CG RAM address             */ +#define LCD_DDRAM 7           /* DB7: set DD RAM address             */ +#define LCD_BUSY 7            /* DB7: LCD is busy                    */ + +/* set entry mode: display shift on/off, dec/inc cursor move direction */ +#define LCD_ENTRY_DEC 0x04       /* display shift off, dec cursor move dir */ +#define LCD_ENTRY_DEC_SHIFT 0x05 /* display shift on,  dec cursor move dir */ +#define LCD_ENTRY_INC_ 0x06      /* display shift off, inc cursor move dir */ +#define LCD_ENTRY_INC_SHIFT 0x07 /* display shift on,  inc cursor move dir */ + +/* display on/off, cursor on/off, blinking char at cursor position */ +#define LCD_DISP_OFF 0x08             /* display off                            */ +#define LCD_DISP_ON 0x0C              /* display on, cursor off                 */ +#define LCD_DISP_ON_BLINK 0x0D        /* display on, cursor off, blink char     */ +#define LCD_DISP_ON_CURSOR 0x0E       /* display on, cursor on                  */ +#define LCD_DISP_ON_CURSOR_BLINK 0x0F /* display on, cursor on, blink char      */ + +/* move cursor/shift display */ +#define LCD_MOVE_CURSOR_LEFT 0x10  /* move cursor left  (decrement)          */ +#define LCD_MOVE_CURSOR_RIGHT 0x14 /* move cursor right (increment)          */ +#define LCD_MOVE_DISP_LEFT 0x18    /* shift display left                     */ +#define LCD_MOVE_DISP_RIGHT 0x1C   /* shift display right                    */ + +/* function set: set interface data length and number of display lines */ +#define LCD_FUNCTION_4BIT_1LINE 0x20  /* 4-bit interface, single line, 5x7 dots */ +#define LCD_FUNCTION_4BIT_2LINES 0x28 /* 4-bit interface, dual line,   5x7 dots */ +#define LCD_FUNCTION_8BIT_1LINE 0x30  /* 8-bit interface, single line, 5x7 dots */ +#define LCD_FUNCTION_8BIT_2LINES 0x38 /* 8-bit interface, dual line,   5x7 dots */ + +#define LCD_MODE_DEFAULT ((1 << LCD_ENTRY_MODE) | (1 << LCD_ENTRY_INC)) + +/** + *  @name Functions + */ + +/** + @brief    Initialize display and select type of cursor + @param    dispAttr \b LCD_DISP_OFF display off\n +                    \b LCD_DISP_ON display on, cursor off\n +                    \b LCD_DISP_ON_CURSOR display on, cursor on\n +                    \b LCD_DISP_ON_CURSOR_BLINK display on, cursor on flashing + @return  none +*/ +extern void lcd_init(uint8_t dispAttr); + +/** + @brief    Clear display and set cursor to home position + @return   none +*/ +extern void lcd_clrscr(void); + +/** + @brief    Set cursor to home position + @return   none +*/ +extern void lcd_home(void); + +/** + @brief    Set cursor to specified position + + @param    x horizontal position\n (0: left most position) + @param    y vertical position\n   (0: first line) + @return   none +*/ +extern void lcd_gotoxy(uint8_t x, uint8_t y); + +/** + @brief    Display character at current cursor position + @param    c character to be displayed + @return   none +*/ +extern void lcd_putc(char c); + +/** + @brief    Display string without auto linefeed + @param    s string to be displayed + @return   none +*/ +extern void lcd_puts(const char *s); + +/** + @brief    Display string from program memory without auto linefeed + @param    progmem_s string from program memory be be displayed + @return   none + @see      lcd_puts_P +*/ +extern void lcd_puts_p(const char *progmem_s); + +/** + @brief    Send LCD controller instruction command + @param    cmd instruction to send to LCD controller, see HD44780 data sheet + @return   none +*/ +extern void lcd_command(uint8_t cmd); + +/** + @brief    Send data byte to LCD controller + + Similar to lcd_putc(), but without interpreting LF + @param    data byte to send to LCD controller, see HD44780 data sheet + @return   none +*/ +extern void lcd_data(uint8_t data); + +/** + @brief macros for automatically storing string constant in program memory +*/ +#define lcd_puts_P(__s) lcd_puts_p(PSTR(__s)) + +/**@}*/ diff --git a/platforms/avr/drivers/i2c_master.c b/platforms/avr/drivers/i2c_master.c new file mode 100644 index 0000000000..2773e00778 --- /dev/null +++ b/platforms/avr/drivers/i2c_master.c @@ -0,0 +1,241 @@ +/*  Copyright (C) 2019 Elia Ritterbusch + + + *  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 3 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 <https://www.gnu.org/licenses/>. + */ +/* Library made by: g4lvanix + * GitHub repository: https://github.com/g4lvanix/I2C-master-lib + */ + +#include <avr/io.h> +#include <util/twi.h> + +#include "i2c_master.h" +#include "timer.h" +#include "wait.h" + +#ifndef F_SCL +#    define F_SCL 400000UL  // SCL frequency +#endif + +#ifndef I2C_START_RETRY_COUNT +#    define I2C_START_RETRY_COUNT 20 +#endif  // I2C_START_RETRY_COUNT + +#define TWBR_val (((F_CPU / F_SCL) - 16) / 2) + +#define MAX(X, Y) ((X) > (Y) ? (X) : (Y)) + +void i2c_init(void) { +    TWSR = 0; /* no prescaler */ +    TWBR = (uint8_t)TWBR_val; + +#ifdef __AVR_ATmega32A__ +    // set pull-up resistors on I2C bus pins +    PORTC |= 0b11; + +    // enable TWI (two-wire interface) +    TWCR |= (1 << TWEN); + +    // enable TWI interrupt and slave address ACK +    TWCR |= (1 << TWIE); +    TWCR |= (1 << TWEA); +#endif +} + +static i2c_status_t i2c_start_impl(uint8_t address, uint16_t timeout) { +    // reset TWI control register +    TWCR = 0; +    // transmit START condition +    TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN); + +    uint16_t timeout_timer = timer_read(); +    while (!(TWCR & (1 << TWINT))) { +        if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { +            return I2C_STATUS_TIMEOUT; +        } +    } + +    // check if the start condition was successfully transmitted +    if (((TW_STATUS & 0xF8) != TW_START) && ((TW_STATUS & 0xF8) != TW_REP_START)) { +        return I2C_STATUS_ERROR; +    } + +    // load slave address into data register +    TWDR = address; +    // start transmission of address +    TWCR = (1 << TWINT) | (1 << TWEN); + +    timeout_timer = timer_read(); +    while (!(TWCR & (1 << TWINT))) { +        if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { +            return I2C_STATUS_TIMEOUT; +        } +    } + +    // check if the device has acknowledged the READ / WRITE mode +    uint8_t twst = TW_STATUS & 0xF8; +    if ((twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK)) { +        return I2C_STATUS_ERROR; +    } + +    return I2C_STATUS_SUCCESS; +} + +i2c_status_t i2c_start(uint8_t address, uint16_t timeout) { +    // Retry i2c_start_impl a bunch times in case the remote side has interrupts disabled. +    uint16_t     timeout_timer = timer_read(); +    uint16_t     time_slice    = MAX(1, (timeout == (I2C_TIMEOUT_INFINITE)) ? 5 : (timeout / (I2C_START_RETRY_COUNT)));  // if it's infinite, wait 1ms between attempts, otherwise split up the entire timeout into the number of retries +    i2c_status_t status; +    do { +        status = i2c_start_impl(address, time_slice); +    } while ((status < 0) && ((timeout == I2C_TIMEOUT_INFINITE) || (timer_elapsed(timeout_timer) < timeout))); +    return status; +} + +i2c_status_t i2c_write(uint8_t data, uint16_t timeout) { +    // load data into data register +    TWDR = data; +    // start transmission of data +    TWCR = (1 << TWINT) | (1 << TWEN); + +    uint16_t timeout_timer = timer_read(); +    while (!(TWCR & (1 << TWINT))) { +        if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { +            return I2C_STATUS_TIMEOUT; +        } +    } + +    if ((TW_STATUS & 0xF8) != TW_MT_DATA_ACK) { +        return I2C_STATUS_ERROR; +    } + +    return I2C_STATUS_SUCCESS; +} + +int16_t i2c_read_ack(uint16_t timeout) { +    // start TWI module and acknowledge data after reception +    TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA); + +    uint16_t timeout_timer = timer_read(); +    while (!(TWCR & (1 << TWINT))) { +        if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { +            return I2C_STATUS_TIMEOUT; +        } +    } + +    // return received data from TWDR +    return TWDR; +} + +int16_t i2c_read_nack(uint16_t timeout) { +    // start receiving without acknowledging reception +    TWCR = (1 << TWINT) | (1 << TWEN); + +    uint16_t timeout_timer = timer_read(); +    while (!(TWCR & (1 << TWINT))) { +        if ((timeout != I2C_TIMEOUT_INFINITE) && ((timer_read() - timeout_timer) >= timeout)) { +            return I2C_STATUS_TIMEOUT; +        } +    } + +    // return received data from TWDR +    return TWDR; +} + +i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout) { +    i2c_status_t status = i2c_start(address | I2C_WRITE, timeout); + +    for (uint16_t i = 0; i < length && status >= 0; i++) { +        status = i2c_write(data[i], timeout); +    } + +    i2c_stop(); + +    return status; +} + +i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout) { +    i2c_status_t status = i2c_start(address | I2C_READ, timeout); + +    for (uint16_t i = 0; i < (length - 1) && status >= 0; i++) { +        status = i2c_read_ack(timeout); +        if (status >= 0) { +            data[i] = status; +        } +    } + +    if (status >= 0) { +        status = i2c_read_nack(timeout); +        if (status >= 0) { +            data[(length - 1)] = status; +        } +    } + +    i2c_stop(); + +    return (status < 0) ? status : I2C_STATUS_SUCCESS; +} + +i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout) { +    i2c_status_t status = i2c_start(devaddr | 0x00, timeout); +    if (status >= 0) { +        status = i2c_write(regaddr, timeout); + +        for (uint16_t i = 0; i < length && status >= 0; i++) { +            status = i2c_write(data[i], timeout); +        } +    } + +    i2c_stop(); + +    return status; +} + +i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout) { +    i2c_status_t status = i2c_start(devaddr, timeout); +    if (status < 0) { +        goto error; +    } + +    status = i2c_write(regaddr, timeout); +    if (status < 0) { +        goto error; +    } + +    status = i2c_start(devaddr | 0x01, timeout); + +    for (uint16_t i = 0; i < (length - 1) && status >= 0; i++) { +        status = i2c_read_ack(timeout); +        if (status >= 0) { +            data[i] = status; +        } +    } + +    if (status >= 0) { +        status = i2c_read_nack(timeout); +        if (status >= 0) { +            data[(length - 1)] = status; +        } +    } + +error: +    i2c_stop(); + +    return (status < 0) ? status : I2C_STATUS_SUCCESS; +} + +void i2c_stop(void) { +    // transmit STOP condition +    TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO); +} diff --git a/platforms/avr/drivers/i2c_master.h b/platforms/avr/drivers/i2c_master.h new file mode 100644 index 0000000000..e5af73364b --- /dev/null +++ b/platforms/avr/drivers/i2c_master.h @@ -0,0 +1,43 @@ +/*  Copyright (C) 2019 Elia Ritterbusch + + + *  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 3 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 <https://www.gnu.org/licenses/>. + */ +/* Library made by: g4lvanix + * GitHub repository: https://github.com/g4lvanix/I2C-master-lib + */ + +#pragma once + +#define I2C_READ 0x01 +#define I2C_WRITE 0x00 + +typedef int16_t i2c_status_t; + +#define I2C_STATUS_SUCCESS (0) +#define I2C_STATUS_ERROR (-1) +#define I2C_STATUS_TIMEOUT (-2) + +#define I2C_TIMEOUT_IMMEDIATE (0) +#define I2C_TIMEOUT_INFINITE (0xFFFF) + +void         i2c_init(void); +i2c_status_t i2c_start(uint8_t address, uint16_t timeout); +i2c_status_t i2c_write(uint8_t data, uint16_t timeout); +int16_t      i2c_read_ack(uint16_t timeout); +int16_t      i2c_read_nack(uint16_t timeout); +i2c_status_t i2c_transmit(uint8_t address, const uint8_t* data, uint16_t length, uint16_t timeout); +i2c_status_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout); +i2c_status_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, const uint8_t* data, uint16_t length, uint16_t timeout); +i2c_status_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout); +void         i2c_stop(void); diff --git a/platforms/avr/drivers/i2c_slave.c b/platforms/avr/drivers/i2c_slave.c new file mode 100644 index 0000000000..2907f164c0 --- /dev/null +++ b/platforms/avr/drivers/i2c_slave.c @@ -0,0 +1,111 @@ +/*  Copyright (C) 2019 Elia Ritterbusch + + + *  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 3 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 <https://www.gnu.org/licenses/>. + */ +/* Library made by: g4lvanix + * GitHub repository: https://github.com/g4lvanix/I2C-slave-lib + */ + +#include <stddef.h> +#include <avr/io.h> +#include <util/twi.h> +#include <avr/interrupt.h> +#include <stdbool.h> + +#include "i2c_slave.h" + +#if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +#    include "transactions.h" + +static volatile bool is_callback_executor = false; +#endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) + +volatile uint8_t i2c_slave_reg[I2C_SLAVE_REG_COUNT]; + +static volatile uint8_t buffer_address; +static volatile bool    slave_has_register_set = false; + +void i2c_slave_init(uint8_t address) { +    // load address into TWI address register +    TWAR = address; +    // set the TWCR to enable address matching and enable TWI, clear TWINT, enable TWI interrupt +    TWCR = (1 << TWIE) | (1 << TWEA) | (1 << TWINT) | (1 << TWEN); +} + +void i2c_slave_stop(void) { +    // clear acknowledge and enable bits +    TWCR &= ~((1 << TWEA) | (1 << TWEN)); +} + +ISR(TWI_vect) { +    uint8_t ack = 1; + +    switch (TW_STATUS) { +        case TW_SR_SLA_ACK: +            // The device is now a slave receiver +            slave_has_register_set = false; +#if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +            is_callback_executor = false; +#endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +            break; + +        case TW_SR_DATA_ACK: +            // This device is a slave receiver and has received data +            // First byte is the location then the bytes will be writen in buffer with auto-increment +            if (!slave_has_register_set) { +                buffer_address = TWDR; + +                if (buffer_address >= I2C_SLAVE_REG_COUNT) {  // address out of bounds dont ack +                    ack            = 0; +                    buffer_address = 0; +                } +                slave_has_register_set = true;  // address has been received now fill in buffer + +#if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +                // Work out if we're attempting to execute a callback +                is_callback_executor = buffer_address == split_transaction_table[I2C_EXECUTE_CALLBACK].initiator2target_offset; +#endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +            } else { +                i2c_slave_reg[buffer_address] = TWDR; +                buffer_address++; + +#if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +                // If we're intending to execute a transaction callback, do so, as we've just received the transaction ID +                if (is_callback_executor) { +                    split_transaction_desc_t *trans = &split_transaction_table[split_shmem->transaction_id]; +                    if (trans->slave_callback) { +                        trans->slave_callback(trans->initiator2target_buffer_size, split_trans_initiator2target_buffer(trans), trans->target2initiator_buffer_size, split_trans_target2initiator_buffer(trans)); +                    } +                } +#endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +            } +            break; + +        case TW_ST_SLA_ACK: +        case TW_ST_DATA_ACK: +            // This device is a slave transmitter and master has requested data +            TWDR = i2c_slave_reg[buffer_address]; +            buffer_address++; +            break; + +        case TW_BUS_ERROR: +            // We got an error, reset i2c +            TWCR = 0; +        default: +            break; +    } + +    // Reset i2c state machine to be ready for next interrupt +    TWCR |= (1 << TWIE) | (1 << TWINT) | (ack << TWEA) | (1 << TWEN); +} diff --git a/platforms/avr/drivers/i2c_slave.h b/platforms/avr/drivers/i2c_slave.h new file mode 100644 index 0000000000..a8647c9da3 --- /dev/null +++ b/platforms/avr/drivers/i2c_slave.h @@ -0,0 +1,41 @@ +/*  Copyright (C) 2019 Elia Ritterbusch + + + *  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 3 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 <https://www.gnu.org/licenses/>. + */ +/* Library made by: g4lvanix + * GitHub repository: https://github.com/g4lvanix/I2C-slave-lib + + Info: Inititate the library by giving the required address. +       Read or write to the necessary buffer according to the opperation. + */ + +#pragma once + +#ifndef I2C_SLAVE_REG_COUNT + +#    if defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +#        include "transport.h" +#        define I2C_SLAVE_REG_COUNT sizeof(split_shared_memory_t) +#    else  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) +#        define I2C_SLAVE_REG_COUNT 30 +#    endif  // defined(USE_I2C) && defined(SPLIT_COMMON_TRANSACTIONS) + +#endif  // I2C_SLAVE_REG_COUNT + +_Static_assert(I2C_SLAVE_REG_COUNT < 256, "I2C target registers must be single byte"); + +extern volatile uint8_t i2c_slave_reg[I2C_SLAVE_REG_COUNT]; + +void i2c_slave_init(uint8_t address); +void i2c_slave_stop(void); diff --git a/platforms/avr/drivers/serial.c b/platforms/avr/drivers/serial.c new file mode 100644 index 0000000000..9a7345a53d --- /dev/null +++ b/platforms/avr/drivers/serial.c @@ -0,0 +1,529 @@ +/* + * WARNING: be careful changing this code, it is very timing dependent + * + * 2018-10-28 checked + *  avr-gcc 4.9.2 + *  avr-gcc 5.4.0 + *  avr-gcc 7.3.0 + */ + +#ifndef F_CPU +#    define F_CPU 16000000 +#endif + +#include <avr/io.h> +#include <avr/interrupt.h> +#include <util/delay.h> +#include <stddef.h> +#include <stdbool.h> +#include "serial.h" + +#ifdef SOFT_SERIAL_PIN + +#    if !(defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) || defined(__AVR_AT90USB162__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__)) +#        error serial.c is not supported for the currently selected MCU +#    endif +// if using ATmega32U4/2, AT90USBxxx I2C, can not use PD0 and PD1 in soft serial. +#    if defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) +#        if defined(USE_AVR_I2C) && (SOFT_SERIAL_PIN == D0 || SOFT_SERIAL_PIN == D1) +#            error Using I2C, so can not use PD0, PD1 +#        endif +#    endif +// PD0..PD3, common config +#    if SOFT_SERIAL_PIN == D0 +#        define EIMSK_BIT _BV(INT0) +#        define EICRx_BIT (~(_BV(ISC00) | _BV(ISC01))) +#        define SERIAL_PIN_INTERRUPT INT0_vect +#        define EICRx EICRA +#    elif SOFT_SERIAL_PIN == D1 +#        define EIMSK_BIT _BV(INT1) +#        define EICRx_BIT (~(_BV(ISC10) | _BV(ISC11))) +#        define SERIAL_PIN_INTERRUPT INT1_vect +#        define EICRx EICRA +#    elif SOFT_SERIAL_PIN == D2 +#        define EIMSK_BIT _BV(INT2) +#        define EICRx_BIT (~(_BV(ISC20) | _BV(ISC21))) +#        define SERIAL_PIN_INTERRUPT INT2_vect +#        define EICRx EICRA +#    elif SOFT_SERIAL_PIN == D3 +#        define EIMSK_BIT _BV(INT3) +#        define EICRx_BIT (~(_BV(ISC30) | _BV(ISC31))) +#        define SERIAL_PIN_INTERRUPT INT3_vect +#        define EICRx EICRA +#    endif + +// ATmegaxxU2/AT90USB162 specific config +#    if defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__) || defined(__AVR_AT90USB162__) +// PD4(INT5), PD6(INT6), PD7(INT7), PC7(INT4) +#        if SOFT_SERIAL_PIN == D4 +#            define EIMSK_BIT _BV(INT5) +#            define EICRx_BIT (~(_BV(ISC50) | _BV(ISC51))) +#            define SERIAL_PIN_INTERRUPT INT5_vect +#            define EICRx EICRB +#        elif SOFT_SERIAL_PIN == D6 +#            define EIMSK_BIT _BV(INT6) +#            define EICRx_BIT (~(_BV(ISC60) | _BV(ISC61))) +#            define SERIAL_PIN_INTERRUPT INT6_vect +#            define EICRx EICRB +#        elif SOFT_SERIAL_PIN == D7 +#            define EIMSK_BIT _BV(INT7) +#            define EICRx_BIT (~(_BV(ISC70) | _BV(ISC71))) +#            define SERIAL_PIN_INTERRUPT INT7_vect +#            define EICRx EICRB +#        elif SOFT_SERIAL_PIN == C7 +#            define EIMSK_BIT _BV(INT4) +#            define EICRx_BIT (~(_BV(ISC40) | _BV(ISC41))) +#            define SERIAL_PIN_INTERRUPT INT4_vect +#            define EICRx EICRB +#        endif +#    endif + +// ATmegaxxU4 specific config +#    if defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) +// PE6(INT6) +#        if SOFT_SERIAL_PIN == E6 +#            define EIMSK_BIT _BV(INT6) +#            define EICRx_BIT (~(_BV(ISC60) | _BV(ISC61))) +#            define SERIAL_PIN_INTERRUPT INT6_vect +#            define EICRx EICRB +#        endif +#    endif + +// AT90USBxxx specific config +#    if defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) +// PE4..PE7(INT4..INT7) +#        if SOFT_SERIAL_PIN == E4 +#            define EIMSK_BIT _BV(INT4) +#            define EICRx_BIT (~(_BV(ISC40) | _BV(ISC41))) +#            define SERIAL_PIN_INTERRUPT INT4_vect +#            define EICRx EICRB +#        elif SOFT_SERIAL_PIN == E5 +#            define EIMSK_BIT _BV(INT5) +#            define EICRx_BIT (~(_BV(ISC50) | _BV(ISC51))) +#            define SERIAL_PIN_INTERRUPT INT5_vect +#            define EICRx EICRB +#        elif SOFT_SERIAL_PIN == E6 +#            define EIMSK_BIT _BV(INT6) +#            define EICRx_BIT (~(_BV(ISC60) | _BV(ISC61))) +#            define SERIAL_PIN_INTERRUPT INT6_vect +#            define EICRx EICRB +#        elif SOFT_SERIAL_PIN == E7 +#            define EIMSK_BIT _BV(INT7) +#            define EICRx_BIT (~(_BV(ISC70) | _BV(ISC71))) +#            define SERIAL_PIN_INTERRUPT INT7_vect +#            define EICRx EICRB +#        endif +#    endif + +#    ifndef SERIAL_PIN_INTERRUPT +#        error invalid SOFT_SERIAL_PIN value +#    endif + +#    define setPinInputHigh(pin) (DDRx_ADDRESS(pin) &= ~_BV((pin)&0xF), PORTx_ADDRESS(pin) |= _BV((pin)&0xF)) +#    define setPinOutput(pin) (DDRx_ADDRESS(pin) |= _BV((pin)&0xF)) +#    define writePinHigh(pin) (PORTx_ADDRESS(pin) |= _BV((pin)&0xF)) +#    define writePinLow(pin) (PORTx_ADDRESS(pin) &= ~_BV((pin)&0xF)) +#    define readPin(pin) ((bool)(PINx_ADDRESS(pin) & _BV((pin)&0xF))) + +#    define ALWAYS_INLINE __attribute__((always_inline)) +#    define NO_INLINE __attribute__((noinline)) +#    define _delay_sub_us(x) __builtin_avr_delay_cycles(x) + +// parity check +#    define ODD_PARITY 1 +#    define EVEN_PARITY 0 +#    define PARITY EVEN_PARITY + +#    ifdef SERIAL_DELAY +// custom setup in config.h +// #define TID_SEND_ADJUST 2 +// #define SERIAL_DELAY 6             // micro sec +// #define READ_WRITE_START_ADJUST 30 // cycles +// #define READ_WRITE_WIDTH_ADJUST 8 // cycles +#    else +// ============ Standard setups ============ + +#        ifndef SELECT_SOFT_SERIAL_SPEED +#            define SELECT_SOFT_SERIAL_SPEED 1 +//  0: about 189kbps (Experimental only) +//  1: about 137kbps (default) +//  2: about 75kbps +//  3: about 39kbps +//  4: about 26kbps +//  5: about 20kbps +#        endif + +#        if __GNUC__ < 6 +#            define TID_SEND_ADJUST 14 +#        else +#            define TID_SEND_ADJUST 2 +#        endif + +#        if SELECT_SOFT_SERIAL_SPEED == 0 +// Very High speed +#            define SERIAL_DELAY 4  // micro sec +#            if __GNUC__ < 6 +#                define READ_WRITE_START_ADJUST 33  // cycles +#                define READ_WRITE_WIDTH_ADJUST 3   // cycles +#            else +#                define READ_WRITE_START_ADJUST 34  // cycles +#                define READ_WRITE_WIDTH_ADJUST 7   // cycles +#            endif +#        elif SELECT_SOFT_SERIAL_SPEED == 1 +// High speed +#            define SERIAL_DELAY 6  // micro sec +#            if __GNUC__ < 6 +#                define READ_WRITE_START_ADJUST 30  // cycles +#                define READ_WRITE_WIDTH_ADJUST 3   // cycles +#            else +#                define READ_WRITE_START_ADJUST 33  // cycles +#                define READ_WRITE_WIDTH_ADJUST 7   // cycles +#            endif +#        elif SELECT_SOFT_SERIAL_SPEED == 2 +// Middle speed +#            define SERIAL_DELAY 12             // micro sec +#            define READ_WRITE_START_ADJUST 30  // cycles +#            if __GNUC__ < 6 +#                define READ_WRITE_WIDTH_ADJUST 3  // cycles +#            else +#                define READ_WRITE_WIDTH_ADJUST 7  // cycles +#            endif +#        elif SELECT_SOFT_SERIAL_SPEED == 3 +// Low speed +#            define SERIAL_DELAY 24             // micro sec +#            define READ_WRITE_START_ADJUST 30  // cycles +#            if __GNUC__ < 6 +#                define READ_WRITE_WIDTH_ADJUST 3  // cycles +#            else +#                define READ_WRITE_WIDTH_ADJUST 7  // cycles +#            endif +#        elif SELECT_SOFT_SERIAL_SPEED == 4 +// Very Low speed +#            define SERIAL_DELAY 36             // micro sec +#            define READ_WRITE_START_ADJUST 30  // cycles +#            if __GNUC__ < 6 +#                define READ_WRITE_WIDTH_ADJUST 3  // cycles +#            else +#                define READ_WRITE_WIDTH_ADJUST 7  // cycles +#            endif +#        elif SELECT_SOFT_SERIAL_SPEED == 5 +// Ultra Low speed +#            define SERIAL_DELAY 48             // micro sec +#            define READ_WRITE_START_ADJUST 30  // cycles +#            if __GNUC__ < 6 +#                define READ_WRITE_WIDTH_ADJUST 3  // cycles +#            else +#                define READ_WRITE_WIDTH_ADJUST 7  // cycles +#            endif +#        else +#            error invalid SELECT_SOFT_SERIAL_SPEED value +#        endif /* SELECT_SOFT_SERIAL_SPEED */ +#    endif     /* SERIAL_DELAY */ + +#    define SERIAL_DELAY_HALF1 (SERIAL_DELAY / 2) +#    define SERIAL_DELAY_HALF2 (SERIAL_DELAY - SERIAL_DELAY / 2) + +#    define SLAVE_INT_WIDTH_US 1 +#    define SLAVE_INT_ACK_WIDTH_UNIT 2 +#    define SLAVE_INT_ACK_WIDTH 4 + +inline static void serial_delay(void) ALWAYS_INLINE; +inline static void serial_delay(void) { _delay_us(SERIAL_DELAY); } + +inline static void serial_delay_half1(void) ALWAYS_INLINE; +inline static void serial_delay_half1(void) { _delay_us(SERIAL_DELAY_HALF1); } + +inline static void serial_delay_half2(void) ALWAYS_INLINE; +inline static void serial_delay_half2(void) { _delay_us(SERIAL_DELAY_HALF2); } + +inline static void serial_output(void) ALWAYS_INLINE; +inline static void serial_output(void) { setPinOutput(SOFT_SERIAL_PIN); } + +// make the serial pin an input with pull-up resistor +inline static void serial_input_with_pullup(void) ALWAYS_INLINE; +inline static void serial_input_with_pullup(void) { setPinInputHigh(SOFT_SERIAL_PIN); } + +inline static uint8_t serial_read_pin(void) ALWAYS_INLINE; +inline static uint8_t serial_read_pin(void) { return !!readPin(SOFT_SERIAL_PIN); } + +inline static void serial_low(void) ALWAYS_INLINE; +inline static void serial_low(void) { writePinLow(SOFT_SERIAL_PIN); } + +inline static void serial_high(void) ALWAYS_INLINE; +inline static void serial_high(void) { writePinHigh(SOFT_SERIAL_PIN); } + +void soft_serial_initiator_init(void) { +    serial_output(); +    serial_high(); +} + +void soft_serial_target_init(void) { +    serial_input_with_pullup(); + +    // Enable INT0-INT7 +    EIMSK |= EIMSK_BIT; +    EICRx &= EICRx_BIT; +} + +// Used by the sender to synchronize timing with the reciver. +static void sync_recv(void) NO_INLINE; +static void sync_recv(void) { +    for (uint8_t i = 0; i < SERIAL_DELAY * 5 && serial_read_pin(); i++) { +    } +    // This shouldn't hang if the target disconnects because the +    // serial line will float to high if the target does disconnect. +    while (!serial_read_pin()) +        ; +} + +// Used by the reciver to send a synchronization signal to the sender. +static void sync_send(void) NO_INLINE; +static void sync_send(void) { +    serial_low(); +    serial_delay(); +    serial_high(); +} + +// Reads a byte from the serial line +static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) NO_INLINE; +static uint8_t serial_read_chunk(uint8_t *pterrcount, uint8_t bit) { +    uint8_t byte, i, p, pb; + +    _delay_sub_us(READ_WRITE_START_ADJUST); +    for (i = 0, byte = 0, p = PARITY; i < bit; i++) { +        serial_delay_half1();  // read the middle of pulses +        if (serial_read_pin()) { +            byte = (byte << 1) | 1; +            p ^= 1; +        } else { +            byte = (byte << 1) | 0; +            p ^= 0; +        } +        _delay_sub_us(READ_WRITE_WIDTH_ADJUST); +        serial_delay_half2(); +    } +    /* recive parity bit */ +    serial_delay_half1();  // read the middle of pulses +    pb = serial_read_pin(); +    _delay_sub_us(READ_WRITE_WIDTH_ADJUST); +    serial_delay_half2(); + +    *pterrcount += (p != pb) ? 1 : 0; + +    return byte; +} + +// Sends a byte with MSB ordering +void serial_write_chunk(uint8_t data, uint8_t bit) NO_INLINE; +void serial_write_chunk(uint8_t data, uint8_t bit) { +    uint8_t b, p; +    for (p = PARITY, b = 1 << (bit - 1); b; b >>= 1) { +        if (data & b) { +            serial_high(); +            p ^= 1; +        } else { +            serial_low(); +            p ^= 0; +        } +        serial_delay(); +    } +    /* send parity bit */ +    if (p & 1) { +        serial_high(); +    } else { +        serial_low(); +    } +    serial_delay(); + +    serial_low();  // sync_send() / senc_recv() need raise edge +} + +static void serial_send_packet(uint8_t *buffer, uint8_t size) NO_INLINE; +static void serial_send_packet(uint8_t *buffer, uint8_t size) { +    for (uint8_t i = 0; i < size; ++i) { +        uint8_t data; +        data = buffer[i]; +        sync_send(); +        serial_write_chunk(data, 8); +    } +} + +static uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) NO_INLINE; +static uint8_t serial_recive_packet(uint8_t *buffer, uint8_t size) { +    uint8_t pecount = 0; +    for (uint8_t i = 0; i < size; ++i) { +        uint8_t data; +        sync_recv(); +        data      = serial_read_chunk(&pecount, 8); +        buffer[i] = data; +    } +    return pecount == 0; +} + +inline static void change_sender2reciver(void) { +    sync_send();                 // 0 +    serial_delay_half1();        // 1 +    serial_low();                // 2 +    serial_input_with_pullup();  // 2 +    serial_delay_half1();        // 3 +} + +inline static void change_reciver2sender(void) { +    sync_recv();           // 0 +    serial_delay();        // 1 +    serial_low();          // 3 +    serial_output();       // 3 +    serial_delay_half1();  // 4 +} + +static inline uint8_t nibble_bits_count(uint8_t bits) { +    bits = (bits & 0x5) + (bits >> 1 & 0x5); +    bits = (bits & 0x3) + (bits >> 2 & 0x3); +    return bits; +} + +// interrupt handle to be used by the target device +ISR(SERIAL_PIN_INTERRUPT) { +    // recive transaction table index +    uint8_t tid, bits; +    uint8_t pecount = 0; +    sync_recv(); +    bits = serial_read_chunk(&pecount, 8); +    tid  = bits >> 3; +    bits = (bits & 7) != (nibble_bits_count(tid) & 7); +    if (bits || pecount > 0 || tid > NUM_TOTAL_TRANSACTIONS) { +        return; +    } +    serial_delay_half1(); + +    serial_high();  // response step1 low->high +    serial_output(); +    _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT * SLAVE_INT_ACK_WIDTH); +    split_transaction_desc_t *trans = &split_transaction_table[tid]; +    serial_low();  // response step2 ack high->low + +    // If the transaction has a callback, we can execute it now +    if (trans->slave_callback) { +        trans->slave_callback(trans->initiator2target_buffer_size, split_trans_initiator2target_buffer(trans), trans->target2initiator_buffer_size, split_trans_target2initiator_buffer(trans)); +    } + +    // target send phase +    if (trans->target2initiator_buffer_size > 0) serial_send_packet((uint8_t *)split_trans_target2initiator_buffer(trans), trans->target2initiator_buffer_size); +    // target switch to input +    change_sender2reciver(); + +    // target recive phase +    if (trans->initiator2target_buffer_size > 0) { +        if (serial_recive_packet((uint8_t *)split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size)) { +            *trans->status = TRANSACTION_ACCEPTED; +        } else { +            *trans->status = TRANSACTION_DATA_ERROR; +        } +    } else { +        *trans->status = TRANSACTION_ACCEPTED; +    } + +    sync_recv();  // weit initiator output to high +} + +///////// +//  start transaction by initiator +// +// int  soft_serial_transaction(int sstd_index) +// +// Returns: +//    TRANSACTION_END +//    TRANSACTION_NO_RESPONSE +//    TRANSACTION_DATA_ERROR +// this code is very time dependent, so we need to disable interrupts +int soft_serial_transaction(int sstd_index) { +    if (sstd_index > NUM_TOTAL_TRANSACTIONS) return TRANSACTION_TYPE_ERROR; +    split_transaction_desc_t *trans = &split_transaction_table[sstd_index]; + +    if (!trans->status) return TRANSACTION_TYPE_ERROR;  // not registered + +    cli(); + +    // signal to the target that we want to start a transaction +    serial_output(); +    serial_low(); +    _delay_us(SLAVE_INT_WIDTH_US); + +    // send transaction table index +    int tid = (sstd_index << 3) | (7 & nibble_bits_count(sstd_index)); +    sync_send(); +    _delay_sub_us(TID_SEND_ADJUST); +    serial_write_chunk(tid, 8); +    serial_delay_half1(); + +    // wait for the target response (step1 low->high) +    serial_input_with_pullup(); +    while (!serial_read_pin()) { +        _delay_sub_us(2); +    } + +    // check if the target is present (step2 high->low) +    for (int i = 0; serial_read_pin(); i++) { +        if (i > SLAVE_INT_ACK_WIDTH + 1) { +            // slave failed to pull the line low, assume not present +            serial_output(); +            serial_high(); +            *trans->status = TRANSACTION_NO_RESPONSE; +            sei(); +            return TRANSACTION_NO_RESPONSE; +        } +        _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT); +    } + +    // initiator recive phase +    // if the target is present syncronize with it +    if (trans->target2initiator_buffer_size > 0) { +        if (!serial_recive_packet((uint8_t *)split_trans_target2initiator_buffer(trans), trans->target2initiator_buffer_size)) { +            serial_output(); +            serial_high(); +            *trans->status = TRANSACTION_DATA_ERROR; +            sei(); +            return TRANSACTION_DATA_ERROR; +        } +    } + +    // initiator switch to output +    change_reciver2sender(); + +    // initiator send phase +    if (trans->initiator2target_buffer_size > 0) { +        serial_send_packet((uint8_t *)split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size); +    } + +    // always, release the line when not in use +    sync_send(); + +    *trans->status = TRANSACTION_END; +    sei(); +    return TRANSACTION_END; +} + +int soft_serial_get_and_clean_status(int sstd_index) { +    split_transaction_desc_t *trans = &split_transaction_table[sstd_index]; +    cli(); +    int retval     = *trans->status; +    *trans->status = 0; +    ; +    sei(); +    return retval; +} +#endif + +// Helix serial.c history +//   2018-1-29 fork from let's split and add PD2, modify sync_recv() (#2308, bceffdefc) +//   2018-6-28 bug fix master to slave comm and speed up (#3255, 1038bbef4) +//             (adjusted with avr-gcc 4.9.2) +//   2018-7-13 remove USE_SERIAL_PD2 macro (#3374, f30d6dd78) +//             (adjusted with avr-gcc 4.9.2) +//   2018-8-11 add support multi-type transaction (#3608, feb5e4aae) +//             (adjusted with avr-gcc 4.9.2) +//   2018-10-21 fix serial and RGB animation conflict (#4191, 4665e4fff) +//             (adjusted with avr-gcc 7.3.0) +//   2018-10-28 re-adjust compiler depend value of delay (#4269, 8517f8a66) +//             (adjusted with avr-gcc 5.4.0, 7.3.0) +//   2018-12-17 copy to TOP/quantum/split_common/ and remove backward compatibility code (#4669) diff --git a/platforms/avr/drivers/spi_master.c b/platforms/avr/drivers/spi_master.c new file mode 100644 index 0000000000..4e8fd3bcdf --- /dev/null +++ b/platforms/avr/drivers/spi_master.c @@ -0,0 +1,180 @@ +/*  Copyright 2020 + * + *  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 3 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 <https://www.gnu.org/licenses/>. + */ + +#include "spi_master.h" + +#include "timer.h" + +#if defined(__AVR_AT90USB162__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) +#    define SPI_SCK_PIN B1 +#    define SPI_MOSI_PIN B2 +#    define SPI_MISO_PIN B3 +#elif defined(__AVR_ATmega32A__) +#    define SPI_SCK_PIN B7 +#    define SPI_MOSI_PIN B5 +#    define SPI_MISO_PIN B6 +#elif defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328__) +#    define SPI_SCK_PIN B5 +#    define SPI_MOSI_PIN B3 +#    define SPI_MISO_PIN B4 +#endif + +#ifndef SPI_TIMEOUT +#    define SPI_TIMEOUT 100 +#endif + +static pin_t   currentSlavePin    = NO_PIN; +static uint8_t currentSlaveConfig = 0; +static bool    currentSlave2X     = false; + +void spi_init(void) { +    writePinHigh(SPI_SS_PIN); +    setPinOutput(SPI_SCK_PIN); +    setPinOutput(SPI_MOSI_PIN); +    setPinInput(SPI_MISO_PIN); + +    SPCR = (_BV(SPE) | _BV(MSTR)); +} + +bool spi_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor) { +    if (currentSlavePin != NO_PIN || slavePin == NO_PIN) { +        return false; +    } + +    currentSlaveConfig = 0; + +    if (lsbFirst) { +        currentSlaveConfig |= _BV(DORD); +    } + +    switch (mode) { +        case 1: +            currentSlaveConfig |= _BV(CPHA); +            break; +        case 2: +            currentSlaveConfig |= _BV(CPOL); +            break; +        case 3: +            currentSlaveConfig |= (_BV(CPOL) | _BV(CPHA)); +            break; +    } + +    uint16_t roundedDivisor = 1; +    while (roundedDivisor < divisor) { +        roundedDivisor <<= 1; +    } + +    switch (roundedDivisor) { +        case 16: +            currentSlaveConfig |= _BV(SPR0); +            break; +        case 64: +            currentSlaveConfig |= _BV(SPR1); +            break; +        case 128: +            currentSlaveConfig |= (_BV(SPR1) | _BV(SPR0)); +            break; +        case 2: +            currentSlave2X = true; +            break; +        case 8: +            currentSlave2X = true; +            currentSlaveConfig |= _BV(SPR0); +            break; +        case 32: +            currentSlave2X = true; +            currentSlaveConfig |= _BV(SPR1); +            break; +    } + +    SPCR |= currentSlaveConfig; +    if (currentSlave2X) { +        SPSR |= _BV(SPI2X); +    } +    currentSlavePin = slavePin; +    setPinOutput(currentSlavePin); +    writePinLow(currentSlavePin); + +    return true; +} + +spi_status_t spi_write(uint8_t data) { +    SPDR = data; + +    uint16_t timeout_timer = timer_read(); +    while (!(SPSR & _BV(SPIF))) { +        if ((timer_read() - timeout_timer) >= SPI_TIMEOUT) { +            return SPI_STATUS_TIMEOUT; +        } +    } + +    return SPDR; +} + +spi_status_t spi_read() { +    SPDR = 0x00;  // Dummy + +    uint16_t timeout_timer = timer_read(); +    while (!(SPSR & _BV(SPIF))) { +        if ((timer_read() - timeout_timer) >= SPI_TIMEOUT) { +            return SPI_STATUS_TIMEOUT; +        } +    } + +    return SPDR; +} + +spi_status_t spi_transmit(const uint8_t *data, uint16_t length) { +    spi_status_t status; + +    for (uint16_t i = 0; i < length; i++) { +        status = spi_write(data[i]); + +        if (status < 0) { +            return status; +        } +    } + +    return SPI_STATUS_SUCCESS; +} + +spi_status_t spi_receive(uint8_t *data, uint16_t length) { +    spi_status_t status; + +    for (uint16_t i = 0; i < length; i++) { +        status = spi_read(); + +        if (status >= 0) { +            data[i] = status; +        } else { +            return status; +        } +    } + +    return SPI_STATUS_SUCCESS; +} + +void spi_stop(void) { +    if (currentSlavePin != NO_PIN) { +        setPinOutput(currentSlavePin); +        writePinHigh(currentSlavePin); +        currentSlavePin = NO_PIN; +        SPSR &= ~(_BV(SPI2X)); +        SPCR &= ~(currentSlaveConfig); +        currentSlaveConfig = 0; +        currentSlave2X     = false; +    } +} diff --git a/platforms/avr/drivers/spi_master.h b/platforms/avr/drivers/spi_master.h new file mode 100644 index 0000000000..8a30f47ae4 --- /dev/null +++ b/platforms/avr/drivers/spi_master.h @@ -0,0 +1,59 @@ +/*  Copyright 2020 + * + *  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 3 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 <https://www.gnu.org/licenses/>. + */ + +#pragma once + +#include <stdbool.h> + +#include "gpio.h" + +typedef int16_t spi_status_t; + +// Hardware SS pin is defined in the header so that user code can refer to it +#if defined(__AVR_AT90USB162__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) +#    define SPI_SS_PIN B0 +#elif defined(__AVR_ATmega32A__) +#    define SPI_SS_PIN B4 +#elif defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328__) +#    define SPI_SS_PIN B2 +#endif + +#define SPI_STATUS_SUCCESS (0) +#define SPI_STATUS_ERROR (-1) +#define SPI_STATUS_TIMEOUT (-2) + +#define SPI_TIMEOUT_IMMEDIATE (0) +#define SPI_TIMEOUT_INFINITE (0xFFFF) + +#ifdef __cplusplus +extern "C" { +#endif +void spi_init(void); + +bool spi_start(pin_t slavePin, bool lsbFirst, uint8_t mode, uint16_t divisor); + +spi_status_t spi_write(uint8_t data); + +spi_status_t spi_read(void); + +spi_status_t spi_transmit(const uint8_t *data, uint16_t length); + +spi_status_t spi_receive(uint8_t *data, uint16_t length); + +void spi_stop(void); +#ifdef __cplusplus +} +#endif diff --git a/platforms/avr/drivers/ssd1306.c b/platforms/avr/drivers/ssd1306.c new file mode 100644 index 0000000000..1a09a2bcb7 --- /dev/null +++ b/platforms/avr/drivers/ssd1306.c @@ -0,0 +1,319 @@ +#ifdef SSD1306OLED + +#    include "ssd1306.h" +#    include "i2c.h" +#    include <string.h> +#    include "print.h" +#    include "glcdfont.c" +#    ifdef PROTOCOL_LUFA +#        include "lufa.h" +#    endif +#    include "sendchar.h" +#    include "timer.h" + +struct CharacterMatrix display; + +// Set this to 1 to help diagnose early startup problems +// when testing power-on with ble.  Turn it off otherwise, +// as the latency of printing most of the debug info messes +// with the matrix scan, causing keys to drop. +#    define DEBUG_TO_SCREEN 0 + +// static uint16_t last_battery_update; +// static uint32_t vbat; +//#define BatteryUpdateInterval 10000 /* milliseconds */ +#    define ScreenOffInterval 300000 /* milliseconds */ +#    if DEBUG_TO_SCREEN +static uint8_t displaying; +#    endif +static uint16_t last_flush; + +// Write command sequence. +// Returns true on success. +static inline bool _send_cmd1(uint8_t cmd) { +    bool res = false; + +    if (i2c_start_write(SSD1306_ADDRESS)) { +        xprintf("failed to start write to %d\n", SSD1306_ADDRESS); +        goto done; +    } + +    if (i2c_master_write(0x0 /* command byte follows */)) { +        print("failed to write control byte\n"); + +        goto done; +    } + +    if (i2c_master_write(cmd)) { +        xprintf("failed to write command %d\n", cmd); +        goto done; +    } +    res = true; +done: +    i2c_master_stop(); +    return res; +} + +// Write 2-byte command sequence. +// Returns true on success +static inline bool _send_cmd2(uint8_t cmd, uint8_t opr) { +    if (!_send_cmd1(cmd)) { +        return false; +    } +    return _send_cmd1(opr); +} + +// Write 3-byte command sequence. +// Returns true on success +static inline bool _send_cmd3(uint8_t cmd, uint8_t opr1, uint8_t opr2) { +    if (!_send_cmd1(cmd)) { +        return false; +    } +    if (!_send_cmd1(opr1)) { +        return false; +    } +    return _send_cmd1(opr2); +} + +#    define send_cmd1(c)      \ +        if (!_send_cmd1(c)) { \ +            goto done;        \ +        } +#    define send_cmd2(c, o)      \ +        if (!_send_cmd2(c, o)) { \ +            goto done;           \ +        } +#    define send_cmd3(c, o1, o2)      \ +        if (!_send_cmd3(c, o1, o2)) { \ +            goto done;                \ +        } + +static void clear_display(void) { +    matrix_clear(&display); + +    // Clear all of the display bits (there can be random noise +    // in the RAM on startup) +    send_cmd3(PageAddr, 0, (DisplayHeight / 8) - 1); +    send_cmd3(ColumnAddr, 0, DisplayWidth - 1); + +    if (i2c_start_write(SSD1306_ADDRESS)) { +        goto done; +    } +    if (i2c_master_write(0x40)) { +        // Data mode +        goto done; +    } +    for (uint8_t row = 0; row < MatrixRows; ++row) { +        for (uint8_t col = 0; col < DisplayWidth; ++col) { +            i2c_master_write(0); +        } +    } + +    display.dirty = false; + +done: +    i2c_master_stop(); +} + +#    if DEBUG_TO_SCREEN +#        undef sendchar +static int8_t capture_sendchar(uint8_t c) { +    sendchar(c); +    iota_gfx_write_char(c); + +    if (!displaying) { +        iota_gfx_flush(); +    } +    return 0; +} +#    endif + +bool iota_gfx_init(void) { +    bool success = false; + +    send_cmd1(DisplayOff); +    send_cmd2(SetDisplayClockDiv, 0x80); +    send_cmd2(SetMultiPlex, DisplayHeight - 1); + +    send_cmd2(SetDisplayOffset, 0); + +    send_cmd1(SetStartLine | 0x0); +    send_cmd2(SetChargePump, 0x14 /* Enable */); +    send_cmd2(SetMemoryMode, 0 /* horizontal addressing */); + +#    ifdef OLED_ROTATE180 +    // the following Flip the display orientation 180 degrees +    send_cmd1(SegRemap); +    send_cmd1(ComScanInc); +#    endif +#    ifndef OLED_ROTATE180 +    // Flips the display orientation 0 degrees +    send_cmd1(SegRemap | 0x1); +    send_cmd1(ComScanDec); +#    endif + +    send_cmd2(SetComPins, 0x2); +    send_cmd2(SetContrast, 0x8f); +    send_cmd2(SetPreCharge, 0xf1); +    send_cmd2(SetVComDetect, 0x40); +    send_cmd1(DisplayAllOnResume); +    send_cmd1(NormalDisplay); +    send_cmd1(DeActivateScroll); +    send_cmd1(DisplayOn); + +    send_cmd2(SetContrast, 0);  // Dim + +    clear_display(); + +    success = true; + +    iota_gfx_flush(); + +#    if DEBUG_TO_SCREEN +    print_set_sendchar(capture_sendchar); +#    endif + +done: +    return success; +} + +bool iota_gfx_off(void) { +    bool success = false; + +    send_cmd1(DisplayOff); +    success = true; + +done: +    return success; +} + +bool iota_gfx_on(void) { +    bool success = false; + +    send_cmd1(DisplayOn); +    success = true; + +done: +    return success; +} + +void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c) { +    *matrix->cursor = c; +    ++matrix->cursor; + +    if (matrix->cursor - &matrix->display[0][0] == sizeof(matrix->display)) { +        // We went off the end; scroll the display upwards by one line +        memmove(&matrix->display[0], &matrix->display[1], MatrixCols * (MatrixRows - 1)); +        matrix->cursor = &matrix->display[MatrixRows - 1][0]; +        memset(matrix->cursor, ' ', MatrixCols); +    } +} + +void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c) { +    matrix->dirty = true; + +    if (c == '\n') { +        // Clear to end of line from the cursor and then move to the +        // start of the next line +        uint8_t cursor_col = (matrix->cursor - &matrix->display[0][0]) % MatrixCols; + +        while (cursor_col++ < MatrixCols) { +            matrix_write_char_inner(matrix, ' '); +        } +        return; +    } + +    matrix_write_char_inner(matrix, c); +} + +void iota_gfx_write_char(uint8_t c) { matrix_write_char(&display, c); } + +void matrix_write(struct CharacterMatrix *matrix, const char *data) { +    const char *end = data + strlen(data); +    while (data < end) { +        matrix_write_char(matrix, *data); +        ++data; +    } +} + +void iota_gfx_write(const char *data) { matrix_write(&display, data); } + +void matrix_write_P(struct CharacterMatrix *matrix, const char *data) { +    while (true) { +        uint8_t c = pgm_read_byte(data); +        if (c == 0) { +            return; +        } +        matrix_write_char(matrix, c); +        ++data; +    } +} + +void iota_gfx_write_P(const char *data) { matrix_write_P(&display, data); } + +void matrix_clear(struct CharacterMatrix *matrix) { +    memset(matrix->display, ' ', sizeof(matrix->display)); +    matrix->cursor = &matrix->display[0][0]; +    matrix->dirty  = true; +} + +void iota_gfx_clear_screen(void) { matrix_clear(&display); } + +void matrix_render(struct CharacterMatrix *matrix) { +    last_flush = timer_read(); +    iota_gfx_on(); +#    if DEBUG_TO_SCREEN +    ++displaying; +#    endif + +    // Move to the home position +    send_cmd3(PageAddr, 0, MatrixRows - 1); +    send_cmd3(ColumnAddr, 0, (MatrixCols * FontWidth) - 1); + +    if (i2c_start_write(SSD1306_ADDRESS)) { +        goto done; +    } +    if (i2c_master_write(0x40)) { +        // Data mode +        goto done; +    } + +    for (uint8_t row = 0; row < MatrixRows; ++row) { +        for (uint8_t col = 0; col < MatrixCols; ++col) { +            const uint8_t *glyph = font + (matrix->display[row][col] * (FontWidth - 1)); + +            for (uint8_t glyphCol = 0; glyphCol < FontWidth - 1; ++glyphCol) { +                uint8_t colBits = pgm_read_byte(glyph + glyphCol); +                i2c_master_write(colBits); +            } + +            // 1 column of space between chars (it's not included in the glyph) +            i2c_master_write(0); +        } +    } + +    matrix->dirty = false; + +done: +    i2c_master_stop(); +#    if DEBUG_TO_SCREEN +    --displaying; +#    endif +} + +void iota_gfx_flush(void) { matrix_render(&display); } + +__attribute__((weak)) void iota_gfx_task_user(void) {} + +void iota_gfx_task(void) { +    iota_gfx_task_user(); + +    if (display.dirty) { +        iota_gfx_flush(); +    } + +    if (timer_elapsed(last_flush) > ScreenOffInterval) { +        iota_gfx_off(); +    } +} +#endif diff --git a/platforms/avr/drivers/ssd1306.h b/platforms/avr/drivers/ssd1306.h new file mode 100644 index 0000000000..6eecdcfaa4 --- /dev/null +++ b/platforms/avr/drivers/ssd1306.h @@ -0,0 +1,87 @@ +#pragma once + +#include <stdbool.h> +#include <stdio.h> +#include "config.h" + +enum ssd1306_cmds { +    DisplayOff = 0xAE, +    DisplayOn  = 0xAF, + +    SetContrast        = 0x81, +    DisplayAllOnResume = 0xA4, + +    DisplayAllOn       = 0xA5, +    NormalDisplay      = 0xA6, +    InvertDisplay      = 0xA7, +    SetDisplayOffset   = 0xD3, +    SetComPins         = 0xda, +    SetVComDetect      = 0xdb, +    SetDisplayClockDiv = 0xD5, +    SetPreCharge       = 0xd9, +    SetMultiPlex       = 0xa8, +    SetLowColumn       = 0x00, +    SetHighColumn      = 0x10, +    SetStartLine       = 0x40, + +    SetMemoryMode = 0x20, +    ColumnAddr    = 0x21, +    PageAddr      = 0x22, + +    ComScanInc    = 0xc0, +    ComScanDec    = 0xc8, +    SegRemap      = 0xa0, +    SetChargePump = 0x8d, +    ExternalVcc   = 0x01, +    SwitchCapVcc  = 0x02, + +    ActivateScroll                   = 0x2f, +    DeActivateScroll                 = 0x2e, +    SetVerticalScrollArea            = 0xa3, +    RightHorizontalScroll            = 0x26, +    LeftHorizontalScroll             = 0x27, +    VerticalAndRightHorizontalScroll = 0x29, +    VerticalAndLeftHorizontalScroll  = 0x2a, +}; + +// Controls the SSD1306 128x32 OLED display via i2c + +#ifndef SSD1306_ADDRESS +#    define SSD1306_ADDRESS 0x3C +#endif + +#define DisplayHeight 32 +#define DisplayWidth 128 + +#define FontHeight 8 +#define FontWidth 6 + +#define MatrixRows (DisplayHeight / FontHeight) +#define MatrixCols (DisplayWidth / FontWidth) + +struct CharacterMatrix { +    uint8_t  display[MatrixRows][MatrixCols]; +    uint8_t *cursor; +    bool     dirty; +}; + +extern struct CharacterMatrix display; + +bool iota_gfx_init(void); +void iota_gfx_task(void); +bool iota_gfx_off(void); +bool iota_gfx_on(void); +void iota_gfx_flush(void); +void iota_gfx_write_char(uint8_t c); +void iota_gfx_write(const char *data); +void iota_gfx_write_P(const char *data); +void iota_gfx_clear_screen(void); + +void iota_gfx_task_user(void); + +void matrix_clear(struct CharacterMatrix *matrix); +void matrix_write_char_inner(struct CharacterMatrix *matrix, uint8_t c); +void matrix_write_char(struct CharacterMatrix *matrix, uint8_t c); +void matrix_write(struct CharacterMatrix *matrix, const char *data); +void matrix_write_P(struct CharacterMatrix *matrix, const char *data); +void matrix_render(struct CharacterMatrix *matrix); diff --git a/platforms/avr/drivers/uart.c b/platforms/avr/drivers/uart.c new file mode 100644 index 0000000000..c6abcb6fe0 --- /dev/null +++ b/platforms/avr/drivers/uart.c @@ -0,0 +1,170 @@ +/* UART Example for Teensy USB Development Board + * http://www.pjrc.com/teensy/ + * Copyright (c) 2009 PJRC.COM, LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +// Version 1.0: Initial Release +// Version 1.1: Add support for Teensy 2.0, minor optimizations + +#include <avr/io.h> +#include <avr/interrupt.h> + +#include "uart.h" + +#if defined(__AVR_AT90USB162__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB1287__) +#    define UDRn UDR1 +#    define UBRRnL UBRR1L +#    define UCSRnA UCSR1A +#    define UCSRnB UCSR1B +#    define UCSRnC UCSR1C +#    define U2Xn U2X1 +#    define RXENn RXEN1 +#    define TXENn TXEN1 +#    define RXCIEn RXCIE1 +#    define UCSZn1 UCSZ11 +#    define UCSZn0 UCSZ10 +#    define UDRIEn UDRIE1 +#    define USARTn_UDRE_vect USART1_UDRE_vect +#    define USARTn_RX_vect USART1_RX_vect +#elif defined(__AVR_ATmega32A__) +#    define UDRn UDR +#    define UBRRnL UBRRL +#    define UCSRnA UCSRA +#    define UCSRnB UCSRB +#    define UCSRnC UCSRC +#    define U2Xn U2X +#    define RXENn RXEN +#    define TXENn TXEN +#    define RXCIEn RXCIE +#    define UCSZn1 UCSZ1 +#    define UCSZn0 UCSZ0 +#    define UDRIEn UDRIE +#    define USARTn_UDRE_vect USART_UDRE_vect +#    define USARTn_RX_vect USART_RX_vect +#elif defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__) +#    define UDRn UDR0 +#    define UBRRnL UBRR0L +#    define UCSRnA UCSR0A +#    define UCSRnB UCSR0B +#    define UCSRnC UCSR0C +#    define U2Xn U2X0 +#    define RXENn RXEN0 +#    define TXENn TXEN0 +#    define RXCIEn RXCIE0 +#    define UCSZn1 UCSZ01 +#    define UCSZn0 UCSZ00 +#    define UDRIEn UDRIE0 +#    define USARTn_UDRE_vect USART_UDRE_vect +#    define USARTn_RX_vect USART_RX_vect +#endif + +// These buffers may be any size from 2 to 256 bytes. +#define RX_BUFFER_SIZE 64 +#define TX_BUFFER_SIZE 256 + +static volatile uint8_t tx_buffer[TX_BUFFER_SIZE]; +static volatile uint8_t tx_buffer_head; +static volatile uint8_t tx_buffer_tail; +static volatile uint8_t rx_buffer[RX_BUFFER_SIZE]; +static volatile uint8_t rx_buffer_head; +static volatile uint8_t rx_buffer_tail; + +// Initialize the UART +void uart_init(uint32_t baud) { +    cli(); +    UBRRnL         = (F_CPU / 4 / baud - 1) / 2; +    UCSRnA         = (1 << U2Xn); +    UCSRnB         = (1 << RXENn) | (1 << TXENn) | (1 << RXCIEn); +    UCSRnC         = (1 << UCSZn1) | (1 << UCSZn0); +    tx_buffer_head = tx_buffer_tail = 0; +    rx_buffer_head = rx_buffer_tail = 0; +    sei(); +} + +// Transmit a byte +void uart_putchar(uint8_t c) { +    uint8_t i; + +    i = tx_buffer_head + 1; +    if (i >= TX_BUFFER_SIZE) i = 0; +    // return immediately to avoid deadlock when interrupt is disabled(called from ISR) +    if (tx_buffer_tail == i && (SREG & (1 << SREG_I)) == 0) return; +    while (tx_buffer_tail == i) +        ;  // wait until space in buffer +    // cli(); +    tx_buffer[i]   = c; +    tx_buffer_head = i; +    UCSRnB         = (1 << RXENn) | (1 << TXENn) | (1 << RXCIEn) | (1 << UDRIEn); +    // sei(); +} + +// Receive a byte +uint8_t uart_getchar(void) { +    uint8_t c, i; + +    while (rx_buffer_head == rx_buffer_tail) +        ;  // wait for character +    i = rx_buffer_tail + 1; +    if (i >= RX_BUFFER_SIZE) i = 0; +    c              = rx_buffer[i]; +    rx_buffer_tail = i; +    return c; +} + +// Return whether the number of bytes waiting in the receive buffer is nonzero. +// Call this before uart_getchar() to check if it will need +// to wait for a byte to arrive. +bool uart_available(void) { +    uint8_t head, tail; + +    head = rx_buffer_head; +    tail = rx_buffer_tail; +    if (head >= tail) return (head - tail) > 0; +    return (RX_BUFFER_SIZE + head - tail) > 0; +} + +// Transmit Interrupt +ISR(USARTn_UDRE_vect) { +    uint8_t i; + +    if (tx_buffer_head == tx_buffer_tail) { +        // buffer is empty, disable transmit interrupt +        UCSRnB = (1 << RXENn) | (1 << TXENn) | (1 << RXCIEn); +    } else { +        i = tx_buffer_tail + 1; +        if (i >= TX_BUFFER_SIZE) i = 0; +        UDRn           = tx_buffer[i]; +        tx_buffer_tail = i; +    } +} + +// Receive Interrupt +ISR(USARTn_RX_vect) { +    uint8_t c, i; + +    c = UDRn; +    i = rx_buffer_head + 1; +    if (i >= RX_BUFFER_SIZE) i = 0; +    if (i != rx_buffer_tail) { +        rx_buffer[i]   = c; +        rx_buffer_head = i; +    } +} diff --git a/platforms/avr/drivers/uart.h b/platforms/avr/drivers/uart.h new file mode 100644 index 0000000000..602eb3d8b0 --- /dev/null +++ b/platforms/avr/drivers/uart.h @@ -0,0 +1,35 @@ +/* UART Example for Teensy USB Development Board + * http://www.pjrc.com/teensy/ + * Copyright (c) 2009 PJRC.COM, LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#pragma once + +#include <stdint.h> +#include <stdbool.h> + +void uart_init(uint32_t baud); + +void uart_putchar(uint8_t c); + +uint8_t uart_getchar(void); + +bool uart_available(void); diff --git a/platforms/avr/drivers/ws2812.c b/platforms/avr/drivers/ws2812.c new file mode 100644 index 0000000000..77c492cd4c --- /dev/null +++ b/platforms/avr/drivers/ws2812.c @@ -0,0 +1,176 @@ +/* + * light weight WS2812 lib V2.0b + * + * Controls WS2811/WS2812/WS2812B RGB-LEDs + * Author: Tim ([email protected]) + * + * Jan 18th, 2014  v2.0b Initial Version + * Nov 29th, 2015  v2.3  Added SK6812RGBW support + * + * 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 "ws2812.h" +#include <avr/interrupt.h> +#include <avr/io.h> +#include <util/delay.h> + +#define pinmask(pin) (_BV((pin)&0xF)) + +/* + * Forward declare internal functions + * + * The functions take a byte-array and send to the data output as WS2812 bitstream. + * The length is the number of bytes to send - three per LED. + */ + +static inline void ws2812_sendarray_mask(uint8_t *data, uint16_t datlen, uint8_t masklo, uint8_t maskhi); + +void ws2812_setleds(LED_TYPE *ledarray, uint16_t number_of_leds) { +    DDRx_ADDRESS(RGB_DI_PIN) |= pinmask(RGB_DI_PIN); + +    uint8_t masklo = ~(pinmask(RGB_DI_PIN)) & PORTx_ADDRESS(RGB_DI_PIN); +    uint8_t maskhi = pinmask(RGB_DI_PIN) | PORTx_ADDRESS(RGB_DI_PIN); + +    ws2812_sendarray_mask((uint8_t *)ledarray, number_of_leds * sizeof(LED_TYPE), masklo, maskhi); + +    _delay_us(WS2812_TRST_US); +} + +/* +  This routine writes an array of bytes with RGB values to the Dataout pin +  using the fast 800kHz clockless WS2811/2812 protocol. +*/ + +// Timing in ns +#define w_zeropulse 350 +#define w_onepulse 900 +#define w_totalperiod 1250 + +// Fixed cycles used by the inner loop +#define w_fixedlow 2 +#define w_fixedhigh 4 +#define w_fixedtotal 8 + +// Insert NOPs to match the timing, if possible +#define w_zerocycles (((F_CPU / 1000) * w_zeropulse) / 1000000) +#define w_onecycles (((F_CPU / 1000) * w_onepulse + 500000) / 1000000) +#define w_totalcycles (((F_CPU / 1000) * w_totalperiod + 500000) / 1000000) + +// w1_nops - nops between rising edge and falling edge - low +#if w_zerocycles >= w_fixedlow +#    define w1_nops (w_zerocycles - w_fixedlow) +#else +#    define w1_nops 0 +#endif + +// w2_nops - nops between fe low and fe high +#if w_onecycles >= (w_fixedhigh + w1_nops) +#    define w2_nops (w_onecycles - w_fixedhigh - w1_nops) +#else +#    define w2_nops 0 +#endif + +// w3_nops - nops to complete loop +#if w_totalcycles >= (w_fixedtotal + w1_nops + w2_nops) +#    define w3_nops (w_totalcycles - w_fixedtotal - w1_nops - w2_nops) +#else +#    define w3_nops 0 +#endif + +// The only critical timing parameter is the minimum pulse length of the "0" +// Warn or throw error if this timing can not be met with current F_CPU settings. +#define w_lowtime ((w1_nops + w_fixedlow) * 1000000) / (F_CPU / 1000) +#if w_lowtime > 550 +#    error "Light_ws2812: Sorry, the clock speed is too low. Did you set F_CPU correctly?" +#elif w_lowtime > 450 +#    warning "Light_ws2812: The timing is critical and may only work on WS2812B, not on WS2812(S)." +#    warning "Please consider a higher clockspeed, if possible" +#endif + +#define w_nop1 "nop      \n\t" +#define w_nop2 "rjmp .+0 \n\t" +#define w_nop4 w_nop2 w_nop2 +#define w_nop8 w_nop4 w_nop4 +#define w_nop16 w_nop8 w_nop8 + +static inline void ws2812_sendarray_mask(uint8_t *data, uint16_t datlen, uint8_t masklo, uint8_t maskhi) { +    uint8_t curbyte, ctr, sreg_prev; + +    sreg_prev = SREG; +    cli(); + +    while (datlen--) { +        curbyte = (*data++); + +        asm volatile("       ldi   %0,8  \n\t" +                     "loop%=:            \n\t" +                     "       out   %2,%3 \n\t"  //  '1' [01] '0' [01] - re +#if (w1_nops & 1) +                     w_nop1 +#endif +#if (w1_nops & 2) +                         w_nop2 +#endif +#if (w1_nops & 4) +                             w_nop4 +#endif +#if (w1_nops & 8) +                                 w_nop8 +#endif +#if (w1_nops & 16) +                                     w_nop16 +#endif +                     "       sbrs  %1,7  \n\t"  //  '1' [03] '0' [02] +                     "       out   %2,%4 \n\t"  //  '1' [--] '0' [03] - fe-low +                     "       lsl   %1    \n\t"  //  '1' [04] '0' [04] +#if (w2_nops & 1) +                     w_nop1 +#endif +#if (w2_nops & 2) +                         w_nop2 +#endif +#if (w2_nops & 4) +                             w_nop4 +#endif +#if (w2_nops & 8) +                                 w_nop8 +#endif +#if (w2_nops & 16) +                                     w_nop16 +#endif +                     "       out   %2,%4 \n\t"  //  '1' [+1] '0' [+1] - fe-high +#if (w3_nops & 1) +                     w_nop1 +#endif +#if (w3_nops & 2) +                         w_nop2 +#endif +#if (w3_nops & 4) +                             w_nop4 +#endif +#if (w3_nops & 8) +                                 w_nop8 +#endif +#if (w3_nops & 16) +                                     w_nop16 +#endif + +                     "       dec   %0    \n\t"  //  '1' [+2] '0' [+2] +                     "       brne  loop%=\n\t"  //  '1' [+3] '0' [+4] +                     : "=&d"(ctr) +                     : "r"(curbyte), "I"(_SFR_IO_ADDR(PORTx_ADDRESS(RGB_DI_PIN))), "r"(maskhi), "r"(masklo)); +    } + +    SREG = sreg_prev; +} diff --git a/platforms/avr/drivers/ws2812_i2c.c b/platforms/avr/drivers/ws2812_i2c.c new file mode 100644 index 0000000000..1c332e24b6 --- /dev/null +++ b/platforms/avr/drivers/ws2812_i2c.c @@ -0,0 +1,27 @@ +#include "ws2812.h" +#include "i2c_master.h" + +#ifdef RGBW +#    error "RGBW not supported" +#endif + +#ifndef WS2812_ADDRESS +#    define WS2812_ADDRESS 0xb0 +#endif + +#ifndef WS2812_TIMEOUT +#    define WS2812_TIMEOUT 100 +#endif + +void ws2812_init(void) { i2c_init(); } + +// Setleds for standard RGB +void ws2812_setleds(LED_TYPE *ledarray, uint16_t leds) { +    static bool s_init = false; +    if (!s_init) { +        ws2812_init(); +        s_init = true; +    } + +    i2c_transmit(WS2812_ADDRESS, (uint8_t *)ledarray, sizeof(LED_TYPE) * leds, WS2812_TIMEOUT); +} | 
