wuqiyang312
/
u8g2-copy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
u8g2-copy/cppsrc/U8x8lib.cpp

1911 lines
55 KiB
C++
Executable File
Raw Permalink Blame History

/*
U8x8lib.cpp
Arduino specific low level functions
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
Copyright (c) 2016, olikraus@gmail.com
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "U8x8lib.h"
#ifdef ARDUINO
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
# ifdef U8X8_HAVE_HW_I2C_TEENSY3
# include <i2c_t3.h>
# else
# include <Wire.h>
# ifdef U8X8_HAVE_2ND_HW_I2C
# if defined(MINICORE) && defined(__AVR_ATmega328PB__)
# include <Wire1.h>
# endif
# endif
# endif
#endif /* U8X8_HAVE_HW_I2C */
#endif /* ARDUINO */
/*=============================================*/
size_t U8X8::write(uint8_t v)
{
if ( v == '\n' )
{
uint8_t dy = u8x8_pgm_read(u8x8.font+3); /* new 2019 format */
ty+=dy;
tx=0;
}
else
{
uint8_t dx = u8x8_pgm_read(u8x8.font+2); /* new 2019 format */
u8x8_DrawGlyph(&u8x8, tx, ty, v);
tx+=dx;
}
return 1;
}
/*=============================================*/
/*=== ARDUINO GPIO & DELAY ===*/
#ifdef ARDUINO
#ifdef U8X8_USE_PINS
extern "C" uint8_t u8x8_gpio_and_delay_arduino(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, U8X8_UNUSED void *arg_ptr)
{
uint8_t i;
switch(msg)
{
case U8X8_MSG_GPIO_AND_DELAY_INIT:
for( i = 0; i < U8X8_PIN_CNT; i++ )
if ( u8x8->pins[i] != U8X8_PIN_NONE )
{
if ( i < U8X8_PIN_OUTPUT_CNT )
{
pinMode(u8x8->pins[i], OUTPUT);
}
else
{
#ifdef INPUT_PULLUP
pinMode(u8x8->pins[i], INPUT_PULLUP);
#else
pinMode(u8x8->pins[i], OUTPUT);
digitalWrite(u8x8->pins[i], 1);
#endif
}
}
break;
#ifndef __AVR__
/* this case is not compiled for any AVR, because AVR uC are so slow */
/* that this delay does not matter */
case U8X8_MSG_DELAY_NANO:
delayMicroseconds(arg_int==0?0:1);
break;
#endif
case U8X8_MSG_DELAY_10MICRO:
/* not used at the moment */
break;
case U8X8_MSG_DELAY_100NANO:
/* not used at the moment */
break;
case U8X8_MSG_DELAY_MILLI:
delay(arg_int);
break;
case U8X8_MSG_DELAY_I2C:
/* arg_int is 1 or 4: 100KHz (5us) or 400KHz (1.25us) */
delayMicroseconds(arg_int<=2?5:2);
break;
case U8X8_MSG_GPIO_I2C_CLOCK:
case U8X8_MSG_GPIO_I2C_DATA:
if ( arg_int == 0 )
{
pinMode(u8x8_GetPinValue(u8x8, msg), OUTPUT);
digitalWrite(u8x8_GetPinValue(u8x8, msg), 0);
}
else
{
#ifdef INPUT_PULLUP
pinMode(u8x8_GetPinValue(u8x8, msg), INPUT_PULLUP);
#else
pinMode(u8x8_GetPinValue(u8x8, msg), OUTPUT);
digitalWrite(u8x8_GetPinValue(u8x8, msg), 1);
#endif
}
break;
default:
if ( msg >= U8X8_MSG_GPIO(0) )
{
i = u8x8_GetPinValue(u8x8, msg);
if ( i != U8X8_PIN_NONE )
{
if ( u8x8_GetPinIndex(u8x8, msg) < U8X8_PIN_OUTPUT_CNT )
{
digitalWrite(i, arg_int);
}
else
{
if ( u8x8_GetPinIndex(u8x8, msg) == U8X8_PIN_OUTPUT_CNT )
{
// call yield() for the first pin only, u8x8 will always request all the pins, so this should be ok
yield();
}
u8x8_SetGPIOResult(u8x8, digitalRead(i) == 0 ? 0 : 1);
}
}
break;
}
return 0;
}
return 1;
}
#endif // U8X8_USE_PINS
/*=============================================*/
/*=== 3 WIRE SOFTWARE SPI ===*/
/*
replacement for a more faster u8x8_byte_3wire_sw_spi
in general u8x8_byte_3wire_sw_spi could be a fallback:
uint8_t u8x8_byte_arduino_3wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_3wire_sw_spi(u8x8, msg,arg_int, arg_ptr);
}
*/
#ifndef __AVR_ARCH__
#define __AVR_ARCH__ 0
#endif
#if !defined(U8X8_USE_PINS)
/* no pin information (very strange), so fallback */
uint8_t u8x8_byte_arduino_3wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_3wire_sw_spi(u8x8, msg,arg_int, arg_ptr);
}
#elif __AVR_ARCH__ == 4 || __AVR_ARCH__ == 5 || __AVR_ARCH__ == 51 || __AVR_ARCH__ == 6 || __AVR_ARCH__ == 103
/* this function completely replaces u8x8_byte_4wire_sw_spi*/
extern "C" uint8_t u8x8_byte_arduino_3wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
uint8_t i;
uint8_t takeover_edge = u8x8_GetSPIClockPhase(u8x8);
uint16_t b;
uint8_t *data;
/* the following static vars are recalculated in U8X8_MSG_BYTE_START_TRANSFER */
/* so, it should be possible to use multiple displays with different pins */
static volatile uint8_t *arduino_clock_port;
static uint8_t arduino_clock_mask;
static uint8_t arduino_clock_n_mask;
static volatile uint8_t *arduino_data_port;
static uint8_t arduino_data_mask;
static uint8_t arduino_data_n_mask;
static uint8_t last_dc;
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
data = (uint8_t *)arg_ptr;
if ( takeover_edge == 0 )
{
while( arg_int > 0 )
{
b = *data;
if ( last_dc != 0 )
b |= 256;
data++;
arg_int--;
/* issue 156, check for speed */
#if F_CPU <= 17000000
if ( b == 0 )
{
*arduino_data_port &= arduino_data_n_mask;
for( i = 0; i < 9; i++ )
{
*arduino_clock_port |= arduino_clock_mask;
*arduino_clock_port &= arduino_clock_n_mask;
}
}
else
#endif
{
for( i = 0; i < 9; i++ )
{
if ( b & 256 )
*arduino_data_port |= arduino_data_mask;
else
*arduino_data_port &= arduino_data_n_mask;
*arduino_clock_port |= arduino_clock_mask;
b <<= 1;
*arduino_clock_port &= arduino_clock_n_mask;
}
}
}
}
else
{
while( arg_int > 0 )
{
b = *data;
if ( last_dc != 0 )
b |= 256;
data++;
arg_int--;
/* issue 156, check for speed */
#if F_CPU <= 17000000
if ( b == 0 )
{
*arduino_data_port &= arduino_data_n_mask;
for( i = 0; i < 9; i++ )
{
*arduino_clock_port &= arduino_clock_n_mask;
*arduino_clock_port |= arduino_clock_mask;
}
}
else
#endif
{
for( i = 0; i < 9; i++ )
{
if ( b & 256 )
*arduino_data_port |= arduino_data_mask;
else
*arduino_data_port &= arduino_data_n_mask;
*arduino_clock_port &= arduino_clock_n_mask;
b <<= 1;
*arduino_clock_port |= arduino_clock_mask;
}
}
}
}
break;
case U8X8_MSG_BYTE_INIT:
/* disable chipselect */
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
/* no wait required here */
/* for SPI: setup correct level of the clock signal */
u8x8_gpio_SetSPIClock(u8x8, u8x8_GetSPIClockPhase(u8x8));
break;
case U8X8_MSG_BYTE_SET_DC:
last_dc = arg_int;
break;
case U8X8_MSG_BYTE_START_TRANSFER:
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level);
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->post_chip_enable_wait_ns, NULL);
/* there is no consistency checking for u8x8->pins[U8X8_PIN_SPI_CLOCK] */
arduino_clock_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_CLOCK]));
arduino_clock_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_SPI_CLOCK]);
arduino_clock_n_mask = ~arduino_clock_mask;
/* there is no consistency checking for u8x8->pins[U8X8_PIN_SPI_DATA] */
arduino_data_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_DATA]));
arduino_data_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_SPI_DATA]);
arduino_data_n_mask = ~arduino_data_mask;
break;
case U8X8_MSG_BYTE_END_TRANSFER:
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->pre_chip_disable_wait_ns, NULL);
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
break;
default:
return 0;
}
return 1;
}
#else
/* fallback */
uint8_t u8x8_byte_arduino_3wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_3wire_sw_spi(u8x8, msg,arg_int, arg_ptr);
}
#endif
/*=============================================*/
/*=== 4 WIRE SOFTWARE SPI ===*/
/*
replacement for a more faster u8x8_byte_4wire_sw_spi
in general u8x8_byte_4wire_sw_spi could be a fallback:
uint8_t u8x8_byte_arduino_4wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_4wire_sw_spi(u8x8, msg,arg_int, arg_ptr);
}
*/
#ifndef __AVR_ARCH__
#define __AVR_ARCH__ 0
#endif
#if !defined(U8X8_USE_PINS)
/* no pin information (very strange), so fallback */
uint8_t u8x8_byte_arduino_4wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_4wire_sw_spi(u8x8, msg,arg_int, arg_ptr);
}
#elif __AVR_ARCH__ == 4 || __AVR_ARCH__ == 5 || __AVR_ARCH__ == 51 || __AVR_ARCH__ == 6 || __AVR_ARCH__ == 103
/* this function completely replaces u8x8_byte_4wire_sw_spi*/
extern "C" uint8_t u8x8_byte_arduino_4wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
uint8_t SREG_backup;
uint8_t i, b;
uint8_t *data;
uint8_t takeover_edge = u8x8_GetSPIClockPhase(u8x8);
//uint8_t not_takeover_edge = 1 - takeover_edge;
/* the following static vars are recalculated in U8X8_MSG_BYTE_START_TRANSFER */
/* so, it should be possible to use multiple displays with different pins */
static volatile uint8_t *arduino_clock_port;
static uint8_t arduino_clock_mask;
static uint8_t arduino_clock_n_mask;
static volatile uint8_t *arduino_data_port;
static uint8_t arduino_data_mask;
static uint8_t arduino_data_n_mask;
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
data = (uint8_t *)arg_ptr;
if ( takeover_edge == 0 )
{
while( arg_int > 0 )
{
b = *data;
data++;
arg_int--;
SREG_backup = SREG; cli();
/* issue 156, check for speed */
#if F_CPU <= 17000000
if ( b == 0 )
{
*arduino_data_port &= arduino_data_n_mask;
for( i = 0; i < 8; i++ )
{
*arduino_clock_port |= arduino_clock_mask;
*arduino_clock_port &= arduino_clock_n_mask;
}
}
else
#endif
{
for( i = 0; i < 8; i++ )
{
if ( b & 128 )
*arduino_data_port |= arduino_data_mask;
else
*arduino_data_port &= arduino_data_n_mask;
*arduino_clock_port |= arduino_clock_mask;
b <<= 1;
*arduino_clock_port &= arduino_clock_n_mask;
}
}
SREG = SREG_backup;
}
}
else
{
while( arg_int > 0 )
{
b = *data;
data++;
arg_int--;
SREG_backup = SREG; cli();
/* issue 156, check for speed */
#if F_CPU <= 17000000
if ( b == 0 )
{
*arduino_data_port &= arduino_data_n_mask;
for( i = 0; i < 8; i++ )
{
*arduino_clock_port &= arduino_clock_n_mask;
*arduino_clock_port |= arduino_clock_mask;
}
}
else
#endif
{
for( i = 0; i < 8; i++ )
{
if ( b & 128 )
*arduino_data_port |= arduino_data_mask;
else
*arduino_data_port &= arduino_data_n_mask;
*arduino_clock_port &= arduino_clock_n_mask;
b <<= 1;
*arduino_clock_port |= arduino_clock_mask;
}
}
SREG = SREG_backup;
}
}
break;
case U8X8_MSG_BYTE_INIT:
/* disable chipselect */
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
/* no wait required here */
/* for SPI: setup correct level of the clock signal */
u8x8_gpio_SetSPIClock(u8x8, u8x8_GetSPIClockPhase(u8x8));
break;
case U8X8_MSG_BYTE_SET_DC:
u8x8_gpio_SetDC(u8x8, arg_int);
break;
case U8X8_MSG_BYTE_START_TRANSFER:
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level);
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->post_chip_enable_wait_ns, NULL);
/* there is no consistency checking for u8x8->pins[U8X8_PIN_SPI_CLOCK] */
arduino_clock_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_CLOCK]));
arduino_clock_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_SPI_CLOCK]);
arduino_clock_n_mask = ~arduino_clock_mask;
/* there is no consistency checking for u8x8->pins[U8X8_PIN_SPI_DATA] */
arduino_data_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_DATA]));
arduino_data_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_SPI_DATA]);
arduino_data_n_mask = ~arduino_data_mask;
break;
case U8X8_MSG_BYTE_END_TRANSFER:
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->pre_chip_disable_wait_ns, NULL);
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
break;
default:
return 0;
}
return 1;
}
#elif defined(__SAM3X8E__) /* Arduino DUE */
/* this function completely replaces u8x8_byte_4wire_sw_spi*/
extern "C" uint8_t u8x8_byte_arduino_4wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
uint8_t i, b;
uint16_t us = ((u8x8->display_info->sck_pulse_width_ns + 999)/1000);
uint8_t *data;
uint8_t takeover_edge = u8x8_GetSPIClockPhase(u8x8);
//uint8_t not_takeover_edge = 1 - takeover_edge;
/* the following static vars are recalculated in U8X8_MSG_BYTE_START_TRANSFER */
/* so, it should be possible to use multiple displays with different pins */
/*
static volatile uint32_t *arduino_clock_port;
static uint32_t arduino_clock_mask;
static uint32_t arduino_clock_n_mask;
static volatile uint32_t *arduino_data_port;
static uint32_t arduino_data_mask;
static uint32_t arduino_data_n_mask;
*/
static WoReg *arduinoSetClockPort, *arduinoUnsetClockPort;
static uint32_t arduino_clock_mask;
static WoReg *arduinoSetDataPort, *arduinoUnsetDataPort;
static uint32_t arduino_data_mask;
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
data = (uint8_t *)arg_ptr;
if ( takeover_edge == 0 )
{
while( arg_int > 0 )
{
b = *data;
data++;
arg_int--;
{
for( i = 0; i < 8; i++ )
{
/*
if ( b & 128 )
*arduino_data_port |= arduino_data_mask;
else
*arduino_data_port &= arduino_data_n_mask;
*/
if (b & 128)
*arduinoSetDataPort = arduino_data_mask;
else
*arduinoUnsetDataPort = arduino_data_mask;
//delayMicroseconds(us);
//*arduino_clock_port |= arduino_clock_mask;
*arduinoSetClockPort = arduino_clock_mask;
b <<= 1;
delayMicroseconds(us);
//*arduino_clock_port &= arduino_clock_n_mask;
*arduinoUnsetClockPort = arduino_clock_mask;
}
}
}
}
else
{
while( arg_int > 0 )
{
b = *data;
data++;
arg_int--;
{
for( i = 0; i < 8; i++ )
{
/*
if ( b & 128 )
*arduino_data_port |= arduino_data_mask;
else
*arduino_data_port &= arduino_data_n_mask;
*/
if (b & 128)
*arduinoSetDataPort = arduino_data_mask;
else
*arduinoUnsetDataPort = arduino_data_mask;
//delayMicroseconds(us);
//*arduino_clock_port &= arduino_clock_n_mask;
*arduinoUnsetClockPort = arduino_clock_mask;
b <<= 1;
delayMicroseconds(us);
//*arduino_clock_port |= arduino_clock_mask;
*arduinoSetClockPort = arduino_clock_mask;
}
}
}
}
break;
case U8X8_MSG_BYTE_INIT:
/* disable chipselect */
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
/* no wait required here */
/* for SPI: setup correct level of the clock signal */
u8x8_gpio_SetSPIClock(u8x8, u8x8_GetSPIClockPhase(u8x8));
break;
case U8X8_MSG_BYTE_SET_DC:
u8x8_gpio_SetDC(u8x8, arg_int);
break;
case U8X8_MSG_BYTE_START_TRANSFER:
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level);
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->post_chip_enable_wait_ns, NULL);
/* there is no consistency checking for u8x8->pins[U8X8_PIN_SPI_CLOCK] */
/*
arduino_clock_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_CLOCK]));
arduino_clock_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_SPI_CLOCK]);
arduino_clock_n_mask = ~arduino_clock_mask;
arduino_data_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_DATA]));
arduino_data_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_SPI_DATA]);
arduino_data_n_mask = ~arduino_data_mask;
*/
arduinoSetClockPort = &digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_CLOCK])->PIO_SODR;
arduinoUnsetClockPort = &digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_CLOCK])->PIO_CODR;
arduino_clock_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_SPI_CLOCK]);
arduinoSetDataPort = &digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_DATA])->PIO_SODR;
arduinoUnsetDataPort = &digitalPinToPort(u8x8->pins[U8X8_PIN_SPI_DATA])->PIO_CODR;
arduino_data_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_SPI_DATA]);
break;
case U8X8_MSG_BYTE_END_TRANSFER:
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->pre_chip_disable_wait_ns, NULL);
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
break;
default:
return 0;
}
return 1;
}
#else
/* fallback */
uint8_t u8x8_byte_arduino_4wire_sw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_4wire_sw_spi(u8x8, msg,arg_int, arg_ptr);
}
#endif
/*=============================================*/
/*=== 3 WIRE HARDWARE SPI with 8 bit HW SPI Subsystem ===*/
/*
references:
https://github.com/olikraus/ucglib/blob/master/cppsrc/Ucglib.cpp#L581
https://github.com/olikraus/u8g2/issues/1041
*/
static uint8_t arduino_hw_spi_3w_buffer[9];
static uint8_t arduino_hw_spi_3w_bytepos;
static uint16_t arduino_hw_spi_3w_dc; // 0 = dc==0, 256 = dc==1
static void arduino_hw_spi_3w_init()
{
memset(arduino_hw_spi_3w_buffer, 0, 9);
arduino_hw_spi_3w_bytepos = 0;
}
static void arduino_hw_spi_3w_flush(void)
{
#ifdef U8X8_HAVE_HW_SPI
uint8_t i;
for(i = 0; i <= arduino_hw_spi_3w_bytepos; i++)
{
SPI.transfer(arduino_hw_spi_3w_buffer[i]);
}
#endif
}
static void arduino_hw_spi_3w_sendbyte(uint8_t data)
{
static union { uint16_t val; struct { uint8_t lsb; uint8_t msb; }; } data16; // well well, not legal ISO 9899 code
data16.val = (arduino_hw_spi_3w_dc + data) << (7 - arduino_hw_spi_3w_bytepos);
#ifdef __BYTE_ORDER__
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
arduino_hw_spi_3w_buffer[arduino_hw_spi_3w_bytepos] |= data16.msb;
++arduino_hw_spi_3w_bytepos;
arduino_hw_spi_3w_buffer[arduino_hw_spi_3w_bytepos] |= data16.lsb;
#else
arduino_hw_spi_3w_buffer[arduino_hw_spi_3w_bytepos] |= data16.lsb;
++arduino_hw_spi_3w_bytepos;
arduino_hw_spi_3w_buffer[arduino_hw_spi_3w_bytepos] |= data16.msb;
#endif
#else // __BYTE_ORDER__ not defined (no gcc)
// assume little endian
arduino_hw_spi_3w_buffer[arduino_hw_spi_3w_bytepos] |= data16.msb;
++arduino_hw_spi_3w_bytepos;
arduino_hw_spi_3w_buffer[arduino_hw_spi_3w_bytepos] |= data16.lsb;
#endif
if (arduino_hw_spi_3w_bytepos == 8)
{
arduino_hw_spi_3w_flush();
arduino_hw_spi_3w_init();
}
}
extern "C" uint8_t u8x8_byte_arduino_3wire_hw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
#ifdef U8X8_HAVE_HW_SPI
uint8_t *data;
uint8_t internal_spi_mode;
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
data = (uint8_t *)arg_ptr;
while(arg_int > 0) {
arduino_hw_spi_3w_sendbyte((uint8_t)*data);
data++;
arg_int--;
}
break;
case U8X8_MSG_BYTE_INIT:
if ( u8x8->bus_clock == 0 ) /* issue 769 */
u8x8->bus_clock = u8x8->display_info->sck_clock_hz;
/* disable chipselect */
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
#if defined(ESP_PLATFORM) || defined(ARDUINO_ARCH_ESP32)
/* ESP32 has the following begin: SPI.begin(int8_t sck=SCK, int8_t miso=MISO, int8_t mosi=MOSI, int8_t ss=-1); */
/* not sure about ESP8266 */
/* apply bugfix from PR 2123 */
//if ( u8x8->pins[U8X8_PIN_I2C_CLOCK] != U8X8_PIN_NONE && u8x8->pins[U8X8_PIN_I2C_DATA] != U8X8_PIN_NONE )
if ( u8x8->pins[U8X8_PIN_SPI_CLOCK] != U8X8_PIN_NONE && u8x8->pins[U8X8_PIN_SPI_DATA] != U8X8_PIN_NONE )
{
/* SPI.begin(int8_t sck=SCK, int8_t miso=MISO, int8_t mosi=MOSI, int8_t ss=-1); */
/* actually MISO is not used, but what else could be used here??? */
//SPI.begin(u8x8->pins[U8X8_PIN_I2C_CLOCK], MISO, u8x8->pins[U8X8_PIN_I2C_DATA]);
SPI.begin(u8x8->pins[U8X8_PIN_SPI_CLOCK], MISO, u8x8->pins[U8X8_PIN_SPI_DATA]);
}
else
{
SPI.begin();
}
#else
SPI.begin();
#endif
break;
case U8X8_MSG_BYTE_SET_DC:
arduino_hw_spi_3w_dc = arg_int ? 256 : 0;
break;
case U8X8_MSG_BYTE_START_TRANSFER:
/* SPI mode has to be mapped to the mode of the current controller;
at least Uno, Due, 101 have different SPI_MODEx values */
internal_spi_mode = 0;
switch(u8x8->display_info->spi_mode) {
case 0: internal_spi_mode = SPI_MODE0; break;
case 1: internal_spi_mode = SPI_MODE1; break;
case 2: internal_spi_mode = SPI_MODE2; break;
case 3: internal_spi_mode = SPI_MODE3; break;
}
#if ARDUINO >= 10600
SPI.beginTransaction(
SPISettings(u8x8->bus_clock, MSBFIRST, internal_spi_mode));
#else
SPI.begin();
if (u8x8->display_info->sck_pulse_width_ns < 70)
SPI.setClockDivider(SPI_CLOCK_DIV2);
else if (u8x8->display_info->sck_pulse_width_ns < 140)
SPI.setClockDivider(SPI_CLOCK_DIV4);
else
SPI.setClockDivider(SPI_CLOCK_DIV8);
SPI.setDataMode(internal_spi_mode);
SPI.setBitOrder(MSBFIRST);
#endif
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level);
u8x8->gpio_and_delay_cb(
u8x8,
U8X8_MSG_DELAY_NANO,
u8x8->display_info->post_chip_enable_wait_ns,
NULL);
arduino_hw_spi_3w_init();
break;
case U8X8_MSG_BYTE_END_TRANSFER:
u8x8->gpio_and_delay_cb(
u8x8,
U8X8_MSG_DELAY_NANO,
u8x8->display_info->pre_chip_disable_wait_ns,
NULL);
if (arduino_hw_spi_3w_bytepos)
arduino_hw_spi_3w_flush();
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
#if ARDUINO >= 10600
SPI.endTransaction();
#else
SPI.end();
#endif
break;
default:
return 0;
}
#endif // U8X8_HAVE_HW_SPI
return 1;
}
/*=============================================*/
/*=== 4 WIRE HARDWARE SPI ===*/
#ifdef U8X8_USE_PINS
extern "C" uint8_t u8x8_byte_arduino_hw_spi(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
#ifdef U8X8_HAVE_HW_SPI
#if !defined(ESP_PLATFORM)
uint8_t *data;
#endif
uint8_t internal_spi_mode;
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
#if defined(ESP_PLATFORM)
//T.M.L 2023-02-28: use the block transfer function on ESP, which does not overwrite the buffer.
SPI.writeBytes((uint8_t*)arg_ptr, arg_int);
#else
// 1.6.5 offers a block transfer, but the problem is, that the
// buffer is overwritten with the incoming data
// so it can not be used...
// SPI.transfer((uint8_t *)arg_ptr, arg_int);
data = (uint8_t *)arg_ptr;
while( arg_int > 0 )
{
SPI.transfer((uint8_t)*data);
data++;
arg_int--;
}
#endif
break;
case U8X8_MSG_BYTE_INIT:
if ( u8x8->bus_clock == 0 ) /* issue 769 */
u8x8->bus_clock = u8x8->display_info->sck_clock_hz;
/* disable chipselect */
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
/* no wait required here */
/* for SPI: setup correct level of the clock signal */
// removed, use SPI.begin() instead: pinMode(11, OUTPUT);
// removed, use SPI.begin() instead: pinMode(13, OUTPUT);
// removed, use SPI.begin() instead: digitalWrite(13, u8x8_GetSPIClockPhase(u8x8));
/* setup hardware with SPI.begin() instead of previous digitalWrite() and pinMode() calls */
/* issue #377 */
/* issue #378: removed ESP8266 support, which is implemented differently */
#if defined(ESP_PLATFORM) || defined(ARDUINO_ARCH_ESP32)
/* ESP32 has the following begin: SPI.begin(int8_t sck=SCK, int8_t miso=MISO, int8_t mosi=MOSI, int8_t ss=-1); */
/* not sure about ESP8266 */
if ( u8x8->pins[U8X8_PIN_SPI_CLOCK] != U8X8_PIN_NONE && u8x8->pins[U8X8_PIN_SPI_DATA] != U8X8_PIN_NONE )
{
/* SPI.begin(int8_t sck=SCK, int8_t miso=MISO, int8_t mosi=MOSI, int8_t ss=-1); */
/* actually MISO is not used, but what else could be used here??? */
SPI.begin(u8x8->pins[U8X8_PIN_SPI_CLOCK], MISO, u8x8->pins[U8X8_PIN_SPI_DATA]);
}
else
{
SPI.begin();
}
#else
SPI.begin();
#endif
break;
case U8X8_MSG_BYTE_SET_DC:
u8x8_gpio_SetDC(u8x8, arg_int);
break;
case U8X8_MSG_BYTE_START_TRANSFER:
/* SPI mode has to be mapped to the mode of the current controller, at least Uno, Due, 101 have different SPI_MODEx values */
internal_spi_mode = 0;
switch(u8x8->display_info->spi_mode)
{
case 0: internal_spi_mode = SPI_MODE0; break;
case 1: internal_spi_mode = SPI_MODE1; break;
case 2: internal_spi_mode = SPI_MODE2; break;
case 3: internal_spi_mode = SPI_MODE3; break;
}
#if ARDUINO >= 10600
SPI.beginTransaction(SPISettings(u8x8->bus_clock, MSBFIRST, internal_spi_mode));
#else
SPI.begin();
if ( u8x8->display_info->sck_pulse_width_ns < 70 )
SPI.setClockDivider( SPI_CLOCK_DIV2 );
else if ( u8x8->display_info->sck_pulse_width_ns < 140 )
SPI.setClockDivider( SPI_CLOCK_DIV4 );
else
SPI.setClockDivider( SPI_CLOCK_DIV8 );
SPI.setDataMode(internal_spi_mode);
SPI.setBitOrder(MSBFIRST);
#endif
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level);
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->post_chip_enable_wait_ns, NULL);
break;
case U8X8_MSG_BYTE_END_TRANSFER:
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->pre_chip_disable_wait_ns, NULL);
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
#if ARDUINO >= 10600
SPI.endTransaction();
#else
SPI.end();
#endif
break;
default:
return 0;
}
#else /* U8X8_HAVE_HW_SPI */
#endif /* U8X8_HAVE_HW_SPI */
return 1;
}
/* issue #244 */
extern "C" uint8_t u8x8_byte_arduino_2nd_hw_spi(U8X8_UNUSED u8x8_t *u8x8, U8X8_UNUSED uint8_t msg, U8X8_UNUSED uint8_t arg_int, U8X8_UNUSED void *arg_ptr)
{
#ifdef U8X8_HAVE_2ND_HW_SPI
uint8_t *data;
uint8_t internal_spi_mode;
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
// 1.6.5 offers a block transfer, but the problem is, that the
// buffer is overwritten with the incoming data
// so it can not be used...
// SPI.transfer((uint8_t *)arg_ptr, arg_int);
data = (uint8_t *)arg_ptr;
while( arg_int > 0 )
{
SPI1.transfer((uint8_t)*data);
data++;
arg_int--;
}
break;
case U8X8_MSG_BYTE_INIT:
if ( u8x8->bus_clock == 0 ) /* issue 769 */
u8x8->bus_clock = u8x8->display_info->sck_clock_hz;
/* disable chipselect */
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
/* no wait required here */
/* for SPI1: setup correct level of the clock signal */
// removed, use SPI.begin() instead: pinMode(11, OUTPUT);
// removed, use SPI.begin() instead: pinMode(13, OUTPUT);
// removed, use SPI.begin() instead: digitalWrite(13, u8x8_GetSPIClockPhase(u8x8));
/* setup hardware with SPI.begin() instead of previous digitalWrite() and pinMode() calls */
SPI1.begin();
break;
case U8X8_MSG_BYTE_SET_DC:
u8x8_gpio_SetDC(u8x8, arg_int);
break;
case U8X8_MSG_BYTE_START_TRANSFER:
/* SPI1 mode has to be mapped to the mode of the current controller, at least Uno, Due, 101 have different SPI_MODEx values */
internal_spi_mode = 0;
switch(u8x8->display_info->spi_mode)
{
case 0: internal_spi_mode = SPI_MODE0; break;
case 1: internal_spi_mode = SPI_MODE1; break;
case 2: internal_spi_mode = SPI_MODE2; break;
case 3: internal_spi_mode = SPI_MODE3; break;
}
#if ARDUINO >= 10600
SPI1.beginTransaction(SPISettings(u8x8->bus_clock, MSBFIRST, internal_spi_mode));
#else
SPI1.begin();
if ( u8x8->display_info->sck_pulse_width_ns < 70 )
SPI1.setClockDivider( SPI_CLOCK_DIV2 );
else if ( u8x8->display_info->sck_pulse_width_ns < 140 )
SPI1.setClockDivider( SPI_CLOCK_DIV4 );
else
SPI1.setClockDivider( SPI_CLOCK_DIV8 );
SPI1.setDataMode(internal_spi_mode);
SPI1.setBitOrder(MSBFIRST);
#endif
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level);
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->post_chip_enable_wait_ns, NULL);
break;
case U8X8_MSG_BYTE_END_TRANSFER:
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->pre_chip_disable_wait_ns, NULL);
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
#if ARDUINO >= 10600
SPI1.endTransaction();
#else
SPI1.end();
#endif
break;
default:
return 0;
}
#else
#endif
return 1;
}
/*=============================================*/
/* fast SW I2C for AVR uC */
#if !defined(U8X8_USE_PINS)
/* no pin information (very strange), so fallback */
extern "C" uint8_t u8x8_byte_arduino_sw_i2c(U8X8_UNUSED u8x8_t *u8x8, U8X8_UNUSED uint8_t msg, U8X8_UNUSED uint8_t arg_int, U8X8_UNUSED void *arg_ptr)
{
return u8x8_byte_sw_i2c(u8x8, msg,arg_int, arg_ptr);
}
#elif !defined(U8X8_USE_ARDUINO_AVR_SW_I2C_OPTIMIZATION)
extern "C" uint8_t u8x8_byte_arduino_sw_i2c(U8X8_UNUSED u8x8_t *u8x8, U8X8_UNUSED uint8_t msg, U8X8_UNUSED uint8_t arg_int, U8X8_UNUSED void *arg_ptr)
{
return u8x8_byte_sw_i2c(u8x8, msg,arg_int, arg_ptr);
}
#elif __AVR_ARCH__ == 4 || __AVR_ARCH__ == 5 || __AVR_ARCH__ == 51 || __AVR_ARCH__ == 6 || __AVR_ARCH__ == 103
/* the following static vars are recalculated in U8X8_MSG_BYTE_START_TRANSFER */
/* so, it should be possible to use multiple displays with different pins */
static volatile uint8_t *arduino_i2c_clock_port;
static uint8_t arduino_i2c_clock_mask;
static uint8_t arduino_i2c_clock_n_mask;
static volatile uint8_t *arduino_i2c_data_port;
static uint8_t arduino_i2c_data_mask;
static uint8_t arduino_i2c_data_n_mask;
/*
software i2c,
ignores ACK response (which is anyway not provided by some displays)
also does not allow reading from the device
*/
static void i2c_delay(u8x8_t *u8x8) U8X8_NOINLINE;
static void i2c_delay(u8x8_t *u8x8)
{
//u8x8_gpio_Delay(u8x8, U8X8_MSG_DELAY_10MICRO, u8x8->display_info->i2c_bus_clock_100kHz);
u8x8_gpio_Delay(u8x8, U8X8_MSG_DELAY_I2C, u8x8->display_info->i2c_bus_clock_100kHz);
}
static void i2c_init(u8x8_t *u8x8)
{
*arduino_i2c_clock_port |= arduino_i2c_clock_mask;
*arduino_i2c_data_port |= arduino_i2c_data_mask;
i2c_delay(u8x8);
}
/* actually, the scl line is not observed, so this procedure does not return a value */
static void i2c_read_scl_and_delay(u8x8_t *u8x8)
{
/* set as input (line will be high) */
*arduino_i2c_clock_port |= arduino_i2c_clock_mask;
i2c_delay(u8x8);
}
static void i2c_clear_scl(u8x8_t *u8x8)
{
*arduino_i2c_clock_port &= arduino_i2c_clock_n_mask;
}
static void i2c_read_sda(u8x8_t *u8x8)
{
/* set as input (line will be high) */
*arduino_i2c_data_port |= arduino_i2c_data_mask;
}
static void i2c_clear_sda(u8x8_t *u8x8)
{
/* set open collector and drive low */
*arduino_i2c_data_port &= arduino_i2c_data_n_mask;
}
static void i2c_start(u8x8_t *u8x8)
{
if ( u8x8->i2c_started != 0 )
{
/* if already started: do restart */
i2c_read_sda(u8x8); /* SDA = 1 */
i2c_delay(u8x8);
i2c_read_scl_and_delay(u8x8);
}
i2c_read_sda(u8x8);
/* send the start condition, both lines go from 1 to 0 */
i2c_clear_sda(u8x8);
i2c_delay(u8x8);
i2c_clear_scl(u8x8);
u8x8->i2c_started = 1;
}
static void i2c_stop(u8x8_t *u8x8)
{
/* set SDA to 0 */
i2c_clear_sda(u8x8);
i2c_delay(u8x8);
/* now release all lines */
i2c_read_scl_and_delay(u8x8);
/* set SDA to 1 */
i2c_read_sda(u8x8);
i2c_delay(u8x8);
u8x8->i2c_started = 0;
}
static void i2c_write_bit(u8x8_t *u8x8, uint8_t val)
{
if (val)
i2c_read_sda(u8x8);
else
i2c_clear_sda(u8x8);
i2c_delay(u8x8);
i2c_read_scl_and_delay(u8x8);
i2c_clear_scl(u8x8);
}
static void i2c_read_bit(u8x8_t *u8x8)
{
//uint8_t val;
/* do not drive SDA */
i2c_read_sda(u8x8);
i2c_delay(u8x8);
i2c_read_scl_and_delay(u8x8);
i2c_read_sda(u8x8);
i2c_delay(u8x8);
i2c_clear_scl(u8x8);
//return val;
}
static void i2c_write_byte(u8x8_t *u8x8, uint8_t b)
{
i2c_write_bit(u8x8, b & 128);
i2c_write_bit(u8x8, b & 64);
i2c_write_bit(u8x8, b & 32);
i2c_write_bit(u8x8, b & 16);
i2c_write_bit(u8x8, b & 8);
i2c_write_bit(u8x8, b & 4);
i2c_write_bit(u8x8, b & 2);
i2c_write_bit(u8x8, b & 1);
/* read ack from client */
/* 0: ack was given by client */
/* 1: nothing happend during ack cycle */
i2c_read_bit(u8x8);
}
extern "C" uint8_t u8x8_byte_arduino_sw_i2c(U8X8_UNUSED u8x8_t *u8x8, U8X8_UNUSED uint8_t msg, U8X8_UNUSED uint8_t arg_int, U8X8_UNUSED void *arg_ptr)
{
uint8_t *data;
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
data = (uint8_t *)arg_ptr;
while( arg_int > 0 )
{
i2c_write_byte(u8x8, *data);
data++;
arg_int--;
}
break;
case U8X8_MSG_BYTE_INIT:
pinMode(u8x8->pins[U8X8_PIN_I2C_CLOCK], OUTPUT);
digitalWrite(u8x8->pins[U8X8_PIN_I2C_CLOCK], 1);
pinMode(u8x8->pins[U8X8_PIN_I2C_DATA], OUTPUT);
digitalWrite(u8x8->pins[U8X8_PIN_I2C_DATA], 1);
i2c_init(u8x8);
break;
case U8X8_MSG_BYTE_SET_DC:
break;
case U8X8_MSG_BYTE_START_TRANSFER:
/* there is no consistency checking for u8x8->pins[U8X8_PIN_I2C_CLOCK] */
arduino_i2c_clock_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_I2C_CLOCK]));
arduino_i2c_clock_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_I2C_CLOCK]);
arduino_i2c_clock_n_mask = ~arduino_i2c_clock_mask;
/* there is no consistency checking for u8x8->pins[U8X8_PIN_I2C_DATA] */
arduino_i2c_data_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_I2C_DATA]));
arduino_i2c_data_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_I2C_DATA]);
arduino_i2c_data_n_mask = ~arduino_i2c_data_mask;
i2c_start(u8x8);
i2c_write_byte(u8x8, u8x8_GetI2CAddress(u8x8));
break;
case U8X8_MSG_BYTE_END_TRANSFER:
i2c_stop(u8x8);
break;
default:
return 0;
}
return 1;
}
#else
/* not AVR architecture, fallback */
extern "C" uint8_t u8x8_byte_arduino_sw_i2c(U8X8_UNUSED u8x8_t *u8x8, U8X8_UNUSED uint8_t msg, U8X8_UNUSED uint8_t arg_int, U8X8_UNUSED void *arg_ptr)
{
return u8x8_byte_sw_i2c(u8x8, msg,arg_int, arg_ptr);
}
#endif
/*=============================================*/
/*=== HARDWARE I2C ===*/
extern "C" uint8_t u8x8_byte_arduino_hw_i2c(U8X8_UNUSED u8x8_t *u8x8, U8X8_UNUSED uint8_t msg, U8X8_UNUSED uint8_t arg_int, U8X8_UNUSED void *arg_ptr)
{
#ifdef U8X8_HAVE_HW_I2C
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
Wire.write((uint8_t *)arg_ptr, (int)arg_int);
break;
case U8X8_MSG_BYTE_INIT:
if ( u8x8->bus_clock == 0 ) /* issue 769 */
u8x8->bus_clock = u8x8->display_info->i2c_bus_clock_100kHz * 100000UL;
#if defined(ESP8266) || defined(ARDUINO_ARCH_ESP8266) || defined(ESP_PLATFORM) || defined(ARDUINO_ARCH_ESP32)
/* for ESP8266/ESP32, Wire.begin has two more arguments: clock and data */
if ( u8x8->pins[U8X8_PIN_I2C_CLOCK] != U8X8_PIN_NONE && u8x8->pins[U8X8_PIN_I2C_DATA] != U8X8_PIN_NONE )
{
// second argument for the wire lib is the clock pin. In u8g2, the first argument of the clock pin in the clock/data pair
Wire.begin((int)u8x8->pins[U8X8_PIN_I2C_DATA] , u8x8->pins[U8X8_PIN_I2C_CLOCK]);
}
else
{
Wire.begin();
}
#else
Wire.begin();
#endif
break;
case U8X8_MSG_BYTE_SET_DC:
break;
case U8X8_MSG_BYTE_START_TRANSFER:
#if ARDUINO >= 10600
/* not sure when the setClock function was introduced, but it is there since 1.6.0 */
/* if there is any error with Wire.setClock() just remove this function call by */
/* defining U8X8_DO_NOT_SET_WIRE_CLOCK */
#ifndef U8X8_DO_NOT_SET_WIRE_CLOCK
Wire.setClock(u8x8->bus_clock);
#endif
#endif
Wire.beginTransmission(u8x8_GetI2CAddress(u8x8)>>1);
break;
case U8X8_MSG_BYTE_END_TRANSFER:
Wire.endTransmission();
break;
default:
return 0;
}
#endif
return 1;
}
extern "C" uint8_t u8x8_byte_arduino_2nd_hw_i2c(U8X8_UNUSED u8x8_t *u8x8, U8X8_UNUSED uint8_t msg, U8X8_UNUSED uint8_t arg_int, U8X8_UNUSED void *arg_ptr)
{
#ifdef U8X8_HAVE_2ND_HW_I2C
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
Wire1.write((uint8_t *)arg_ptr, (int)arg_int);
break;
case U8X8_MSG_BYTE_INIT:
if ( u8x8->bus_clock == 0 ) /* issue 769 */
u8x8->bus_clock = u8x8->display_info->i2c_bus_clock_100kHz * 100000UL;
Wire1.begin();
break;
case U8X8_MSG_BYTE_SET_DC:
break;
case U8X8_MSG_BYTE_START_TRANSFER:
#if ARDUINO >= 10600
/* not sure when the setClock function was introduced, but it is there since 1.6.0 */
/* if there is any error with Wire.setClock() just remove this function call by */
/* defining U8X8_DO_NOT_SET_WIRE_CLOCK */
#ifndef U8X8_DO_NOT_SET_WIRE_CLOCK
Wire1.setClock(u8x8->bus_clock);
#endif
#endif
Wire1.beginTransmission(u8x8_GetI2CAddress(u8x8)>>1);
break;
case U8X8_MSG_BYTE_END_TRANSFER:
Wire1.endTransmission();
break;
default:
return 0;
}
#endif
return 1;
}
#endif // U8X8_USE_PINS
/*=============================================*/
/*
replacement for a more faster u8x8_byte_8bit_8080mode
in general u8x8_byte_8bit_8080mode could be a fallback:
uint8_t u8x8_byte_arduino_8bit_8080mode(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_8bit_8080mode(u8x8, msg,arg_int, arg_ptr);
}
*/
#ifndef __AVR_ARCH__
#define __AVR_ARCH__ 0
#endif
#if !defined(U8X8_USE_PINS)
/* no pin information (very strange), so fallback */
extern "C" uint8_t u8x8_byte_arduino_8bit_8080mode(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_8bit_8080mode(u8x8, msg,arg_int, arg_ptr);
}
#elif __AVR_ARCH__ == 4 || __AVR_ARCH__ == 5 || __AVR_ARCH__ == 51 || __AVR_ARCH__ == 6 || __AVR_ARCH__ == 103
/* this function completly replaces u8x8_byte_8bit_8080mode*/
extern "C" uint8_t u8x8_byte_arduino_8bit_8080mode(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
uint8_t i, b;
uint8_t *data;
/* the following static vars are recalculated in U8X8_MSG_BYTE_START_TRANSFER */
/* so, it should be possible to use multiple displays with different pins */
static volatile uint8_t *arduino_e_port;
static volatile uint8_t arduino_e_mask;
static volatile uint8_t arduino_e_n_mask;
static volatile uint8_t *arduino_data_port[8];
static volatile uint8_t arduino_data_mask[8];
static volatile uint8_t arduino_data_n_mask[8];
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
data = (uint8_t *)arg_ptr;
while( arg_int > 0 )
{
b = *data;
data++;
arg_int--;
for( i = 0; i < 8; i++ )
{
if ( b & 1 )
*arduino_data_port[i] |= arduino_data_mask[i];
else
*arduino_data_port[i] &= arduino_data_n_mask[i];
b >>= 1;
}
*arduino_e_port &= arduino_e_n_mask;
/* AVR Architecture is very slow, extra call is not required */
//u8x8_gpio_Delay(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->sda_setup_time_ns);
u8x8_gpio_Delay(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->data_setup_time_ns);
*arduino_e_port |= arduino_e_mask;
/* AVR Architecture is very slow, extra call is not required */
//u8x8_gpio_Delay(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->sck_pulse_width_ns);
u8x8_gpio_Delay(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->write_pulse_width_ns);
}
break;
case U8X8_MSG_BYTE_INIT:
/* disable chipselect */
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
/* no wait required here */
/* ensure that the enable signal is high */
u8x8_gpio_call(u8x8, U8X8_MSG_GPIO_E, 1);
break;
case U8X8_MSG_BYTE_SET_DC:
u8x8_gpio_SetDC(u8x8, arg_int);
break;
case U8X8_MSG_BYTE_START_TRANSFER:
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_enable_level);
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->post_chip_enable_wait_ns, NULL);
/* there is no consistency checking for u8x8->pins[U8X8_PIN_E] */
arduino_e_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_E]));
arduino_e_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_E]);
arduino_e_n_mask = ~arduino_e_mask;
/* there is no consistency checking for u8x8->pins[U8X8_PIN_D0] */
for( i = 0; i < 8; i++ )
{
arduino_data_port[i] = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_D0+i]));
arduino_data_mask[i] = digitalPinToBitMask(u8x8->pins[U8X8_PIN_D0+i]);
arduino_data_n_mask[i] = ~arduino_data_mask[i];
}
break;
case U8X8_MSG_BYTE_END_TRANSFER:
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->pre_chip_disable_wait_ns, NULL);
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
break;
default:
return 0;
}
return 1;
}
#else
/* fallback */
extern "C" uint8_t u8x8_byte_arduino_8bit_8080mode(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_8bit_8080mode(u8x8, msg,arg_int, arg_ptr);
}
#endif
/*=============================================*/
/*
replacement for a more faster u8x8_byte_ks0108
in general u8x8_byte_ks0108 could be a fallback:
uint8_t u8x8_byte_arduino_ks0108(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_ks0108(u8x8, msg,arg_int, arg_ptr);
}
*/
#ifndef __AVR_ARCH__
#define __AVR_ARCH__ 0
#endif
#if !defined(U8X8_USE_PINS)
/* no pin information (very strange), so fallback */
extern "C" uint8_t u8x8_byte_arduino_ks0108(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_ks0108(u8x8, msg,arg_int, arg_ptr);
}
#elif __AVR_ARCH__ == 4 || __AVR_ARCH__ == 5 || __AVR_ARCH__ == 51 || __AVR_ARCH__ == 6 || __AVR_ARCH__ == 103
/* this function completly replaces u8x8_byte_ks0108*/
extern "C" uint8_t u8x8_byte_arduino_ks0108(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
uint8_t i, b;
uint8_t *data;
/* the following static vars are recalculated in U8X8_MSG_BYTE_START_TRANSFER */
/* so, it should be possible to use multiple displays with different pins */
static volatile uint8_t *arduino_e_port;
static volatile uint8_t arduino_e_mask;
static volatile uint8_t arduino_e_n_mask;
static volatile uint8_t *arduino_data_port[8];
static volatile uint8_t arduino_data_mask[8];
static volatile uint8_t arduino_data_n_mask[8];
switch(msg)
{
case U8X8_MSG_BYTE_SEND:
data = (uint8_t *)arg_ptr;
while( arg_int > 0 )
{
b = *data;
data++;
arg_int--;
for( i = 0; i < 8; i++ )
{
if ( b & 1 )
*arduino_data_port[i] |= arduino_data_mask[i];
else
*arduino_data_port[i] &= arduino_data_n_mask[i];
b >>= 1;
}
*arduino_e_port |= arduino_e_mask;
/* AVR Architecture is very slow, extra call is not required */
u8x8_gpio_Delay(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->data_setup_time_ns);
*arduino_e_port &= arduino_e_n_mask;
/* AVR Architecture is very slow, extra call is not required */
u8x8_gpio_Delay(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->write_pulse_width_ns);
}
break;
case U8X8_MSG_BYTE_INIT:
/* disable chipselect */
u8x8_gpio_SetCS(u8x8, u8x8->display_info->chip_disable_level);
/* no wait required here */
/* ensure that the enable signal is low */
u8x8_gpio_call(u8x8, U8X8_MSG_GPIO_E, 0);
break;
case U8X8_MSG_BYTE_SET_DC:
u8x8_gpio_SetDC(u8x8, arg_int);
break;
case U8X8_MSG_BYTE_START_TRANSFER:
u8x8_byte_set_ks0108_cs(u8x8, arg_int);
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->post_chip_enable_wait_ns, NULL);
/* there is no consistency checking for u8x8->pins[U8X8_PIN_E] */
arduino_e_port = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_E]));
arduino_e_mask = digitalPinToBitMask(u8x8->pins[U8X8_PIN_E]);
arduino_e_n_mask = ~arduino_e_mask;
/* there is no consistency checking for u8x8->pins[U8X8_PIN_D0] */
for( i = 0; i < 8; i++ )
{
arduino_data_port[i] = portOutputRegister(digitalPinToPort(u8x8->pins[U8X8_PIN_D0+i]));
arduino_data_mask[i] = digitalPinToBitMask(u8x8->pins[U8X8_PIN_D0+i]);
arduino_data_n_mask[i] = ~arduino_data_mask[i];
}
break;
case U8X8_MSG_BYTE_END_TRANSFER:
u8x8->gpio_and_delay_cb(u8x8, U8X8_MSG_DELAY_NANO, u8x8->display_info->pre_chip_disable_wait_ns, NULL);
u8x8_byte_set_ks0108_cs(u8x8, arg_int);
break;
default:
return 0;
}
return 1;
}
#else
/* fallback */
extern "C" uint8_t u8x8_byte_arduino_ks0108(u8x8_t *u8x8, uint8_t msg, uint8_t arg_int, void *arg_ptr)
{
return u8x8_byte_ks0108(u8x8, msg,arg_int, arg_ptr);
}
#endif
#endif /*ARDUINO*/
#ifdef U8X8_USE_PINS
/*
use U8X8_PIN_NONE as value for "reset", if there is no reset line
*/
void u8x8_SetPin_4Wire_SW_SPI(u8x8_t *u8x8, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_SPI_CLOCK, clock);
u8x8_SetPin(u8x8, U8X8_PIN_SPI_DATA, data);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#ifdef _obsolete_com_specific_setup
void u8x8_Setup_4Wire_SW_SPI(u8x8_t *u8x8, u8x8_msg_cb display_cb, uint8_t clock, uint8_t data, uint8_t cs, uint8_t dc, uint8_t reset)
{
u8x8_Setup(u8x8, display_cb, u8x8_cad_001, u8x8_byte_4wire_sw_spi, u8x8_gpio_and_delay_arduino);
/* assign individual pin values (only for ARDUINO, if pin_list is available) */
u8x8_SetPin(u8x8, U8X8_PIN_SPI_CLOCK, clock);
u8x8_SetPin(u8x8, U8X8_PIN_SPI_DATA, data);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#endif /* obsolete com specific setup */
void u8x8_SetPin_3Wire_SW_SPI(u8x8_t *u8x8, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_SPI_CLOCK, clock);
u8x8_SetPin(u8x8, U8X8_PIN_SPI_DATA, data);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#ifdef _obsolete_com_specific_setup
void u8x8_Setup_3Wire_SW_SPI(u8x8_t *u8x8, u8x8_msg_cb display_cb, uint8_t clock, uint8_t data, uint8_t cs, uint8_t reset)
{
u8x8_Setup(u8x8, display_cb, u8x8_cad_001, u8x8_byte_3wire_sw_spi, u8x8_gpio_and_delay_arduino);
/* assign individual pin values (only for ARDUINO, if pin_list is available) */
u8x8_SetPin(u8x8, U8X8_PIN_SPI_CLOCK, clock);
u8x8_SetPin(u8x8, U8X8_PIN_SPI_DATA, data);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#endif /* obsolete com specific setup */
/*
use U8X8_PIN_NONE as value for "reset", if there is no reset line
*/
void u8x8_SetPin_3Wire_HW_SPI(u8x8_t *u8x8, uint8_t cs, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
/*
use U8X8_PIN_NONE as value for "reset", if there is no reset line
*/
void u8x8_SetPin_4Wire_HW_SPI(u8x8_t *u8x8, uint8_t cs, uint8_t dc, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
void u8x8_SetPin_ST7920_HW_SPI(u8x8_t *u8x8, uint8_t cs, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#ifdef _obsolete_com_specific_setup
void u8x8_Setup_4Wire_HW_SPI(u8x8_t *u8x8, u8x8_msg_cb display_cb, uint8_t cs, uint8_t dc, uint8_t reset)
{
u8x8_Setup(u8x8, display_cb, u8x8_cad_001, u8x8_byte_arduino_hw_spi, u8x8_gpio_and_delay_arduino);
/* assign individual pin values (only for ARDUINO, if pin_list is available) */
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#endif /* obsolete com specific setup */
void u8x8_SetPin_SW_I2C(u8x8_t *u8x8, uint8_t clock, uint8_t data, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_I2C_CLOCK, clock);
u8x8_SetPin(u8x8, U8X8_PIN_I2C_DATA, data);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#ifdef _obsolete_com_specific_setup
void u8x8_Setup_SSD13xx_SW_I2C(u8x8_t *u8x8, u8x8_msg_cb display_cb, uint8_t clock, uint8_t data, uint8_t reset)
{
u8x8_Setup(u8x8, display_cb, u8x8_cad_001, u8x8_byte_ssd13xx_sw_i2c, u8x8_gpio_and_delay_arduino);
/* assign individual pin values (only for ARDUINO, if pin_list is available) */
u8x8_SetPin(u8x8, U8X8_PIN_I2C_CLOCK, clock);
u8x8_SetPin(u8x8, U8X8_PIN_I2C_DATA, data);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#endif /* obsolete com specific setup */
void u8x8_SetPin_HW_I2C(u8x8_t *u8x8, uint8_t reset, uint8_t clock, uint8_t data)
{
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
u8x8_SetPin(u8x8, U8X8_PIN_I2C_CLOCK, clock);
u8x8_SetPin(u8x8, U8X8_PIN_I2C_DATA, data);
}
void u8x8_SetPin_8Bit_6800(u8x8_t *u8x8, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, uint8_t enable, uint8_t cs, uint8_t dc, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_D0, d0);
u8x8_SetPin(u8x8, U8X8_PIN_D1, d1);
u8x8_SetPin(u8x8, U8X8_PIN_D2, d2);
u8x8_SetPin(u8x8, U8X8_PIN_D3, d3);
u8x8_SetPin(u8x8, U8X8_PIN_D4, d4);
u8x8_SetPin(u8x8, U8X8_PIN_D5, d5);
u8x8_SetPin(u8x8, U8X8_PIN_D6, d6);
u8x8_SetPin(u8x8, U8X8_PIN_D7, d7);
u8x8_SetPin(u8x8, U8X8_PIN_E, enable);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#ifdef _obsolete_com_specific_setup
void u8x8_Setup_8Bit_6800(u8x8_t *u8x8, u8x8_msg_cb display_cb, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, uint8_t enable, uint8_t cs, uint8_t dc, uint8_t reset)
{
u8x8_Setup(u8x8, display_cb, u8x8_cad_001, u8x8_byte_8bit_6800mode, u8x8_gpio_and_delay_arduino);
/* assign individual pin values (only for ARDUINO, if pin_list is available) */
u8x8_SetPin(u8x8, U8X8_PIN_D0, d0);
u8x8_SetPin(u8x8, U8X8_PIN_D1, d1);
u8x8_SetPin(u8x8, U8X8_PIN_D2, d2);
u8x8_SetPin(u8x8, U8X8_PIN_D3, d3);
u8x8_SetPin(u8x8, U8X8_PIN_D4, d4);
u8x8_SetPin(u8x8, U8X8_PIN_D5, d5);
u8x8_SetPin(u8x8, U8X8_PIN_D6, d6);
u8x8_SetPin(u8x8, U8X8_PIN_D7, d7);
u8x8_SetPin(u8x8, U8X8_PIN_E, enable);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#endif /* obsolete com specific setup */
void u8x8_SetPin_8Bit_8080(u8x8_t *u8x8, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, uint8_t wr, uint8_t cs, uint8_t dc, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_D0, d0);
u8x8_SetPin(u8x8, U8X8_PIN_D1, d1);
u8x8_SetPin(u8x8, U8X8_PIN_D2, d2);
u8x8_SetPin(u8x8, U8X8_PIN_D3, d3);
u8x8_SetPin(u8x8, U8X8_PIN_D4, d4);
u8x8_SetPin(u8x8, U8X8_PIN_D5, d5);
u8x8_SetPin(u8x8, U8X8_PIN_D6, d6);
u8x8_SetPin(u8x8, U8X8_PIN_D7, d7);
u8x8_SetPin(u8x8, U8X8_PIN_E, wr);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#ifdef _obsolete_com_specific_setup
void u8x8_Setup_8Bit_8080(u8x8_t *u8x8, u8x8_msg_cb display_cb, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, uint8_t wr, uint8_t cs, uint8_t dc, uint8_t reset)
{
u8x8_Setup(u8x8, display_cb, u8x8_cad_001, u8x8_byte_8bit_8080mode, u8x8_gpio_and_delay_arduino);
/* assign individual pin values (only for ARDUINO, if pin_list is available) */
u8x8_SetPin(u8x8, U8X8_PIN_D0, d0);
u8x8_SetPin(u8x8, U8X8_PIN_D1, d1);
u8x8_SetPin(u8x8, U8X8_PIN_D2, d2);
u8x8_SetPin(u8x8, U8X8_PIN_D3, d3);
u8x8_SetPin(u8x8, U8X8_PIN_D4, d4);
u8x8_SetPin(u8x8, U8X8_PIN_D5, d5);
u8x8_SetPin(u8x8, U8X8_PIN_D6, d6);
u8x8_SetPin(u8x8, U8X8_PIN_D7, d7);
u8x8_SetPin(u8x8, U8X8_PIN_E, wr);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#endif /* obsolete com specific setup */
void u8x8_SetPin_KS0108(u8x8_t *u8x8, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, uint8_t enable, uint8_t dc, uint8_t cs0, uint8_t cs1, uint8_t cs2, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_D0, d0);
u8x8_SetPin(u8x8, U8X8_PIN_D1, d1);
u8x8_SetPin(u8x8, U8X8_PIN_D2, d2);
u8x8_SetPin(u8x8, U8X8_PIN_D3, d3);
u8x8_SetPin(u8x8, U8X8_PIN_D4, d4);
u8x8_SetPin(u8x8, U8X8_PIN_D5, d5);
u8x8_SetPin(u8x8, U8X8_PIN_D6, d6);
u8x8_SetPin(u8x8, U8X8_PIN_D7, d7);
u8x8_SetPin(u8x8, U8X8_PIN_E, enable);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_CS, cs0);
u8x8_SetPin(u8x8, U8X8_PIN_CS1, cs1);
u8x8_SetPin(u8x8, U8X8_PIN_CS2, cs2);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
void u8x8_SetPin_SED1520(u8x8_t *u8x8, uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3, uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, uint8_t dc, uint8_t e1, uint8_t e2, uint8_t reset)
{
u8x8_SetPin(u8x8, U8X8_PIN_D0, d0);
u8x8_SetPin(u8x8, U8X8_PIN_D1, d1);
u8x8_SetPin(u8x8, U8X8_PIN_D2, d2);
u8x8_SetPin(u8x8, U8X8_PIN_D3, d3);
u8x8_SetPin(u8x8, U8X8_PIN_D4, d4);
u8x8_SetPin(u8x8, U8X8_PIN_D5, d5);
u8x8_SetPin(u8x8, U8X8_PIN_D6, d6);
u8x8_SetPin(u8x8, U8X8_PIN_D7, d7);
u8x8_SetPin(u8x8, U8X8_PIN_E, e1);
u8x8_SetPin(u8x8, U8X8_PIN_CS, e2);
u8x8_SetPin(u8x8, U8X8_PIN_DC, dc);
u8x8_SetPin(u8x8, U8X8_PIN_RESET, reset);
}
#endif // U8X8_USE_PINS
Reference in New Issue View Git Blame Copy Permalink