diff options
Diffstat (limited to 'drivers/avr')
| -rw-r--r-- | drivers/avr/analog.c | 138 | ||||
| -rw-r--r-- | drivers/avr/analog.h | 53 | ||||
| -rw-r--r-- | drivers/avr/glcdfont.c | 23 | ||||
| -rw-r--r-- | drivers/avr/hd44780.c | 536 | ||||
| -rw-r--r-- | drivers/avr/hd44780.h | 348 | ||||
| -rw-r--r-- | drivers/avr/i2c_master.c | 224 | ||||
| -rw-r--r-- | drivers/avr/i2c_master.h | 43 | ||||
| -rw-r--r-- | drivers/avr/i2c_slave.c | 86 | ||||
| -rw-r--r-- | drivers/avr/i2c_slave.h | 30 | ||||
| -rw-r--r-- | drivers/avr/serial.c | 563 | ||||
| -rw-r--r-- | drivers/avr/serial.h | 62 | ||||
| -rw-r--r-- | drivers/avr/spi_master.c | 180 | ||||
| -rw-r--r-- | drivers/avr/spi_master.h | 59 | ||||
| -rw-r--r-- | drivers/avr/ssd1306.c | 319 | ||||
| -rw-r--r-- | drivers/avr/ssd1306.h | 87 | ||||
| -rw-r--r-- | drivers/avr/uart.c | 170 | ||||
| -rw-r--r-- | drivers/avr/uart.h | 35 | ||||
| -rw-r--r-- | drivers/avr/ws2812.c | 176 | ||||
| -rw-r--r-- | drivers/avr/ws2812_i2c.c | 27 | 
19 files changed, 0 insertions, 3159 deletions
| diff --git a/drivers/avr/analog.c b/drivers/avr/analog.c deleted file mode 100644 index 8d299ffdb9..0000000000 --- a/drivers/avr/analog.c +++ /dev/null @@ -1,138 +0,0 @@ -/* 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/drivers/avr/analog.h b/drivers/avr/analog.h deleted file mode 100644 index 058882450d..0000000000 --- a/drivers/avr/analog.h +++ /dev/null @@ -1,53 +0,0 @@ -/* 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/drivers/avr/glcdfont.c b/drivers/avr/glcdfont.c deleted file mode 100644 index 5e763b054f..0000000000 --- a/drivers/avr/glcdfont.c +++ /dev/null @@ -1,23 +0,0 @@ -// 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/drivers/avr/hd44780.c b/drivers/avr/hd44780.c deleted file mode 100644 index f71069dece..0000000000 --- a/drivers/avr/hd44780.c +++ /dev/null @@ -1,536 +0,0 @@ -/**************************************************************************** - 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/drivers/avr/hd44780.h b/drivers/avr/hd44780.h deleted file mode 100644 index 08e60f8a44..0000000000 --- a/drivers/avr/hd44780.h +++ /dev/null @@ -1,348 +0,0 @@ -/************************************************************************* - 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/drivers/avr/i2c_master.c b/drivers/avr/i2c_master.c deleted file mode 100644 index b1e4885298..0000000000 --- a/drivers/avr/i2c_master.c +++ /dev/null @@ -1,224 +0,0 @@ -/*  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 - -#define TWBR_val (((F_CPU / F_SCL) - 16) / 2) - -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 -} - -i2c_status_t i2c_start(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_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/drivers/avr/i2c_master.h b/drivers/avr/i2c_master.h deleted file mode 100644 index e5af73364b..0000000000 --- a/drivers/avr/i2c_master.h +++ /dev/null @@ -1,43 +0,0 @@ -/*  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/drivers/avr/i2c_slave.c b/drivers/avr/i2c_slave.c deleted file mode 100644 index 62a378165a..0000000000 --- a/drivers/avr/i2c_slave.c +++ /dev/null @@ -1,86 +0,0 @@ -/*  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 <avr/io.h> -#include <util/twi.h> -#include <avr/interrupt.h> -#include <stdbool.h> - -#include "i2c_slave.h" - -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; -            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-incriment -            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 receaved now fill in buffer -            } else { -                i2c_slave_reg[buffer_address] = TWDR; -                buffer_address++; -            } -            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/drivers/avr/i2c_slave.h b/drivers/avr/i2c_slave.h deleted file mode 100644 index 1cd0625ef4..0000000000 --- a/drivers/avr/i2c_slave.h +++ /dev/null @@ -1,30 +0,0 @@ -/*  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 - -#define I2C_SLAVE_REG_COUNT 30 - -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/drivers/avr/serial.c b/drivers/avr/serial.c deleted file mode 100644 index 3647bee0d3..0000000000 --- a/drivers/avr/serial.c +++ /dev/null @@ -1,563 +0,0 @@ -/* - * 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 -#    ifndef SERIAL_USE_MULTI_TRANSACTION -#        define SLAVE_INT_RESPONSE_TIME SERIAL_DELAY -#    else -#        define SLAVE_INT_ACK_WIDTH_UNIT 2 -#        define SLAVE_INT_ACK_WIDTH 4 -#    endif - -static SSTD_t *Transaction_table      = NULL; -static uint8_t Transaction_table_size = 0; - -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(SSTD_t *sstd_table, int sstd_table_size) { -    Transaction_table      = sstd_table; -    Transaction_table_size = (uint8_t)sstd_table_size; -    serial_output(); -    serial_high(); -} - -void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size) { -    Transaction_table      = sstd_table; -    Transaction_table_size = (uint8_t)sstd_table_size; -    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) { -#    ifndef SERIAL_USE_MULTI_TRANSACTION -    serial_low(); -    serial_output(); -    SSTD_t *trans = Transaction_table; -#    else -    // recive transaction table index -    uint8_t tid, bits; -    uint8_t pecount = 0; -    sync_recv(); -    bits = serial_read_chunk(&pecount, 7); -    tid  = bits >> 3; -    bits = (bits & 7) != nibble_bits_count(tid); -    if (bits || pecount > 0 || tid > Transaction_table_size) { -        return; -    } -    serial_delay_half1(); - -    serial_high();  // response step1 low->high -    serial_output(); -    _delay_sub_us(SLAVE_INT_ACK_WIDTH_UNIT * SLAVE_INT_ACK_WIDTH); -    SSTD_t *trans = &Transaction_table[tid]; -    serial_low();  // response step2 ack high->low -#    endif - -    // target send phase -    if (trans->target2initiator_buffer_size > 0) serial_send_packet((uint8_t *)trans->target2initiator_buffer, 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 *)trans->initiator2target_buffer, 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 -#    ifndef SERIAL_USE_MULTI_TRANSACTION -int soft_serial_transaction(void) { -    SSTD_t *trans = Transaction_table; -#    else -int soft_serial_transaction(int sstd_index) { -    if (sstd_index > Transaction_table_size) return TRANSACTION_TYPE_ERROR; -    SSTD_t *trans = &Transaction_table[sstd_index]; -#    endif -    cli(); - -    // signal to the target that we want to start a transaction -    serial_output(); -    serial_low(); -    _delay_us(SLAVE_INT_WIDTH_US); - -#    ifndef SERIAL_USE_MULTI_TRANSACTION -    // wait for the target response -    serial_input_with_pullup(); -    _delay_us(SLAVE_INT_RESPONSE_TIME); - -    // check if the target is present -    if (serial_read_pin()) { -        // target failed to pull the line low, assume not present -        serial_output(); -        serial_high(); -        *trans->status = TRANSACTION_NO_RESPONSE; -        sei(); -        return TRANSACTION_NO_RESPONSE; -    } - -#    else -    // 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, 7); -    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); -    } -#    endif - -    // initiator recive phase -    // if the target is present syncronize with it -    if (trans->target2initiator_buffer_size > 0) { -        if (!serial_recive_packet((uint8_t *)trans->target2initiator_buffer, 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 *)trans->initiator2target_buffer, trans->initiator2target_buffer_size); -    } - -    // always, release the line when not in use -    sync_send(); - -    *trans->status = TRANSACTION_END; -    sei(); -    return TRANSACTION_END; -} - -#    ifdef SERIAL_USE_MULTI_TRANSACTION -int soft_serial_get_and_clean_status(int sstd_index) { -    SSTD_t *trans = &Transaction_table[sstd_index]; -    cli(); -    int retval     = *trans->status; -    *trans->status = 0; -    ; -    sei(); -    return retval; -} -#    endif - -#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/drivers/avr/serial.h b/drivers/avr/serial.h deleted file mode 100644 index 53e66cf905..0000000000 --- a/drivers/avr/serial.h +++ /dev/null @@ -1,62 +0,0 @@ -#pragma once - -#include <stdbool.h> - -// ///////////////////////////////////////////////////////////////// -// Need Soft Serial defines in config.h -// ///////////////////////////////////////////////////////////////// -// ex. -//  #define SOFT_SERIAL_PIN ??   // ?? = D0,D1,D2,D3,E6 -//  OPTIONAL: #define SELECT_SOFT_SERIAL_SPEED ? // ? = 1,2,3,4,5 -//                                               //  1: about 137kbps (default) -//                                               //  2: about 75kbps -//                                               //  3: about 39kbps -//                                               //  4: about 26kbps -//                                               //  5: about 20kbps -// -// //// USE simple API (using signle-type transaction function) -//   /* nothing */ -// //// USE flexible API (using multi-type transaction function) -//   #define SERIAL_USE_MULTI_TRANSACTION -// -// ///////////////////////////////////////////////////////////////// - -// Soft Serial Transaction Descriptor -typedef struct _SSTD_t { -    uint8_t *status; -    uint8_t  initiator2target_buffer_size; -    uint8_t *initiator2target_buffer; -    uint8_t  target2initiator_buffer_size; -    uint8_t *target2initiator_buffer; -} SSTD_t; -#define TID_LIMIT(table) (sizeof(table) / sizeof(SSTD_t)) - -// initiator is transaction start side -void soft_serial_initiator_init(SSTD_t *sstd_table, int sstd_table_size); -// target is interrupt accept side -void soft_serial_target_init(SSTD_t *sstd_table, int sstd_table_size); - -// initiator resullt -#define TRANSACTION_END 0 -#define TRANSACTION_NO_RESPONSE 0x1 -#define TRANSACTION_DATA_ERROR 0x2 -#define TRANSACTION_TYPE_ERROR 0x4 -#ifndef SERIAL_USE_MULTI_TRANSACTION -int soft_serial_transaction(void); -#else -int soft_serial_transaction(int sstd_index); -#endif - -// target status -// *SSTD_t.status has -//   initiator: -//       TRANSACTION_END -//    or TRANSACTION_NO_RESPONSE -//    or TRANSACTION_DATA_ERROR -//   target: -//       TRANSACTION_DATA_ERROR -//    or TRANSACTION_ACCEPTED -#define TRANSACTION_ACCEPTED 0x8 -#ifdef SERIAL_USE_MULTI_TRANSACTION -int soft_serial_get_and_clean_status(int sstd_index); -#endif diff --git a/drivers/avr/spi_master.c b/drivers/avr/spi_master.c deleted file mode 100644 index 4e8fd3bcdf..0000000000 --- a/drivers/avr/spi_master.c +++ /dev/null @@ -1,180 +0,0 @@ -/*  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/drivers/avr/spi_master.h b/drivers/avr/spi_master.h deleted file mode 100644 index 8a30f47ae4..0000000000 --- a/drivers/avr/spi_master.h +++ /dev/null @@ -1,59 +0,0 @@ -/*  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/drivers/avr/ssd1306.c b/drivers/avr/ssd1306.c deleted file mode 100644 index 1a09a2bcb7..0000000000 --- a/drivers/avr/ssd1306.c +++ /dev/null @@ -1,319 +0,0 @@ -#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/drivers/avr/ssd1306.h b/drivers/avr/ssd1306.h deleted file mode 100644 index 6eecdcfaa4..0000000000 --- a/drivers/avr/ssd1306.h +++ /dev/null @@ -1,87 +0,0 @@ -#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/drivers/avr/uart.c b/drivers/avr/uart.c deleted file mode 100644 index c6abcb6fe0..0000000000 --- a/drivers/avr/uart.c +++ /dev/null @@ -1,170 +0,0 @@ -/* 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/drivers/avr/uart.h b/drivers/avr/uart.h deleted file mode 100644 index 602eb3d8b0..0000000000 --- a/drivers/avr/uart.h +++ /dev/null @@ -1,35 +0,0 @@ -/* 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/drivers/avr/ws2812.c b/drivers/avr/ws2812.c deleted file mode 100644 index 77c492cd4c..0000000000 --- a/drivers/avr/ws2812.c +++ /dev/null @@ -1,176 +0,0 @@ -/* - * 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/drivers/avr/ws2812_i2c.c b/drivers/avr/ws2812_i2c.c deleted file mode 100644 index 1c332e24b6..0000000000 --- a/drivers/avr/ws2812_i2c.c +++ /dev/null @@ -1,27 +0,0 @@ -#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); -} | 
