io.h

Go to the documentation of this file.

/*
    MIT License

    Copyright (c) 2018-2022, Alexey Dynda

    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.
*/

#ifndef _LCD_HAL_IO_H_
#define _LCD_HAL_IO_H_

#include "UserSettings.h"
#include "interface.h"

#if defined(ARDUINO) || defined(PARTICLE_USER_MODULE)
#include "arduino/io.h"

#ifdef __cplusplus
#include "arduino/arduino_spi.h"
#include "arduino/arduino_wire.h"
#include "avr/spi_avr.h"
#include "avr/i2c_twi.h"
#include "avr/spi_usi.h"
#include "avr/i2c_embedded.h"
#include "esp/esp32_i2c.h"
#include "esp/esp32_spi.h"
#include "esp/esp8266_i2c.h"
#include "esp/esp8266_spi.h"
#endif

#elif defined(__AVR__) && !defined(ARDUINO)
#include "avr/io.h"
#ifdef __cplusplus
#include "avr/spi_avr.h"
#include "avr/i2c_twi.h"
#include "avr/spi_usi.h"
#include "avr/i2c_embedded.h"
#endif
#elif defined(__XTENSA__) && !defined(ARDUINO)
#include "esp/io.h"
#ifdef __cplusplus
#include "esp/esp32_i2c.h"
#include "esp/esp32_spi.h"
#include "esp/esp8266_i2c.h"
#include "esp/esp8266_spi.h"
#endif
#elif defined(STM32F1) || defined(STM32F2) || defined(STM32F4)
#include "stm32/io.h"
#elif defined(__linux__) || defined(__APPLE__)
#include "linux/io.h"
#ifdef __cplusplus
#include "linux/linux_i2c.h"
#include "linux/linux_spi.h"
#include "linux/sdl_i2c.h"
#include "linux/sdl_spi.h"
#endif
#elif defined(__MINGW32__)
#include "mingw/io.h"
#ifdef __cplusplus
#include "linux/sdl_i2c.h"
#include "linux/sdl_spi.h"
#endif
#elif defined(PICO_BOARD)
#include "pico/io.h"
#ifdef __cplusplus
#include "pico/pico_spi.h"
#include "pico/pico_i2c.h"
#endif
#else
#warning "Platform is not supported. Use template to add support"
#endif

#include <stdint.h>

#ifndef LCDINT_TYPES_DEFINED

#define LCDINT_TYPES_DEFINED

typedef int lcdint_t;
typedef unsigned int lcduint_t;
#endif

#define ssd1306_swap_data(a, b, type)                                                                                  \
    {                                                                                                                  \
        type t = a;                                                                                                    \
        a = b;                                                                                                         \
        b = t;                                                                                                         \
    }

//                   HAL Layer functions

#ifndef DOXYGEN_SHOULD_SKIP_THIS
#define ARDUINO_COMPAT
#endif

#if defined(ARDUINO)

#define LCD_LOW LOW
#define LCD_HIGH HIGH
#define LCD_GPIO_INPUT INPUT
#define LCD_GPIO_OUTPUT OUTPUT
#define LCD_GPIO_INPUT_PULLUP INPUT_PULLUP
#define LCD_GPIO_INPUT_PULLDOWN INPUT_PULLDOWN
#define LCD_PROGMEM PROGMEM

#define lcd_gpioRead digitalRead
#define lcd_gpioMode pinMode
#define lcd_adcRead analogRead

#ifdef __cplusplus
extern "C"
{
#endif

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void lcd_registerGpioEvent(int pin, void (*on_pin_change)(void *), void *arg);
    void lcd_unregisterGpioEvent(int pin);
#endif

    void lcd_gpioWrite(int pin, int level);

#ifdef __cplusplus
}
#endif

#define lcd_pgmReadByte pgm_read_byte
#define lcd_eepromReadWord eeprom_read_word
#define lcd_eepromWriteWord eeprom_write_word

#define lcd_millis millis
#define lcd_micros micros
#define lcd_delay delay
#define lcd_delayUs delayMicroseconds
#define lcd_attachInterrupt attachInterrupt

#define lcd_random random
#define lcd_randomSeed randomSeed

#else

#define LCD_LOW 0

#define LCD_HIGH 1

#define LCD_GPIO_INPUT 0

#define LCD_GPIO_OUTPUT 1

#define LCD_GPIO_INPUT_PULLUP 2

#define LCD_GPIO_INPUT_PULLDOWN 3
// LCD_PROMEM is platform specific definition
#ifndef LCD_PROGMEM

#define LCD_PROGMEM PROGMEM
#endif

#ifdef __cplusplus
extern "C"
{
#endif

    void lcd_gpioMode(int pin, int mode);

    int lcd_gpioRead(int pin);

    void lcd_gpioWrite(int pin, int level);

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void lcd_registerGpioEvent(int pin, void (*on_pin_change)(void *), void *arg);
    void lcd_unregisterGpioEvent(int pin);
#endif

    int lcd_adcRead(int pin);

    uint32_t lcd_millis(void);

    uint32_t lcd_micros(void);

    void lcd_randomSeed(int seed);

    void lcd_attachInterrupt(int pin, void (*interrupt)(), int level);

    void lcd_delay(unsigned long ms);

    void lcd_delayUs(unsigned long us);

    uint8_t lcd_pgmReadByte(const void *ptr);

    uint16_t lcd_eepromReadWord(const void *ptr);

    void lcd_eepromWriteWord(const void *ptr, uint16_t val);

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus

int lcd_random(int max);

int lcd_random(int min, int max);
#endif

#ifdef ARDUINO_COMPAT

#define LOW LCD_LOW

#define HIGH LCD_HIGH

#define INPUT LCD_GPIO_INPUT

#define OUTPUT LCD_GPIO_OUTPUT

#define INPUT_PULLUP LCD_GPIO_INPUT_PULLUP

#define INPUT_PULLDOWN LCD_GPIO_INPUT_PULLDOWN
#ifndef PROGMEM

#define PROGMEM LCD_PROGMEM
#endif

#define digitalRead lcd_gpioRead

#define digitalWrite lcd_gpioWrite

#define pinMode lcd_gpioMode

#define analogRead lcd_adcRead

#if !defined(__AVR__)

#define pgm_read_byte lcd_pgmReadByte

#define eeprom_read_word lcd_eepromReadWord

#define eeprom_write_word lcd_eepromWriteWord
#endif

#define millis lcd_millis

#define micros lcd_micros

#define delay lcd_delay

#define delayMicroseconds lcd_delayUs

#define random lcd_random

#define randomSeed lcd_randomSeed

#endif

#endif

#ifdef __cplusplus

//                    I2C PLATFORM

#if defined(CONFIG_ARDUINO_I2C_AVAILABLE) && defined(CONFIG_ARDUINO_I2C_ENABLE)

class PlatformI2c: public ArduinoI2c
{
public:
    explicit PlatformI2c(const SPlatformI2cConfig &config)
        : ArduinoI2c(config.scl, config.sda, config.addr)
    {
    }
};

#elif defined(CONFIG_TWI_I2C_AVAILABLE) && defined(CONFIG_TWI_I2C_ENABLE)

class PlatformI2c: public TwiI2c
{
public:
    explicit PlatformI2c(const SPlatformI2cConfig &config)
        : TwiI2c(config.addr)
    {
    }
};

#elif defined(CONFIG_LINUX_I2C_AVAILABLE) && defined(CONFIG_LINUX_I2C_ENABLE)

#if defined(SDL_EMULATION)

class PlatformI2c: public SdlI2c
{
public:
    explicit PlatformI2c(const SPlatformI2cConfig &config)
        : SdlI2c(config.scl, config.sda, config.addr)
    {
    }
};
#else

class PlatformI2c: public LinuxI2c
{
public:
    explicit PlatformI2c(const SPlatformI2cConfig &config)
        : LinuxI2c(config.busId, config.addr)
    {
    }
};
#endif

#elif defined(CONFIG_ESP32_I2C_AVAILABLE) && defined(CONFIG_ESP32_I2C_ENABLE)

class PlatformI2c: public EspI2c
{
public:
    explicit PlatformI2c(const SPlatformI2cConfig &config)
        : EspI2c(config.busId, config.addr, config.scl, config.sda, 400000)
    {
    }
};

#elif defined(CONFIG_ESP8266_I2C_AVAILABLE) && defined(CONFIG_ESP8266_I2C_ENABLE)

class PlatformI2c: public EspI2c
{
public:
    explicit PlatformI2c(const SPlatformI2cConfig &config)
        : EspI2c(config.busId, config.addr, config.scl, config.sda, 400000)
    {
    }
};

#elif defined(CONFIG_SOFTWARE_I2C_AVAILABLE) && defined(CONFIG_SOFTWARE_I2C_ENABLE)

class PlatformI2c: public SoftwareI2c
{
public:
    explicit PlatformI2c(const SPlatformI2cConfig &config)
        : SoftwareI2c(config.scl, config.sda, config.addr)
    {
    }
};

#elif defined(PICO_BOARD)

class PlatformI2c: public PicoI2c
{
public:
    explicit PlatformI2c(const SPlatformI2cConfig &config)
        : PicoI2c(config.scl, config.sda, config.addr)
    {
    }
};

#else

#error "Platform not supported"

#endif

//                    SPI PLATFORM

#if defined(CONFIG_AVR_SPI_AVAILABLE) && defined(CONFIG_AVR_SPI_ENABLE)

class PlatformSpi: public AvrSpi
{
public:
    explicit PlatformSpi(const SPlatformSpiConfig &config)
        : AvrSpi(config.cs, config.dc, config.frequency)
    {
    }
};

#elif defined(CONFIG_ARDUINO_SPI_AVAILABLE) && defined(CONFIG_ARDUINO_SPI_ENABLE)

class PlatformSpi: public ArduinoSpi
{
public:
    explicit PlatformSpi(const SPlatformSpiConfig &config)
        : ArduinoSpi(config.cs, config.dc, config.scl, config.sda, config.frequency)
    {
    }
};

#elif defined(CONFIG_LINUX_SPI_AVAILABLE) && defined(CONFIG_LINUX_SPI_ENABLE)

#if defined(SDL_EMULATION)

class PlatformSpi: public SdlSpi
{
public:
    explicit PlatformSpi(const SPlatformSpiConfig &config)
        : SdlSpi(config.dc)
    {
    }
};
#else

class PlatformSpi: public LinuxSpi
{
public:
    explicit PlatformSpi(const SPlatformSpiConfig &config)
        : LinuxSpi(config.busId, config.devId, config.dc, config.frequency)
    {
    }
};
#endif

#elif defined(CONFIG_ESP32_SPI_AVAILABLE) && defined(CONFIG_ESP32_SPI_ENABLE)

class PlatformSpi: public EspSpi
{
public:
    explicit PlatformSpi(const SPlatformSpiConfig &config)
        : EspSpi(config.busId, config.cs, config.dc, config.scl, config.sda, config.frequency)
    {
    }
};

#elif defined(CONFIG_ESP8266_SPI_AVAILABLE) && defined(CONFIG_ESP8266_SPI_ENABLE)

class PlatformSpi: public EspSpi
{
public:
    explicit PlatformSpi(const SPlatformSpiConfig &config)
        : EspSpi(config.busId, config.cs, config.dc, config.scl, config.sda, config.frequency)
    {
    }
};

#elif defined(CONFIG_USI_SPI_AVAILABLE) && defined(CONFIG_USI_SPI_ENABLE)

class PlatformSpi: public UsiSpi
{
public:
    explicit PlatformSpi(const SPlatformSpiConfig &config)
        : UsiSpi(config.cs, config.dc)
    {
    }
};

#elif defined(PICO_BOARD)

class PlatformSpi: public PicoSpi
{
public:
    explicit PlatformSpi(const SPlatformSpiConfig &config)
        : PicoSpi(config.cs, config.dc, config.scl, config.sda, config.frequency)
    {
    }
};

#else

#error "Platform not supported"

#endif

#include "custom_interface.h"

#endif

#endif