Add Arduino_GFX lib

This commit is contained in:
lewisxhe
2024-09-19 11:13:25 +08:00
parent 5794daa8aa
commit 36fa1369cf
261 changed files with 277823 additions and 0 deletions
+155
View File
@@ -0,0 +1,155 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#include "Arduino_DataBus.h"
Arduino_DataBus::Arduino_DataBus() {}
void Arduino_DataBus::writeC8D8(uint8_t c, uint8_t d)
{
writeCommand(c);
write(d);
}
void Arduino_DataBus::writeC8D16(uint8_t c, uint16_t d)
{
writeCommand(c);
write16(d);
}
void Arduino_DataBus::writeC16D16(uint16_t c, uint16_t d)
{
writeCommand16(c);
write16(d);
}
void Arduino_DataBus::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
writeCommand(c);
write16(d1);
write16(d2);
}
void Arduino_DataBus::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
writeCommand(c);
_data16.value = d1;
write(_data16.msb);
write(_data16.lsb);
_data16.value = d2;
write(_data16.msb);
write(_data16.lsb);
}
void Arduino_DataBus::sendCommand(uint8_t c)
{
beginWrite();
writeCommand(c);
endWrite();
}
void Arduino_DataBus::sendCommand16(uint16_t c)
{
beginWrite();
writeCommand16(c);
endWrite();
}
void Arduino_DataBus::sendData(uint8_t d)
{
beginWrite();
write(d);
endWrite();
}
void Arduino_DataBus::sendData16(uint16_t d)
{
beginWrite();
write16(d);
endWrite();
}
void Arduino_DataBus::batchOperation(const uint8_t *operations, size_t len)
{
for (size_t i = 0; i < len; ++i)
{
uint8_t l = 0;
switch (operations[i])
{
case BEGIN_WRITE:
beginWrite();
break;
case WRITE_C8_D16:
l++;
/* fall through */
case WRITE_C8_D8:
l++;
/* fall through */
case WRITE_COMMAND_8:
writeCommand(operations[++i]);
break;
case WRITE_C16_D16:
l = 2;
/* fall through */
case WRITE_COMMAND_16:
_data16.msb = operations[++i];
_data16.lsb = operations[++i];
writeCommand16(_data16.value);
break;
case WRITE_DATA_8:
l = 1;
break;
case WRITE_DATA_16:
l = 2;
break;
case WRITE_BYTES:
l = operations[++i];
break;
case END_WRITE:
endWrite();
break;
case DELAY:
delay(operations[++i]);
break;
default:
printf("Unknown operation id at %d: %d", i, operations[i]);
break;
}
while (l--)
{
write(operations[++i]);
}
}
}
#if !defined(LITTLE_FOOT_PRINT)
void Arduino_DataBus::writePattern(uint8_t *data, uint8_t len, uint32_t repeat)
{
while (repeat--)
{
writeBytes(data, len);
}
}
void Arduino_DataBus::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
write16(idx[*(data++)]);
}
}
void Arduino_DataBus::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
uint8_t *d = data;
while (len--)
{
_data16.value = idx[*(d++)];
write(_data16.msb);
write(_data16.lsb);
write(_data16.msb);
write(_data16.lsb);
}
}
#endif // !defined(LITTLE_FOOT_PRINT)
+289
View File
@@ -0,0 +1,289 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_DATABUS_H_
#define _ARDUINO_DATABUS_H_
#include <Arduino.h>
#define GFX_SKIP_OUTPUT_BEGIN -2
#define GFX_NOT_DEFINED -1
#define GFX_STR_HELPER(x) #x
#define GFX_STR(x) GFX_STR_HELPER(x)
#if defined(__AVR__)
#define LITTLE_FOOT_PRINT // reduce program size for limited flash MCU
#define USE_FAST_PINIO ///< Use direct PORT register access
typedef uint8_t ARDUINOGFX_PORT_t;
#elif defined(ARDUINO_ARCH_NRF52840)
#define USE_FAST_PINIO ///< Use direct PORT register access
#define HAS_PORT_SET_CLR ///< PORTs have set & clear registers
typedef uint32_t ARDUINOGFX_PORT_t;
#elif defined(TARGET_RP2040)
#define USE_FAST_PINIO ///< Use direct PORT register access
#define HAS_PORT_SET_CLR ///< PORTs have set & clear registers
typedef uint32_t ARDUINOGFX_PORT_t;
#elif defined(ESP32)
#define USE_FAST_PINIO ///< Use direct PORT register access
#define HAS_PORT_SET_CLR ///< PORTs have set & clear registers
typedef uint32_t ARDUINOGFX_PORT_t;
#elif defined(ESP8266)
#define ESP8266SAFEBATCHBITSIZE (2048 * 8 * 9)
#define USE_FAST_PINIO ///< Use direct PORT register access
typedef uint32_t ARDUINOGFX_PORT_t;
#elif defined(ARDUINO_ARCH_STM32)
#define USE_FAST_PINIO ///< Use direct PORT register access
typedef uint32_t ARDUINOGFX_PORT_t;
#elif defined(__arm__)
#if defined(ARDUINO_ARCH_SAMD)
// Adafruit M0, M4
#define USE_FAST_PINIO ///< Use direct PORT register access
#define HAS_PORT_SET_CLR ///< PORTs have set & clear registers
typedef uint32_t ARDUINOGFX_PORT_t;
#elif defined(CONFIG_ARCH_CHIP_CXD56XX) // Sony Spresense
#define USE_FAST_PINIO ///< Use direct PORT register access
typedef uint8_t ARDUINOGFX_PORT_t;
#elif defined(RTL8722DM)
#define USE_FAST_PINIO ///< Use direct PORT register access
typedef uint32_t ARDUINOGFX_PORT_t;
#elif defined(CORE_TEENSY)
#define USE_FAST_PINIO ///< Use direct PORT register access
#define HAS_PORT_SET_CLR ///< PORTs have set & clear registers
#if defined(__IMXRT1052__) || defined(__IMXRT1062__)
// PJRC Teensy 4.x
typedef uint32_t ARDUINOGFX_PORT_t;
#else
// PJRC Teensy 3.x
typedef uint8_t ARDUINOGFX_PORT_t;
#endif
#else
// Arduino Due?
// USE_FAST_PINIO not available here (yet)...Due has a totally different
// GPIO register set and will require some changes elsewhere (e.g. in
// constructors especially).
#endif
#else // !ARM
// Unknow architecture, USE_FAST_PINIO is not available here (yet)
// but don't worry about it too much...the digitalWrite() implementation
// on these platforms is reasonably efficient and already RAM-resident,
// only gotcha then is no parallel connection support for now.
#endif // !ARM
#ifdef USE_FAST_PINIO
typedef volatile ARDUINOGFX_PORT_t *PORTreg_t;
#endif
#if defined(ARDUINO_ARCH_ARC32) || defined(ARDUINO_MAXIM)
#define SPI_DEFAULT_FREQ 16000000
// Teensy 3.0, 3.1/3.2, 3.5, 3.6
#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)
#define SPI_DEFAULT_FREQ 40000000
// Teensy 4.x
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
#define SPI_DEFAULT_FREQ 40000000
#elif defined(__AVR__) || defined(TEENSYDUINO)
#define SPI_DEFAULT_FREQ 8000000
#elif defined(ARDUINO_ARCH_NRF52840)
#define SPI_DEFAULT_FREQ 8000000
#elif defined(ESP8266) || defined(ESP32)
#define SPI_DEFAULT_FREQ 40000000
#elif defined(RTL8722DM)
#define SPI_DEFAULT_FREQ 20000000
#elif defined(RASPI)
#define SPI_DEFAULT_FREQ 80000000
#elif defined(ARDUINO_ARCH_STM32F1)
#define SPI_DEFAULT_FREQ 36000000
#elif defined(ARDUINO_BLACKPILL_F411CE)
#define SPI_DEFAULT_FREQ 50000000
#elif defined(F_CPU)
#define SPI_DEFAULT_FREQ (F_CPU / 4)
#else
#define SPI_DEFAULT_FREQ 24000000 ///< Default SPI data clock frequency
#endif
#ifndef UNUSED
#define UNUSED(x) (void)(x)
#endif
#define ATTR_UNUSED __attribute__((unused))
#define MSB_16(val) (((val)&0xFF00) >> 8) | (((val)&0xFF) << 8)
#define MSB_16_SET(var, val) \
{ \
(var) = MSB_16(val); \
}
#define MSB_32_SET(var, val) \
{ \
uint8_t *v = (uint8_t *)&(val); \
(var) = v[3] | (v[2] << 8) | (v[1] << 16) | (v[0] << 24); \
}
#define MSB_32_16_16_SET(var, v1, v2) \
{ \
(var) = (((uint32_t)v2 & 0xff00) << 8) | (((uint32_t)v2 & 0xff) << 24) | ((v1 & 0xff00) >> 8) | ((v1 & 0xff) << 8); \
}
#define MSB_32_8_ARRAY_SET(var, a) \
{ \
(var) = ((uint32_t)a[0] << 8 | a[1] | a[2] << 24 | a[3] << 16); \
}
#if defined(ESP32)
#define INLINE __attribute__((always_inline)) inline
#else
#define INLINE inline
#endif
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
#include <esp_lcd_panel_io.h>
#include <esp_lcd_panel_io_interface.h>
#include <esp_pm.h>
#include <esp_private/gdma.h>
#include <hal/dma_types.h>
#include <hal/lcd_hal.h>
#include <soc/dport_reg.h>
#include <soc/gpio_sig_map.h>
#include <soc/lcd_cam_reg.h>
#include <soc/lcd_cam_struct.h>
typedef struct esp_lcd_i80_bus_t esp_lcd_i80_bus_t;
typedef struct lcd_panel_io_i80_t lcd_panel_io_i80_t;
typedef struct lcd_i80_trans_descriptor_t lcd_i80_trans_descriptor_t;
struct esp_lcd_i80_bus_t
{
int bus_id; // Bus ID, index from 0
portMUX_TYPE spinlock; // spinlock used to protect i80 bus members(hal, device_list, cur_trans)
lcd_hal_context_t hal; // Hal object
size_t bus_width; // Number of data lines
intr_handle_t intr; // LCD peripheral interrupt handle
esp_pm_lock_handle_t pm_lock; // Power management lock
size_t num_dma_nodes; // Number of DMA descriptors
uint8_t *format_buffer; // The driver allocates an internal buffer for DMA to do data format transformer
size_t resolution_hz; // LCD_CLK resolution, determined by selected clock source
gdma_channel_handle_t dma_chan; // DMA channel handle
size_t psram_trans_align; // DMA transfer alignment for data allocated from PSRAM
size_t sram_trans_align; // DMA transfer alignment for data allocated from SRAM
lcd_i80_trans_descriptor_t *cur_trans; // Current transaction
lcd_panel_io_i80_t *cur_device; // Current working device
LIST_HEAD(i80_device_list, lcd_panel_io_i80_t)
device_list; // Head of i80 device list
struct
{
unsigned int exclusive : 1; // Indicate whether the I80 bus is owned by one device (whose CS GPIO is not assigned) exclusively
} flags;
dma_descriptor_t dma_nodes[]; // DMA descriptor pool, the descriptors are shared by all i80 devices
};
struct lcd_i80_trans_descriptor_t
{
lcd_panel_io_i80_t *i80_device; // i80 device issuing this transaction
int cmd_value; // Command value
uint32_t cmd_cycles; // Command cycles
const void *data; // Data buffer
uint32_t data_length; // Data buffer size
void *user_ctx; // private data used by trans_done_cb
esp_lcd_panel_io_color_trans_done_cb_t trans_done_cb; // transaction done callback
};
struct lcd_panel_io_i80_t
{
esp_lcd_panel_io_t base; // Base class of generic lcd panel io
esp_lcd_i80_bus_t *bus; // Which bus the device is attached to
int cs_gpio_num; // GPIO used for CS line
unsigned int pclk_hz; // PCLK clock frequency
size_t clock_prescale; // Prescaler coefficient, determined by user's configured PCLK frequency
QueueHandle_t trans_queue; // Transaction queue, transactions in this queue are pending for scheduler to dispatch
QueueHandle_t done_queue; // Transaction done queue, transactions in this queue are finished but not recycled by the caller
size_t queue_size; // Size of transaction queue
size_t num_trans_inflight; // Number of transactions that are undergoing (the descriptor not recycled yet)
int lcd_cmd_bits; // Bit width of LCD command
int lcd_param_bits; // Bit width of LCD parameter
void *user_ctx; // private data used when transfer color data
esp_lcd_panel_io_color_trans_done_cb_t on_color_trans_done; // color data trans done callback
LIST_ENTRY(lcd_panel_io_i80_t)
device_list_entry; // Entry of i80 device list
struct
{
unsigned int dc_idle_level : 1; // Level of DC line in IDLE phase
unsigned int dc_cmd_level : 1; // Level of DC line in CMD phase
unsigned int dc_dummy_level : 1; // Level of DC line in DUMMY phase
unsigned int dc_data_level : 1; // Level of DC line in DATA phase
} dc_levels;
struct
{
unsigned int cs_active_high : 1; // Whether the CS line is active on high level
unsigned int reverse_color_bits : 1; // Reverse the data bits, D[N:0] -> D[0:N]
unsigned int swap_color_bytes : 1; // Swap adjacent two data bytes before sending out
unsigned int pclk_active_neg : 1; // The display will write data lines when there's a falling edge on WR line
unsigned int pclk_idle_low : 1; // The WR line keeps at low level in IDLE phase
} flags;
lcd_i80_trans_descriptor_t trans_pool[]; // Transaction pool
};
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
typedef enum
{
BEGIN_WRITE,
WRITE_COMMAND_8,
WRITE_COMMAND_16,
WRITE_DATA_8,
WRITE_DATA_16,
WRITE_BYTES,
WRITE_C8_D8,
WRITE_C8_D16,
WRITE_C16_D16,
END_WRITE,
DELAY,
} spi_operation_type_t;
union
{
uint16_t value;
struct
{
uint8_t lsb;
uint8_t msb;
};
} _data16;
class Arduino_DataBus
{
public:
Arduino_DataBus();
void unused() { UNUSED(_data16); } // avoid compiler warning
virtual bool begin(int32_t speed = SPI_DEFAULT_FREQ, int8_t dataMode = GFX_NOT_DEFINED) = 0;
virtual void beginWrite() = 0;
virtual void endWrite() = 0;
virtual void writeCommand(uint8_t c) = 0;
virtual void writeCommand16(uint16_t c) = 0;
virtual void write(uint8_t) = 0;
virtual void write16(uint16_t) = 0;
virtual void writeC8D8(uint8_t c, uint8_t d);
virtual void writeC16D16(uint16_t c, uint16_t d);
virtual void writeC8D16(uint8_t c, uint16_t d);
virtual void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2);
virtual void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2);
virtual void writeRepeat(uint16_t p, uint32_t len) = 0;
virtual void writePixels(uint16_t *data, uint32_t len) = 0;
void sendCommand(uint8_t c);
void sendCommand16(uint16_t c);
void sendData(uint8_t d);
void sendData16(uint16_t d);
void batchOperation(const uint8_t *operations, size_t len);
#if !defined(LITTLE_FOOT_PRINT)
virtual void writeBytes(uint8_t *data, uint32_t len) = 0;
virtual void writePattern(uint8_t *data, uint8_t len, uint32_t repeat);
virtual void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len);
virtual void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len);
#endif // !defined(LITTLE_FOOT_PRINT)
protected:
int32_t _speed;
int8_t _dataMode;
};
#endif // _ARDUINO_DATABUS_H_
+279
View File
@@ -0,0 +1,279 @@
#if !defined(LITTLE_FOOT_PRINT)
#include "Arduino_G.h"
/**************************************************************************/
/*!
@brief Instatiate a GFX context for graphics! Can only be done by a superclass
@param w Display width, in pixels
@param h Display height, in pixels
*/
/**************************************************************************/
Arduino_G::Arduino_G(int16_t w, int16_t h) : WIDTH(w), HEIGHT(h)
{
}
// utility functions
bool gfx_draw_bitmap_to_framebuffer(
uint16_t *from_bitmap, int16_t bitmap_w, int16_t bitmap_h,
uint16_t *framebuffer, int16_t x, int16_t y, int16_t framebuffer_w, int16_t framebuffer_h)
{
int16_t max_X = framebuffer_w - 1;
int16_t max_Y = framebuffer_h - 1;
if (
((x + bitmap_w - 1) < 0) || // Outside left
((y + bitmap_h - 1) < 0) || // Outside top
(x > max_X) || // Outside right
(y > max_Y) // Outside bottom
)
{
return false;
}
else
{
int16_t xskip = 0;
if ((y + bitmap_h - 1) > max_Y)
{
bitmap_h -= (y + bitmap_h - 1) - max_Y;
}
if (y < 0)
{
from_bitmap -= y * bitmap_w;
bitmap_h += y;
y = 0;
}
if ((x + bitmap_w - 1) > max_X)
{
xskip = (x + bitmap_w - 1) - max_X;
bitmap_w -= xskip;
}
if (x < 0)
{
from_bitmap -= x;
xskip -= x;
bitmap_w += x;
x = 0;
}
uint16_t *row = framebuffer;
row += y * framebuffer_w; // shift framebuffer to y offset
row += x; // shift framebuffer to x offset
if (((framebuffer_w & 1) == 0) && ((xskip & 1) == 0) && ((bitmap_w & 1) == 0))
{
uint32_t *row2 = (uint32_t *)row;
uint32_t *from_bitmap2 = (uint32_t *)from_bitmap;
int16_t framebuffer_w2 = framebuffer_w >> 1;
int16_t xskip2 = xskip >> 1;
int16_t w2 = bitmap_w >> 1;
int16_t j = bitmap_h;
while (j--)
{
for (int16_t i = 0; i < w2; ++i)
{
row2[i] = *from_bitmap2++;
}
from_bitmap2 += xskip2;
row2 += framebuffer_w2;
}
}
else
{
int16_t j = bitmap_h;
while (j--)
{
for (int i = 0; i < bitmap_w; ++i)
{
row[i] = *from_bitmap++;
}
from_bitmap += xskip;
row += framebuffer_w;
}
}
return true;
}
}
bool gfx_draw_bitmap_to_framebuffer_rotate_1(
uint16_t *from_bitmap, int16_t bitmap_w, int16_t bitmap_h,
uint16_t *framebuffer, int16_t x, int16_t y, int16_t framebuffer_w, int16_t framebuffer_h)
{
int16_t max_X = framebuffer_w - 1;
int16_t max_Y = framebuffer_h - 1;
if (
((x + bitmap_w - 1) < 0) || // Outside left
((y + bitmap_h - 1) < 0) || // Outside top
(x > max_X) || // Outside right
(y > max_Y) // Outside bottom
)
{
return false;
}
else
{
int16_t xskip = 0;
if ((y + bitmap_h - 1) > max_Y)
{
bitmap_h -= (y + bitmap_h - 1) - max_Y;
}
if (y < 0)
{
from_bitmap -= y * bitmap_w;
bitmap_h += y;
y = 0;
}
if ((x + bitmap_w - 1) > max_X)
{
xskip = (x + bitmap_w - 1) - max_X;
bitmap_w -= xskip;
}
if (x < 0)
{
from_bitmap -= x;
xskip -= x;
bitmap_w += x;
x = 0;
}
uint16_t *p;
int16_t i;
for (int16_t j = 0; j < bitmap_h; j++)
{
p = framebuffer;
p += (x * framebuffer_h); // shift framebuffer to y offset
p += (framebuffer_h - y - j); // shift framebuffer to x offset
i = bitmap_w;
while (i--)
{
*p = *from_bitmap++;
p += framebuffer_h;
}
from_bitmap += xskip;
}
return true;
}
}
bool gfx_draw_bitmap_to_framebuffer_rotate_2(
uint16_t *from_bitmap, int16_t bitmap_w, int16_t bitmap_h,
uint16_t *framebuffer, int16_t x, int16_t y, int16_t framebuffer_w, int16_t framebuffer_h)
{
int16_t max_X = framebuffer_w - 1;
int16_t max_Y = framebuffer_h - 1;
if (
((x + bitmap_w - 1) < 0) || // Outside left
((y + bitmap_h - 1) < 0) || // Outside top
(x > max_X) || // Outside right
(y > max_Y) // Outside bottom
)
{
return false;
}
else
{
int16_t xskip = 0;
if ((y + bitmap_h - 1) > max_Y)
{
bitmap_h -= (y + bitmap_h - 1) - max_Y;
}
if (y < 0)
{
from_bitmap -= y * bitmap_w;
bitmap_h += y;
y = 0;
}
if ((x + bitmap_w - 1) > max_X)
{
xskip = (x + bitmap_w - 1) - max_X;
bitmap_w -= xskip;
}
if (x < 0)
{
from_bitmap -= x;
xskip -= x;
bitmap_w += x;
x = 0;
}
uint16_t *row = framebuffer;
row += (max_Y - y) * framebuffer_w; // shift framebuffer to y offset
row += framebuffer_w - x - bitmap_w; // shift framebuffer to x offset
int16_t i;
int16_t j = bitmap_h;
while (j--)
{
i = bitmap_w;
while (i--)
{
row[i] = *from_bitmap++;
}
from_bitmap += xskip;
row -= framebuffer_w;
}
return true;
}
}
bool gfx_draw_bitmap_to_framebuffer_rotate_3(
uint16_t *from_bitmap, int16_t bitmap_w, int16_t bitmap_h,
uint16_t *framebuffer, int16_t x, int16_t y, int16_t framebuffer_w, int16_t framebuffer_h)
{
int16_t max_X = framebuffer_w - 1;
int16_t max_Y = framebuffer_h - 1;
if (
((x + bitmap_w - 1) < 0) || // Outside left
((y + bitmap_h - 1) < 0) || // Outside top
(x > max_X) || // Outside right
(y > max_Y) // Outside bottom
)
{
return false;
}
else
{
int16_t xskip = 0;
if ((y + bitmap_h - 1) > max_Y)
{
bitmap_h -= (y + bitmap_h - 1) - max_Y;
}
if (y < 0)
{
from_bitmap -= y * bitmap_w;
bitmap_h += y;
y = 0;
}
if ((x + bitmap_w - 1) > max_X)
{
xskip = (x + bitmap_w - 1) - max_X;
bitmap_w -= xskip;
}
if (x < 0)
{
from_bitmap -= x;
xskip -= x;
bitmap_w += x;
x = 0;
}
uint16_t *p;
int16_t i;
for (int16_t j = 0; j < bitmap_h; j++)
{
p = framebuffer;
p += ((max_X - x) * framebuffer_h); // shift framebuffer to y offset
p += y + j; // shift framebuffer to x offset
i = bitmap_w;
while (i--)
{
*p = *from_bitmap++;
p -= framebuffer_h;
}
from_bitmap += xskip;
}
return true;
}
}
#endif // !defined(LITTLE_FOOT_PRINT)
+50
View File
@@ -0,0 +1,50 @@
#if !defined(LITTLE_FOOT_PRINT)
#ifndef _ARDUINO_G_H_
#define _ARDUINO_G_H_
#include <Arduino.h>
#include "Arduino_DataBus.h"
/// A generic graphics superclass that can handle all sorts of drawing. At a minimum you can subclass and provide drawPixel(). At a maximum you can do a ton of overriding to optimize. Used for any/all Adafruit displays!
class Arduino_G
{
public:
Arduino_G(int16_t w, int16_t h); // Constructor
// This MUST be defined by the subclass:
virtual bool begin(int32_t speed = GFX_NOT_DEFINED) = 0;
virtual void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) = 0;
virtual void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip = 0) = 0;
virtual void draw3bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h) = 0;
virtual void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h) = 0;
virtual void draw24bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h) = 0;
protected:
int16_t
WIDTH, ///< This is the 'raw' display width - never changes
HEIGHT; ///< This is the 'raw' display height - never changes
};
#endif // _ARDUINO_G_H_
// utility functions
bool gfx_draw_bitmap_to_framebuffer(
uint16_t *from_bitmap, int16_t bitmap_w, int16_t bitmap_h,
uint16_t *framebuffer, int16_t x, int16_t y, int16_t framebuffer_w, int16_t framebuffer_h);
bool gfx_draw_bitmap_to_framebuffer_rotate_1(
uint16_t *from_bitmap, int16_t bitmap_w, int16_t bitmap_h,
uint16_t *framebuffer, int16_t x, int16_t y, int16_t framebuffer_w, int16_t framebuffer_h);
bool gfx_draw_bitmap_to_framebuffer_rotate_2(
uint16_t *from_bitmap, int16_t bitmap_w, int16_t bitmap_h,
uint16_t *framebuffer, int16_t x, int16_t y, int16_t framebuffer_w, int16_t framebuffer_h);
bool gfx_draw_bitmap_to_framebuffer_rotate_3(
uint16_t *from_bitmap, int16_t bitmap_w, int16_t bitmap_h,
uint16_t *framebuffer, int16_t x, int16_t y, int16_t framebuffer_w, int16_t framebuffer_h);
#endif // !defined(LITTLE_FOOT_PRINT)
File diff suppressed because it is too large Load Diff
+458
View File
@@ -0,0 +1,458 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_GFX_H_
#define _ARDUINO_GFX_H_
#include <Arduino.h>
#include <Print.h>
#include "Arduino_G.h"
#include "Arduino_DataBus.h"
#if !defined(ATTINY_CORE)
#include "gfxfont.h"
#endif // !defined(ATTINY_CORE)
#ifndef DEGTORAD
#define DEGTORAD 0.017453292519943295769236907684886F
#endif
#if __has_include(<U8g2lib.h>)
#include <U8g2lib.h>
#define U8G2_FONT_SUPPORT
#include "font/u8g2_font_chill7_h_cjk.h"
#include "font/u8g2_font_cubic11_h_cjk.h"
#include "font/u8g2_font_quan7_h_cjk.h"
#include "font/u8g2_font_unifont_h_utf8.h"
#include "font/u8g2_font_unifont_t_chinese.h"
#include "font/u8g2_font_unifont_t_chinese4.h"
#include "font/u8g2_font_unifont_t_cjk.h"
#endif
#define RGB565(r, g, b) ((((r)&0xF8) << 8) | (((g)&0xFC) << 3) | ((b) >> 3))
#define RGB16TO24(c) ((((uint32_t)c & 0xF800) << 8) | ((c & 0x07E0) << 5) | ((c & 0x1F) << 3))
#define RGB565_BLACK RGB565(0, 0, 0)
#define RGB565_NAVY RGB565(0, 0, 123)
#define RGB565_DARKGREEN RGB565(0, 125, 0)
#define RGB565_DARKCYAN RGB565(0, 125, 123)
#define RGB565_MAROON RGB565(123, 0, 0)
#define RGB565_PURPLE RGB565(123, 0, 123)
#define RGB565_OLIVE RGB565(123, 125, 0)
#define RGB565_LIGHTGREY RGB565(198, 195, 198)
#define RGB565_DARKGREY RGB565(123, 125, 123)
#define RGB565_BLUE RGB565(0, 0, 255)
#define RGB565_GREEN RGB565(0, 255, 0)
#define RGB565_CYAN RGB565(0, 255, 255)
#define RGB565_RED RGB565(255, 0, 0)
#define RGB565_MAGENTA RGB565(255, 0, 255)
#define RGB565_YELLOW RGB565(255, 255, 0)
#define RGB565_WHITE RGB565(255, 255, 255)
#define RGB565_ORANGE RGB565(255, 165, 0)
#define RGB565_GREENYELLOW RGB565(173, 255, 41)
#define RGB565_PINK RGB565(255, 130, 198)
// Color definitions
#ifndef DISABLE_COLOR_DEFINES
#define BLACK RGB565_BLACK
#define NAVY RGB565_NAVY
#define DARKGREEN RGB565_DARKGREEN
#define DARKCYAN RGB565_DARKCYAN
#define MAROON RGB565_MAROON
#define PURPLE RGB565_PURPLE
#define OLIVE RGB565_OLIVE
#define LIGHTGREY RGB565_LIGHTGREY
#define DARKGREY RGB565_DARKGREY
#define BLUE RGB565_BLUE
#define GREEN RGB565_GREEN
#define CYAN RGB565_CYAN
#define RED RGB565_RED
#define MAGENTA RGB565_MAGENTA
#define YELLOW RGB565_YELLOW
#define WHITE RGB565_WHITE
#define ORANGE RGB565_ORANGE
#define GREENYELLOW RGB565_GREENYELLOW
#define PINK RGB565_PINK
#endif
// Many (but maybe not all) non-AVR board installs define macros
// for compatibility with existing PROGMEM-reading AVR code.
// Do our own checks and defines here for good measure...
#ifndef pgm_read_byte
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#endif
#ifndef pgm_read_word
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
#ifndef pgm_read_dword
#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
#endif
// workaround of a15 asm compile error
#ifdef ESP8266
#undef pgm_read_word
#define pgm_read_word(addr) (*(const unsigned short *)(addr))
#endif
// Pointers are a peculiar case...typically 16-bit on AVR boards,
// 32 bits elsewhere. Try to accommodate both...
#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
#else
#define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
#endif
#ifndef _swap_uint8_t
#define _swap_uint8_t(a, b) \
{ \
uint8_t t = a; \
a = b; \
b = t; \
}
#endif
#ifndef _swap_int16_t
#define _swap_int16_t(a, b) \
{ \
int16_t t = a; \
a = b; \
b = t; \
}
#endif
#ifndef _diff
#define _diff(a, b) ((a > b) ? (a - b) : (b - a))
#endif
#ifndef _ordered_in_range
#define _ordered_in_range(v, a, b) ((a <= v) && (v <= b))
#endif
#ifndef _in_range
#define _in_range(v, a, b) ((a > b) ? _ordered_in_range(v, b, a) : _ordered_in_range(v, a, b))
#endif
#if !defined(ATTINY_CORE)
INLINE GFXglyph *pgm_read_glyph_ptr(const GFXfont *gfxFont, uint8_t c)
{
#ifdef __AVR__
return &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
#else
// expression in __AVR__ section may generate "dereferencing type-punned pointer will break strict-aliasing rules" warning
// In fact, on other platforms (such as STM32) there is no need to do this pointer magic as program memory may be read in a usual way
// So expression may be simplified
return gfxFont->glyph + c;
#endif //__AVR__
}
INLINE uint8_t *pgm_read_bitmap_ptr(const GFXfont *gfxFont)
{
#ifdef __AVR__
return (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
#else
// expression in __AVR__ section generates "dereferencing type-punned pointer will break strict-aliasing rules" warning
// In fact, on other platforms (such as STM32) there is no need to do this pointer magic as program memory may be read in a usual way
// So expression may be simplified
return gfxFont->bitmap;
#endif //__AVR__
}
#endif // !defined(ATTINY_CORE)
/// A generic graphics superclass that can handle all sorts of drawing. At a minimum you can subclass and provide drawPixel(). At a maximum you can do a ton of overriding to optimize. Used for any/all Adafruit displays!
#if defined(LITTLE_FOOT_PRINT)
class Arduino_GFX : public Print
#else
class Arduino_GFX : public Print, public Arduino_G
#endif // !defined(LITTLE_FOOT_PRINT)
{
public:
Arduino_GFX(int16_t w, int16_t h); // Constructor
// This MUST be defined by the subclass:
virtual bool begin(int32_t speed = GFX_NOT_DEFINED) = 0;
virtual void writePixelPreclipped(int16_t x, int16_t y, uint16_t color) = 0;
// TRANSACTION API / CORE DRAW API
// These MAY be overridden by the subclass to provide device-specific
// optimized code. Otherwise 'generic' versions are used.
virtual void startWrite();
virtual void writeFillRectPreclipped(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
virtual void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
virtual void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
virtual void writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
virtual void endWrite(void);
// CONTROL API
// These MAY be overridden by the subclass to provide device-specific
// optimized code. Otherwise 'generic' versions are used.
virtual void setRotation(uint8_t r);
virtual void invertDisplay(bool i);
virtual void displayOn();
virtual void displayOff();
// BASIC DRAW API
// These MAY be overridden by the subclass to provide device-specific
// optimized code. Otherwise 'generic' versions are used.
// It's good to implement those, even if using transaction API
void writePixel(int16_t x, int16_t y, uint16_t color);
void drawPixel(int16_t x, int16_t y, uint16_t color);
void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);
void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);
void writeFillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
void fillScreen(uint16_t color);
void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
void drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
void fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);
void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);
void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);
void drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color);
void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
void drawXBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color);
void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[], const uint8_t mask[], int16_t w, int16_t h);
void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint8_t *mask, int16_t w, int16_t h);
void draw16bitRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], const uint8_t mask[], int16_t w, int16_t h);
void draw24bitRGBBitmap(int16_t x, int16_t y, const uint8_t bitmap[], const uint8_t mask[], int16_t w, int16_t h);
void draw24bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint8_t *mask, int16_t w, int16_t h);
void getTextBounds(const char *string, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
void getTextBounds(const __FlashStringHelper *s, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
void getTextBounds(const String &str, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);
void setTextSize(uint8_t s);
void setTextSize(uint8_t sx, uint8_t sy);
void setTextSize(uint8_t sx, uint8_t sy, uint8_t pixel_margin);
#if !defined(ATTINY_CORE)
void setFont(const GFXfont *f = NULL);
#if defined(U8G2_FONT_SUPPORT)
void setFont(const uint8_t *font);
void setUTF8Print(bool isEnable);
uint16_t u8g2_font_get_word(const uint8_t *font, uint8_t offset);
uint8_t u8g2_font_decode_get_unsigned_bits(uint8_t cnt);
int8_t u8g2_font_decode_get_signed_bits(uint8_t cnt);
void u8g2_font_decode_len(uint8_t len, uint8_t is_foreground, uint16_t color, uint16_t bg);
#endif // defined(U8G2_FONT_SUPPORT)
virtual void flush(void);
#endif // !defined(ATTINY_CORE)
// adopt from LovyanGFX
void drawEllipse(int16_t x, int16_t y, int16_t rx, int16_t ry, uint16_t color);
void drawEllipseHelper(int32_t x, int32_t y, int32_t rx, int32_t ry, uint8_t cornername, uint16_t color);
void fillEllipse(int16_t x, int16_t y, int16_t rx, int16_t ry, uint16_t color);
void fillEllipseHelper(int32_t x, int32_t y, int32_t rx, int32_t ry, uint8_t cornername, int16_t delta, uint16_t color);
void drawArc(int16_t x, int16_t y, int16_t r1, int16_t r2, float start, float end, uint16_t color);
void fillArc(int16_t x, int16_t y, int16_t r1, int16_t r2, float start, float end, uint16_t color);
void fillArcHelper(int16_t cx, int16_t cy, int16_t oradius, int16_t iradius, float start, float end, uint16_t color);
// TFT optimization code, too big for ATMEL family
#if defined(LITTLE_FOOT_PRINT)
void writeSlashLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
void drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color, uint16_t bg);
void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h);
void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h);
void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip = 0);
void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, uint8_t chroma_key, int16_t w, int16_t h, int16_t x_skip = 0);
void draw3bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h);
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h);
void draw16bitRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], int16_t w, int16_t h);
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h);
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint16_t transparent_color, int16_t w, int16_t h);
void draw16bitBeRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h);
void draw24bitRGBBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h);
void draw24bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h);
void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg);
#else // !defined(LITTLE_FOOT_PRINT)
virtual void writeSlashLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
virtual void drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color, uint16_t bg);
virtual void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
virtual void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h);
virtual void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h);
virtual void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip = 0);
virtual void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, uint8_t chroma_key, int16_t w, int16_t h, int16_t x_skip = 0);
virtual void draw3bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h);
virtual void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h);
virtual void draw16bitRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], int16_t w, int16_t h);
virtual void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h);
virtual void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint16_t transparent_color, int16_t w, int16_t h);
virtual void draw16bitBeRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h);
virtual void draw24bitRGBBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h);
virtual void draw24bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h);
virtual void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg);
#endif // !defined(LITTLE_FOOT_PRINT)
/**********************************************************************/
/*!
@brief Set text cursor location
@param x X coordinate in pixels
@param y Y coordinate in pixels
*/
/**********************************************************************/
void setCursor(int16_t x, int16_t y)
{
cursor_x = x;
cursor_y = y;
}
/**********************************************************************/
/*!
@brief Set text font color with transparant background
@param c 16-bit 5-6-5 Color to draw text with
@note For 'transparent' background, background and foreground
are set to same color rather than using a separate flag.
*/
/**********************************************************************/
void setTextColor(uint16_t c) { textcolor = textbgcolor = c; }
/**********************************************************************/
/*!
@brief Set text font color with custom background color
@param c 16-bit 5-6-5 Color to draw text with
@param bg 16-bit 5-6-5 Color to draw background/fill with
*/
/**********************************************************************/
void setTextColor(uint16_t c, uint16_t bg)
{
textcolor = c;
textbgcolor = bg;
}
/**********************************************************************/
/*!
@brief Set whether text that is too long for the screen width should
automatically wrap around to the next line (else clip right).
@param w true for wrapping, false for clipping
*/
/**********************************************************************/
void setTextWrap(bool w) { wrap = w; }
virtual size_t write(uint8_t);
/************************************************************************/
/*!
@brief Get width of the display, accounting for current rotation
@returns Width in pixels
*/
/************************************************************************/
int16_t width(void) const { return _width; };
/************************************************************************/
/*!
@brief Get height of the display, accounting for current rotation
@returns Height in pixels
*/
/************************************************************************/
int16_t height(void) const { return _height; }
/************************************************************************/
/*!
@brief Get rotation setting for display
@returns 0 thru 3 corresponding to 4 cardinal rotations
*/
/************************************************************************/
uint8_t getRotation(void) const { return _rotation; }
// get current cursor position (get rotation safe maximum values,
// using: width() for x, height() for y)
/************************************************************************/
/*!
@brief Get text cursor X location
@returns X coordinate in pixels
*/
/************************************************************************/
int16_t getCursorX(void) const { return cursor_x; }
/************************************************************************/
/*!
@brief Get text cursor Y location
@returns Y coordinate in pixels
*/
/************************************************************************/
int16_t getCursorY(void) const { return cursor_y; };
/*!
@brief Given 8-bit red, green and blue values, return a 'packed'
16-bit color value in '565' RGB format (5 bits red, 6 bits
green, 5 bits blue). This is just a mathematical operation,
no hardware is touched.
@param red 8-bit red brightnesss (0 = off, 255 = max).
@param green 8-bit green brightnesss (0 = off, 255 = max).
@param blue 8-bit blue brightnesss (0 = off, 255 = max).
@return 'Packed' 16-bit color value (565 format).
*/
uint16_t color565(uint8_t red, uint8_t green, uint8_t blue)
{
return ((red & 0xF8) << 8) | ((green & 0xFC) << 3) | (blue >> 3);
}
protected:
void charBounds(char c, int16_t *x, int16_t *y, int16_t *minx, int16_t *miny, int16_t *maxx, int16_t *maxy);
int16_t
_width, ///< Display width as modified by current rotation
_height, ///< Display height as modified by current rotation
_max_x, ///< x zero base bound (_width - 1)
_max_y, ///< y zero base bound (_height - 1)
cursor_x, ///< x location to start print()ing text
cursor_y; ///< y location to start print()ing text
uint16_t
textcolor, ///< 16-bit background color for print()
textbgcolor; ///< 16-bit text color for print()
uint8_t
textsize_x, ///< Desired magnification in X-axis of text to print()
textsize_y, ///< Desired magnification in Y-axis of text to print()
text_pixel_margin, ///< Margin for each text pixel
_rotation; ///< Display rotation (0 thru 3)
bool
wrap; ///< If set, 'wrap' text at right edge of display
#if !defined(ATTINY_CORE)
GFXfont *gfxFont; ///< Pointer to special font
#endif // !defined(ATTINY_CORE)
#if defined(U8G2_FONT_SUPPORT)
uint8_t *u8g2Font;
bool _enableUTF8Print = false;
uint8_t _utf8_state = 0;
uint16_t _encoding;
uint8_t _u8g2_glyph_cnt;
uint8_t _u8g2_bits_per_0;
uint8_t _u8g2_bits_per_1;
uint8_t _u8g2_bits_per_char_width;
uint8_t _u8g2_bits_per_char_height;
uint8_t _u8g2_bits_per_char_x;
uint8_t _u8g2_bits_per_char_y;
uint8_t _u8g2_bits_per_delta_x;
int8_t _u8g2_max_char_width;
int8_t _u8g2_max_char_height;
uint16_t _u8g2_start_pos_upper_A;
uint16_t _u8g2_start_pos_lower_a;
uint16_t _u8g2_start_pos_unicode;
uint8_t _u8g2_first_char;
uint8_t _u8g2_char_width;
uint8_t _u8g2_char_height;
int8_t _u8g2_char_x;
int8_t _u8g2_char_y;
int8_t _u8g2_delta_x;
int8_t _u8g2_dx;
int8_t _u8g2_dy;
uint16_t _u8g2_target_x;
uint16_t _u8g2_target_y;
const uint8_t *_u8g2_decode_ptr;
uint8_t _u8g2_decode_bit_pos;
#endif // defined(U8G2_FONT_SUPPORT)
#if defined(LITTLE_FOOT_PRINT)
int16_t
WIDTH, ///< This is the 'raw' display width - never changes
HEIGHT; ///< This is the 'raw' display height - never changes
#endif // defined(LITTLE_FOOT_PRINT)
};
#endif // _ARDUINO_GFX_H_
@@ -0,0 +1,38 @@
#include "Arduino_GFX_Library.h"
Arduino_DataBus *create_default_Arduino_DataBus()
{
#if defined(ARDUINO_ARCH_NRF52840)
return new Arduino_NRFXSPI(DF_GFX_DC, DF_GFX_CS, DF_GFX_SCK, DF_GFX_MOSI, DF_GFX_MISO);
#elif defined(TARGET_RP2040)
return new Arduino_RPiPicoSPI(DF_GFX_DC, DF_GFX_CS, DF_GFX_SCK, DF_GFX_MOSI, DF_GFX_MISO, DF_GFX_SPI);
#elif defined(ESP32)
return new Arduino_ESP32SPI(DF_GFX_DC, DF_GFX_CS, DF_GFX_SCK, DF_GFX_MOSI, DF_GFX_MISO);
#elif defined(ESP8266)
return new Arduino_ESP8266SPI(DF_GFX_DC, DF_GFX_CS);
#else
return new Arduino_HWSPI(DF_GFX_DC, DF_GFX_CS);
#endif
}
Arduino_GFX *create_default_Arduino_GFX()
{
Arduino_DataBus *bus = create_default_Arduino_DataBus();
#if defined(WIO_TERMINAL)
return new Arduino_ILI9341(bus, DF_GFX_RST, 1 /* rotation */);
#elif defined(ESP32_S3_BOX)
return new Arduino_ILI9342(bus, DF_GFX_RST, 0 /* rotation */);
#elif defined(M5STACK_CORE)
return new Arduino_ILI9342(bus, DF_GFX_RST, 2 /* rotation */);
#elif defined(M5STACK_ATOMS3)
return new Arduino_GC9107(bus, 34 /* RST */, 0 /* rotation */, true /* IPS */);
#elif defined(ODROID_GO)
return new Arduino_ILI9341(bus, DF_GFX_RST, 3 /* rotation */);
#elif defined(TTGO_T_WATCH)
return new Arduino_ST7789(bus, DF_GFX_RST, 0 /* rotation */, true /* IPS */, 240, 240, 0, 80);
#elif defined(WAVESHARE_RP2040_LCD_1_28)
return new Arduino_ST7789(bus, DF_GFX_RST, 0 /* rotation */, true /* IPS */, 240, 240, 0, 80);
#else
return new Arduino_GC9A01(bus, DF_GFX_RST, 0 /* rotation */, true /* IPS */);
#endif
}
+282
View File
@@ -0,0 +1,282 @@
#ifndef _ARDUINO_GFX_LIBRARIES_H_
#define _ARDUINO_GFX_LIBRARIES_H_
#include "Arduino_DataBus.h"
#include "databus/Arduino_AVRPAR8.h"
#include "databus/Arduino_AVRPAR16.h"
#include "databus/Arduino_ESP32LCD8.h"
#include "databus/Arduino_ESP32LCD16.h"
#include "databus/Arduino_ESP32PAR8.h"
#include "databus/Arduino_ESP32PAR8Q.h"
#include "databus/Arduino_ESP32PAR8QQ.h"
#include "databus/Arduino_ESP32PAR8QQQ.h"
#include "databus/Arduino_ESP32PAR16.h"
#include "databus/Arduino_ESP32PAR16Q.h"
#include "databus/Arduino_ESP32PAR16QQ.h"
#include "databus/Arduino_ESP32QSPI.h"
#include "databus/Arduino_ESP32RGBPanel.h"
#include "databus/Arduino_ESP32S2PAR8.h"
#include "databus/Arduino_ESP32S2PAR8Q.h"
#include "databus/Arduino_ESP32S2PAR16.h"
#include "databus/Arduino_ESP32S2PAR16Q.h"
#include "databus/Arduino_ESP32SPI.h"
#include "databus/Arduino_ESP32SPIDMA.h"
#include "databus/Arduino_ESP8266SPI.h"
#include "databus/Arduino_HWSPI.h"
#include "databus/Arduino_mbedSPI.h"
#include "databus/Arduino_NRFXSPI.h"
#include "databus/Arduino_RPiPicoPAR8.h"
#include "databus/Arduino_RPiPicoPAR16.h"
#include "databus/Arduino_RPiPicoSPI.h"
#include "databus/Arduino_RTLPAR8.h"
#include "databus/Arduino_STM32PAR8.h"
#include "databus/Arduino_SWPAR8.h"
#include "databus/Arduino_SWPAR16.h"
#include "databus/Arduino_SWSPI.h"
#include "databus/Arduino_XL9535SWSPI.h"
#include "Arduino_GFX.h" // Core graphics library
#if !defined(LITTLE_FOOT_PRINT)
#include "canvas/Arduino_Canvas.h"
#include "canvas/Arduino_Canvas_Indexed.h"
#include "canvas/Arduino_Canvas_3bit.h"
#include "canvas/Arduino_Canvas_Mono.h"
#include "display/Arduino_ILI9488_3bit.h"
#endif // !defined(LITTLE_FOOT_PRINT)
#include "display/Arduino_GC9106.h"
#include "display/Arduino_GC9107.h"
#include "display/Arduino_GC9A01.h"
#include "display/Arduino_HX8347C.h"
#include "display/Arduino_HX8347D.h"
#include "display/Arduino_HX8352C.h"
#include "display/Arduino_HX8357A.h"
#include "display/Arduino_HX8357B.h"
#include "display/Arduino_HX8369A.h"
#include "display/Arduino_ILI9225.h"
#include "display/Arduino_ILI9331.h"
#include "display/Arduino_ILI9341.h"
#include "display/Arduino_ILI9342.h"
#include "display/Arduino_ILI9481_18bit.h"
#include "display/Arduino_ILI9486.h"
#include "display/Arduino_ILI9486_18bit.h"
#include "display/Arduino_ILI9488.h"
#include "display/Arduino_ILI9488_18bit.h"
#include "display/Arduino_ILI9806.h"
#include "display/Arduino_JBT6K71.h"
#include "display/Arduino_NT35310.h"
#include "display/Arduino_NT35510.h"
#include "display/Arduino_NT39125.h"
#include "display/Arduino_NV3041A.h"
#include "display/Arduino_OTM8009A.h"
#include "display/Arduino_R61529.h"
#include "display/Arduino_RM67162.h"
#include "display/Arduino_RGB_Display.h"
#include "display/Arduino_SEPS525.h"
#include "display/Arduino_SSD1283A.h"
#include "display/Arduino_SSD1331.h"
#include "display/Arduino_SSD1351.h"
#include "display/Arduino_ST7735.h"
#include "display/Arduino_ST7789.h"
#include "display/Arduino_ST7796.h"
#if defined(ARDUINO_ARCH_SAMD) && defined(SEEED_GROVE_UI_WIRELESS)
#define DISPLAY_DEV_KIT
#define WIO_TERMINAL
#define DF_GFX_CS LCD_SS_PIN
#define DF_GFX_DC LCD_DC
#define DF_GFX_RST GFX_NOT_DEFINED
#define DF_GFX_BL LCD_BACKLIGHT
#elif defined(ARDUINO_ESP32_S3_BOX)
#define DISPLAY_DEV_KIT
#define ESP32_S3_BOX
#define DF_GFX_SCK TFT_CLK
#define DF_GFX_MOSI TFT_MOSI
#define DF_GFX_MISO TFT_MISO
#define DF_GFX_CS TFT_CS
#define DF_GFX_DC TFT_DC
#define DF_GFX_RST TFT_RST
#define DF_GFX_BL TFT_BL
#elif defined(ARDUINO_M5Stack_Core_ESP32) || defined(ARDUINO_M5STACK_FIRE)
#define DISPLAY_DEV_KIT
#define M5STACK_CORE
#define DF_GFX_SCK 18
#define DF_GFX_MOSI 23
#define DF_GFX_MISO 19
#define DF_GFX_CS 14
#define DF_GFX_DC 27
#define DF_GFX_RST 33
#define DF_GFX_BL 32
#elif defined(ARDUINO_M5Stack_ATOMS3)
#define DISPLAY_DEV_KIT
#define M5STACK_ATOMS3
#define DF_GFX_SCK 17
#define DF_GFX_MOSI 21
#define DF_GFX_MISO GFX_NOT_DEFINED
#define DF_GFX_CS 15
#define DF_GFX_DC 33
#define DF_GFX_RST 34
#define DF_GFX_BL 16
#elif defined(ARDUINO_ODROID_ESP32)
#define DISPLAY_DEV_KIT
#define ODROID_GO
#define DF_GFX_SCK 18
#define DF_GFX_MOSI 23
#define DF_GFX_MISO 19
#define DF_GFX_CS 5
#define DF_GFX_DC 21
#define DF_GFX_RST GFX_NOT_DEFINED
#define DF_GFX_BL 14
/* TTGO T-Watch */
#elif defined(ARDUINO_T) || defined(ARDUINO_TWATCH_BASE) || defined(ARDUINO_TWATCH_2020_V1) || defined(ARDUINO_TWATCH_2020_V2)
#define DISPLAY_DEV_KIT
#define TTGO_T_WATCH
#define DF_GFX_SCK 18
#define DF_GFX_MOSI 19
#define DF_GFX_MISO GFX_NOT_DEFINED
#define DF_GFX_CS 5
#define DF_GFX_DC 27
#define DF_GFX_RST GFX_NOT_DEFINED
#define DF_GFX_BL 12
/* Waveshare RP2040-LCD-1.28 */
#elif defined(ARDUINO_WAVESHARE_RP2040_LCD_1_28)
#define DISPLAY_DEV_KIT
#define WAVESHARE_RP2040_LCD_1_28
#define DF_GFX_SCK 10
#define DF_GFX_MOSI 11
#define DF_GFX_MISO 12
#define DF_GFX_CS 9
#define DF_GFX_DC 8
#define DF_GFX_RST 12
#define DF_GFX_BL 25
#define DF_GFX_SPI spi1
#elif defined(ARDUINO_ARCH_NRF52840)
#define DF_GFX_SCK 13
#define DF_GFX_MOSI 11
#define DF_GFX_MISO 12
#define DF_GFX_CS 9
#define DF_GFX_DC 8
#define DF_GFX_RST 7
#define DF_GFX_BL 6
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
// PJRC Teensy 4.x
#define DF_GFX_SCK 13
#define DF_GFX_MOSI 11
#define DF_GFX_MISO 12
#define DF_GFX_CS 39 // GFX_NOT_DEFINED for display without CS pin
#define DF_GFX_DC 41
#define DF_GFX_RST 40
#define DF_GFX_BL 22
#elif defined(ARDUINO_BLACKPILL_F411CE)
#define DF_GFX_SCK 5
#define DF_GFX_MOSI 7
#define DF_GFX_MISO 6
#define DF_GFX_CS 4
#define DF_GFX_DC 3
#define DF_GFX_RST 2
#define DF_GFX_BL 1
#elif defined(TARGET_RP2040)
#define DF_GFX_SCK 18
#define DF_GFX_MOSI 19
#define DF_GFX_MISO 16
#define DF_GFX_CS 17
#define DF_GFX_DC 27
#define DF_GFX_RST 26
#define DF_GFX_BL 28
#define DF_GFX_SPI spi0
#elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32)
#define DF_GFX_SCK 18
#define DF_GFX_MOSI 23
#define DF_GFX_MISO GFX_NOT_DEFINED
#define DF_GFX_CS 5
#define DF_GFX_DC 27
#define DF_GFX_RST 33
#define DF_GFX_BL 22
#elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2)
#define DF_GFX_SCK 36
#define DF_GFX_MOSI 35
#define DF_GFX_MISO GFX_NOT_DEFINED
#define DF_GFX_CS 34
#define DF_GFX_DC 38
#define DF_GFX_RST 33
#define DF_GFX_BL 21
#elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
#define DF_GFX_SCK 36
#define DF_GFX_MOSI 35
#define DF_GFX_MISO GFX_NOT_DEFINED
#define DF_GFX_CS 40
#define DF_GFX_DC 41
#define DF_GFX_RST 42
#define DF_GFX_BL 48
#elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32C3)
#define DF_GFX_SCK 4
#define DF_GFX_MOSI 6
#define DF_GFX_MISO GFX_NOT_DEFINED
#define DF_GFX_CS 7
#define DF_GFX_DC 2
#define DF_GFX_RST 1
#define DF_GFX_BL 3
#elif defined(ESP8266)
#define DF_GFX_SCK 14
#define DF_GFX_MOSI 13
#define DF_GFX_MISO 12
#define DF_GFX_CS 15
#define DF_GFX_DC 4
#define DF_GFX_RST 2
#define DF_GFX_BL 5
#elif defined(RTL8722DM)
#if defined(BOARD_RTL8720DN_BW16)
#define DF_GFX_SCK 10
#define DF_GFX_MOSI 12
#define DF_GFX_MISO 11
#define DF_GFX_CS 9
#define DF_GFX_DC 8
#define DF_GFX_RST 6
#define DF_GFX_BL 3
#elif defined(BOARD_RTL8722DM)
#define DF_GFX_SCK 13
#define DF_GFX_MOSI 11
#define DF_GFX_MISO 12
#define DF_GFX_CS 18
#define DF_GFX_DC 17
#define DF_GFX_RST 22
#define DF_GFX_BL 23
#elif defined(BOARD_RTL8722DM_MINI)
#define DF_GFX_SCK 11
#define DF_GFX_MOSI 9
#define DF_GFX_MISO 10
#define DF_GFX_CS 12
#define DF_GFX_DC 14
#define DF_GFX_RST 15
#define DF_GFX_BL 13
#else // old version
#define DF_GFX_SCK 19
#define DF_GFX_MOSI 21
#define DF_GFX_MISO 20
#define DF_GFX_CS 18 // GFX_NOT_DEFINED for display without CS pin
#define DF_GFX_DC 17
#define DF_GFX_RST 2
#define DF_GFX_BL 23
#endif
#elif defined(SEEED_XIAO_M0)
#define DF_GFX_SCK 8
#define DF_GFX_MOSI 10
#define DF_GFX_MISO 9
#define DF_GFX_CS 3 // GFX_NOT_DEFINED for display without CS pin
#define DF_GFX_DC 2
#define DF_GFX_RST 1
#define DF_GFX_BL 0
#else // default pins for Arduino Nano, Mini, Micro and more
#define DF_GFX_SCK 13
#define DF_GFX_MOSI 11
#define DF_GFX_MISO 12
#define DF_GFX_CS 9
#define DF_GFX_DC 8
#define DF_GFX_RST 7
#define DF_GFX_BL 6
#endif
Arduino_DataBus *create_default_Arduino_DataBus();
Arduino_GFX *create_default_Arduino_GFX();
#endif // _ARDUINO_GFX_LIBRARIES_H_
+995
View File
@@ -0,0 +1,995 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#include "Arduino_DataBus.h"
#include "Arduino_GFX.h"
#include "Arduino_TFT.h"
#include "font/glcdfont.h"
Arduino_TFT::Arduino_TFT(
Arduino_DataBus *bus, int8_t rst, uint8_t r,
bool ips, int16_t w, int16_t h,
uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2)
: Arduino_GFX(w, h), _bus(bus), _rst(rst), _ips(ips),
COL_OFFSET1(col_offset1), ROW_OFFSET1(row_offset1),
COL_OFFSET2(col_offset2), ROW_OFFSET2(row_offset2)
{
_rotation = r;
}
bool Arduino_TFT::begin(int32_t speed)
{
if (_override_datamode != GFX_NOT_DEFINED)
{
if (!_bus->begin(speed, _override_datamode))
{
return false;
}
}
else
{
if (!_bus->begin(speed))
{
return false;
}
}
tftInit();
setRotation(_rotation); // apply the setting rotation to the display
setAddrWindow(0, 0, _width, _height);
return true;
}
void Arduino_TFT::startWrite()
{
_bus->beginWrite();
}
void Arduino_TFT::writePixelPreclipped(int16_t x, int16_t y, uint16_t color)
{
writeAddrWindow(x, y, 1, 1);
_bus->write16(color);
}
void Arduino_TFT::writeRepeat(uint16_t color, uint32_t len)
{
_bus->writeRepeat(color, len);
}
void Arduino_TFT::writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color)
{
if (_ordered_in_range(x, 0, _max_x) && h)
{ // X on screen, nonzero height
if (h < 0)
{ // If negative height...
y += h + 1; // Move Y to top edge
h = -h; // Use positive height
}
if (y <= _max_y)
{ // Not off bottom
int16_t y2 = y + h - 1;
if (y2 >= 0)
{ // Not off top
// Line partly or fully overlaps screen
if (y < 0)
{
y = 0;
h = y2 + 1;
} // Clip top
if (y2 > _max_y)
{
h = _max_y - y + 1;
} // Clip bottom
writeFillRectPreclipped(x, y, 1, h, color);
}
}
}
}
void Arduino_TFT::writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color)
{
if (_ordered_in_range(y, 0, _max_y) && w)
{ // Y on screen, nonzero width
if (w < 0)
{ // If negative width...
x += w + 1; // Move X to left edge
w = -w; // Use positive width
}
if (x <= _max_x)
{ // Not off right
int16_t x2 = x + w - 1;
if (x2 >= 0)
{ // Not off left
// Line partly or fully overlaps screen
if (x < 0)
{
x = 0;
w = x2 + 1;
} // Clip left
if (x2 > _max_x)
{
w = _max_x - x + 1;
} // Clip right
writeFillRectPreclipped(x, y, w, 1, color);
}
}
}
}
void Arduino_TFT::writeFillRectPreclipped(
int16_t x, int16_t y,
int16_t w, int16_t h, uint16_t color)
{
#ifdef ESP8266
yield();
#endif
writeAddrWindow(x, y, w, h);
writeRepeat(color, (uint32_t)w * h);
}
void Arduino_TFT::endWrite()
{
_bus->endWrite();
}
void Arduino_TFT::setAddrWindow(int16_t x0, int16_t y0, uint16_t w,
uint16_t h)
{
startWrite();
writeAddrWindow(x0, y0, w, h);
endWrite();
}
void Arduino_TFT::setRotation(uint8_t r)
{
Arduino_GFX::setRotation(r);
switch (_rotation)
{
case 5:
case 3:
_xStart = ROW_OFFSET2;
_yStart = COL_OFFSET1;
break;
case 6:
case 2:
_xStart = COL_OFFSET2;
_yStart = ROW_OFFSET2;
break;
case 7:
case 1:
_xStart = ROW_OFFSET1;
_yStart = COL_OFFSET2;
break;
case 4:
default: // case 0:
_xStart = COL_OFFSET1;
_yStart = ROW_OFFSET1;
break;
}
_currentX = 0xFFFF;
_currentY = 0xFFFF;
_currentW = 0xFFFF;
_currentH = 0xFFFF;
}
void Arduino_TFT::writeColor(uint16_t color)
{
_bus->write16(color);
}
// TFT optimization code, too big for ATMEL family
#if !defined(LITTLE_FOOT_PRINT)
void Arduino_TFT::writeBytes(uint8_t *data, uint32_t len)
{
_bus->writeBytes(data, len);
}
void Arduino_TFT::writePixels(uint16_t *data, uint32_t len)
{
_bus->writePixels(data, len);
}
void Arduino_TFT::pushColor(uint16_t color)
{
_bus->beginWrite();
writeColor(color);
_bus->endWrite();
}
void Arduino_TFT::writeSlashLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color)
{
int16_t dx;
int16_t dy;
int16_t err;
int16_t xs;
int16_t step;
int16_t len;
bool steep = _diff(y1, y0) > _diff(x1, x0);
if (steep)
{
_swap_int16_t(x0, y0);
_swap_int16_t(x1, y1);
}
if (x0 > x1)
{
_swap_int16_t(x0, x1);
_swap_int16_t(y0, y1);
}
dx = x1 - x0;
dy = _diff(y1, y0);
err = dx >> 1;
xs = x0;
step = (y0 < y1) ? 1 : -1;
len = 0;
while (x0 <= x1)
{
x0++;
len++;
err -= dy;
if ((err < 0) || ((x0 > x1) && len))
{
if (steep)
{
writeFillRectPreclipped(y0, xs, 1, len, color);
}
else
{
writeFillRectPreclipped(xs, y0, len, 1, color);
}
err += dx;
y0 += step;
len = 0;
xs = x0;
}
}
}
// TFT tuned BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS ---------------------
void Arduino_TFT::writeIndexedPixels(uint8_t *bitmap, uint16_t *color_index, uint32_t len)
{
_bus->writeIndexedPixels(bitmap, color_index, len);
}
void Arduino_TFT::writeIndexedPixelsDouble(uint8_t *bitmap, uint16_t *color_index, uint32_t len)
{
_bus->writeIndexedPixelsDouble(bitmap, color_index, len);
}
void Arduino_TFT::drawBitmap(
int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color, uint16_t bg)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawBitmap(x, y, bitmap, w, h, color, bg);
}
else
{
int32_t pixels = w * h;
uint8_t byte = 0;
uint16_t idx = 0;
startWrite();
writeAddrWindow(x, y, w, h);
for (int32_t i = 0; i < pixels; i++)
{
if (i & 7)
{
byte <<= 1;
}
else
{
byte = pgm_read_byte(&bitmap[idx++]);
}
_bus->write16((byte & 0x80) ? color : bg);
}
endWrite();
}
}
void Arduino_TFT::drawBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawBitmap(x, y, bitmap, w, h, color, bg);
}
else
{
int32_t pixels = w * h;
uint8_t byte = 0;
startWrite();
writeAddrWindow(x, y, w, h);
for (int32_t i = 0; i < pixels; i++)
{
if (i & 7)
{
byte <<= 1;
}
else
{
byte = *(bitmap++);
}
_bus->write16((byte & 0x80) ? color : bg);
}
endWrite();
}
}
void Arduino_TFT::drawGrayscaleBitmap(
int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawGrayscaleBitmap(x, y, bitmap, w, h);
}
else
{
uint32_t len = (uint32_t)w * h;
uint8_t v;
startWrite();
writeAddrWindow(x, y, w, h);
for (uint32_t i = 0; i < len; i++)
{
v = (uint8_t)pgm_read_byte(&bitmap[i]);
_bus->write16(color565(v, v, v));
}
endWrite();
}
}
void Arduino_TFT::drawGrayscaleBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawGrayscaleBitmap(x, y, bitmap, w, h);
}
else
{
uint32_t len = (uint32_t)w * h;
uint8_t v;
startWrite();
writeAddrWindow(x, y, w, h);
while (len--)
{
v = *(bitmap++);
_bus->write16(color565(v, v, v));
}
endWrite();
}
}
void Arduino_TFT::drawIndexedBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawIndexedBitmap(x, y, bitmap, color_index, w, h, x_skip);
}
else
{
startWrite();
writeAddrWindow(x, y, w, h);
if (x_skip == 0) {
_bus->writeIndexedPixels(bitmap, color_index, h*w);
} else {
while (h--)
{
_bus->writeIndexedPixels(bitmap, color_index, w);
bitmap += w + x_skip;
}
}
endWrite();
}
}
void Arduino_TFT::draw16bitRGBBitmap(int16_t x, int16_t y,
uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw16bitRGBBitmap(x, y, bitmap, mask, w, h);
}
else
{
int32_t offset = 0, maskIdx = 0, len = 0;
uint8_t byte = 0;
startWrite();
for (int16_t j = 0; j < h; j++, y++)
{
for (int16_t i = 0; i < w; i++)
{
if (i & 7)
{
byte <<= 1;
}
else
{
byte = mask[maskIdx++];
}
if (byte & 0x80)
{
len++;
}
else
{
if (len)
{
writeAddrWindow(x + i - len, y, len, 1);
_bus->writePixels(&bitmap[offset - len], len);
len = 0;
}
}
offset++;
}
if (len)
{
writeAddrWindow(x + w - 1 - len, y, len, 1);
_bus->writePixels(&bitmap[offset - len], len);
len = 0;
}
}
endWrite();
}
}
void Arduino_TFT::draw16bitRGBBitmap(
int16_t x, int16_t y,
const uint16_t bitmap[], int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw16bitRGBBitmap(x, y, bitmap, w, h);
}
else
{
uint32_t len = (uint32_t)w * h;
startWrite();
writeAddrWindow(x, y, w, h);
for (uint32_t i = 0; i < len; i++)
{
_bus->write16(pgm_read_word(&bitmap[i]));
}
endWrite();
}
}
void Arduino_TFT::draw16bitRGBBitmap(
int16_t x, int16_t y,
uint16_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw16bitRGBBitmap(x, y, bitmap, w, h);
}
else
{
startWrite();
writeAddrWindow(x, y, w, h);
_bus->writePixels(bitmap, (uint32_t)w * h);
endWrite();
}
}
void Arduino_TFT::draw16bitBeRGBBitmap(
int16_t x, int16_t y,
uint16_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw16bitBeRGBBitmap(x, y, bitmap, w, h);
}
else
{
startWrite();
writeAddrWindow(x, y, w, h);
_bus->writeBytes((uint8_t *)bitmap, (uint32_t)w * h * 2);
endWrite();
}
}
void Arduino_TFT::draw24bitRGBBitmap(
int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw24bitRGBBitmap(x, y, bitmap, w, h);
}
else
{
uint32_t len = (uint32_t)w * h;
uint32_t offset = 0;
startWrite();
writeAddrWindow(x, y, w, h);
while (len--)
{
_bus->write16(color565(pgm_read_byte(&bitmap[offset]), pgm_read_byte(&bitmap[offset + 1]), pgm_read_byte(&bitmap[offset + 2])));
offset += 3;
}
endWrite();
}
}
void Arduino_TFT::draw24bitRGBBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw24bitRGBBitmap(x, y, bitmap, w, h);
}
else
{
uint32_t len = (uint32_t)w * h;
uint32_t offset = 0;
startWrite();
writeAddrWindow(x, y, w, h);
while (len--)
{
_bus->write16(color565(bitmap[offset], bitmap[offset + 1], bitmap[offset + 2]));
offset += 3;
}
endWrite();
}
}
void Arduino_TFT::drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg)
{
uint16_t block_w;
uint16_t block_h;
#if !defined(ATTINY_CORE)
if (gfxFont) // custom font
{
// Character is assumed previously filtered by write() to eliminate
// newlines, returns, non-printable characters, etc. Calling
// drawChar() directly with 'bad' characters of font may cause mayhem!
uint8_t first = pgm_read_byte(&gfxFont->first);
GFXglyph *glyph = pgm_read_glyph_ptr(gfxFont, c - first);
uint8_t *bitmap = pgm_read_bitmap_ptr(gfxFont);
uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height),
xAdvance = pgm_read_byte(&glyph->xAdvance),
yAdvance = pgm_read_byte(&gfxFont->yAdvance),
baseline = yAdvance * 2 / 3; // TODO: baseline is an arbitrary currently, may be define in font file
int8_t xo = pgm_read_byte(&glyph->xOffset),
yo = pgm_read_byte(&glyph->yOffset);
// urgly workaround for the character not fit in the box
if ((bg != color) // have background color
&& ((xo + w) > xAdvance)) // if character draw outside the box
{
xo = xAdvance - w; // pad inside the box
}
uint8_t xx, yy, bits = 0, bit = 0;
int16_t xo16 = xo, yo16 = yo;
if (xAdvance < w)
{
xAdvance = w; // Don't know why it exists
}
block_w = xAdvance * textsize_x;
block_h = yAdvance * textsize_y;
int16_t x1 = (xo < 0) ? (x + xo) : x;
if (
(x1 < 0) || // Clip left
((y - baseline) < 0) || // Clip top
((x1 + block_w - 1) > _max_x) || // Clip right
((y - baseline + block_h - 1) > _max_y) // Clip bottom
)
{
// partial draw char by parent class
Arduino_GFX::drawChar(x, y, c, color, bg);
}
else
{
// NOTE: Different from Adafruit_GFX design, Adruino_GFX also cater background.
// Since it may introduce many ugly output, it should limited using on mono font only.
if (xo < 0) // padding X offset to >= 0
{
x += xo;
xo = 0;
}
startWrite();
if (bg != color) // have background color
{
writeAddrWindow(x, y - (baseline * textsize_y), block_w, block_h);
uint16_t line_buf[block_w];
int8_t i;
bool draw_dot;
for (yy = 0; yy < yAdvance; yy++)
{
if ((yy < (baseline + yo)) || (yy > (baseline + yo + h - 1)))
{
writeRepeat(bg, block_w * textsize_y);
}
else
{
i = 0;
for (xx = 0; xx < xAdvance; xx++)
{
if ((xx < xo) || (xx > (xo + w - 1)))
{
draw_dot = false;
}
else
{
if (!(bit++ & 7))
{
bits = pgm_read_byte(&bitmap[bo++]);
}
draw_dot = bits & 0x80;
bits <<= 1;
}
if (textsize_x == 1)
{
line_buf[i++] = draw_dot ? color : bg;
}
else
{
if (draw_dot)
{
for (int8_t k = 0; k < textsize_x; k++)
{
line_buf[i++] = (k < (textsize_x - text_pixel_margin)) ? color : bg;
}
}
else
{
for (int8_t k = 0; k < textsize_x; k++)
{
line_buf[i++] = bg;
}
}
}
}
if (textsize_y == 1)
{
writePixels(line_buf, block_w);
}
else
{
for (int8_t l = 0; l < textsize_y; l++)
{
if (l < (textsize_y - text_pixel_margin))
{
writePixels(line_buf, block_w);
}
else
{
writeRepeat(bg, block_w);
}
}
}
}
}
}
else // (bg == color), no background color
{
for (yy = 0; yy < h; yy++)
{
for (xx = 0; xx < w; xx++)
{
if (!(bit++ & 7))
{
bits = pgm_read_byte(&bitmap[bo++]);
}
if (bits & 0x80)
{
if (textsize_x == 1 && textsize_y == 1)
{
writePixelPreclipped(x + xo + xx, y + yo + yy, color);
}
else
{
writeFillRectPreclipped(x + (xo16 + xx) * textsize_x, y + (yo16 + yy) * textsize_y,
textsize_x - text_pixel_margin, textsize_y - text_pixel_margin, color);
}
}
bits <<= 1;
}
}
}
endWrite();
}
}
else // not gfxFont
#endif // !defined(ATTINY_CORE)
#if defined(U8G2_FONT_SUPPORT)
if (u8g2Font)
{
Arduino_GFX::drawChar(x, y, c, color, bg);
}
else // not u8g2Font
#endif // defined(U8G2_FONT_SUPPORT)
{
block_w = 6 * textsize_x;
block_h = 8 * textsize_y;
if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + block_w - 1) > _max_x) || // Clip right
((y + block_h - 1) > _max_y) // Clip bottom
)
{
// partial draw char by parent class
Arduino_GFX::drawChar(x, y, c, color, bg);
}
else
{
uint8_t col[5];
for (int8_t i = 0; i < 5; i++)
{
col[i] = pgm_read_byte(&font[c * 5 + i]);
}
startWrite();
if (bg != color) // have background color
{
writeAddrWindow(x, y, block_w, block_h);
uint16_t line_buf[block_w];
if (textsize_x == 1)
{
line_buf[5] = bg; // last column always bg
}
else
{
for (int8_t k = 0; k < textsize_x; k++)
{
line_buf[5 * textsize_x + k] = bg;
}
}
uint8_t bit = 1;
bool draw_dot;
while (bit)
{
for (int8_t i = 0; i < 5; i++)
{
draw_dot = col[i] & bit;
if (textsize_x == 1)
{
line_buf[i] = (draw_dot) ? color : bg;
}
else
{
if (draw_dot)
{
for (int8_t k = 0; k < textsize_x; k++)
{
line_buf[i * textsize_x + k] = (k < (textsize_x - text_pixel_margin)) ? color : bg;
}
}
else
{
for (int8_t k = 0; k < textsize_x; k++)
{
line_buf[i * textsize_x + k] = bg;
}
}
}
}
if (textsize_y == 1)
{
writePixels(line_buf, block_w);
}
else
{
for (int8_t l = 0; l < textsize_y; l++)
{
if (l < (textsize_y - text_pixel_margin))
{
writePixels(line_buf, block_w);
}
else
{
writeRepeat(bg, block_w);
}
}
}
bit <<= 1;
}
}
else // (bg == color), no background color
{
for (int8_t i = 0; i < 5; i++)
{ // Char bitmap = 5 columns
uint8_t line = col[i];
for (int8_t j = 0; j < 8; j++, line >>= 1)
{
if (line & 1)
{
if (textsize_x == 1 && textsize_y == 1)
{
writePixelPreclipped(x + i, y + j, color);
}
else
{
writeFillRectPreclipped(x + i * textsize_x, y + j * textsize_y, textsize_x - text_pixel_margin, textsize_y - text_pixel_margin, color);
}
}
}
}
}
endWrite();
}
}
}
#endif // !defined(LITTLE_FOOT_PRINT)
+76
View File
@@ -0,0 +1,76 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_TFT_H_
#define _ARDUINO_TFT_H_
#include "Arduino_DataBus.h"
#include "Arduino_GFX.h"
class Arduino_TFT : public Arduino_GFX
{
public:
Arduino_TFT(Arduino_DataBus *bus, int8_t rst, uint8_t r, bool ips, int16_t w, int16_t h, uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2);
// This SHOULD be defined by the subclass:
void setRotation(uint8_t r) override;
// This MUST be defined by the subclass:
// and also protected function: tftInit()
virtual void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) = 0;
bool begin(int32_t speed = GFX_NOT_DEFINED);
void startWrite(void) override;
void endWrite(void) override;
void writePixelPreclipped(int16_t x, int16_t y, uint16_t color) override;
void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) override;
void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) override;
void writeFillRectPreclipped(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) override;
virtual void writeRepeat(uint16_t color, uint32_t len);
void setAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h);
virtual void writeColor(uint16_t color);
// TFT optimization code, too big for ATMEL family
#if !defined(LITTLE_FOOT_PRINT)
virtual void writePixels(uint16_t *data, uint32_t size);
virtual void writeIndexedPixels(uint8_t *bitmap, uint16_t *color_index, uint32_t len);
virtual void writeIndexedPixelsDouble(uint8_t *bitmap, uint16_t *color_index, uint32_t len);
void writeBytes(uint8_t *data, uint32_t size);
void pushColor(uint16_t color);
void writeSlashLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) override;
void drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color, uint16_t bg) override;
void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) override;
void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h) override;
void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h) override;
void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip = 0) override;
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h) override;
void draw16bitRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], int16_t w, int16_t h) override;
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h) override;
void draw16bitBeRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h) override;
void draw24bitRGBBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h) override;
void draw24bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h) override;
void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg) override;
#endif // !defined(LITTLE_FOOT_PRINT)
protected:
virtual void tftInit() = 0;
Arduino_DataBus *_bus;
int8_t _rst;
bool _ips;
uint8_t COL_OFFSET1, ROW_OFFSET1;
uint8_t COL_OFFSET2, ROW_OFFSET2;
uint8_t _xStart, _yStart;
int16_t _currentX, _currentY;
uint16_t _currentW, _currentH;
int8_t _override_datamode = GFX_NOT_DEFINED;
private:
};
#endif
+584
View File
@@ -0,0 +1,584 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#include "Arduino_DataBus.h"
#include "Arduino_GFX.h"
#include "Arduino_TFT_18bit.h"
Arduino_TFT_18bit::Arduino_TFT_18bit(
Arduino_DataBus *bus, int8_t rst, uint8_t r,
bool ips, int16_t w, int16_t h,
uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2)
: Arduino_TFT(bus, rst, r, ips, w, h, col_offset1, row_offset1, col_offset2, row_offset2)
{
}
void Arduino_TFT_18bit::writeColor(uint16_t color)
{
_bus->write((color & 0xF800) >> 8);
_bus->write((color & 0x07E0) >> 3);
_bus->write(color << 3);
}
void Arduino_TFT_18bit::writePixelPreclipped(int16_t x, int16_t y, uint16_t color)
{
writeAddrWindow(x, y, 1, 1);
_bus->write((color & 0xF800) >> 8);
_bus->write((color & 0x07E0) >> 3);
_bus->write(color << 3);
}
void Arduino_TFT_18bit::writeRepeat(uint16_t color, uint32_t len)
{
#if defined(ESP8266) || defined(ESP32)
uint8_t c[3] = {(uint8_t)((color & 0xF800) >> 8), (uint8_t)((color & 0x07E0) >> 3), (uint8_t)((color & 0x001F) << 3)};
_bus->writePattern(c, 3, len);
#else
uint8_t c1 = (uint8_t)((color & 0xF800) >> 8);
uint8_t c2 = (uint8_t)((color & 0x07E0) >> 3);
uint8_t c3 = (uint8_t)((color & 0x001F) << 3);
while (len--)
{
_bus->write(c1);
_bus->write(c2);
_bus->write(c3);
}
#endif
}
// TFT optimization code, too big for ATMEL family
#if !defined(LITTLE_FOOT_PRINT)
void Arduino_TFT_18bit::writePixels(uint16_t *data, uint32_t len)
{
uint16_t d;
while (len--)
{
d = *data++;
_bus->write((d & 0xF800) >> 8);
_bus->write((d & 0x07E0) >> 3);
_bus->write(d << 3);
}
}
// TFT tuned BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS ---------------------
void Arduino_TFT_18bit::writeIndexedPixels(uint8_t *bitmap, uint16_t *color_index, uint32_t len)
{
uint16_t d;
while (len--)
{
d = color_index[*(bitmap++)];
_bus->write((d & 0xF800) >> 8);
_bus->write((d & 0x07E0) >> 3);
_bus->write(d << 3);
}
}
void Arduino_TFT_18bit::writeIndexedPixelsDouble(uint8_t *bitmap, uint16_t *color_index, uint32_t len)
{
uint8_t r, g, b;
uint16_t d;
while (len--)
{
d = color_index[*(bitmap++)];
r = (d & 0xF800) >> 8;
g = (d & 0x07E0) >> 3;
b = d << 3;
_bus->write(r);
_bus->write(g);
_bus->write(b);
_bus->write(r);
_bus->write(g);
_bus->write(b);
}
}
void Arduino_TFT_18bit::drawBitmap(
int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color, uint16_t bg)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawBitmap(x, y, bitmap, w, h, color, bg);
}
else
{
uint16_t c;
int32_t pixels = w * h;
uint8_t byte = 0;
uint16_t idx = 0;
startWrite();
writeAddrWindow(x, y, w, h);
for (int32_t i = 0; i < pixels; i++)
{
if (i & 7)
{
byte <<= 1;
}
else
{
byte = pgm_read_byte(&bitmap[idx++]);
}
c = (byte & 0x80) ? color : bg;
_bus->write((c & 0xF800) >> 8);
_bus->write((c & 0x07E0) >> 3);
_bus->write((c & 0x001F) << 3);
}
endWrite();
}
}
void Arduino_TFT_18bit::drawBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawBitmap(x, y, bitmap, w, h, color, bg);
}
else
{
uint16_t c;
int32_t pixels = w * h;
uint8_t byte = 0;
startWrite();
writeAddrWindow(x, y, w, h);
for (int32_t i = 0; i < pixels; i++)
{
if (i & 7)
{
byte <<= 1;
}
else
{
byte = *(bitmap++);
}
c = (byte & 0x80) ? color : bg;
_bus->write((c & 0xF800) >> 8);
_bus->write((c & 0x07E0) >> 3);
_bus->write((c & 0x001F) << 3);
}
endWrite();
}
}
void Arduino_TFT_18bit::drawGrayscaleBitmap(
int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawGrayscaleBitmap(x, y, bitmap, w, h);
}
else
{
uint8_t v;
startWrite();
writeAddrWindow(x, y, w, h);
for (int16_t j = 0; j < h; j++, y++)
{
for (int16_t i = 0; i < w; i++)
{
v = (uint8_t)pgm_read_byte(&bitmap[j * w + i]);
_bus->write(v);
_bus->write(v);
_bus->write(v);
}
}
endWrite();
}
}
void Arduino_TFT_18bit::drawGrayscaleBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawGrayscaleBitmap(x, y, bitmap, w, h);
}
else
{
uint8_t v;
startWrite();
writeAddrWindow(x, y, w, h);
for (int16_t j = 0; j < h; j++, y++)
{
for (int16_t i = 0; i < w; i++)
{
v = bitmap[j * w + i];
_bus->write(v);
_bus->write(v);
_bus->write(v);
}
}
endWrite();
}
}
void Arduino_TFT_18bit::drawIndexedBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::drawIndexedBitmap(x, y, bitmap, color_index, w, h, x_skip);
}
else
{
startWrite();
writeAddrWindow(x, y, w, h);
while (h--)
{
writeIndexedPixels(bitmap, color_index, w);
bitmap += w + x_skip;
}
endWrite();
}
}
void Arduino_TFT_18bit::draw16bitRGBBitmap(
int16_t x, int16_t y,
const uint16_t bitmap[], int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw16bitRGBBitmap(x, y, bitmap, w, h);
}
else
{
uint16_t d;
startWrite();
writeAddrWindow(x, y, w, h);
for (int16_t j = 0; j < h; j++, y++)
{
for (int16_t i = 0; i < w; i++)
{
d = pgm_read_word(&bitmap[j * w + i]);
_bus->write((d & 0xF800) >> 8);
_bus->write((d & 0x07E0) >> 3);
_bus->write(d << 3);
}
}
endWrite();
}
}
void Arduino_TFT_18bit::draw16bitRGBBitmap(
int16_t x, int16_t y,
uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw16bitRGBBitmap(x, y, bitmap, mask, w, h);
}
else
{
uint16_t d;
int32_t offset = 0, maskIdx = 0, len = 0;
uint8_t byte = 0;
startWrite();
for (int16_t j = 0; j < h; j++, y++)
{
for (int16_t i = 0; i < w; i++)
{
if (i & 7)
{
byte <<= 1;
}
else
{
byte = mask[maskIdx++];
}
if (byte & 0x80)
{
len++;
}
else
{
if (len)
{
writeAddrWindow(x + i - len, y, len, 1);
for (int16_t i = len; i > 0; i--)
{
d = bitmap[offset - i];
_bus->write((d & 0xF800) >> 8);
_bus->write((d & 0x07E0) >> 3);
_bus->write(d << 3);
}
len = 0;
}
}
offset++;
}
if (len)
{
writeAddrWindow(x + w - 1 - len, y, len, 1);
for (int16_t i = len; i > 0; i--)
{
d = bitmap[offset - i];
_bus->write((d & 0xF800) >> 8);
_bus->write((d & 0x07E0) >> 3);
_bus->write(d << 3);
}
len = 0;
}
}
endWrite();
}
}
void Arduino_TFT_18bit::draw16bitRGBBitmap(
int16_t x, int16_t y,
uint16_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw16bitRGBBitmap(x, y, bitmap, w, h);
}
else
{
uint16_t d;
startWrite();
writeAddrWindow(x, y, w, h);
for (int16_t j = 0; j < h; j++, y++)
{
for (int16_t i = 0; i < w; i++)
{
d = bitmap[j * w + i];
_bus->write((d & 0xF800) >> 8);
_bus->write((d & 0x07E0) >> 3);
_bus->write(d << 3);
}
}
endWrite();
}
}
void Arduino_TFT_18bit::draw16bitBeRGBBitmap(
int16_t x, int16_t y,
uint16_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw16bitBeRGBBitmap(x, y, bitmap, w, h);
}
else
{
uint16_t d;
startWrite();
writeAddrWindow(x, y, w, h);
for (int16_t j = 0; j < h; j++, y++)
{
for (int16_t i = 0; i < w; i++)
{
d = bitmap[j * w + i];
_bus->write((d & 0x00F8));
_bus->write(((d & 0xE000) >> 11) | (d & 0x0007) << 5);
_bus->write((d & 0x1F00) >> 5);
}
}
endWrite();
}
}
void Arduino_TFT_18bit::draw24bitRGBBitmap(
int16_t x, int16_t y,
const uint8_t bitmap[], int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw24bitRGBBitmap(x, y, bitmap, w, h);
}
else
{
int16_t offset = 0;
startWrite();
writeAddrWindow(x, y, w, h);
for (int16_t j = 0; j < h; j++, y++)
{
for (int16_t i = 0; i < w; i++)
{
_bus->write(pgm_read_byte(&bitmap[offset++]));
_bus->write(pgm_read_byte(&bitmap[offset++]));
_bus->write(pgm_read_byte(&bitmap[offset++]));
}
}
endWrite();
}
}
void Arduino_TFT_18bit::draw24bitRGBBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else if (
(x < 0) || // Clip left
(y < 0) || // Clip top
((x + w - 1) > _max_x) || // Clip right
((y + h - 1) > _max_y) // Clip bottom
)
{
Arduino_GFX::draw24bitRGBBitmap(x, y, bitmap, w, h);
}
else
{
startWrite();
writeAddrWindow(x, y, w, h);
_bus->writeBytes(bitmap, w * h * 3);
endWrite();
}
}
#endif // !defined(LITTLE_FOOT_PRINT)
+44
View File
@@ -0,0 +1,44 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_TFT_18BIT_H_
#define _ARDUINO_TFT_18BIT_H_
#include "Arduino_DataBus.h"
#include "Arduino_GFX.h"
#include "Arduino_TFT.h"
class Arduino_TFT_18bit : public Arduino_TFT
{
public:
Arduino_TFT_18bit(Arduino_DataBus *bus, int8_t rst, uint8_t r, bool ips, int16_t w, int16_t h, uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2);
void writeColor(uint16_t color) override;
void writePixelPreclipped(int16_t x, int16_t y, uint16_t color) override;
void writeRepeat(uint16_t color, uint32_t len) override;
// TFT optimization code, too big for ATMEL family
#if !defined(LITTLE_FOOT_PRINT)
void writePixels(uint16_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *bitmap, uint16_t *color_index, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *bitmap, uint16_t *color_index, uint32_t len) override;
void drawBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h, uint16_t color, uint16_t bg) override;
void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) override;
void drawGrayscaleBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h) override;
void drawGrayscaleBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h) override;
void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip = 0) override;
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint8_t *mask, int16_t w, int16_t h) override;
void draw16bitRGBBitmap(int16_t x, int16_t y, const uint16_t bitmap[], int16_t w, int16_t h) override;
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h) override;
void draw16bitBeRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h) override;
void draw24bitRGBBitmap(int16_t x, int16_t y, const uint8_t bitmap[], int16_t w, int16_t h) override;
void draw24bitRGBBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h) override;
#endif // !defined(LITTLE_FOOT_PRINT)
protected:
private:
};
#endif
@@ -0,0 +1,551 @@
#include "../Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#include "../Arduino_GFX.h"
#include "Arduino_Canvas.h"
Arduino_Canvas::Arduino_Canvas(
int16_t w, int16_t h, Arduino_G *output, int16_t output_x, int16_t output_y)
: Arduino_GFX(w, h), _output(output), _output_x(output_x), _output_y(output_y)
{
}
Arduino_Canvas::~Arduino_Canvas()
{
if (_framebuffer)
{
free(_framebuffer);
}
}
bool Arduino_Canvas::begin(int32_t speed)
{
if (
(speed != GFX_SKIP_OUTPUT_BEGIN) && (_output))
{
if (!_output->begin(speed))
{
return false;
}
}
if (!_framebuffer)
{
size_t s = _width * _height * 2;
#if defined(ESP32)
if (psramFound())
{
_framebuffer = (uint16_t *)ps_malloc(s);
}
else
{
_framebuffer = (uint16_t *)malloc(s);
}
#else
_framebuffer = (uint16_t *)malloc(s);
#endif
if (!_framebuffer)
{
return false;
}
}
return true;
}
void Arduino_Canvas::writePixelPreclipped(int16_t x, int16_t y, uint16_t color)
{
_framebuffer[((int32_t)y * _width) + x] = color;
}
void Arduino_Canvas::writeFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color)
{
if (_ordered_in_range(x, 0, _max_x) && h)
{ // X on screen, nonzero height
if (h < 0)
{ // If negative height...
y += h + 1; // Move Y to top edge
h = -h; // Use positive height
}
if (y <= _max_y)
{ // Not off bottom
int16_t y2 = y + h - 1;
if (y2 >= 0)
{ // Not off top
// Line partly or fully overlaps screen
if (y < 0)
{
y = 0;
h = y2 + 1;
} // Clip top
if (y2 > _max_y)
{
h = _max_y - y + 1;
} // Clip bottom
uint16_t *fb = _framebuffer + ((int32_t)y * _width) + x;
while (h--)
{
*fb = color;
fb += _width;
}
}
}
}
}
void Arduino_Canvas::writeFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color)
{
if (_ordered_in_range(y, 0, _max_y) && w)
{ // Y on screen, nonzero width
if (w < 0)
{ // If negative width...
x += w + 1; // Move X to left edge
w = -w; // Use positive width
}
if (x <= _max_x)
{ // Not off right
int16_t x2 = x + w - 1;
if (x2 >= 0)
{ // Not off left
// Line partly or fully overlaps screen
if (x < 0)
{
x = 0;
w = x2 + 1;
} // Clip left
if (x2 > _max_x)
{
w = _max_x - x + 1;
} // Clip right
uint16_t *fb = _framebuffer + ((int32_t)y * _width) + x;
while (w--)
{
*(fb++) = color;
}
}
}
}
}
void Arduino_Canvas::writeFillRectPreclipped(int16_t x, int16_t y,
int16_t w, int16_t h, uint16_t color)
{
uint16_t *row = _framebuffer;
row += y * _width;
row += x;
for (int j = 0; j < h; j++)
{
for (int i = 0; i < w; i++)
{
row[i] = color;
}
row += _width;
}
}
void Arduino_Canvas::drawIndexedBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else
{
if ((y + h - 1) > _max_y)
{
h -= (y + h - 1) - _max_y;
}
if (y < 0)
{
bitmap -= y * w;
h += y;
y = 0;
}
if ((x + w - 1) > _max_x)
{
x_skip += (x + w - 1) - _max_x;
w -= (x + w - 1) - _max_x;
}
if (x < 0)
{
bitmap -= x;
x_skip -= x;
w += x;
x = 0;
}
uint16_t *row = _framebuffer;
row += y * _width;
row += x;
int16_t i;
int16_t wi;
while (h--)
{
i = 0;
wi = w;
while (wi >= 4)
{
uint32_t b32 = *((uint32_t *)bitmap);
row[i++] = color_index[(b32 & 0xff)];
row[i++] = color_index[(b32 & 0xff00) >> 8];
row[i++] = color_index[(b32 & 0xff0000) >> 16];
row[i++] = color_index[(b32 & 0xff000000) >> 24];
wi -= 4;
bitmap += 4;
}
while (i < w)
{
row[i++] = color_index[*bitmap++];
}
bitmap += x_skip;
row += _width;
}
}
}
void Arduino_Canvas::drawIndexedBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, uint16_t *color_index, uint8_t chroma_key, int16_t w, int16_t h, int16_t x_skip)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else
{
if ((y + h - 1) > _max_y)
{
h -= (y + h - 1) - _max_y;
}
if (y < 0)
{
bitmap -= y * w;
h += y;
y = 0;
}
if ((x + w - 1) > _max_x)
{
x_skip += (x + w - 1) - _max_x;
w -= (x + w - 1) - _max_x;
}
if (x < 0)
{
bitmap -= x;
x_skip -= x;
w += x;
x = 0;
}
uint16_t *row = _framebuffer;
row += y * _width;
row += x;
int16_t i;
int16_t wi;
uint8_t color_key;
while (h--)
{
i = 0;
wi = w;
while (wi >= 4)
{
uint32_t b32 = *((uint32_t *)bitmap);
color_key = (b32 & 0xff);
if (color_key != chroma_key)
{
row[i] = color_index[color_key];
}
++i;
color_key = (b32 & 0xff00) >> 8;
if (color_key != chroma_key)
{
row[i] = color_index[color_key];
}
++i;
color_key = (b32 & 0xff0000) >> 16;
if (color_key != chroma_key)
{
row[i] = color_index[color_key];
}
++i;
color_key = (b32 & 0xff000000) >> 24;
if (color_key != chroma_key)
{
row[i] = color_index[color_key];
}
++i;
wi -= 4;
bitmap += 4;
}
while (i < w)
{
color_key = *bitmap++;
if (color_key != chroma_key)
{
row[i] = color_index[color_key];
}
++i;
}
bitmap += x_skip;
row += _width;
}
}
}
void Arduino_Canvas::draw16bitRGBBitmap(int16_t x, int16_t y,
uint16_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else
{
int16_t xskip = 0;
if ((y + h - 1) > _max_y)
{
h -= (y + h - 1) - _max_y;
}
if (y < 0)
{
bitmap -= y * w;
h += y;
y = 0;
}
if ((x + w - 1) > _max_x)
{
xskip = (x + w - 1) - _max_x;
w -= xskip;
}
if (x < 0)
{
bitmap -= x;
xskip -= x;
w += x;
x = 0;
}
uint16_t *row = _framebuffer;
row += y * _width;
row += x;
int16_t i;
int16_t wi;
while (h--)
{
i = 0;
wi = w;
while (wi >= 4)
{
uint32_t b32 = *((uint32_t *)bitmap);
row[i++] = (b32 & 0xffff);
row[i++] = (b32 & 0xffff0000) >> 16;
wi -= 2;
bitmap += 2;
}
while (i < w)
{
row[i++] = *bitmap++;
}
bitmap += xskip;
row += _width;
}
}
}
void Arduino_Canvas::draw16bitRGBBitmap(
int16_t x, int16_t y,
uint16_t *bitmap, uint16_t transparent_color, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else
{
int16_t xskip = 0;
if ((y + h - 1) > _max_y)
{
h -= (y + h - 1) - _max_y;
}
if (y < 0)
{
bitmap -= y * w;
h += y;
y = 0;
}
if ((x + w - 1) > _max_x)
{
xskip = (x + w - 1) - _max_x;
w -= xskip;
}
if (x < 0)
{
bitmap -= x;
xskip -= x;
w += x;
x = 0;
}
uint16_t *row = _framebuffer;
row += y * _width;
row += x;
int16_t i;
int16_t wi;
uint16_t p;
while (h--)
{
i = 0;
wi = w;
while (wi >= 4)
{
uint32_t b32 = *((uint32_t *)bitmap);
p = (b32 & 0xffff);
if (p != transparent_color)
{
row[i] = p;
}
++i;
p = (b32 & 0xffff0000) >> 16;
if (p != transparent_color)
{
row[i] = p;
}
++i;
wi -= 2;
bitmap += 2;
}
while (i < w)
{
p = *bitmap++;
if (p != transparent_color)
{
row[i] = p;
}
++i;
}
bitmap += xskip;
row += _width;
}
}
}
void Arduino_Canvas::draw16bitBeRGBBitmap(int16_t x, int16_t y,
uint16_t *bitmap, int16_t w, int16_t h)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else
{
int16_t xskip = 0;
if ((y + h - 1) > _max_y)
{
h -= (y + h - 1) - _max_y;
}
if (y < 0)
{
bitmap -= y * w;
h += y;
y = 0;
}
if ((x + w - 1) > _max_x)
{
xskip = (x + w - 1) - _max_x;
w -= xskip;
}
if (x < 0)
{
bitmap -= x;
xskip -= x;
w += x;
x = 0;
}
uint16_t *row = _framebuffer;
row += y * _width;
row += x;
uint16_t color;
for (int j = 0; j < h; j++)
{
for (int i = 0; i < w; i++)
{
color = *bitmap++;
MSB_16_SET(row[i], color);
}
bitmap += xskip;
row += _width;
}
}
}
void Arduino_Canvas::flush()
{
if (_output)
{
_output->draw16bitRGBBitmap(_output_x, _output_y, _framebuffer, _width, _height);
}
}
void Arduino_Canvas::flushQuad(void)
{
int16_t y = _output_y;
uint16_t *row1 = _framebuffer;
uint16_t *row2 = _framebuffer + _width;
if (_output)
{
int16_t hQuad = _height / 2;
int16_t wQuad = _width / 2;
if (!_rowBuf)
{
_rowBuf = (uint16_t *)malloc(wQuad * 2);
}
uint16_t p;
while (hQuad--)
{
for (int16_t i = 0; i < wQuad; ++i)
{
p = (*row1++ & 0b1110011110011100) >> 2;
p += (*row1++ & 0b1110011110011100) >> 2;
p += (*row2++ & 0b1110011110011100) >> 2;
p += (*row2++ & 0b1110011110011100) >> 2;
_rowBuf[i] = p;
}
_output->draw16bitRGBBitmap(_output_x, _output_y + y++, _rowBuf, wQuad, 1);
row1 += _width;
row2 += _width;
}
}
}
uint16_t *Arduino_Canvas::getFramebuffer()
{
return _framebuffer;
}
#endif // !defined(LITTLE_FOOT_PRINT)
@@ -0,0 +1,41 @@
#include "../Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#ifndef _ARDUINO_CANVAS_H_
#define _ARDUINO_CANVAS_H_
#include "../Arduino_GFX.h"
class Arduino_Canvas : public Arduino_GFX
{
public:
Arduino_Canvas(int16_t w, int16_t h, Arduino_G *output, int16_t output_x = 0, int16_t output_y = 0);
~Arduino_Canvas();
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writePixelPreclipped(int16_t x, int16_t y, uint16_t color) override;
void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) override;
void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) override;
void writeFillRectPreclipped(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) override;
void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip = 0) override;
void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, uint8_t chroma_key, int16_t w, int16_t h, int16_t x_skip = 0) override;
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h) override;
void draw16bitRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, uint16_t transparent_color, int16_t w, int16_t h) override;
void draw16bitBeRGBBitmap(int16_t x, int16_t y, uint16_t *bitmap, int16_t w, int16_t h) override;
void flush(void) override;
void flushQuad(void);
uint16_t *getFramebuffer();
protected:
uint16_t *_framebuffer = nullptr;
uint16_t *_rowBuf = nullptr;
Arduino_G *_output = nullptr;
int16_t _output_x, _output_y;
private:
};
#endif // _ARDUINO_CANVAS_H_
#endif // !defined(LITTLE_FOOT_PRINT)
@@ -0,0 +1,81 @@
#include "../Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#include "../Arduino_GFX.h"
#include "Arduino_Canvas_3bit.h"
Arduino_Canvas_3bit::Arduino_Canvas_3bit(int16_t w, int16_t h, Arduino_G *output, int16_t output_x, int16_t output_y)
: Arduino_GFX(w, h), _output(output), _output_x(output_x), _output_y(output_y)
{
}
Arduino_Canvas_3bit::~Arduino_Canvas_3bit()
{
if (_framebuffer)
{
free(_framebuffer);
}
}
bool Arduino_Canvas_3bit::begin(int32_t speed)
{
if (speed != GFX_SKIP_OUTPUT_BEGIN)
{
if (!_output->begin(speed))
{
return false;
}
}
if (!_framebuffer)
{
size_t s = (_width * _height + 1) / 2;
#if defined(ESP32)
if (psramFound())
{
_framebuffer = (uint8_t *)ps_malloc(s);
}
else
{
_framebuffer = (uint8_t *)malloc(s);
}
#else
_framebuffer = (uint8_t *)malloc(s);
#endif
if (!_framebuffer)
{
return false;
}
}
return true;
}
void Arduino_Canvas_3bit::writePixelPreclipped(int16_t x, int16_t y, uint16_t color)
{
int32_t pos = x + (y * _width);
int32_t idx = pos >> 1;
uint8_t c = (((color & 0b1000000000000000) ? 0b100 : 0) |
((color & 0b0000010000000000) ? 0b010 : 0) |
((color & 0b0000000000010000) ? 0b001 : 0));
if (pos & 1)
{
_framebuffer[idx] = (_framebuffer[idx] & 0b00111000) | c;
}
else
{
_framebuffer[idx] = (_framebuffer[idx] & 0b00000111) | (c << 3);
}
}
void Arduino_Canvas_3bit::flush()
{
_output->draw3bitRGBBitmap(_output_x, _output_y, _framebuffer, _width, _height);
}
uint8_t *Arduino_Canvas_3bit::getFramebuffer()
{
return _framebuffer;
}
#endif // !defined(LITTLE_FOOT_PRINT)
@@ -0,0 +1,31 @@
#include "../Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#ifndef _ARDUINO_CANVAS_3BIT_H_
#define _ARDUINO_CANVAS_3BIT_H_
#include "../Arduino_GFX.h"
class Arduino_Canvas_3bit : public Arduino_GFX
{
public:
Arduino_Canvas_3bit(int16_t w, int16_t h, Arduino_G *output, int16_t output_x = 0, int16_t output_y = 0);
~Arduino_Canvas_3bit();
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writePixelPreclipped(int16_t x, int16_t y, uint16_t color) override;
void flush(void) override;
uint8_t *getFramebuffer();
protected:
uint8_t *_framebuffer = nullptr;
Arduino_G *_output = nullptr;
int16_t _output_x, _output_y;
private:
};
#endif // _ARDUINO_CANVAS_3BIT_H_
#endif // !defined(LITTLE_FOOT_PRINT)
@@ -0,0 +1,393 @@
#include "../Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#include "../Arduino_GFX.h"
#include "Arduino_Canvas_Indexed.h"
Arduino_Canvas_Indexed::Arduino_Canvas_Indexed(int16_t w, int16_t h, Arduino_G *output, int16_t output_x, int16_t output_y, uint8_t mask_level)
: Arduino_GFX(w, h), _output(output), _output_x(output_x), _output_y(output_y)
{
if (mask_level >= MAXMASKLEVEL)
{
mask_level = MAXMASKLEVEL - 1;
}
_current_mask_level = mask_level;
_color_mask = mask_level_list[_current_mask_level];
}
Arduino_Canvas_Indexed::~Arduino_Canvas_Indexed()
{
if (_framebuffer)
{
free(_framebuffer);
}
}
bool Arduino_Canvas_Indexed::begin(int32_t speed)
{
if (speed != GFX_SKIP_OUTPUT_BEGIN)
{
if (!_output->begin(speed))
{
return false;
}
}
if (!_framebuffer)
{
size_t s = _width * _height;
#if defined(ESP32)
if (psramFound())
{
_framebuffer = (uint8_t *)ps_malloc(s);
}
else
{
_framebuffer = (uint8_t *)malloc(s);
}
#else
_framebuffer = (uint8_t *)malloc(s);
#endif
if (!_framebuffer)
{
return false;
}
}
return true;
}
void Arduino_Canvas_Indexed::writePixelPreclipped(int16_t x, int16_t y, uint16_t color)
{
if (_isDirectUseColorIndex)
{
_framebuffer[((int32_t)y * _width) + x] = (uint8_t)color;
}
else
{
_framebuffer[((int32_t)y * _width) + x] = get_color_index(color);
}
}
void Arduino_Canvas_Indexed::writeFastVLine(int16_t x, int16_t y,
int16_t h, uint16_t color)
{
if (_ordered_in_range(x, 0, _max_x) && h)
{ // X on screen, nonzero height
if (h < 0)
{ // If negative height...
y += h + 1; // Move Y to top edge
h = -h; // Use positive height
}
if (y <= _max_y)
{ // Not off bottom
int16_t y2 = y + h - 1;
if (y2 >= 0)
{ // Not off top
// Line partly or fully overlaps screen
if (y < 0)
{
y = 0;
h = y2 + 1;
} // Clip top
if (y2 > _max_y)
{
h = _max_y - y + 1;
} // Clip bottom
uint8_t idx;
if (_isDirectUseColorIndex)
{
idx = color;
}
else
{
idx = get_color_index(color);
}
uint8_t *fb = _framebuffer + ((int32_t)y * _width) + x;
while (h--)
{
*fb = idx;
fb += _width;
}
}
}
}
}
void Arduino_Canvas_Indexed::writeFastHLine(int16_t x, int16_t y,
int16_t w, uint16_t color)
{
if (_ordered_in_range(y, 0, _max_y) && w)
{ // Y on screen, nonzero width
if (w < 0)
{ // If negative width...
x += w + 1; // Move X to left edge
w = -w; // Use positive width
}
if (x <= _max_x)
{ // Not off right
int16_t x2 = x + w - 1;
if (x2 >= 0)
{ // Not off left
// Line partly or fully overlaps screen
if (x < 0)
{
x = 0;
w = x2 + 1;
} // Clip left
if (x2 > _max_x)
{
w = _max_x - x + 1;
} // Clip right
uint8_t idx;
if (_isDirectUseColorIndex)
{
idx = color;
}
else
{
idx = get_color_index(color);
}
uint8_t *fb = _framebuffer + ((int32_t)y * _width) + x;
while (w--)
{
*(fb++) = idx;
}
}
}
}
}
void Arduino_Canvas_Indexed::drawIndexedBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else
{
if ((y + h - 1) > _max_y)
{
h -= (y + h - 1) - _max_y;
}
if (y < 0)
{
bitmap -= y * w;
h += y;
y = 0;
}
if ((x + w - 1) > _max_x)
{
x_skip += (x + w - 1) - _max_x;
w -= (x + w - 1) - _max_x;
}
if (x < 0)
{
bitmap -= x;
x_skip -= x;
w += x;
x = 0;
}
uint8_t *row = _framebuffer;
row += y * _width;
row += x;
int16_t i;
int16_t wi;
if (_isDirectUseColorIndex)
{
while (h--)
{
i = 0;
wi = w;
while (wi >= 4)
{
*((uint32_t *)&row[i]) = *((uint32_t *)bitmap);
i += 4;
wi -= 4;
bitmap += 4;
}
while (i < w)
{
row[i++] = *bitmap++;
}
bitmap += x_skip;
row += _width;
}
}
else
{
while (h--)
{
for (int i = 0; i < w; i++)
{
row[i] = get_color_index(color_index[*bitmap++]);
}
bitmap += x_skip;
row += _width;
}
}
}
}
void Arduino_Canvas_Indexed::drawIndexedBitmap(
int16_t x, int16_t y,
uint8_t *bitmap, uint16_t *color_index, uint8_t chroma_key, int16_t w, int16_t h, int16_t x_skip)
{
if (
((x + w - 1) < 0) || // Outside left
((y + h - 1) < 0) || // Outside top
(x > _max_x) || // Outside right
(y > _max_y) // Outside bottom
)
{
return;
}
else
{
if ((y + h - 1) > _max_y)
{
h -= (y + h - 1) - _max_y;
}
if (y < 0)
{
bitmap -= y * w;
h += y;
y = 0;
}
if ((x + w - 1) > _max_x)
{
x_skip += (x + w - 1) - _max_x;
w -= (x + w - 1) - _max_x;
}
if (x < 0)
{
bitmap -= x;
x_skip -= x;
w += x;
x = 0;
}
uint8_t *row = _framebuffer;
row += y * _width;
row += x;
uint8_t color_key;
if (_isDirectUseColorIndex)
{
while (h--)
{
for (int i = 0; i < w; i++)
{
color_key = *bitmap++;
if (color_key != chroma_key)
{
row[i] = color_key;
}
}
bitmap += x_skip;
row += _width;
}
}
else
{
while (h--)
{
for (int i = 0; i < w; i++)
{
color_key = *bitmap++;
if (color_key != chroma_key)
{
row[i] = get_color_index(color_index[color_key]);
}
}
bitmap += x_skip;
row += _width;
}
}
}
}
void Arduino_Canvas_Indexed::flush()
{
_output->drawIndexedBitmap(_output_x, _output_y, _framebuffer, _color_index, _width, _height);
}
uint8_t *Arduino_Canvas_Indexed::getFramebuffer()
{
return _framebuffer;
}
uint16_t *Arduino_Canvas_Indexed::getColorIndex()
{
return _color_index;
}
void Arduino_Canvas_Indexed::setDirectUseColorIndex(bool isEnable)
{
_isDirectUseColorIndex = isEnable;
}
uint8_t Arduino_Canvas_Indexed::get_color_index(uint16_t color)
{
color &= _color_mask;
for (uint8_t i = 0; i < _indexed_size; i++)
{
if (_color_index[i] == color)
{
return i;
}
}
if (_indexed_size == (COLOR_IDX_SIZE - 1)) // overflowed
{
raise_mask_level();
}
_color_index[_indexed_size] = color;
// Serial.print("color_index[");
// Serial.print(_indexed_size);
// Serial.print("] = ");
// Serial.println(color);
return _indexed_size++;
}
uint16_t Arduino_Canvas_Indexed::get_index_color(uint8_t idx)
{
return _color_index[idx];
}
void Arduino_Canvas_Indexed::raise_mask_level()
{
if ((_current_mask_level + 1) < MAXMASKLEVEL)
{
int32_t buffer_size = _width * _height;
uint8_t old_indexed_size = _indexed_size;
uint8_t new_color;
_indexed_size = 0;
_color_mask = mask_level_list[++_current_mask_level];
Serial.print("Raised mask level: ");
Serial.println(_current_mask_level);
// update _framebuffer color index, it is a time consuming job
for (uint8_t old_color = 0; old_color < old_indexed_size; old_color++)
{
new_color = get_color_index(_color_index[old_color]);
for (int32_t i = 0; i < buffer_size; i++)
{
if (_framebuffer[i] == old_color)
{
_framebuffer[i] = new_color;
}
}
}
}
}
#endif // !defined(LITTLE_FOOT_PRINT)
@@ -0,0 +1,55 @@
#include "../Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#ifndef _ARDUINO_CANVAS_INDEXED_H_
#define _ARDUINO_CANVAS_INDEXED_H_
#include "../Arduino_GFX.h"
#define COLOR_IDX_SIZE 256
class Arduino_Canvas_Indexed : public Arduino_GFX
{
public:
Arduino_Canvas_Indexed(int16_t w, int16_t h, Arduino_G *output, int16_t output_x = 0, int16_t output_y = 0, uint8_t mask_level = 0);
~Arduino_Canvas_Indexed();
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writePixelPreclipped(int16_t x, int16_t y, uint16_t color) override;
void writeFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) override;
void writeFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) override;
void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, int16_t w, int16_t h, int16_t x_skip = 0) override;
void drawIndexedBitmap(int16_t x, int16_t y, uint8_t *bitmap, uint16_t *color_index, uint8_t chroma_key, int16_t w, int16_t h, int16_t x_skip = 0) override;
void flush(void) override;
uint8_t *getFramebuffer();
uint16_t *getColorIndex();
void setDirectUseColorIndex(bool isEnable);
uint8_t get_color_index(uint16_t color);
uint16_t get_index_color(uint8_t idx);
void raise_mask_level();
protected:
uint8_t *_framebuffer = nullptr;
Arduino_G *_output = nullptr;
int16_t _output_x, _output_y;
uint16_t _color_index[COLOR_IDX_SIZE];
uint8_t _indexed_size = 0;
bool _isDirectUseColorIndex = false;
uint8_t _current_mask_level;
uint16_t _color_mask;
#define MAXMASKLEVEL 3
uint16_t mask_level_list[MAXMASKLEVEL] = {
0b1111111111111111, // 16-bit, 65536 colors
0b1111011110011110, // 12-bit, 4096 colors
0b1100011000011000 // 7-bit, 128 colors
};
private:
};
#endif // _ARDUINO_CANVAS_INDEXED_H_
#endif // !defined(LITTLE_FOOT_PRINT)
@@ -0,0 +1,78 @@
#include "../Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#include "../Arduino_GFX.h"
#include "Arduino_Canvas_Mono.h"
Arduino_Canvas_Mono::Arduino_Canvas_Mono(int16_t w, int16_t h, Arduino_G *output, int16_t output_x, int16_t output_y)
: Arduino_GFX(w, h), _output(output), _output_x(output_x), _output_y(output_y)
{
}
Arduino_Canvas_Mono::~Arduino_Canvas_Mono()
{
if (_framebuffer)
{
free(_framebuffer);
}
}
bool Arduino_Canvas_Mono::begin(int32_t speed)
{
if (speed != GFX_SKIP_OUTPUT_BEGIN)
{
if (!_output->begin(speed))
{
return false;
}
}
if (!_framebuffer)
{
size_t s = (_width + 7) / 8 * _height;
#if defined(ESP32)
if (psramFound())
{
_framebuffer = (uint8_t *)ps_malloc(s);
}
else
{
_framebuffer = (uint8_t *)malloc(s);
}
#else
_framebuffer = (uint8_t *)malloc(s);
#endif
if (!_framebuffer)
{
return false;
}
}
return true;
}
void Arduino_Canvas_Mono::writePixelPreclipped(int16_t x, int16_t y, uint16_t color)
{
int16_t w = (_width + 7) / 8;
int32_t pos = y * w + x / 8;
if (color & 0b1000010000010000)
{
_framebuffer[pos] |= 0x80 >> (x & 7);
}
else
{
_framebuffer[pos] &= ~(0x80 >> (x & 7));
}
}
void Arduino_Canvas_Mono::flush()
{
_output->drawBitmap(_output_x, _output_y, _framebuffer, _width, _height, WHITE, BLACK);
}
uint8_t *Arduino_Canvas_Mono::getFramebuffer()
{
return _framebuffer;
}
#endif // !defined(LITTLE_FOOT_PRINT)
@@ -0,0 +1,31 @@
#include "../Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#ifndef _ARDUINO_CANVAS_MONO_H_
#define _ARDUINO_CANVAS_MONO_H_
#include "../Arduino_GFX.h"
class Arduino_Canvas_Mono : public Arduino_GFX
{
public:
Arduino_Canvas_Mono(int16_t w, int16_t h, Arduino_G *output, int16_t output_x = 0, int16_t output_y = 0);
~Arduino_Canvas_Mono();
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writePixelPreclipped(int16_t x, int16_t y, uint16_t color) override;
void flush(void) override;
uint8_t *getFramebuffer();
protected:
uint8_t *_framebuffer = nullptr;
Arduino_G *_output = nullptr;
int16_t _output_x, _output_y;
private:
};
#endif // _ARDUINO_CANVAS_MONO_H_
#endif // !defined(LITTLE_FOOT_PRINT)
@@ -0,0 +1,224 @@
#ifdef __AVR__
#include "Arduino_AVRPAR16.h"
Arduino_AVRPAR16::Arduino_AVRPAR16(int8_t dc, int8_t cs, int8_t wr, int8_t rd, uint8_t portLow, uint8_t portHigh)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd), _portLow(portLow), _portHigh(portHigh)
{
}
bool Arduino_AVRPAR16::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
_dcPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_dc));
_dcPinMaskSet = digitalPinToBitMask(_dc);
_dcPinMaskClr = ~_dcPinMaskSet;
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // Disable chip select
_csPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_cs));
_csPinMaskSet = digitalPinToBitMask(_cs);
}
_csPinMaskClr = ~_csPinMaskSet;
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
_wrPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_wr));
_wrPinMaskSet = digitalPinToBitMask(_wr);
_wrPinMaskClr = ~_wrPinMaskSet;
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH); // Disable RD
_rdPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_rd));
_rdPinMaskSet = digitalPinToBitMask(_rd);
}
else
{
_rdPort = _dcPort;
_rdPinMaskSet = 0;
}
_rdPinMaskClr = ~_rdPinMaskSet;
*(portModeRegister(_portLow)) = 0xFF;
_dataPortLow = portOutputRegister(_portLow);
*_dataPortLow = 0xFF;
*(portModeRegister(_portHigh)) = 0xFF;
_dataPortHigh = portOutputRegister(_portHigh);
*_dataPortHigh = 0xFF;
return true;
}
void Arduino_AVRPAR16::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_AVRPAR16::endWrite()
{
CS_HIGH();
}
void Arduino_AVRPAR16::writeCommand(uint8_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_AVRPAR16::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_AVRPAR16::write(uint8_t d)
{
WRITE16(d);
}
void Arduino_AVRPAR16::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_AVRPAR16::writeRepeat(uint16_t p, uint32_t len)
{
uint8_t wrMaskBase = *_wrPort & _wrPinMaskClr;
uint8_t wrMaskSet = wrMaskBase | _wrPinMaskSet;
_data16.value = p;
*_dataPortLow = _data16.lsb;
*_dataPortHigh = _data16.msb;
while (len--)
{
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
void Arduino_AVRPAR16::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
WRITE16(*data++);
}
}
void Arduino_AVRPAR16::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_AVRPAR16::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_AVRPAR16::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
WRITE16(d1);
WRITE16(d2);
}
void Arduino_AVRPAR16::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
uint8_t wrMaskBase = *_wrPort & _wrPinMaskClr;
_data16.value = c;
*_dataPortLow = _data16.lsb;
*_dataPortHigh = _data16.msb;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskBase | _wrPinMaskSet;
DC_HIGH();
_data16.value = d1;
*_dataPortLow = _data16.msb;
*_dataPortHigh = 0;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskBase | _wrPinMaskSet;
*_dataPortLow = _data16.lsb;
*_dataPortHigh = 0;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskBase | _wrPinMaskSet;
_data16.value = d2;
*_dataPortLow = _data16.msb;
*_dataPortHigh = 0;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskBase | _wrPinMaskSet;
*_dataPortLow = _data16.lsb;
*_dataPortHigh = 0;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskBase | _wrPinMaskSet;
}
INLINE void Arduino_AVRPAR16::WRITE16(uint16_t d)
{
uint8_t wrMaskBase = *_wrPort & _wrPinMaskClr;
_data16.value = d;
*_dataPortLow = _data16.lsb;
*_dataPortHigh = _data16.msb;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskBase | _wrPinMaskSet;
}
/******** low level bit twiddling **********/
INLINE void Arduino_AVRPAR16::DC_HIGH(void)
{
*_dcPort |= _dcPinMaskSet;
}
INLINE void Arduino_AVRPAR16::DC_LOW(void)
{
*_dcPort &= _dcPinMaskClr;
}
INLINE void Arduino_AVRPAR16::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPort |= _csPinMaskSet;
}
}
INLINE void Arduino_AVRPAR16::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPort &= _csPinMaskClr;
}
}
#endif // #ifdef __AVR__
@@ -0,0 +1,63 @@
#ifdef __AVR__
#ifndef _ARDUINO_AVRPAR16_H_
#define _ARDUINO_AVRPAR16_H_
#include "Arduino_DataBus.h"
class Arduino_AVRPAR16 : public Arduino_DataBus
{
public:
Arduino_AVRPAR16(int8_t dc, int8_t cs, int8_t wr, int8_t rd, uint8_t portLow, uint8_t portHigh); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
protected:
private:
INLINE void WRITE16(uint16_t d);
INLINE void WRITEREPEAT(uint16_t p, uint32_t len);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
uint8_t _portLow;
uint8_t _portHigh;
PORTreg_t _dcPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _dcPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _dcPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _csPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _csPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _csPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _wrPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _wrPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _wrPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _rdPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _rdPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _rdPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _dataPortLow; ///< PORT register for data/command
PORTreg_t _dataPortHigh; ///< PORT register for data/command
};
#endif // _ARDUINO_AVRPAR16_H_
#endif // #ifdef __AVR__
@@ -0,0 +1,215 @@
#ifdef __AVR__
#include "Arduino_AVRPAR8.h"
Arduino_AVRPAR8::Arduino_AVRPAR8(int8_t dc, int8_t cs, int8_t wr, int8_t rd, uint8_t port)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd), _port(port)
{
}
bool Arduino_AVRPAR8::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
_dcPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_dc));
_dcPinMaskSet = digitalPinToBitMask(_dc);
_dcPinMaskClr = ~_dcPinMaskSet;
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // Disable chip select
_csPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_cs));
_csPinMaskSet = digitalPinToBitMask(_cs);
}
_csPinMaskClr = ~_csPinMaskSet;
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
_wrPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_wr));
_wrPinMaskSet = digitalPinToBitMask(_wr);
_wrPinMaskClr = ~_wrPinMaskSet;
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH); // Disable RD
_rdPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_rd));
_rdPinMaskSet = digitalPinToBitMask(_rd);
}
else
{
_rdPort = _dcPort;
_rdPinMaskSet = 0;
}
_rdPinMaskClr = ~_rdPinMaskSet;
*(portModeRegister(_port)) = 0xFF;
_dataPort = portOutputRegister(_port);
*_dataPort = 0xFF;
return true;
}
void Arduino_AVRPAR8::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_AVRPAR8::endWrite()
{
CS_HIGH();
}
void Arduino_AVRPAR8::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_AVRPAR8::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_AVRPAR8::write(uint8_t d)
{
WRITE(d);
}
void Arduino_AVRPAR8::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_AVRPAR8::writeRepeat(uint16_t p, uint32_t len)
{
uint8_t wrMaskBase = *_wrPort & _wrPinMaskClr;
uint8_t wrMaskSet = wrMaskBase | _wrPinMaskSet;
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
*_dataPort = _data16.msb;
while (len--)
{
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
else
{
while (len--)
{
*_dataPort = _data16.msb;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_dataPort = _data16.lsb;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
}
void Arduino_AVRPAR8::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_AVRPAR8::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_AVRPAR8::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_AVRPAR8::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
INLINE void Arduino_AVRPAR8::WRITE(uint8_t d)
{
uint8_t wrMaskBase = *_wrPort & _wrPinMaskClr;
*_dataPort = d;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskBase | _wrPinMaskSet;
}
/******** low level bit twiddling **********/
INLINE void Arduino_AVRPAR8::DC_HIGH(void)
{
*_dcPort |= _dcPinMaskSet;
}
INLINE void Arduino_AVRPAR8::DC_LOW(void)
{
*_dcPort &= _dcPinMaskClr;
}
INLINE void Arduino_AVRPAR8::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPort |= _csPinMaskSet;
}
}
INLINE void Arduino_AVRPAR8::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPort &= _csPinMaskClr;
}
}
#endif // #ifdef __AVR__
@@ -0,0 +1,59 @@
#ifdef __AVR__
#ifndef _ARDUINO_AVRPAR8_H_
#define _ARDUINO_AVRPAR8_H_
#include "Arduino_DataBus.h"
class Arduino_AVRPAR8 : public Arduino_DataBus
{
public:
Arduino_AVRPAR8(int8_t dc, int8_t cs, int8_t wr, int8_t rd, uint8_t port); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
uint8_t _port;
PORTreg_t _dcPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _dcPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _dcPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _csPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _csPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _csPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _wrPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _wrPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _wrPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _rdPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _rdPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _rdPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _dataPort; ///< PORT register for data/command
};
#endif // _ARDUINO_AVRPAR8_H_
#endif // #ifdef __AVR__
@@ -0,0 +1,489 @@
/*
* start rewrite from:
* https://github.com/lovyan03/LovyanGFX/blob/master/src/lgfx/v0/platforms/LGFX_PARALLEL_ESP32.hpp
*/
#include "Arduino_ESP32LCD16.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
#define WAIT_LCD_NOT_BUSY while (LCD_CAM.lcd_user.val & LCD_CAM_LCD_START)
Arduino_ESP32LCD16::Arduino_ESP32LCD16(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7),
_d8(d8), _d9(d9), _d10(d10), _d11(d11), _d12(d12), _d13(d13), _d14(d14), _d15(d15)
{
}
bool Arduino_ESP32LCD16::begin(int32_t speed, int8_t dataMode)
{
if (speed == GFX_NOT_DEFINED)
{
_speed = 8000000UL; // safe frequency
}
else
{
_speed = speed;
}
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
esp_lcd_i80_bus_config_t bus_config = {
.dc_gpio_num = _dc,
.wr_gpio_num = _wr,
.clk_src = LCD_CLK_SRC_PLL160M,
.data_gpio_nums = {
_d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7,
_d8, _d9, _d10, _d11, _d12, _d13, _d14, _d15},
.bus_width = 16,
.max_transfer_bytes = LCD_MAX_PIXELS_AT_ONCE * 2,
.psram_trans_align = 0,
.sram_trans_align = 0};
esp_lcd_new_i80_bus(&bus_config, &_i80_bus);
uint32_t diff = INT32_MAX;
uint32_t div_n = 256;
uint32_t div_a = 63;
uint32_t div_b = 62;
uint32_t clkcnt = 64;
uint32_t start_cnt = std::min<uint32_t>(64u, (F_CPU / (_speed * 2) + 1));
uint32_t end_cnt = std::max<uint32_t>(2u, F_CPU / 256u / _speed);
if (start_cnt <= 2)
{
end_cnt = 1;
}
for (uint32_t cnt = start_cnt; diff && cnt >= end_cnt; --cnt)
{
float fdiv = (float)F_CPU / cnt / _speed;
uint32_t n = std::max<uint32_t>(2u, (uint32_t)fdiv);
fdiv -= n;
for (uint32_t a = 63; diff && a > 0; --a)
{
uint32_t b = roundf(fdiv * a);
if (a == b && n == 256)
{
break;
}
uint32_t freq = F_CPU / ((n * cnt) + (float)(b * cnt) / (float)a);
uint32_t d = abs(_speed - (int)freq);
if (diff <= d)
{
continue;
}
diff = d;
clkcnt = cnt;
div_n = n;
div_b = b;
div_a = a;
if (b == 0 || a == b)
{
break;
}
}
}
if (div_a == div_b)
{
div_b = 0;
div_n += 1;
}
int wait = 24 - (div_n * clkcnt);
_fast_wait = (wait < 0) ? 0 : wait;
lcd_cam_lcd_clock_reg_t lcd_clock;
lcd_clock.lcd_clkcnt_n = std::max(1u, clkcnt - 1);
lcd_clock.lcd_clk_equ_sysclk = (clkcnt == 1);
lcd_clock.lcd_ck_idle_edge = true;
lcd_clock.lcd_ck_out_edge = false;
lcd_clock.lcd_clkm_div_num = div_n;
lcd_clock.lcd_clkm_div_b = div_b;
lcd_clock.lcd_clkm_div_a = div_a;
lcd_clock.lcd_clk_sel = 2; // clock_select: 1=XTAL CLOCK / 2=240MHz / 3=160MHz
lcd_clock.clk_en = true;
LCD_CAM.lcd_clock.val = lcd_clock.val;
_dma_chan = _i80_bus->dma_chan;
_dmadesc = (dma_descriptor_t *)heap_caps_malloc(sizeof(dma_descriptor_t), MALLOC_CAP_DMA);
return true;
}
void Arduino_ESP32LCD16::beginWrite()
{
CS_LOW();
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_user.val = 0;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG;
}
void Arduino_ESP32LCD16::endWrite()
{
WAIT_LCD_NOT_BUSY;
CS_HIGH();
}
void Arduino_ESP32LCD16::writeCommand(uint8_t c)
{
WRITECOMMAND16(c);
}
void Arduino_ESP32LCD16::writeCommand16(uint16_t c)
{
WRITECOMMAND16(c);
}
void Arduino_ESP32LCD16::write(uint8_t d)
{
WRITE16(d);
}
void Arduino_ESP32LCD16::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_ESP32LCD16::writeRepeat(uint16_t p, uint32_t len)
{
if (len < USE_DMA_THRESHOLD)
{
while (len--)
{
WRITE16(p);
}
}
else
{
uint32_t bufLen = (len < LCD_MAX_PIXELS_AT_ONCE) ? len : LCD_MAX_PIXELS_AT_ONCE;
uint32_t xferLen, l;
uint32_t c32 = p * 0x10001;
l = (bufLen + 1) / 2;
for (uint32_t i = 0; i < l; i++)
{
_buffer32[i] = c32;
}
while (len) // While pixels remain
{
xferLen = (bufLen <= len) ? bufLen : len; // How many this pass?
l = (xferLen - 2) * 2;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = _buffer;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.val = c32;
uint32_t wait = _fast_wait;
if (wait > 0)
{
do
{
__asm__ __volatile__("nop");
} while (--wait);
}
len -= xferLen;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
WAIT_LCD_NOT_BUSY;
}
}
}
void Arduino_ESP32LCD16::writePixels(uint16_t *data, uint32_t len)
{
uint32_t xferLen, l;
while (len > USE_DMA_THRESHOLD) // While pixels remain
{
xferLen = (len < LCD_MAX_PIXELS_AT_ONCE) ? len : LCD_MAX_PIXELS_AT_ONCE; // How many this pass?
_data32.value16 = *data++;
_data32.value16_2 = *data++;
l = xferLen - 2;
l <<= 1;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = data;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.val = _data32.value;
uint32_t wait = _fast_wait;
while (wait--)
{
__asm__ __volatile__("nop");
}
data += xferLen - 2;
len -= xferLen;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
WAIT_LCD_NOT_BUSY;
}
while (len--)
{
WRITE16(*data++);
}
}
void Arduino_ESP32LCD16::writeC8D8(uint8_t c, uint8_t d)
{
WRITECOMMAND16(c);
WRITE16(d);
}
void Arduino_ESP32LCD16::writeC8D16(uint8_t c, uint16_t d)
{
WRITECOMMAND16(c);
WRITE16(d);
}
void Arduino_ESP32LCD16::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
WRITECOMMAND16(c);
WRITE16(d1);
WRITE16(d2);
}
void Arduino_ESP32LCD16::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
WRITECOMMAND16(c);
_data16.value = d1;
WRITE16(_data16.msb);
WRITE16(_data16.lsb);
_data16.value = d2;
WRITE16(_data16.msb);
WRITE16(_data16.lsb);
}
void Arduino_ESP32LCD16::writeBytes(uint8_t *data, uint32_t len)
{
uint32_t xferLen, l;
while (len > (USE_DMA_THRESHOLD * 2)) // While pixels remain
{
xferLen = (len < (LCD_MAX_PIXELS_AT_ONCE * 2)) ? len : (LCD_MAX_PIXELS_AT_ONCE * 2); // How many this pass?
_data32.msb = *data++;
_data32.lsb = *data++;
_data32.msb_2 = *data++;
_data32.lsb_2 = *data++;
l = xferLen - 4;
l >>= 1;
for (int i = 0; i < l; ++i)
{
_buffer[(i * 2) + 1] = *data++;
_buffer[i * 2] = *data++;
}
l <<= 1;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = _buffer;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.val = _data32.value;
uint32_t wait = _fast_wait;
while (wait--)
{
__asm__ __volatile__("nop");
}
len -= xferLen;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
WAIT_LCD_NOT_BUSY;
}
while (len)
{
if (len == 1)
{
WRITE16(*data);
len--;
}
else
{
_data16.lsb = *data++;
_data16.msb = *data++;
WRITE16(_data16.value);
len -= 2;
}
}
}
void Arduino_ESP32LCD16::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
uint32_t xferLen, l;
uint32_t p;
while (len > USE_DMA_THRESHOLD) // While pixels remain
{
xferLen = (len < LCD_MAX_PIXELS_AT_ONCE) ? len : LCD_MAX_PIXELS_AT_ONCE; // How many this pass?
l = xferLen - 2;
p = idx[*data++];
p <<= 16;
p |= idx[*data++];
for (int i = 0; i < l; ++i)
{
_buffer16[i] = idx[*data++];
}
l <<= 1;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = _buffer;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.val = p;
uint32_t wait = _fast_wait;
while (wait--)
{
__asm__ __volatile__("nop");
}
len -= xferLen;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
WAIT_LCD_NOT_BUSY;
}
while (len--)
{
WRITE16(idx[*data++]);
}
}
void Arduino_ESP32LCD16::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
len <<= 1; // double length
uint32_t xferLen, l;
uint32_t p;
while (len > USE_DMA_THRESHOLD) // While pixels remain
{
xferLen = (len < LCD_MAX_PIXELS_AT_ONCE) ? len : LCD_MAX_PIXELS_AT_ONCE; // How many this pass?
l = (xferLen - 2) / 2;
p = idx[*data++] * 0x10001;
for (int i = 0; i < l; ++i)
{
_buffer32[i] = idx[*data++] * 0x10001;
}
l <<= 2;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = _buffer;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.val = p;
uint32_t wait = _fast_wait;
while (wait--)
{
__asm__ __volatile__("nop");
}
len -= xferLen;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
WAIT_LCD_NOT_BUSY;
}
len >>= 1;
while (len--)
{
p = idx[*data++] * 0x10001;
WRITE32(p);
}
}
INLINE void Arduino_ESP32LCD16::WRITECOMMAND16(uint16_t c)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE | LCD_CAM_LCD_CD_CMD_SET;
LCD_CAM.lcd_cmd_val.val = c;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
INLINE void Arduino_ESP32LCD16::WRITE16(uint16_t d)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.val = d;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
INLINE void Arduino_ESP32LCD16::WRITE32(uint32_t d)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.val = d;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_2BYTE_EN | LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32LCD16::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32LCD16::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,90 @@
/*
* start rewrite from:
* https://github.com/lovyan03/LovyanGFX/blob/master/src/lgfx/v0/platforms/LGFX_PARALLEL_ESP32.hpp
*/
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32LCD16_H_
#define _ARDUINO_ESP32LCD16_H_
#define LCD_MAX_PIXELS_AT_ONCE 2046
#define USE_DMA_THRESHOLD 6
class Arduino_ESP32LCD16 : public Arduino_DataBus
{
public:
Arduino_ESP32LCD16(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITECOMMAND16(uint16_t c);
INLINE void WRITE16(uint16_t d);
INLINE void WRITE32(uint32_t d);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
int8_t _d8, _d9, _d10, _d11, _d12, _d13, _d14, _d15;
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
uint32_t _fast_wait;
esp_lcd_i80_bus_handle_t _i80_bus = nullptr;
dma_descriptor_t *_dmadesc = nullptr;
gdma_channel_handle_t _dma_chan;
union
{
uint32_t value;
struct
{
uint16_t value16;
uint16_t value16_2;
};
struct
{
uint8_t lsb;
uint8_t msb;
uint8_t lsb_2;
uint8_t msb_2;
};
} _data32;
union
{
uint8_t _buffer[LCD_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t _buffer16[LCD_MAX_PIXELS_AT_ONCE];
uint32_t _buffer32[LCD_MAX_PIXELS_AT_ONCE / 2];
};
};
#endif // _ARDUINO_ESP32LCD16_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,764 @@
/*
* start rewrite from:
* https://github.com/lovyan03/LovyanGFX/blob/master/src/lgfx/v0/platforms/LGFX_PARALLEL_ESP32.hpp
*/
#include "Arduino_ESP32LCD8.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
#define WAIT_LCD_NOT_BUSY while (LCD_CAM.lcd_user.val & LCD_CAM_LCD_START)
/**
* @brief Construct a new Arduino_ESP32LCD8::Arduino_ESP32LCD8 object
*
* @param dc
* @param cs
* @param wr
* @param rd
* @param d0
* @param d1
* @param d2
* @param d3
* @param d4
* @param d5
* @param d6
* @param d7
*/
Arduino_ESP32LCD8::Arduino_ESP32LCD8(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7)
{
}
/**
* @brief begin
*
* @param speed
* @param dataMode
* @return true
* @return false
*/
bool Arduino_ESP32LCD8::begin(int32_t speed, int8_t dataMode)
{
if (speed == GFX_NOT_DEFINED)
{
_speed = 40000000UL;
}
else
{
_speed = speed;
}
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
esp_lcd_i80_bus_config_t bus_config = {
.dc_gpio_num = _dc,
.wr_gpio_num = _wr,
.clk_src = LCD_CLK_SRC_PLL160M,
.data_gpio_nums = {
_d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7},
.bus_width = 8,
.max_transfer_bytes = LCD_MAX_PIXELS_AT_ONCE * 2,
.psram_trans_align = 0,
.sram_trans_align = 0};
esp_lcd_new_i80_bus(&bus_config, &_i80_bus);
uint32_t diff = INT32_MAX;
uint32_t div_n = 256;
uint32_t div_a = 63;
uint32_t div_b = 62;
uint32_t clkcnt = 64;
uint32_t start_cnt = std::min<uint32_t>(64u, (F_CPU / (_speed * 2) + 1));
uint32_t end_cnt = std::max<uint32_t>(2u, F_CPU / 256u / _speed);
if (start_cnt <= 2)
{
end_cnt = 1;
}
for (uint32_t cnt = start_cnt; diff && cnt >= end_cnt; --cnt)
{
float fdiv = (float)F_CPU / cnt / _speed;
uint32_t n = std::max<uint32_t>(2u, (uint32_t)fdiv);
fdiv -= n;
for (uint32_t a = 63; diff && a > 0; --a)
{
uint32_t b = roundf(fdiv * a);
if (a == b && n == 256)
{
break;
}
uint32_t freq = F_CPU / ((n * cnt) + (float)(b * cnt) / (float)a);
uint32_t d = abs(_speed - (int)freq);
if (diff <= d)
{
continue;
}
diff = d;
clkcnt = cnt;
div_n = n;
div_b = b;
div_a = a;
if (b == 0 || a == b)
{
break;
}
}
}
if (div_a == div_b)
{
div_b = 0;
div_n += 1;
}
lcd_cam_lcd_clock_reg_t lcd_clock;
lcd_clock.lcd_clkcnt_n = std::max(1u, clkcnt - 1);
lcd_clock.lcd_clk_equ_sysclk = (clkcnt == 1);
lcd_clock.lcd_ck_idle_edge = true;
lcd_clock.lcd_ck_out_edge = false;
lcd_clock.lcd_clkm_div_num = div_n;
lcd_clock.lcd_clkm_div_b = div_b;
lcd_clock.lcd_clkm_div_a = div_a;
lcd_clock.lcd_clk_sel = 2; // clock_select: 1=XTAL CLOCK / 2=240MHz / 3=160MHz
lcd_clock.clk_en = true;
LCD_CAM.lcd_clock.val = lcd_clock.val;
_dma_chan = _i80_bus->dma_chan;
_dmadesc = (dma_descriptor_t *)heap_caps_malloc(sizeof(dma_descriptor_t), MALLOC_CAP_DMA);
return true;
}
/**
* @brief beginWrite
*
*/
void Arduino_ESP32LCD8::beginWrite()
{
CS_LOW();
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_user.val = 0;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG;
}
/**
* @brief endWrite
*
*/
void Arduino_ESP32LCD8::endWrite()
{
WAIT_LCD_NOT_BUSY;
CS_HIGH();
}
/**
* @brief writeCommand
*
* @param c
*/
void Arduino_ESP32LCD8::writeCommand(uint8_t c)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE | LCD_CAM_LCD_CD_CMD_SET;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = c;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
}
/**
* @brief writeCommand16
*
* @param c
*/
void Arduino_ESP32LCD8::writeCommand16(uint16_t c)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE | LCD_CAM_LCD_CD_CMD_SET;
_data16.value = c;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
}
/**
* @brief write
*
* @param d
*/
void Arduino_ESP32LCD8::write(uint8_t d)
{
LCD_CAM.lcd_cmd_val.lcd_cmd_value = d;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
/**
* @brief write16
*
* @param d
*/
void Arduino_ESP32LCD8::write16(uint16_t d)
{
_data16.value = d;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
/**
* @brief writeC8D8
*
* @param c
* @param d
*/
void Arduino_ESP32LCD8::writeC8D8(uint8_t c, uint8_t d)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE | LCD_CAM_LCD_CD_CMD_SET;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = c;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = d;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
/**
* @brief writeC8D16
*
* @param c
* @param d
*/
void Arduino_ESP32LCD8::writeC8D16(uint8_t c, uint16_t d)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE | LCD_CAM_LCD_CD_CMD_SET;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = c;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = d;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
/**
* @brief writeC8D16D16
*
* @param c
* @param d1
* @param d2
*/
void Arduino_ESP32LCD8::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE | LCD_CAM_LCD_CD_CMD_SET;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = c;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
_data16.value = d1;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
_data16.value = d2;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
/**
* @brief writeC8D16D16Split
*
* @param c
* @param d1
* @param d2
*/
void Arduino_ESP32LCD8::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE | LCD_CAM_LCD_CD_CMD_SET;
_data16.value = c;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_misc.val = LCD_CAM_LCD_CD_IDLE_EDGE;
_data16.value = d1;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
_data16.value = d2;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
/**
* @brief writeRepeat
*
* @param p
* @param len
*/
void Arduino_ESP32LCD8::writeRepeat(uint16_t p, uint32_t len)
{
if (len > USE_DMA_THRESHOLD)
{
uint32_t bufLen = (len < LCD_MAX_PIXELS_AT_ONCE) ? len : LCD_MAX_PIXELS_AT_ONCE;
uint32_t xferLen, l;
uint32_t c32;
MSB_32_16_16_SET(c32, p, p);
l = (bufLen + 1) / 2;
for (uint32_t i = 0; i < l; i++)
{
_buffer32[i] = c32;
}
_data16.value = p;
_data32.value = 0;
_data32.lsb = _data16.msb;
_data32.lsb_2 = _data16.lsb;
while (len > USE_DMA_THRESHOLD)
{
xferLen = (bufLen <= len) ? bufLen : len; // How many this pass?
LCD_CAM.lcd_cmd_val.val = _data32.value;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
l = xferLen - 2;
l <<= 1;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = _buffer;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_cmd_val.val = _data32.value;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG;
len -= xferLen;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_START;
}
}
while (len--)
{
_data16.value = p;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
}
/**
* @brief writePixels
*
* @param data
* @param len
*/
void Arduino_ESP32LCD8::writePixels(uint16_t *data, uint32_t len)
{
uint32_t xferLen, l;
if (esp_ptr_dma_capable(data))
{
while (len > (USE_DMA_THRESHOLD)) // While pixels remain
{
xferLen = (len >= LCD_MAX_PIXELS_AT_ONCE) ? (LCD_MAX_PIXELS_AT_ONCE) : len; // How many this pass?
_data16.value = *data++;
_data32.value = 0;
_data32.lsb = _data16.msb;
_data32.lsb_2 = _data16.lsb;
LCD_CAM.lcd_cmd_val.val = _data32.value;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
_data16.value = *data++;
_data32.value = 0;
_data32.lsb = _data16.msb;
_data32.lsb_2 = _data16.lsb;
l = xferLen - 2;
l <<= 1;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = data;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_cmd_val.val = _data32.value;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG;
data += xferLen - 2;
len -= xferLen;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_START;
}
}
else
{
while (len > (USE_DMA_THRESHOLD)) // While pixels remain
{
xferLen = (len >= LCD_MAX_PIXELS_AT_ONCE) ? (LCD_MAX_PIXELS_AT_ONCE) : len; // How many this pass?
_data16.value = *data++;
_data32.value = 0;
_data32.lsb = _data16.msb;
_data32.lsb_2 = _data16.lsb;
LCD_CAM.lcd_cmd_val.val = _data32.value;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
_data16.value = *data++;
_data32.value = 0;
_data32.lsb = _data16.msb;
_data32.lsb_2 = _data16.lsb;
l = xferLen - 2;
l <<= 1;
for (uint32_t i = 0; i < l;)
{
_data16.value = *data++;
_buffer[i++] = _data16.msb;
_buffer[i++] = _data16.lsb;
}
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = _buffer32;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_cmd_val.val = _data32.value;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG;
len -= xferLen;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_START;
}
}
while (len--)
{
_data16.value = *data++;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
}
/**
* @brief writeBytes
*
* @param data
* @param len
*/
void Arduino_ESP32LCD8::writeBytes(uint8_t *data, uint32_t len)
{
uint32_t xferLen, l;
if (esp_ptr_dma_capable(data))
{
while (len > (USE_DMA_THRESHOLD << 1)) // While pixels remain
{
xferLen = (len >= LCD_MAX_PIXELS_AT_ONCE << 1) ? (LCD_MAX_PIXELS_AT_ONCE << 1) : len; // How many this pass?
_data32.value = 0;
_data32.lsb = *data++;
_data32.lsb_2 = *data++;
LCD_CAM.lcd_cmd_val.val = _data32.value;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
_data32.value = 0;
_data32.lsb = *data++;
_data32.lsb_2 = *data++;
l = xferLen - 4;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = data;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_cmd_val.val = _data32.value;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG;
data += xferLen - 4;
len -= xferLen;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_START;
}
}
else
{
uint32_t l4;
uint32_t *p;
while (len > (USE_DMA_THRESHOLD << 1)) // While pixels remain
{
xferLen = (len >= LCD_MAX_PIXELS_AT_ONCE << 1) ? (LCD_MAX_PIXELS_AT_ONCE << 1) : len; // How many this pass?
_data32.value = 0;
_data32.lsb = *data++;
_data32.lsb_2 = *data++;
LCD_CAM.lcd_cmd_val.val = _data32.value;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
_data32.value = 0;
_data32.lsb = *data++;
_data32.lsb_2 = *data++;
l = xferLen - 4;
l4 = (l + 3) >> 2;
p = (uint32_t *)data;
for (uint32_t i = 0; i < l4; i++)
{
_buffer32[i] = *p++;
}
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = _buffer32;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_cmd_val.val = _data32.value;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG;
data += xferLen - 4;
len -= xferLen;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_START;
}
}
while (len)
{
if (len == 1)
{
LCD_CAM.lcd_cmd_val.lcd_cmd_value = *data;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
len--;
}
else
{
LCD_CAM.lcd_cmd_val.lcd_cmd_value = *data++;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = *data++;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
len -= 2;
}
}
}
/**
* @brief writeIndexedPixels
*
* @param data
* @param idx
* @param len
*/
void Arduino_ESP32LCD8::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
if (len > USE_DMA_THRESHOLD)
{
uint32_t bufLen = (len < LCD_MAX_PIXELS_AT_ONCE) ? len : LCD_MAX_PIXELS_AT_ONCE;
uint32_t xferLen, l;
while (len > USE_DMA_THRESHOLD)
{
xferLen = (bufLen <= len) ? bufLen : len; // How many this pass?
_data16.value = idx[*data++];
_data32.value = 0;
_data32.lsb = _data16.msb;
_data32.lsb_2 = _data16.lsb;
LCD_CAM.lcd_cmd_val.val = _data32.value;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
_data16.value = idx[*data++];
_data32.value = 0;
_data32.lsb = _data16.msb;
_data32.lsb_2 = _data16.lsb;
l = xferLen - 2;
l >>= 1;
for (uint32_t i = 0; i < l; i++)
{
_data16.value = idx[*data++];
_data32.lsb = _data16.msb;
_data32.msb = _data16.lsb;
_data16.value = idx[*data++];
_data32.lsb_2 = _data16.msb;
_data32.msb_2 = _data16.lsb;
_buffer32[i] = _data32.value;
}
l <<= 2;
*(uint32_t *)_dmadesc = ((l + 3) & (~3)) | l << 12 | 0xC0000000;
_dmadesc->buffer = _buffer;
_dmadesc->next = nullptr;
gdma_start(_dma_chan, (intptr_t)(_dmadesc));
LCD_CAM.lcd_cmd_val.val = _data32.value;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_UPDATE_REG;
len -= xferLen;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_ALWAYS_OUT_EN | LCD_CAM_LCD_DOUT | LCD_CAM_LCD_CMD | LCD_CAM_LCD_CMD_2_CYCLE_EN | LCD_CAM_LCD_START;
}
}
while (len--)
{
_data16.value = idx[*data++];
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
}
/**
* @brief writeIndexedPixelsDouble
*
* @param data
* @param idx
* @param len
*/
void Arduino_ESP32LCD8::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.msb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
LCD_CAM.lcd_cmd_val.lcd_cmd_value = _data16.lsb;
WAIT_LCD_NOT_BUSY;
LCD_CAM.lcd_user.val = LCD_CAM_LCD_CMD | LCD_CAM_LCD_UPDATE_REG | LCD_CAM_LCD_START;
}
}
/******** low level bit twiddling **********/
/**
* @brief CS_HIGH
*
* @return INLINE
*/
INLINE void Arduino_ESP32LCD8::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
/**
* @brief CS_LOW
*
* @return INLINE
*/
INLINE void Arduino_ESP32LCD8::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,79 @@
#pragma once
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
#define LCD_MAX_PIXELS_AT_ONCE 2046
#define USE_DMA_THRESHOLD 6
class Arduino_ESP32LCD8 : public Arduino_DataBus
{
public:
Arduino_ESP32LCD8(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
PORTreg_t _csPortSet; ///< PORT register for chip select SET
PORTreg_t _csPortClr; ///< PORT register for chip select CLEAR
uint32_t _csPinMask; ///< Bitmask for chip select
esp_lcd_i80_bus_handle_t _i80_bus = nullptr;
dma_descriptor_t *_dmadesc = nullptr;
gdma_channel_handle_t _dma_chan;
union
{
uint32_t value;
struct
{
uint16_t value16;
uint16_t value16_2;
};
struct
{
uint8_t lsb;
uint8_t msb;
uint8_t lsb_2;
uint8_t msb_2;
};
} _data32;
union
{
uint8_t _buffer[LCD_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t _buffer16[LCD_MAX_PIXELS_AT_ONCE];
uint32_t _buffer32[LCD_MAX_PIXELS_AT_ONCE / 2];
};
};
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,616 @@
#include "Arduino_ESP32PAR16.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32PAR16::Arduino_ESP32PAR16(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7),
_d8(d8), _d9(d9), _d10(d10), _d11(d11), _d12(d12), _d13(d13), _d14(d14), _d15(d15)
{
}
bool Arduino_ESP32PAR16::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
pinMode(_d0, OUTPUT);
pinMode(_d1, OUTPUT);
pinMode(_d2, OUTPUT);
pinMode(_d3, OUTPUT);
pinMode(_d4, OUTPUT);
pinMode(_d5, OUTPUT);
pinMode(_d6, OUTPUT);
pinMode(_d7, OUTPUT);
pinMode(_d8, OUTPUT);
pinMode(_d9, OUTPUT);
pinMode(_d10, OUTPUT);
pinMode(_d11, OUTPUT);
pinMode(_d12, OUTPUT);
pinMode(_d13, OUTPUT);
pinMode(_d14, OUTPUT);
pinMode(_d15, OUTPUT);
// INIT 16-bit mask
_data1ClrMask = 0;
_data2ClrMask = 0;
if (_d0 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d0);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d0);
}
if (_d1 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d1);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d1);
}
if (_d2 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d2);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d2);
}
if (_d3 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d3);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d3);
}
if (_d4 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d4);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d4);
}
if (_d5 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d5);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d5);
}
if (_d6 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d6);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d6);
}
if (_d7 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d7);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d7);
}
if (_d8 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d8);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d8);
}
if (_d9 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d9);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d9);
}
if (_d10 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d10);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d10);
}
if (_d11 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d11);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d11);
}
if (_d12 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d12);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d12);
}
if (_d13 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d13);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d13);
}
if (_d14 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d14);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d14);
}
if (_d15 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d15);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d15);
}
for (int32_t c = 0; c < 256; c++)
{
_xset_mask1_lo[c] = 0;
_xset_mask2_lo[c] = 0;
if (c & 0x01)
{
if (_d0 >= 32)
{
_xset_mask2_lo[c] |= digitalPinToBitMask(_d0);
}
else
{
_xset_mask1_lo[c] |= digitalPinToBitMask(_d0);
}
}
if (c & 0x02)
{
if (_d1 >= 32)
{
_xset_mask2_lo[c] |= digitalPinToBitMask(_d1);
}
else
{
_xset_mask1_lo[c] |= digitalPinToBitMask(_d1);
}
}
if (c & 0x04)
{
if (_d2 >= 32)
{
_xset_mask2_lo[c] |= digitalPinToBitMask(_d2);
}
else
{
_xset_mask1_lo[c] |= digitalPinToBitMask(_d2);
}
}
if (c & 0x08)
{
if (_d3 >= 32)
{
_xset_mask2_lo[c] |= digitalPinToBitMask(_d3);
}
else
{
_xset_mask1_lo[c] |= digitalPinToBitMask(_d3);
}
}
if (c & 0x10)
{
if (_d4 >= 32)
{
_xset_mask2_lo[c] |= digitalPinToBitMask(_d4);
}
else
{
_xset_mask1_lo[c] |= digitalPinToBitMask(_d4);
}
}
if (c & 0x20)
{
if (_d5 >= 32)
{
_xset_mask2_lo[c] |= digitalPinToBitMask(_d5);
}
else
{
_xset_mask1_lo[c] |= digitalPinToBitMask(_d5);
}
}
if (c & 0x40)
{
if (_d6 >= 32)
{
_xset_mask2_lo[c] |= digitalPinToBitMask(_d6);
}
else
{
_xset_mask1_lo[c] |= digitalPinToBitMask(_d6);
}
}
if (c & 0x80)
{
if (_d7 >= 32)
{
_xset_mask2_lo[c] |= digitalPinToBitMask(_d7);
}
else
{
_xset_mask1_lo[c] |= digitalPinToBitMask(_d7);
}
}
}
for (int32_t c = 0; c < 256; c++)
{
_xset_mask1_hi[c] = 0;
_xset_mask2_hi[c] = 0;
if (c & 0x01)
{
if (_d8 >= 32)
{
_xset_mask2_hi[c] |= digitalPinToBitMask(_d8);
}
else
{
_xset_mask1_hi[c] |= digitalPinToBitMask(_d8);
}
}
if (c & 0x02)
{
if (_d9 >= 32)
{
_xset_mask2_hi[c] |= digitalPinToBitMask(_d9);
}
else
{
_xset_mask1_hi[c] |= digitalPinToBitMask(_d9);
}
}
if (c & 0x04)
{
if (_d10 >= 32)
{
_xset_mask2_hi[c] |= digitalPinToBitMask(_d10);
}
else
{
_xset_mask1_hi[c] |= digitalPinToBitMask(_d10);
}
}
if (c & 0x08)
{
if (_d11 >= 32)
{
_xset_mask2_hi[c] |= digitalPinToBitMask(_d11);
}
else
{
_xset_mask1_hi[c] |= digitalPinToBitMask(_d11);
}
}
if (c & 0x10)
{
if (_d12 >= 32)
{
_xset_mask2_hi[c] |= digitalPinToBitMask(_d12);
}
else
{
_xset_mask1_hi[c] |= digitalPinToBitMask(_d12);
}
}
if (c & 0x20)
{
if (_d13 >= 32)
{
_xset_mask2_hi[c] |= digitalPinToBitMask(_d13);
}
else
{
_xset_mask1_hi[c] |= digitalPinToBitMask(_d13);
}
}
if (c & 0x40)
{
if (_d14 >= 32)
{
_xset_mask2_hi[c] |= digitalPinToBitMask(_d14);
}
else
{
_xset_mask1_hi[c] |= digitalPinToBitMask(_d14);
}
}
if (c & 0x80)
{
if (_d15 >= 32)
{
_xset_mask2_hi[c] |= digitalPinToBitMask(_d15);
}
else
{
_xset_mask1_hi[c] |= digitalPinToBitMask(_d15);
}
}
}
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
return true;
}
void Arduino_ESP32PAR16::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32PAR16::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32PAR16::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32PAR16::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_ESP32PAR16::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32PAR16::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_ESP32PAR16::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
uint32_t d1 = _xset_mask1_hi[_data16.msb] | _xset_mask1_lo[_data16.lsb];
uint32_t d2 = _xset_mask2_hi[_data16.msb] | _xset_mask2_lo[_data16.lsb];
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
GPIO.out_w1ts = d1;
GPIO.out1_w1ts.val = d2;
while (len--)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
void Arduino_ESP32PAR16::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
WRITE16(*data++);
}
}
void Arduino_ESP32PAR16::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32PAR16::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_ESP32PAR16::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d1);
WRITE16(d2);
}
void Arduino_ESP32PAR16::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR16::writeBytes(uint8_t *data, uint32_t len)
{
while (len > 1)
{
_data16.msb = *data++;
_data16.lsb = *data++;
WRITE16(_data16.value);
len -= 2;
}
if (len)
{
WRITE(*data);
}
}
void Arduino_ESP32PAR16::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
WRITE16(idx[*data++]);
}
}
void Arduino_ESP32PAR16::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
GPIO.out_w1ts = _xset_mask1_hi[_data16.msb] | _xset_mask1_lo[_data16.lsb];
GPIO.out1_w1ts.val = _xset_mask2_hi[_data16.msb] | _xset_mask2_lo[_data16.lsb];
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
INLINE void Arduino_ESP32PAR16::WRITE(uint8_t d)
{
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
GPIO.out_w1ts = _xset_mask1_lo[d];
GPIO.out1_w1ts.val = _xset_mask2_lo[d];
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
INLINE void Arduino_ESP32PAR16::WRITE16(uint16_t d)
{
_data16.value = d;
uint32_t d1 = _xset_mask1_hi[_data16.msb] | _xset_mask1_lo[_data16.lsb];
uint32_t d2 = _xset_mask2_hi[_data16.msb] | _xset_mask2_lo[_data16.lsb];
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
GPIO.out_w1ts = d1;
GPIO.out1_w1ts.val = d2;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32PAR16::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32PAR16::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32PAR16::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32PAR16::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,71 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32PAR16_H_
#define _ARDUINO_ESP32PAR16_H_
class Arduino_ESP32PAR16 : public Arduino_DataBus
{
public:
Arduino_ESP32PAR16(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
int8_t _d8, _d9, _d10, _d11, _d12, _d13, _d14, _d15;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
uint32_t _data1ClrMask;
uint32_t _data2ClrMask;
// Lookup table for ESP32 parallel bus interface uses 4kbyte RAM
uint32_t _xset_mask1_lo[256];
uint32_t _xset_mask1_hi[256];
uint32_t _xset_mask2_lo[256];
uint32_t _xset_mask2_hi[256];
};
#endif // _ARDUINO_ESP32PAR16_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,360 @@
#include "Arduino_ESP32PAR16Q.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32PAR16Q::Arduino_ESP32PAR16Q(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7),
_d8(d8), _d9(d9), _d10(d10), _d11(d11), _d12(d12), _d13(d13), _d14(d14), _d15(d15)
{
}
bool Arduino_ESP32PAR16Q::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
// TODO: check pin range 0-31
pinMode(_d0, OUTPUT);
pinMode(_d1, OUTPUT);
pinMode(_d2, OUTPUT);
pinMode(_d3, OUTPUT);
pinMode(_d4, OUTPUT);
pinMode(_d5, OUTPUT);
pinMode(_d6, OUTPUT);
pinMode(_d7, OUTPUT);
pinMode(_d8, OUTPUT);
pinMode(_d9, OUTPUT);
pinMode(_d10, OUTPUT);
pinMode(_d11, OUTPUT);
pinMode(_d12, OUTPUT);
pinMode(_d13, OUTPUT);
pinMode(_d14, OUTPUT);
pinMode(_d15, OUTPUT);
// INIT 16-bit mask
_dataClrMask = (1 << _wr) | (1 << _d0) | (1 << _d1) | (1 << _d2) | (1 << _d3) | (1 << _d4) | (1 << _d5) | (1 << _d6) | (1 << _d7) | (1 << _d8) | (1 << _d9) | (1 << _d10) | (1 << _d11) | (1 << _d12) | (1 << _d13) | (1 << _d14) | (1 << _d15);
for (int32_t c = 0; c < 256; c++)
{
_xset_mask_lo[c] = 0;
if (c & 0x01)
{
_xset_mask_lo[c] |= (1 << _d0);
}
if (c & 0x02)
{
_xset_mask_lo[c] |= (1 << _d1);
}
if (c & 0x04)
{
_xset_mask_lo[c] |= (1 << _d2);
}
if (c & 0x08)
{
_xset_mask_lo[c] |= (1 << _d3);
}
if (c & 0x10)
{
_xset_mask_lo[c] |= (1 << _d4);
}
if (c & 0x20)
{
_xset_mask_lo[c] |= (1 << _d5);
}
if (c & 0x40)
{
_xset_mask_lo[c] |= (1 << _d6);
}
if (c & 0x80)
{
_xset_mask_lo[c] |= (1 << _d7);
}
}
for (int32_t c = 0; c < 256; c++)
{
_xset_mask_hi[c] = 0;
if (c & 0x01)
{
_xset_mask_hi[c] |= (1 << _d8);
}
if (c & 0x02)
{
_xset_mask_hi[c] |= (1 << _d9);
}
if (c & 0x04)
{
_xset_mask_hi[c] |= (1 << _d10);
}
if (c & 0x08)
{
_xset_mask_hi[c] |= (1 << _d11);
}
if (c & 0x10)
{
_xset_mask_hi[c] |= (1 << _d12);
}
if (c & 0x20)
{
_xset_mask_hi[c] |= (1 << _d13);
}
if (c & 0x40)
{
_xset_mask_hi[c] |= (1 << _d14);
}
if (c & 0x80)
{
_xset_mask_hi[c] |= (1 << _d15);
}
}
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32PAR16Q::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32PAR16Q::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32PAR16Q::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32PAR16Q::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_ESP32PAR16Q::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32PAR16Q::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_ESP32PAR16Q::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
uint32_t d = _xset_mask_hi[_data16.msb] | _xset_mask_lo[_data16.lsb];
*_dataPortClr = _dataClrMask;
*_dataPortSet = d;
while (len--)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
void Arduino_ESP32PAR16Q::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
WRITE16(*data++);
}
}
void Arduino_ESP32PAR16Q::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32PAR16Q::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_ESP32PAR16Q::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d1);
WRITE16(d2);
}
void Arduino_ESP32PAR16Q::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR16Q::writeBytes(uint8_t *data, uint32_t len)
{
while (len > 1)
{
_data16.msb = *data++;
_data16.lsb = *data++;
WRITE16(_data16.value);
len -= 2;
}
if (len)
{
WRITE(*data);
}
}
void Arduino_ESP32PAR16Q::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
WRITE16(idx[*data++]);
}
}
void Arduino_ESP32PAR16Q::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
*_dataPortClr = _dataClrMask;
*_dataPortSet = _xset_mask_hi[_data16.msb] | _xset_mask_lo[_data16.lsb];
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
INLINE void Arduino_ESP32PAR16Q::WRITE(uint8_t d)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = _xset_mask_lo[d];
*_wrPortSet = _wrPinMask;
}
INLINE void Arduino_ESP32PAR16Q::WRITE16(uint16_t d)
{
_data16.value = d;
*_dataPortClr = _dataClrMask;
*_dataPortSet = _xset_mask_hi[_data16.msb] | _xset_mask_lo[_data16.lsb];
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32PAR16Q::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32PAR16Q::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32PAR16Q::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32PAR16Q::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,70 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32PAR16Q_H_
#define _ARDUINO_ESP32PAR16Q_H_
class Arduino_ESP32PAR16Q : public Arduino_DataBus
{
public:
Arduino_ESP32PAR16Q(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
int8_t _d8, _d9, _d10, _d11, _d12, _d13, _d14, _d15;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
// Lookup table for ESP32 parallel bus interface uses 2kbyte RAM,
uint32_t _xset_mask_lo[256];
uint32_t _xset_mask_hi[256];
};
#endif // _ARDUINO_ESP32PAR16Q_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,355 @@
#include "Arduino_ESP32PAR16QQ.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32PAR16QQ::Arduino_ESP32PAR16QQ(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7),
_d8(d8), _d9(d9), _d10(d10), _d11(d11), _d12(d12), _d13(d13), _d14(d14), _d15(d15)
{
}
bool Arduino_ESP32PAR16QQ::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
// TODO: check pin range 0-31
pinMode(_d0, OUTPUT);
pinMode(_d1, OUTPUT);
pinMode(_d2, OUTPUT);
pinMode(_d3, OUTPUT);
pinMode(_d4, OUTPUT);
pinMode(_d5, OUTPUT);
pinMode(_d6, OUTPUT);
pinMode(_d7, OUTPUT);
pinMode(_d8, OUTPUT);
pinMode(_d9, OUTPUT);
pinMode(_d10, OUTPUT);
pinMode(_d11, OUTPUT);
pinMode(_d12, OUTPUT);
pinMode(_d13, OUTPUT);
pinMode(_d14, OUTPUT);
pinMode(_d15, OUTPUT);
// INIT 16-bit mask
_dataClrMask = (1 << _wr) | (1 << _d0) | (1 << _d1) | (1 << _d2) | (1 << _d3) | (1 << _d4) | (1 << _d5) | (1 << _d6) | (1 << _d7) | (1 << _d8) | (1 << _d9) | (1 << _d10) | (1 << _d11) | (1 << _d12) | (1 << _d13) | (1 << _d14) | (1 << _d15);
for (int32_t c = 0; c < 256; c++)
{
_xset_mask_lo[c] = (1 << _wr);
if (c & 0x01)
{
_xset_mask_lo[c] |= (1 << _d0);
}
if (c & 0x02)
{
_xset_mask_lo[c] |= (1 << _d1);
}
if (c & 0x04)
{
_xset_mask_lo[c] |= (1 << _d2);
}
if (c & 0x08)
{
_xset_mask_lo[c] |= (1 << _d3);
}
if (c & 0x10)
{
_xset_mask_lo[c] |= (1 << _d4);
}
if (c & 0x20)
{
_xset_mask_lo[c] |= (1 << _d5);
}
if (c & 0x40)
{
_xset_mask_lo[c] |= (1 << _d6);
}
if (c & 0x80)
{
_xset_mask_lo[c] |= (1 << _d7);
}
}
for (int32_t c = 0; c < 256; c++)
{
_xset_mask_hi[c] = 0;
if (c & 0x01)
{
_xset_mask_hi[c] |= (1 << _d8);
}
if (c & 0x02)
{
_xset_mask_hi[c] |= (1 << _d9);
}
if (c & 0x04)
{
_xset_mask_hi[c] |= (1 << _d10);
}
if (c & 0x08)
{
_xset_mask_hi[c] |= (1 << _d11);
}
if (c & 0x10)
{
_xset_mask_hi[c] |= (1 << _d12);
}
if (c & 0x20)
{
_xset_mask_hi[c] |= (1 << _d13);
}
if (c & 0x40)
{
_xset_mask_hi[c] |= (1 << _d14);
}
if (c & 0x80)
{
_xset_mask_hi[c] |= (1 << _d15);
}
}
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32PAR16QQ::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32PAR16QQ::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32PAR16QQ::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32PAR16QQ::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_ESP32PAR16QQ::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32PAR16QQ::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_ESP32PAR16QQ::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
uint32_t d = _xset_mask_hi[_data16.msb] | _xset_mask_lo[_data16.lsb];
while (len--)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = d;
}
}
void Arduino_ESP32PAR16QQ::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
WRITE16(*data++);
}
}
void Arduino_ESP32PAR16QQ::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32PAR16QQ::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_ESP32PAR16QQ::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d1);
WRITE16(d2);
}
void Arduino_ESP32PAR16QQ::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR16QQ::writeBytes(uint8_t *data, uint32_t len)
{
while (len > 1)
{
_data16.msb = *data++;
_data16.lsb = *data++;
WRITE16(_data16.value);
len -= 2;
}
if (len)
{
WRITE(*data);
}
}
void Arduino_ESP32PAR16QQ::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
WRITE16(idx[*data++]);
}
}
void Arduino_ESP32PAR16QQ::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
*_dataPortClr = _dataClrMask;
*_dataPortSet = _xset_mask_hi[_data16.msb] | _xset_mask_lo[_data16.lsb];
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
INLINE void Arduino_ESP32PAR16QQ::WRITE(uint8_t d)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = _xset_mask_lo[d];
}
INLINE void Arduino_ESP32PAR16QQ::WRITE16(uint16_t d)
{
_data16.value = d;
*_dataPortClr = _dataClrMask;
*_dataPortSet = _xset_mask_hi[_data16.msb] | _xset_mask_lo[_data16.lsb];
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32PAR16QQ::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32PAR16QQ::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32PAR16QQ::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32PAR16QQ::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,70 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32PAR16QQ_H_
#define _ARDUINO_ESP32PAR16QQ_H_
class Arduino_ESP32PAR16QQ : public Arduino_DataBus
{
public:
Arduino_ESP32PAR16QQ(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
int8_t _d8, _d9, _d10, _d11, _d12, _d13, _d14, _d15;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
// Lookup table for ESP32 parallel bus interface uses 2kbyte RAM,
uint32_t _xset_mask_lo[256];
uint32_t _xset_mask_hi[256];
};
#endif // _ARDUINO_ESP32PAR16QQ_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,470 @@
#include "Arduino_ESP32PAR8.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32PAR8::Arduino_ESP32PAR8(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7)
{
}
bool Arduino_ESP32PAR8::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
pinMode(_d0, OUTPUT);
pinMode(_d1, OUTPUT);
pinMode(_d2, OUTPUT);
pinMode(_d3, OUTPUT);
pinMode(_d4, OUTPUT);
pinMode(_d5, OUTPUT);
pinMode(_d6, OUTPUT);
pinMode(_d7, OUTPUT);
// INIT 8-bit mask
_data1ClrMask = 0;
_data2ClrMask = 0;
if (_d0 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d0);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d0);
}
if (_d1 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d1);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d1);
}
if (_d2 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d2);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d2);
}
if (_d3 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d3);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d3);
}
if (_d4 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d4);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d4);
}
if (_d5 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d5);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d5);
}
if (_d6 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d6);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d6);
}
if (_d7 >= 32)
{
_data2ClrMask |= digitalPinToBitMask(_d7);
}
else
{
_data1ClrMask |= digitalPinToBitMask(_d7);
}
for (int32_t c = 0; c < 256; c++)
{
_xset_mask1[c] = 0;
_xset_mask2[c] = 0;
if (c & 0x01)
{
if (_d0 >= 32)
{
_xset_mask2[c] |= digitalPinToBitMask(_d0);
}
else
{
_xset_mask1[c] |= digitalPinToBitMask(_d0);
}
}
if (c & 0x02)
{
if (_d1 >= 32)
{
_xset_mask2[c] |= digitalPinToBitMask(_d1);
}
else
{
_xset_mask1[c] |= digitalPinToBitMask(_d1);
}
}
if (c & 0x04)
{
if (_d2 >= 32)
{
_xset_mask2[c] |= digitalPinToBitMask(_d2);
}
else
{
_xset_mask1[c] |= digitalPinToBitMask(_d2);
}
}
if (c & 0x08)
{
if (_d3 >= 32)
{
_xset_mask2[c] |= digitalPinToBitMask(_d3);
}
else
{
_xset_mask1[c] |= digitalPinToBitMask(_d3);
}
}
if (c & 0x10)
{
if (_d4 >= 32)
{
_xset_mask2[c] |= digitalPinToBitMask(_d4);
}
else
{
_xset_mask1[c] |= digitalPinToBitMask(_d4);
}
}
if (c & 0x20)
{
if (_d5 >= 32)
{
_xset_mask2[c] |= digitalPinToBitMask(_d5);
}
else
{
_xset_mask1[c] |= digitalPinToBitMask(_d5);
}
}
if (c & 0x40)
{
if (_d6 >= 32)
{
_xset_mask2[c] |= digitalPinToBitMask(_d6);
}
else
{
_xset_mask1[c] |= digitalPinToBitMask(_d6);
}
}
if (c & 0x80)
{
if (_d7 >= 32)
{
_xset_mask2[c] |= digitalPinToBitMask(_d7);
}
else
{
_xset_mask1[c] |= digitalPinToBitMask(_d7);
}
}
}
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
return true;
}
void Arduino_ESP32PAR8::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32PAR8::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32PAR8::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32PAR8::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_ESP32PAR8::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32PAR8::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
uint32_t setMask1 = _xset_mask1[_data16.msb];
uint32_t setMask2 = _xset_mask2[_data16.msb];
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
GPIO.out_w1ts = setMask1;
GPIO.out1_w1ts.val = setMask2;
while (len--)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
else
{
uint32_t hiMask1 = _xset_mask1[_data16.msb];
uint32_t hiMask2 = _xset_mask2[_data16.msb];
uint32_t loMask1 = _xset_mask1[_data16.lsb];
uint32_t loMask2 = _xset_mask2[_data16.lsb];
while (len--)
{
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
GPIO.out_w1ts = hiMask1;
GPIO.out1_w1ts.val = hiMask2;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
GPIO.out_w1ts = loMask1;
GPIO.out1_w1ts.val = loMask2;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
}
void Arduino_ESP32PAR8::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32PAR8::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32PAR8::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_ESP32PAR8::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32PAR8::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
INLINE void Arduino_ESP32PAR8::WRITE(uint8_t d)
{
uint32_t setMask1 = _xset_mask1[d];
uint32_t setMask2 = _xset_mask2[d];
GPIO.out_w1tc = _data1ClrMask;
GPIO.out1_w1tc.val = _data2ClrMask;
GPIO.out_w1ts = setMask1;
GPIO.out1_w1ts.val = setMask2;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32PAR8::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32PAR8::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32PAR8::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32PAR8::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,66 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32PAR8_H_
#define _ARDUINO_ESP32PAR8_H_
class Arduino_ESP32PAR8 : public Arduino_DataBus
{
public:
Arduino_ESP32PAR8(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
uint32_t _data1ClrMask;
uint32_t _data2ClrMask;
// Lookup table for ESP32 parallel bus interface uses 1kbyte RAM,
uint32_t _xset_mask1[256];
uint32_t _xset_mask2[256];
};
#endif // _ARDUINO_ESP32PAR8_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,347 @@
#include "Arduino_ESP32PAR8Q.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32PAR8Q::Arduino_ESP32PAR8Q(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7)
{
}
bool Arduino_ESP32PAR8Q::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
// TODO: check pin range 0-31
pinMode(_d0, OUTPUT);
pinMode(_d1, OUTPUT);
pinMode(_d2, OUTPUT);
pinMode(_d3, OUTPUT);
pinMode(_d4, OUTPUT);
pinMode(_d5, OUTPUT);
pinMode(_d6, OUTPUT);
pinMode(_d7, OUTPUT);
if (_d0 >= 32)
{
_dataPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dataPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
// INIT 8-bit mask
_dataClrMask = digitalPinToBitMask(_d0) | digitalPinToBitMask(_d1) | digitalPinToBitMask(_d2) | digitalPinToBitMask(_d3) | digitalPinToBitMask(_d4) | digitalPinToBitMask(_d5) | digitalPinToBitMask(_d6) | digitalPinToBitMask(_d7);
for (int32_t c = 0; c < 256; c++)
{
_xset_mask[c] = 0;
if (c & 0x01)
{
_xset_mask[c] |= digitalPinToBitMask(_d0);
}
if (c & 0x02)
{
_xset_mask[c] |= digitalPinToBitMask(_d1);
}
if (c & 0x04)
{
_xset_mask[c] |= digitalPinToBitMask(_d2);
}
if (c & 0x08)
{
_xset_mask[c] |= digitalPinToBitMask(_d3);
}
if (c & 0x10)
{
_xset_mask[c] |= digitalPinToBitMask(_d4);
}
if (c & 0x20)
{
_xset_mask[c] |= digitalPinToBitMask(_d5);
}
if (c & 0x40)
{
_xset_mask[c] |= digitalPinToBitMask(_d6);
}
if (c & 0x80)
{
_xset_mask[c] |= digitalPinToBitMask(_d7);
}
}
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32PAR8Q::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32PAR8Q::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32PAR8Q::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32PAR8Q::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_ESP32PAR8Q::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32PAR8Q::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8Q::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
uint32_t setMask = _xset_mask[_data16.msb];
*_dataPortClr = _dataClrMask;
*_dataPortSet = setMask;
while (len--)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
else
{
uint32_t hiMask = _xset_mask[_data16.msb];
uint32_t loMask = _xset_mask[_data16.lsb];
while (len--)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = hiMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_dataPortClr = _dataClrMask;
*_dataPortSet = loMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
}
void Arduino_ESP32PAR8Q::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32PAR8Q::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32PAR8Q::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8Q::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8Q::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8Q::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_ESP32PAR8Q::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32PAR8Q::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
INLINE void Arduino_ESP32PAR8Q::WRITE(uint8_t d)
{
uint32_t setMask = _xset_mask[d];
*_dataPortClr = _dataClrMask;
*_dataPortSet = setMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32PAR8Q::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32PAR8Q::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32PAR8Q::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32PAR8Q::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,66 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32PAR8Q_H_
#define _ARDUINO_ESP32PAR8Q_H_
class Arduino_ESP32PAR8Q : public Arduino_DataBus
{
public:
Arduino_ESP32PAR8Q(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
// Lookup table for ESP32 parallel bus interface uses 1kbyte RAM,
uint32_t _xset_mask[256];
};
#endif // _ARDUINO_ESP32PAR8Q_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,347 @@
#include "Arduino_ESP32PAR8QQ.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32PAR8QQ::Arduino_ESP32PAR8QQ(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7)
{
}
bool Arduino_ESP32PAR8QQ::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
// TODO: check pin range 0-31
pinMode(_d0, OUTPUT);
pinMode(_d1, OUTPUT);
pinMode(_d2, OUTPUT);
pinMode(_d3, OUTPUT);
pinMode(_d4, OUTPUT);
pinMode(_d5, OUTPUT);
pinMode(_d6, OUTPUT);
pinMode(_d7, OUTPUT);
if (_d0 >= 32)
{
_dataPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dataPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
// INIT 8-bit mask
_dataClrMask = digitalPinToBitMask(_d0) | digitalPinToBitMask(_d1) | digitalPinToBitMask(_d2) | digitalPinToBitMask(_d3) | digitalPinToBitMask(_d4) | digitalPinToBitMask(_d5) | digitalPinToBitMask(_d6) | digitalPinToBitMask(_d7);
for (int32_t c = 0; c < 256; c++)
{
_xset_mask[c] = 0;
if (c & 0x01)
{
_xset_mask[c] |= digitalPinToBitMask(_d0);
}
if (c & 0x02)
{
_xset_mask[c] |= digitalPinToBitMask(_d1);
}
if (c & 0x04)
{
_xset_mask[c] |= digitalPinToBitMask(_d2);
}
if (c & 0x08)
{
_xset_mask[c] |= digitalPinToBitMask(_d3);
}
if (c & 0x10)
{
_xset_mask[c] |= digitalPinToBitMask(_d4);
}
if (c & 0x20)
{
_xset_mask[c] |= digitalPinToBitMask(_d5);
}
if (c & 0x40)
{
_xset_mask[c] |= digitalPinToBitMask(_d6);
}
if (c & 0x80)
{
_xset_mask[c] |= digitalPinToBitMask(_d7);
}
}
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32PAR8QQ::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32PAR8QQ::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32PAR8QQ::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32PAR8QQ::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_ESP32PAR8QQ::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32PAR8QQ::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8QQ::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
uint32_t setMask = _xset_mask[_data16.msb];
*_dataPortClr = _dataClrMask;
*_dataPortSet = setMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
while (--len)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
else
{
uint32_t hiMask = _xset_mask[_data16.msb];
uint32_t loMask = _xset_mask[_data16.lsb];
while (len--)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = hiMask;
*_wrPortSet = _wrPinMask;
*_dataPortClr = _dataClrMask;
*_dataPortSet = loMask;
*_wrPortSet = _wrPinMask;
}
}
}
void Arduino_ESP32PAR8QQ::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32PAR8QQ::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32PAR8QQ::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8QQ::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8QQ::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8QQ::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_ESP32PAR8QQ::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32PAR8QQ::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
INLINE void Arduino_ESP32PAR8QQ::WRITE(uint8_t d)
{
uint32_t setMask = _xset_mask[d];
*_dataPortClr = _dataClrMask;
*_dataPortSet = setMask;
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32PAR8QQ::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32PAR8QQ::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32PAR8QQ::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32PAR8QQ::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,66 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32PAR8QQ_H_
#define _ARDUINO_ESP32PAR8QQ_H_
class Arduino_ESP32PAR8QQ : public Arduino_DataBus
{
public:
Arduino_ESP32PAR8QQ(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
// Lookup table for ESP32 parallel bus interface uses 1kbyte RAM,
uint32_t _xset_mask[256];
};
#endif // _ARDUINO_ESP32PAR8QQ_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,341 @@
#include "Arduino_ESP32PAR8QQQ.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32PAR8QQQ::Arduino_ESP32PAR8QQQ(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7)
{
}
bool Arduino_ESP32PAR8QQQ::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
// TODO: check pin range 0-31
pinMode(_d0, OUTPUT);
pinMode(_d1, OUTPUT);
pinMode(_d2, OUTPUT);
pinMode(_d3, OUTPUT);
pinMode(_d4, OUTPUT);
pinMode(_d5, OUTPUT);
pinMode(_d6, OUTPUT);
pinMode(_d7, OUTPUT);
if (_d0 >= 32)
{
_dataPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dataPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
// INIT 8-bit mask
_dataClrMask = digitalPinToBitMask(_d0) | digitalPinToBitMask(_d1) | digitalPinToBitMask(_d2) | digitalPinToBitMask(_d3) | digitalPinToBitMask(_d4) | digitalPinToBitMask(_d5) | digitalPinToBitMask(_d6) | digitalPinToBitMask(_d7);
for (int32_t c = 0; c < 256; c++)
{
_xset_mask[c] = digitalPinToBitMask(_wr);
if (c & 0x01)
{
_xset_mask[c] |= digitalPinToBitMask(_d0);
}
if (c & 0x02)
{
_xset_mask[c] |= digitalPinToBitMask(_d1);
}
if (c & 0x04)
{
_xset_mask[c] |= digitalPinToBitMask(_d2);
}
if (c & 0x08)
{
_xset_mask[c] |= digitalPinToBitMask(_d3);
}
if (c & 0x10)
{
_xset_mask[c] |= digitalPinToBitMask(_d4);
}
if (c & 0x20)
{
_xset_mask[c] |= digitalPinToBitMask(_d5);
}
if (c & 0x40)
{
_xset_mask[c] |= digitalPinToBitMask(_d6);
}
if (c & 0x80)
{
_xset_mask[c] |= digitalPinToBitMask(_d7);
}
}
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32PAR8QQQ::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32PAR8QQQ::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32PAR8QQQ::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32PAR8QQQ::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_ESP32PAR8QQQ::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32PAR8QQQ::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8QQQ::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
uint32_t setMask = _xset_mask[_data16.msb];
*_dataPortClr = _dataClrMask;
*_dataPortSet = setMask;
while (len--)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
else
{
uint32_t hiMask = _xset_mask[_data16.msb];
uint32_t loMask = _xset_mask[_data16.lsb];
while (len--)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = hiMask;
*_dataPortClr = _dataClrMask;
*_dataPortSet = loMask;
}
}
}
void Arduino_ESP32PAR8QQQ::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32PAR8QQQ::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32PAR8QQQ::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8QQQ::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8QQQ::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32PAR8QQQ::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_ESP32PAR8QQQ::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32PAR8QQQ::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
INLINE void Arduino_ESP32PAR8QQQ::WRITE(uint8_t d)
{
uint32_t setMask = _xset_mask[d];
*_dataPortClr = _dataClrMask;
*_dataPortSet = setMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32PAR8QQQ::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32PAR8QQQ::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32PAR8QQQ::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32PAR8QQQ::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,66 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32PAR8QQQ_H_
#define _ARDUINO_ESP32PAR8QQQ_H_
class Arduino_ESP32PAR8QQQ : public Arduino_DataBus
{
public:
Arduino_ESP32PAR8QQQ(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
// Lookup table for ESP32 parallel bus interface uses 1kbyte RAM,
uint32_t _xset_mask[256];
};
#endif // _ARDUINO_ESP32PAR8QQQ_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,544 @@
#include "Arduino_ESP32QSPI.h"
#if defined(ESP32)
/**
* @brief Arduino_ESP32QSPI
*
*/
Arduino_ESP32QSPI::Arduino_ESP32QSPI(
int8_t cs, int8_t sck, int8_t mosi, int8_t miso, int8_t quadwp, int8_t quadhd, bool is_shared_interface /* = false */)
: _cs(cs), _sck(sck), _mosi(mosi), _miso(miso), _quadwp(quadwp), _quadhd(quadhd), _is_shared_interface(is_shared_interface)
{
}
/**
* @brief begin
*
* @param speed
* @param dataMode
* @return true
* @return false
*/
bool Arduino_ESP32QSPI::begin(int32_t speed, int8_t dataMode)
{
// set SPI parameters
_speed = (speed == GFX_NOT_DEFINED) ? QSPI_FREQUENCY : speed;
_dataMode = (dataMode == GFX_NOT_DEFINED) ? QSPI_SPI_MODE : dataMode;
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
#if (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
#endif
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
spi_bus_config_t buscfg = {
.mosi_io_num = _mosi,
.miso_io_num = _miso,
.sclk_io_num = _sck,
.quadwp_io_num = _quadwp,
.quadhd_io_num = _quadhd,
.data4_io_num = -1,
.data5_io_num = -1,
.data6_io_num = -1,
.data7_io_num = -1,
.max_transfer_sz = (ESP32QSPI_MAX_PIXELS_AT_ONCE * 16) + 8,
.flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_GPIO_PINS,
.intr_flags = 0};
esp_err_t ret = spi_bus_initialize(QSPI_SPI_HOST, &buscfg, QSPI_DMA_CHANNEL);
if (ret != ESP_OK)
{
ESP_ERROR_CHECK(ret);
return false;
}
spi_device_interface_config_t devcfg = {
.command_bits = 8,
.address_bits = 24,
.dummy_bits = 0,
.mode = (uint8_t)_dataMode,
.duty_cycle_pos = 0,
.cs_ena_pretrans = 0,
.cs_ena_posttrans = 0,
.clock_speed_hz = _speed,
.input_delay_ns = 0,
.spics_io_num = -1, // avoid use system CS control
.flags = SPI_DEVICE_HALFDUPLEX,
.queue_size = 1,
.pre_cb = nullptr,
.post_cb = nullptr};
ret = spi_bus_add_device(QSPI_SPI_HOST, &devcfg, &_handle);
if (ret != ESP_OK)
{
ESP_ERROR_CHECK(ret);
return false;
}
if (!_is_shared_interface)
{
spi_device_acquire_bus(_handle, portMAX_DELAY);
}
memset(&_spi_tran_ext, 0, sizeof(_spi_tran_ext));
_spi_tran = (spi_transaction_t *)&_spi_tran_ext;
return true;
}
/**
* @brief beginWrite
*
*/
void Arduino_ESP32QSPI::beginWrite()
{
if (_is_shared_interface)
{
spi_device_acquire_bus(_handle, portMAX_DELAY);
}
}
/**
* @brief endWrite
*
*/
void Arduino_ESP32QSPI::endWrite()
{
if (_is_shared_interface)
{
spi_device_acquire_bus(_handle, portMAX_DELAY);
}
}
/**
* @brief writeCommand
*
* @param c
*/
void Arduino_ESP32QSPI::writeCommand(uint8_t c)
{
CS_LOW();
_spi_tran_ext.base.flags = SPI_TRANS_MULTILINE_CMD | SPI_TRANS_MULTILINE_ADDR;
_spi_tran_ext.base.cmd = 0x02;
_spi_tran_ext.base.addr = ((uint32_t)c) << 8;
_spi_tran_ext.base.tx_buffer = NULL;
_spi_tran_ext.base.length = 0;
POLL_START();
POLL_END();
CS_HIGH();
}
/**
* @brief writeCommand16
*
* @param c
*/
void Arduino_ESP32QSPI::writeCommand16(uint16_t c)
{
CS_LOW();
_spi_tran_ext.base.flags = SPI_TRANS_MULTILINE_CMD | SPI_TRANS_MULTILINE_ADDR;
_spi_tran_ext.base.cmd = 0x02;
_spi_tran_ext.base.addr = c;
_spi_tran_ext.base.tx_buffer = NULL;
_spi_tran_ext.base.length = 0;
POLL_START();
POLL_END();
CS_HIGH();
}
/**
* @brief write
*
* @param d
*/
void Arduino_ESP32QSPI::write(uint8_t d)
{
CS_LOW();
_spi_tran_ext.base.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_MODE_QIO;
_spi_tran_ext.base.cmd = 0x32;
_spi_tran_ext.base.addr = 0x003C00;
_spi_tran_ext.base.tx_data[0] = d;
_spi_tran_ext.base.length = 8;
POLL_START();
POLL_END();
CS_HIGH();
}
/**
* @brief write16
*
* @param d
*/
void Arduino_ESP32QSPI::write16(uint16_t d)
{
CS_LOW();
_spi_tran_ext.base.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_MODE_QIO;
_spi_tran_ext.base.cmd = 0x32;
_spi_tran_ext.base.addr = 0x003C00;
_spi_tran_ext.base.tx_data[0] = d >> 8;
_spi_tran_ext.base.tx_data[1] = d;
_spi_tran_ext.base.length = 16;
POLL_START();
POLL_END();
CS_HIGH();
}
/**
* @brief writeC8D8
*
* @param c
* @param d
*/
void Arduino_ESP32QSPI::writeC8D8(uint8_t c, uint8_t d)
{
CS_LOW();
_spi_tran_ext.base.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_MULTILINE_CMD | SPI_TRANS_MULTILINE_ADDR;
_spi_tran_ext.base.cmd = 0x02;
_spi_tran_ext.base.addr = ((uint32_t)c) << 8;
_spi_tran_ext.base.tx_data[0] = d;
_spi_tran_ext.base.length = 8;
POLL_START();
POLL_END();
CS_HIGH();
}
/**
* @brief writeC8D16D16
*
* @param c
* @param d1
* @param d2
*/
void Arduino_ESP32QSPI::writeC8D16(uint8_t c, uint16_t d)
{
CS_LOW();
_spi_tran_ext.base.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_MULTILINE_CMD | SPI_TRANS_MULTILINE_ADDR;
_spi_tran_ext.base.cmd = 0x02;
_spi_tran_ext.base.addr = ((uint32_t)c) << 8;
_spi_tran_ext.base.tx_data[0] = d >> 8;
_spi_tran_ext.base.tx_data[1] = d;
_spi_tran_ext.base.length = 16;
POLL_START();
POLL_END();
CS_HIGH();
}
/**
* @brief writeC8D16D16
*
* @param c
* @param d1
* @param d2
*/
void Arduino_ESP32QSPI::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
CS_LOW();
_spi_tran_ext.base.flags = SPI_TRANS_USE_TXDATA | SPI_TRANS_MULTILINE_CMD | SPI_TRANS_MULTILINE_ADDR;
_spi_tran_ext.base.cmd = 0x02;
_spi_tran_ext.base.addr = ((uint32_t)c) << 8;
_spi_tran_ext.base.tx_data[0] = d1 >> 8;
_spi_tran_ext.base.tx_data[1] = d1;
_spi_tran_ext.base.tx_data[2] = d2 >> 8;
_spi_tran_ext.base.tx_data[3] = d2;
_spi_tran_ext.base.length = 32;
POLL_START();
POLL_END();
CS_HIGH();
}
/**
* @brief writeRepeat
*
* @param p
* @param len
*/
void Arduino_ESP32QSPI::writeRepeat(uint16_t p, uint32_t len)
{
bool first_send = true;
uint16_t bufLen = (len >= ESP32QSPI_MAX_PIXELS_AT_ONCE) ? ESP32QSPI_MAX_PIXELS_AT_ONCE : len;
int16_t xferLen, l;
uint32_t c32;
MSB_32_16_16_SET(c32, p, p);
l = (bufLen + 1) / 2;
for (uint32_t i = 0; i < l; i++)
{
_buffer32[i] = c32;
}
CS_LOW();
// Issue pixels in blocks from temp buffer
while (len) // While pixels remain
{
xferLen = (bufLen <= len) ? bufLen : len; // How many this pass?
if (first_send)
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO;
_spi_tran_ext.base.cmd = 0x32;
_spi_tran_ext.base.addr = 0x003C00;
first_send = false;
}
else
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
}
_spi_tran_ext.base.tx_buffer = _buffer16;
_spi_tran_ext.base.length = xferLen << 4;
POLL_START();
POLL_END();
len -= xferLen;
}
CS_HIGH();
}
/**
* @brief writePixels
*
* @param data
* @param len
*/
void Arduino_ESP32QSPI::writePixels(uint16_t *data, uint32_t len)
{
CS_LOW();
uint32_t l, l2;
uint16_t p1, p2;
bool first_send = true;
while (len)
{
l = (len > ESP32QSPI_MAX_PIXELS_AT_ONCE) ? ESP32QSPI_MAX_PIXELS_AT_ONCE : len;
if (first_send)
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO;
_spi_tran_ext.base.cmd = 0x32;
_spi_tran_ext.base.addr = 0x003C00;
first_send = false;
}
else
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
}
l2 = l >> 1;
for (uint32_t i = 0; i < l2; ++i)
{
p1 = *data++;
p2 = *data++;
MSB_32_16_16_SET(_buffer32[i], p1, p2);
}
if (l & 1)
{
p1 = *data++;
MSB_16_SET(_buffer16[l - 1], p1);
}
_spi_tran_ext.base.tx_buffer = _buffer32;
_spi_tran_ext.base.length = l << 4;
POLL_START();
POLL_END();
len -= l;
}
CS_HIGH();
}
/**
* @brief writeBytes
*
* @param data
* @param len
*/
void Arduino_ESP32QSPI::writeBytes(uint8_t *data, uint32_t len)
{
CS_LOW();
uint32_t l;
bool first_send = true;
while (len)
{
l = (len >= (ESP32QSPI_MAX_PIXELS_AT_ONCE << 1)) ? (ESP32QSPI_MAX_PIXELS_AT_ONCE << 1) : len;
if (first_send)
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO;
_spi_tran_ext.base.cmd = 0x32;
_spi_tran_ext.base.addr = 0x003C00;
first_send = false;
}
else
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
}
_spi_tran_ext.base.tx_buffer = data;
_spi_tran_ext.base.length = l << 3;
POLL_START();
POLL_END();
len -= l;
data += l;
}
CS_HIGH();
}
/**
* @brief writeIndexedPixels
*
* @param data
* @param idx
* @param len
*/
void Arduino_ESP32QSPI::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
CS_LOW();
uint32_t l, l2;
uint16_t p1, p2;
bool first_send = true;
while (len)
{
l = (len > ESP32QSPI_MAX_PIXELS_AT_ONCE) ? ESP32QSPI_MAX_PIXELS_AT_ONCE : len;
if (first_send)
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO;
_spi_tran_ext.base.cmd = 0x32;
_spi_tran_ext.base.addr = 0x003C00;
first_send = false;
}
else
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
}
l2 = l >> 1;
for (uint32_t i = 0; i < l2; ++i)
{
p1 = idx[*data++];
p2 = idx[*data++];
MSB_32_16_16_SET(_buffer32[i], p1, p2);
}
if (l & 1)
{
p1 = idx[*data++];
MSB_16_SET(_buffer16[l - 1], p1);
}
_spi_tran_ext.base.tx_buffer = _buffer32;
_spi_tran_ext.base.length = l << 4;
POLL_START();
POLL_END();
len -= l;
}
CS_HIGH();
}
/**
* @brief writeIndexedPixelsDouble
*
* @param data
* @param idx
* @param len
*/
void Arduino_ESP32QSPI::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
CS_LOW();
uint32_t l;
uint16_t p;
bool first_send = true;
while (len)
{
l = (len > (ESP32QSPI_MAX_PIXELS_AT_ONCE >> 1)) ? (ESP32QSPI_MAX_PIXELS_AT_ONCE >> 1) : len;
if (first_send)
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO;
_spi_tran_ext.base.cmd = 0x32;
_spi_tran_ext.base.addr = 0x003C00;
first_send = false;
}
else
{
_spi_tran_ext.base.flags = SPI_TRANS_MODE_QIO | SPI_TRANS_VARIABLE_CMD |
SPI_TRANS_VARIABLE_ADDR | SPI_TRANS_VARIABLE_DUMMY;
}
for (uint32_t i = 0; i < l; ++i)
{
p = idx[*data++];
MSB_32_16_16_SET(_buffer32[i], p, p);
}
_spi_tran_ext.base.tx_buffer = _buffer32;
_spi_tran_ext.base.length = l << 5;
POLL_START();
POLL_END();
len -= l;
}
CS_HIGH();
}
/******** low level bit twiddling **********/
/**
* @brief CS_HIGH
*
* @return INLINE
*/
INLINE void Arduino_ESP32QSPI::CS_HIGH(void)
{
*_csPortSet = _csPinMask;
}
/**
* @brief CS_LOW
*
* @return INLINE
*/
INLINE void Arduino_ESP32QSPI::CS_LOW(void)
{
*_csPortClr = _csPinMask;
}
/**
* @brief POLL_START
*
* @return INLINE
*/
INLINE void Arduino_ESP32QSPI::POLL_START()
{
spi_device_polling_start(_handle, _spi_tran, portMAX_DELAY);
}
/**
* @brief POLL_END
*
* @return INLINE
*/
INLINE void Arduino_ESP32QSPI::POLL_END()
{
spi_device_polling_end(_handle, portMAX_DELAY);
}
#endif // #if defined(ESP32)
@@ -0,0 +1,65 @@
#pragma once
#include "Arduino_DataBus.h"
#if defined(ESP32)
#include <driver/spi_master.h>
#define ESP32QSPI_MAX_PIXELS_AT_ONCE 1024
#define QSPI_FREQUENCY 80000000
#define QSPI_SPI_MODE SPI_MODE0
#define QSPI_SPI_HOST SPI2_HOST
#define QSPI_DMA_CHANNEL SPI_DMA_CH_AUTO
class Arduino_ESP32QSPI : public Arduino_DataBus
{
public:
Arduino_ESP32QSPI(
int8_t cs, int8_t sck, int8_t mosi, int8_t miso, int8_t quadwp, int8_t quadhd, bool is_shared_interface = false); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
INLINE void POLL_START();
INLINE void POLL_END();
int8_t _cs, _sck, _mosi, _miso, _quadwp, _quadhd;
bool _is_shared_interface;
PORTreg_t _csPortSet; ///< PORT register for chip select SET
PORTreg_t _csPortClr; ///< PORT register for chip select CLEAR
uint32_t _csPinMask; ///< Bitmask for chip select
spi_device_handle_t _handle;
spi_transaction_ext_t _spi_tran_ext;
spi_transaction_t *_spi_tran;
union
{
uint8_t _buffer[ESP32QSPI_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t _buffer16[ESP32QSPI_MAX_PIXELS_AT_ONCE];
uint32_t _buffer32[ESP32QSPI_MAX_PIXELS_AT_ONCE / 2];
};
};
#endif // #if defined(ESP32)
@@ -0,0 +1,132 @@
#include "Arduino_ESP32RGBPanel.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32RGBPanel::Arduino_ESP32RGBPanel(
int8_t de, int8_t vsync, int8_t hsync, int8_t pclk,
int8_t r0, int8_t r1, int8_t r2, int8_t r3, int8_t r4,
int8_t g0, int8_t g1, int8_t g2, int8_t g3, int8_t g4, int8_t g5,
int8_t b0, int8_t b1, int8_t b2, int8_t b3, int8_t b4,
uint16_t hsync_polarity, uint16_t hsync_front_porch, uint16_t hsync_pulse_width, uint16_t hsync_back_porch,
uint16_t vsync_polarity, uint16_t vsync_front_porch, uint16_t vsync_pulse_width, uint16_t vsync_back_porch,
uint16_t pclk_active_neg, int32_t prefer_speed, bool useBigEndian,
uint16_t de_idle_high, uint16_t pclk_idle_high)
: _de(de), _vsync(vsync), _hsync(hsync), _pclk(pclk),
_r0(r0), _r1(r1), _r2(r2), _r3(r3), _r4(r4),
_g0(g0), _g1(g1), _g2(g2), _g3(g3), _g4(g4), _g5(g5),
_b0(b0), _b1(b1), _b2(b2), _b3(b3), _b4(b4),
_hsync_polarity(hsync_polarity), _hsync_front_porch(hsync_front_porch), _hsync_pulse_width(hsync_pulse_width), _hsync_back_porch(hsync_back_porch),
_vsync_polarity(vsync_polarity), _vsync_front_porch(vsync_front_porch), _vsync_pulse_width(vsync_pulse_width), _vsync_back_porch(vsync_back_porch),
_pclk_active_neg(pclk_active_neg), _prefer_speed(prefer_speed), _useBigEndian(useBigEndian),
_de_idle_high(de_idle_high), _pclk_idle_high(pclk_idle_high)
{
}
bool Arduino_ESP32RGBPanel::begin(int32_t speed)
{
if (speed == GFX_NOT_DEFINED)
{
#ifdef CONFIG_SPIRAM_MODE_QUAD
_speed = 6000000L;
#else
_speed = 12000000L;
#endif
}
else
{
_speed = speed;
}
return true;
}
uint16_t *Arduino_ESP32RGBPanel::getFrameBuffer(int16_t w, int16_t h)
{
esp_lcd_rgb_panel_config_t *_panel_config = (esp_lcd_rgb_panel_config_t *)heap_caps_calloc(1, sizeof(esp_lcd_rgb_panel_config_t), MALLOC_CAP_DMA | MALLOC_CAP_INTERNAL);
_panel_config->clk_src = LCD_CLK_SRC_PLL160M;
_panel_config->timings.pclk_hz = (_prefer_speed == GFX_NOT_DEFINED) ? _speed : _prefer_speed;
_panel_config->timings.h_res = w;
_panel_config->timings.v_res = h;
// The following parameters should refer to LCD spec
_panel_config->timings.hsync_pulse_width = _hsync_pulse_width;
_panel_config->timings.hsync_back_porch = _hsync_back_porch;
_panel_config->timings.hsync_front_porch = _hsync_front_porch;
_panel_config->timings.vsync_pulse_width = _vsync_pulse_width;
_panel_config->timings.vsync_back_porch = _vsync_back_porch;
_panel_config->timings.vsync_front_porch = _vsync_front_porch;
_panel_config->timings.flags.hsync_idle_low = (_hsync_polarity == 0) ? 1 : 0;
_panel_config->timings.flags.vsync_idle_low = (_vsync_polarity == 0) ? 1 : 0;
_panel_config->timings.flags.de_idle_high = _de_idle_high;
_panel_config->timings.flags.pclk_active_neg = _pclk_active_neg;
_panel_config->timings.flags.pclk_idle_high = _pclk_idle_high;
_panel_config->data_width = 16; // RGB565 in parallel mode, thus 16bit in width
_panel_config->sram_trans_align = 8;
_panel_config->psram_trans_align = 64;
_panel_config->hsync_gpio_num = _hsync;
_panel_config->vsync_gpio_num = _vsync;
_panel_config->de_gpio_num = _de;
_panel_config->pclk_gpio_num = _pclk;
if (_useBigEndian)
{
_panel_config->data_gpio_nums[0] = _g3;
_panel_config->data_gpio_nums[1] = _g4;
_panel_config->data_gpio_nums[2] = _g5;
_panel_config->data_gpio_nums[3] = _r0;
_panel_config->data_gpio_nums[4] = _r1;
_panel_config->data_gpio_nums[5] = _r2;
_panel_config->data_gpio_nums[6] = _r3;
_panel_config->data_gpio_nums[7] = _r4;
_panel_config->data_gpio_nums[8] = _b0;
_panel_config->data_gpio_nums[9] = _b1;
_panel_config->data_gpio_nums[10] = _b2;
_panel_config->data_gpio_nums[11] = _b3;
_panel_config->data_gpio_nums[12] = _b4;
_panel_config->data_gpio_nums[13] = _g0;
_panel_config->data_gpio_nums[14] = _g1;
_panel_config->data_gpio_nums[15] = _g2;
}
else
{
_panel_config->data_gpio_nums[0] = _b0;
_panel_config->data_gpio_nums[1] = _b1;
_panel_config->data_gpio_nums[2] = _b2;
_panel_config->data_gpio_nums[3] = _b3;
_panel_config->data_gpio_nums[4] = _b4;
_panel_config->data_gpio_nums[5] = _g0;
_panel_config->data_gpio_nums[6] = _g1;
_panel_config->data_gpio_nums[7] = _g2;
_panel_config->data_gpio_nums[8] = _g3;
_panel_config->data_gpio_nums[9] = _g4;
_panel_config->data_gpio_nums[10] = _g5;
_panel_config->data_gpio_nums[11] = _r0;
_panel_config->data_gpio_nums[12] = _r1;
_panel_config->data_gpio_nums[13] = _r2;
_panel_config->data_gpio_nums[14] = _r3;
_panel_config->data_gpio_nums[15] = _r4;
}
_panel_config->disp_gpio_num = GPIO_NUM_NC;
_panel_config->flags.disp_active_low = 0;
_panel_config->flags.relax_on_idle = 0;
_panel_config->flags.fb_in_psram = 1; // allocate frame buffer in PSRAM
ESP_ERROR_CHECK(esp_lcd_new_rgb_panel(_panel_config, &_panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_reset(_panel_handle));
ESP_ERROR_CHECK(esp_lcd_panel_init(_panel_handle));
uint16_t color = random(0xffff);
ESP_ERROR_CHECK(_panel_handle->draw_bitmap(_panel_handle, 0, 0, 1, 1, &color));
_rgb_panel = __containerof(_panel_handle, esp_rgb_panel_t, base);
LCD_CAM.lcd_ctrl2.lcd_vsync_idle_pol = _vsync_polarity;
LCD_CAM.lcd_ctrl2.lcd_hsync_idle_pol = _hsync_polarity;
return (uint16_t *)_rgb_panel->fb;
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,100 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32RGBPANEL_H_
#define _ARDUINO_ESP32RGBPANEL_H_
#include "esp_lcd_panel_io.h"
#include "esp_lcd_panel_rgb.h"
#include "esp_lcd_panel_vendor.h"
#include "esp_lcd_panel_ops.h"
#include "esp_lcd_panel_interface.h"
#include "esp_private/gdma.h"
#include "esp_pm.h"
#include "hal/dma_types.h"
#include "hal/lcd_hal.h"
#include "hal/lcd_ll.h"
#include "esp32s3/rom/cache.h"
// This function is located in ROM (also see esp_rom/${target}/ld/${target}.rom.ld)
extern int Cache_WriteBack_Addr(uint32_t addr, uint32_t size);
// extract from esp-idf esp_lcd_rgb_panel.c
struct esp_rgb_panel_t
{
esp_lcd_panel_t base; // Base class of generic lcd panel
int panel_id; // LCD panel ID
lcd_hal_context_t hal; // Hal layer object
size_t data_width; // Number of data lines (e.g. for RGB565, the data width is 16)
size_t sram_trans_align; // Alignment for framebuffer that allocated in SRAM
size_t psram_trans_align; // Alignment for framebuffer that allocated in PSRAM
int disp_gpio_num; // Display control GPIO, which is used to perform action like "disp_off"
intr_handle_t intr; // LCD peripheral interrupt handle
esp_pm_lock_handle_t pm_lock; // Power management lock
size_t num_dma_nodes; // Number of DMA descriptors that used to carry the frame buffer
uint8_t *fb; // Frame buffer
size_t fb_size; // Size of frame buffer
int data_gpio_nums[SOC_LCD_RGB_DATA_WIDTH]; // GPIOs used for data lines, we keep these GPIOs for action like "invert_color"
size_t resolution_hz; // Peripheral clock resolution
esp_lcd_rgb_timing_t timings; // RGB timing parameters (e.g. pclk, sync pulse, porch width)
gdma_channel_handle_t dma_chan; // DMA channel handle
esp_lcd_rgb_panel_frame_trans_done_cb_t on_frame_trans_done; // Callback, invoked after frame trans done
void *user_ctx; // Reserved user's data of callback functions
int x_gap; // Extra gap in x coordinate, it's used when calculate the flush window
int y_gap; // Extra gap in y coordinate, it's used when calculate the flush window
struct
{
unsigned int disp_en_level : 1; // The level which can turn on the screen by `disp_gpio_num`
unsigned int stream_mode : 1; // If set, the LCD transfers data continuously, otherwise, it stops refreshing the LCD when transaction done
unsigned int fb_in_psram : 1; // Whether the frame buffer is in PSRAM
} flags;
dma_descriptor_t dma_nodes[]; // DMA descriptor pool of size `num_dma_nodes`
};
class Arduino_ESP32RGBPanel
{
public:
Arduino_ESP32RGBPanel(
int8_t de, int8_t vsync, int8_t hsync, int8_t pclk,
int8_t r0, int8_t r1, int8_t r2, int8_t r3, int8_t r4,
int8_t g0, int8_t g1, int8_t g2, int8_t g3, int8_t g4, int8_t g5,
int8_t b0, int8_t b1, int8_t b2, int8_t b3, int8_t b4,
uint16_t hsync_polarity, uint16_t hsync_front_porch, uint16_t hsync_pulse_width, uint16_t hsync_back_porch,
uint16_t vsync_polarity, uint16_t vsync_front_porch, uint16_t vsync_pulse_width, uint16_t vsync_back_porch,
uint16_t pclk_active_neg = 0, int32_t prefer_speed = GFX_NOT_DEFINED, bool useBigEndian = false,
uint16_t de_idle_high = 0, uint16_t pclk_idle_high = 0);
bool begin(int32_t speed = GFX_NOT_DEFINED);
uint16_t *getFrameBuffer(int16_t w, int16_t h);
protected:
private:
int32_t _speed;
int8_t _de, _vsync, _hsync, _pclk;
int8_t _r0, _r1, _r2, _r3, _r4;
int8_t _g0, _g1, _g2, _g3, _g4, _g5;
int8_t _b0, _b1, _b2, _b3, _b4;
uint16_t _hsync_polarity;
uint16_t _hsync_front_porch;
uint16_t _hsync_pulse_width;
uint16_t _hsync_back_porch;
uint16_t _vsync_polarity;
uint16_t _vsync_front_porch;
uint16_t _vsync_pulse_width;
uint16_t _vsync_back_porch;
uint16_t _pclk_active_neg;
int32_t _prefer_speed;
bool _useBigEndian;
uint16_t _de_idle_high;
uint16_t _pclk_idle_high;
esp_lcd_panel_handle_t _panel_handle = NULL;
esp_rgb_panel_t *_rgb_panel;
};
#endif // _ARDUINO_ESP32RGBPANEL_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,281 @@
#include "Arduino_ESP32S2PAR16.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32S2PAR16::Arduino_ESP32S2PAR16(int8_t dc, int8_t cs, int8_t wr, int8_t rd)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd)
{
}
bool Arduino_ESP32S2PAR16::begin(int32_t speed, int8_t dataMode)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
pinMode(14, OUTPUT);
pinMode(15, OUTPUT);
// INIT 16-bit mask
_dataClrMask = 0xFFFF;
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32S2PAR16::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32S2PAR16::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32S2PAR16::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32S2PAR16::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_ESP32S2PAR16::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32S2PAR16::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_ESP32S2PAR16::writeRepeat(uint16_t p, uint32_t len)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = p;
while (len--)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
void Arduino_ESP32S2PAR16::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
WRITE16(*data++);
}
}
void Arduino_ESP32S2PAR16::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32S2PAR16::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_ESP32S2PAR16::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d1);
WRITE16(d2);
}
void Arduino_ESP32S2PAR16::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32S2PAR16::writeBytes(uint8_t *data, uint32_t len)
{
while (len > 1)
{
_data16.msb = *data++;
_data16.lsb = *data++;
WRITE16(_data16.value);
len -= 2;
}
if (len)
{
WRITE(*data);
}
}
void Arduino_ESP32S2PAR16::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
WRITE16(idx[*data++]);
}
}
void Arduino_ESP32S2PAR16::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = idx[*data++];
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
INLINE void Arduino_ESP32S2PAR16::WRITE(uint8_t d)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = d;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
INLINE void Arduino_ESP32S2PAR16::WRITE16(uint16_t d)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = d;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32S2PAR16::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32S2PAR16::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32S2PAR16::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32S2PAR16::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,62 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32S2PAR16_H_
#define _ARDUINO_ESP32S2PAR16_H_
class Arduino_ESP32S2PAR16 : public Arduino_DataBus
{
public:
Arduino_ESP32S2PAR16(int8_t dc, int8_t cs, int8_t wr, int8_t rd); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
};
#endif // _ARDUINO_ESP32S2PAR16_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,278 @@
#include "Arduino_ESP32S2PAR16Q.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32S2PAR16Q::Arduino_ESP32S2PAR16Q(int8_t dc, int8_t cs, int8_t wr, int8_t rd)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd)
{
}
bool Arduino_ESP32S2PAR16Q::begin(int32_t speed, int8_t dataMode)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
pinMode(14, OUTPUT);
pinMode(15, OUTPUT);
// INIT 16-bit mask
_dataClrMask = (1 << _wr) | 0xFFFF;
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32S2PAR16Q::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32S2PAR16Q::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32S2PAR16Q::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32S2PAR16Q::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_ESP32S2PAR16Q::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32S2PAR16Q::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_ESP32S2PAR16Q::writeRepeat(uint16_t p, uint32_t len)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = p;
while (len--)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
void Arduino_ESP32S2PAR16Q::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
WRITE16(*data++);
}
}
void Arduino_ESP32S2PAR16Q::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32S2PAR16Q::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_ESP32S2PAR16Q::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d1);
WRITE16(d2);
}
void Arduino_ESP32S2PAR16Q::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32S2PAR16Q::writeBytes(uint8_t *data, uint32_t len)
{
while (len > 1)
{
_data16.msb = *data++;
_data16.lsb = *data++;
WRITE16(_data16.value);
len -= 2;
}
if (len)
{
WRITE(*data);
}
}
void Arduino_ESP32S2PAR16Q::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
WRITE16(idx[*data++]);
}
}
void Arduino_ESP32S2PAR16Q::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = idx[*data++];
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
INLINE void Arduino_ESP32S2PAR16Q::WRITE(uint8_t d)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = d;
*_wrPortSet = _wrPinMask;
}
INLINE void Arduino_ESP32S2PAR16Q::WRITE16(uint16_t d)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = d;
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32S2PAR16Q::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32S2PAR16Q::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32S2PAR16Q::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32S2PAR16Q::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,62 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32S2PAR16Q_H_
#define _ARDUINO_ESP32S2PAR16Q_H_
class Arduino_ESP32S2PAR16Q : public Arduino_DataBus
{
public:
Arduino_ESP32S2PAR16Q(int8_t dc, int8_t cs, int8_t wr, int8_t rd); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
};
#endif // _ARDUINO_ESP32S2PAR16Q_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,294 @@
#include "Arduino_ESP32S2PAR8.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32S2PAR8::Arduino_ESP32S2PAR8(int8_t dc, int8_t cs, int8_t wr, int8_t rd)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd)
{
}
bool Arduino_ESP32S2PAR8::begin(int32_t speed, int8_t dataMode)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_dc != GFX_NOT_DEFINED)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_wr != GFX_NOT_DEFINED)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
if (_rd >= 32)
{
_rdPinMask = digitalPinToBitMask(_rd);
_rdPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_rdPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_rd != GFX_NOT_DEFINED)
{
_rdPinMask = digitalPinToBitMask(_rd);
_rdPortSet = (PORTreg_t)&GPIO.out_w1ts;
_rdPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
else
{
_rdPinMask = 0;
_rdPortSet = _dcPortSet;
_rdPortClr = _dcPortClr;
}
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
// INIT 8-bit mask
_dataClrMask = 0xFF;
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32S2PAR8::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32S2PAR8::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32S2PAR8::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32S2PAR8::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_ESP32S2PAR8::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32S2PAR8::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32S2PAR8::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = p;
while (len--)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
else
{
while (len--)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = _data16.msb;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_dataPortClr = _dataClrMask;
*_dataPortSet = _data16.lsb;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
}
void Arduino_ESP32S2PAR8::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32S2PAR8::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32S2PAR8::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32S2PAR8::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32S2PAR8::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_ESP32S2PAR8::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32S2PAR8::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
INLINE void Arduino_ESP32S2PAR8::WRITE(uint8_t d)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = d;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32S2PAR8::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32S2PAR8::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32S2PAR8::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32S2PAR8::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,64 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32S2PAR8_H_
#define _ARDUINO_ESP32S2PAR8_H_
class Arduino_ESP32S2PAR8 : public Arduino_DataBus
{
public:
Arduino_ESP32S2PAR8(int8_t dc, int8_t cs, int8_t wr, int8_t rd); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _rdPortSet; ///< PORT register SET
PORTreg_t _rdPortClr; ///< PORT register CLEAR
uint32_t _rdPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
};
#endif // _ARDUINO_ESP32S2PAR8_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,276 @@
#include "Arduino_ESP32S2PAR8Q.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
Arduino_ESP32S2PAR8Q::Arduino_ESP32S2PAR8Q(int8_t dc, int8_t cs, int8_t wr, int8_t rd)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd)
{
}
bool Arduino_ESP32S2PAR8Q::begin(int32_t speed, int8_t dataMode)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_dc != GFX_NOT_DEFINED)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
if (_wr >= 32)
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_wrPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_wrPinMask = digitalPinToBitMask(_wr);
_wrPortSet = (PORTreg_t)&GPIO.out_w1ts;
_wrPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
}
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
// INIT 8-bit mask
_dataClrMask = (1 << _wr) | 0xFF;
_dataPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dataPortClr = (PORTreg_t)&GPIO.out_w1tc;
*_dataPortClr = _dataClrMask;
return true;
}
void Arduino_ESP32S2PAR8Q::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP32S2PAR8Q::endWrite()
{
CS_HIGH();
}
void Arduino_ESP32S2PAR8Q::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP32S2PAR8Q::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_ESP32S2PAR8Q::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP32S2PAR8Q::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32S2PAR8Q::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = _data16.msb;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
while (--len)
{
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
*_wrPortClr = _wrPinMask;
*_wrPortSet = _wrPinMask;
}
}
else
{
while (len--)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = _data16.msb;
*_wrPortSet = _wrPinMask;
*_dataPortClr = _dataClrMask;
*_dataPortSet = _data16.lsb;
*_wrPortSet = _wrPinMask;
}
}
}
void Arduino_ESP32S2PAR8Q::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32S2PAR8Q::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP32S2PAR8Q::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32S2PAR8Q::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_ESP32S2PAR8Q::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_ESP32S2PAR8Q::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_ESP32S2PAR8Q::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
INLINE void Arduino_ESP32S2PAR8Q::WRITE(uint8_t d)
{
*_dataPortClr = _dataClrMask;
*_dataPortSet = d;
*_wrPortSet = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP32S2PAR8Q::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_ESP32S2PAR8Q::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_ESP32S2PAR8Q::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_ESP32S2PAR8Q::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,64 @@
#include "Arduino_DataBus.h"
#if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
#ifndef _ARDUINO_ESP32S2PAR8Q_H_
#define _ARDUINO_ESP32S2PAR8Q_H_
class Arduino_ESP32S2PAR8Q : public Arduino_DataBus
{
public:
Arduino_ESP32S2PAR8Q(int8_t dc, int8_t cs, int8_t wr, int8_t rd); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
PORTreg_t _dcPortSet; ///< PORT register SET
PORTreg_t _dcPortClr; ///< PORT register CLEAR
uint32_t _dcPinMask; ///< Bitmask
PORTreg_t _csPortSet; ///< PORT register SET
PORTreg_t _csPortClr; ///< PORT register CLEAR
uint32_t _csPinMask; ///< Bitmask
PORTreg_t _wrPortSet; ///< PORT register SET
PORTreg_t _wrPortClr; ///< PORT register CLEAR
uint32_t _wrPinMask; ///< Bitmask
PORTreg_t _rdPortSet; ///< PORT register SET
PORTreg_t _rdPortClr; ///< PORT register CLEAR
uint32_t _rdPinMask; ///< Bitmask
PORTreg_t _dataPortSet; ///< PORT register SET
PORTreg_t _dataPortClr; ///< PORT register CLEAR
uint32_t _dataClrMask;
};
#endif // _ARDUINO_ESP32S2PAR8Q_H_
#endif // #if defined(ESP32) && (CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
@@ -0,0 +1,996 @@
/*
* start rewrite from:
* https://github.com/espressif/arduino-esp32.git
*/
#include "Arduino_ESP32SPI.h"
#if defined(ESP32)
struct spi_struct_t
{
spi_dev_t *dev;
#if !CONFIG_DISABLE_HAL_LOCKS
xSemaphoreHandle lock;
#endif
uint8_t num;
};
#if CONFIG_DISABLE_HAL_LOCKS
#define SPI_MUTEX_LOCK()
#define SPI_MUTEX_UNLOCK()
static spi_t _spi_bus_array[] = {
#if CONFIG_IDF_TARGET_ESP32S2
{(volatile spi_dev_t *)(DR_REG_SPI1_BASE), 0},
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 1},
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 2}
#elif CONFIG_IDF_TARGET_ESP32S3
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 0},
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 1}
#else
{(volatile spi_dev_t *)(DR_REG_SPI0_BASE), 0},
{(volatile spi_dev_t *)(DR_REG_SPI1_BASE), 1},
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), 2},
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), 3}
#endif
};
#else // !CONFIG_DISABLE_HAL_LOCKS
#define SPI_MUTEX_LOCK() \
do \
{ \
} while (xSemaphoreTake(_spi->lock, portMAX_DELAY) != pdPASS)
#define SPI_MUTEX_UNLOCK() xSemaphoreGive(_spi->lock)
static spi_t _spi_bus_array[] = {
#if CONFIG_IDF_TARGET_ESP32S2
{(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 0},
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 1},
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 2}
#elif CONFIG_IDF_TARGET_ESP32S3
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 0},
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 1}
#elif CONFIG_IDF_TARGET_ESP32C3
{(volatile spi_dev_t *)(&GPSPI2), NULL, FSPI}
#else
{(volatile spi_dev_t *)(DR_REG_SPI0_BASE), NULL, 0},
{(volatile spi_dev_t *)(DR_REG_SPI1_BASE), NULL, 1},
{(volatile spi_dev_t *)(DR_REG_SPI2_BASE), NULL, 2},
{(volatile spi_dev_t *)(DR_REG_SPI3_BASE), NULL, 3}
#endif
};
#endif // CONFIG_DISABLE_HAL_LOCKS
/**
* @brief Arduino_ESP32SPI
*
*/
Arduino_ESP32SPI::Arduino_ESP32SPI(
int8_t dc /* = GFX_NOT_DEFINED */, int8_t cs /* = GFX_NOT_DEFINED */, int8_t sck /* = GFX_NOT_DEFINED */, int8_t mosi /* = GFX_NOT_DEFINED */, int8_t miso /* = GFX_NOT_DEFINED */, uint8_t spi_num /* = VSPI for ESP32, HSPI for S2 & S3, FSPI for C3 */, bool is_shared_interface /* = true */)
: _dc(dc), _spi_num(spi_num), _is_shared_interface(is_shared_interface)
{
#if CONFIG_IDF_TARGET_ESP32
if (
sck == GFX_NOT_DEFINED && miso == GFX_NOT_DEFINED && mosi == GFX_NOT_DEFINED && cs == GFX_NOT_DEFINED)
{
_sck = (_spi_num == VSPI) ? SCK : 14;
_miso = (_spi_num == VSPI) ? MISO : 12;
_mosi = (_spi_num == VSPI) ? MOSI : 13;
_cs = (_spi_num == VSPI) ? SS : 15;
}
else
{
_sck = sck;
_miso = miso;
_mosi = mosi;
_cs = cs;
}
#else
if (sck == GFX_NOT_DEFINED && miso == GFX_NOT_DEFINED && mosi == GFX_NOT_DEFINED && cs == GFX_NOT_DEFINED)
{
_sck = SCK;
_miso = MISO;
_mosi = MOSI;
_cs = SS;
}
else
{
_sck = sck;
_miso = miso;
_mosi = mosi;
_cs = cs;
}
#endif
}
static void _on_apb_change(void *arg, apb_change_ev_t ev_type, uint32_t old_apb, uint32_t new_apb)
{
spi_t *_spi = (spi_t *)arg;
if (ev_type == APB_BEFORE_CHANGE)
{
SPI_MUTEX_LOCK();
while (_spi->dev->cmd.usr)
;
}
else
{
_spi->dev->clock.val = spiFrequencyToClockDiv(old_apb / ((_spi->dev->clock.clkdiv_pre + 1) * (_spi->dev->clock.clkcnt_n + 1)));
SPI_MUTEX_UNLOCK();
}
}
static void spiInitBus(spi_t *spi)
{
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32
spi->dev->slave.trans_done = 0;
#endif
spi->dev->slave.val = 0;
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3
spi->dev->misc.val = 0;
#else
spi->dev->pin.val = 0;
#endif
spi->dev->user.val = 0;
spi->dev->user1.val = 0;
spi->dev->ctrl.val = 0;
#if CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32
spi->dev->ctrl1.val = 0;
spi->dev->ctrl2.val = 0;
#else
spi->dev->clk_gate.val = 0;
spi->dev->dma_conf.val = 0;
spi->dev->dma_conf.rx_afifo_rst = 1;
spi->dev->dma_conf.buf_afifo_rst = 1;
#endif
spi->dev->clock.val = 0;
}
/**
* @brief begin
*
* @param speed
* @param dataMode
* @return true
* @return false
*/
bool Arduino_ESP32SPI::begin(int32_t speed, int8_t dataMode)
{
// set SPI parameters
_speed = (speed == GFX_NOT_DEFINED) ? SPI_DEFAULT_FREQ : speed;
_dataMode = (dataMode == GFX_NOT_DEFINED) ? SPI_MODE0 : dataMode;
if (!_div)
{
_div = spiFrequencyToClockDiv(_speed);
}
// set pin mode
if (_dc != GFX_NOT_DEFINED)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
#if (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
// set fastIO variables
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
#endif
if (_dc != GFX_NOT_DEFINED)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
#if (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
#endif
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
// SPI.begin(_sck, _miso, _mosi);
// _spi = spiStartBus(_spi_num, _div, SPI_MODE0, SPI_MSBFIRST);
_spi = &_spi_bus_array[_spi_num];
#if !CONFIG_DISABLE_HAL_LOCKS
if (_spi->lock == NULL)
{
_spi->lock = xSemaphoreCreateMutex();
}
#endif
#if CONFIG_IDF_TARGET_ESP32S2
if (_spi_num == FSPI)
{
DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI2_CLK_EN);
DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI2_RST);
}
else if (_spi_num == HSPI)
{
DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI3_CLK_EN);
DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI3_RST);
}
else
{
DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
}
#elif CONFIG_IDF_TARGET_ESP32S3
if (_spi_num == FSPI)
{
periph_module_reset(PERIPH_SPI2_MODULE);
periph_module_enable(PERIPH_SPI2_MODULE);
}
else if (_spi_num == HSPI)
{
periph_module_reset(PERIPH_SPI3_MODULE);
periph_module_enable(PERIPH_SPI3_MODULE);
}
#elif CONFIG_IDF_TARGET_ESP32
if (_spi_num == HSPI)
{
DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI2_CLK_EN);
DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI2_RST);
}
else if (_spi_num == VSPI)
{
DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI3_CLK_EN);
DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI3_RST);
}
else
{
DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI01_CLK_EN);
DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI01_RST);
}
#elif CONFIG_IDF_TARGET_ESP32C3
periph_module_reset(PERIPH_SPI2_MODULE);
periph_module_enable(PERIPH_SPI2_MODULE);
#endif
SPI_MUTEX_LOCK();
spiInitBus(_spi);
#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3
_spi->dev->clk_gate.clk_en = 1;
_spi->dev->clk_gate.mst_clk_sel = 1;
_spi->dev->clk_gate.mst_clk_active = 1;
_spi->dev->dma_conf.tx_seg_trans_clr_en = 1;
_spi->dev->dma_conf.rx_seg_trans_clr_en = 1;
_spi->dev->dma_conf.dma_seg_trans_en = 0;
#endif
_spi->dev->user.usr_mosi = 1;
if (_miso == GFX_NOT_DEFINED)
{
_spi->dev->user.usr_miso = 0;
_spi->dev->user.doutdin = 0;
}
else
{
_spi->dev->user.usr_miso = 1;
_spi->dev->user.doutdin = 1;
}
for (uint8_t i = 0; i < 16; i++)
{
_spi->dev->data_buf[i] = 0x00000000;
}
SPI_MUTEX_UNLOCK();
spiSetDataMode(_spi, _dataMode);
spiSetBitOrder(_spi, _bitOrder);
spiSetClockDiv(_spi, _div);
addApbChangeCallback(_spi, _on_apb_change);
spiAttachSCK(_spi, _sck);
if (_miso != GFX_NOT_DEFINED)
{
spiAttachMISO(_spi, _miso);
}
spiAttachMOSI(_spi, _mosi);
if (!_is_shared_interface)
{
spiTransaction(_spi, _div, _dataMode, _bitOrder);
}
return true;
}
/**
* @brief beginWrite
*
*/
void Arduino_ESP32SPI::beginWrite()
{
_data_buf_bit_idx = 0;
_buffer[0] = 0;
if (_is_shared_interface)
{
spiTransaction(_spi, _div, _dataMode, _bitOrder);
}
if (_dc != GFX_NOT_DEFINED)
{
DC_HIGH();
}
CS_LOW();
}
/**
* @brief endWrite
*
*/
void Arduino_ESP32SPI::endWrite()
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
if (_is_shared_interface)
{
spiEndTransaction(_spi);
}
CS_HIGH();
}
/**
* @brief writeCommand
*
* @param c
*/
void Arduino_ESP32SPI::writeCommand(uint8_t c)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(c);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi->dev->data_buf[0] = c;
POLL(7);
DC_HIGH();
}
}
/**
* @brief writeCommand16
*
* @param c
*/
void Arduino_ESP32SPI::writeCommand16(uint16_t c)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
_data16.value = c;
WRITE9BIT(_data16.msb);
WRITE9BIT(_data16.lsb);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
MSB_16_SET(_spi->dev->data_buf[0], c);
POLL(15);
DC_HIGH();
}
}
/**
* @brief write
*
* @param d
*/
void Arduino_ESP32SPI::write(uint8_t d)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(0x100 | d);
}
else
{
WRITE8BIT(d);
}
}
/**
* @brief write16
*
* @param d
*/
void Arduino_ESP32SPI::write16(uint16_t d)
{
_data16.value = d;
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(0x100 | _data16.msb);
WRITE9BIT(0x100 | _data16.lsb);
}
else
{
WRITE8BIT(_data16.msb);
WRITE8BIT(_data16.lsb);
}
}
/**
* @brief writeC8D8
*
* @param c
* @param d
*/
void Arduino_ESP32SPI::writeC8D8(uint8_t c, uint8_t d)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(c);
WRITE9BIT(0x100 | d);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi->dev->data_buf[0] = c;
POLL(7);
DC_HIGH();
_spi->dev->data_buf[0] = d;
POLL(7);
}
}
/**
* @brief writeC8D16
*
* @param c
* @param d
*/
void Arduino_ESP32SPI::writeC8D16(uint8_t c, uint16_t d)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(c);
_data16.value = d;
WRITE9BIT(0x100 | _data16.msb);
WRITE9BIT(0x100 | _data16.lsb);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi->dev->data_buf[0] = c;
POLL(7);
DC_HIGH();
MSB_16_SET(_spi->dev->data_buf[0], d);
POLL(15);
}
}
/**
* @brief writeC8D16D16
*
* @param c
* @param d1
* @param d2
*/
void Arduino_ESP32SPI::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(c);
_data16.value = d1;
WRITE9BIT(0x100 | _data16.msb);
WRITE9BIT(0x100 | _data16.lsb);
_data16.value = d2;
WRITE9BIT(0x100 | _data16.msb);
WRITE9BIT(0x100 | _data16.lsb);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi->dev->data_buf[0] = c;
POLL(7);
DC_HIGH();
MSB_32_16_16_SET(_spi->dev->data_buf[0], d1, d2);
POLL(31);
}
}
/**
* @brief writeRepeat
*
* @param p
* @param len
*/
void Arduino_ESP32SPI::writeRepeat(uint16_t p, uint32_t len)
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
_data16.value = p;
uint32_t hi = 0x100 | _data16.msb;
uint32_t lo = 0x100 | _data16.lsb;
uint16_t idx;
uint8_t shift;
uint32_t l;
uint16_t bufLen = (len <= 28) ? len : 28;
int16_t xferLen;
for (uint32_t t = 0; t < bufLen; t++)
{
idx = _data_buf_bit_idx >> 3;
shift = (_data_buf_bit_idx % 8);
if (shift)
{
_buffer[idx++] |= hi >> (shift + 1);
_buffer[idx] = hi << (7 - shift);
}
else
{
_buffer[idx++] = hi >> 1;
_buffer[idx] = hi << 7;
}
_data_buf_bit_idx += 9;
idx = _data_buf_bit_idx >> 3;
shift = (_data_buf_bit_idx % 8);
if (shift)
{
_buffer[idx++] |= lo >> (shift + 1);
_buffer[idx] = lo << (7 - shift);
}
else
{
_buffer[idx++] = lo >> 1;
_buffer[idx] = lo << 7;
}
_data_buf_bit_idx += 9;
}
if (_miso == GFX_NOT_DEFINED)
{
l = (_data_buf_bit_idx + 31) / 32;
for (uint32_t i = 0; i < l; i++)
{
_spi->dev->data_buf[i] = _buffer32[i];
}
}
// Issue pixels in blocks from temp buffer
while (len) // While pixels remain
{
xferLen = (bufLen < len) ? bufLen : len; // How many this pass?
_data_buf_bit_idx = xferLen * 18;
if (_miso != GFX_NOT_DEFINED)
{
l = (_data_buf_bit_idx + 31) / 32;
for (uint32_t i = 0; i < l; i++)
{
_spi->dev->data_buf[i] = _buffer32[i];
}
}
POLL(_data_buf_bit_idx - 1);
len -= xferLen;
}
}
else // 8-bit SPI
{
uint16_t bufLen = (len >= ESP32SPI_MAX_PIXELS_AT_ONCE) ? ESP32SPI_MAX_PIXELS_AT_ONCE : len;
int16_t xferLen, l;
uint32_t c32;
MSB_32_16_16_SET(c32, p, p);
l = (bufLen + 1) / 2;
if (_miso == GFX_NOT_DEFINED)
{
l = (bufLen + 1) >> 1;
for (uint32_t i = 0; i < l; i++)
{
_spi->dev->data_buf[i] = c32;
}
}
// Issue pixels in blocks from temp buffer
while (len) // While pixels remain
{
xferLen = (bufLen <= len) ? bufLen : len; // How many this pass?
if (_miso != GFX_NOT_DEFINED)
{
l = (xferLen + 1) >> 1;
for (uint32_t i = 0; i < l; i++)
{
_spi->dev->data_buf[i] = c32;
}
}
POLL((xferLen << 4) - 1);
len -= xferLen;
}
}
_data_buf_bit_idx = 0;
}
/**
* @brief writePixels
*
* @param data
* @param len
*/
void Arduino_ESP32SPI::writePixels(uint16_t *data, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
while (len--)
{
write16(*data++);
}
}
else // 8-bit SPI
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l, l2;
uint16_t p1, p2;
uint32_t *p32 = (uint32_t *)_spi->dev->data_buf;
while (len)
{
l = (len > ESP32SPI_MAX_PIXELS_AT_ONCE) ? ESP32SPI_MAX_PIXELS_AT_ONCE : len;
l2 = (l + 1) >> 1;
for (uint32_t i = 0; i < l2; ++i)
{
p1 = *data++;
p2 = *data++;
MSB_32_16_16_SET(p32[i], p1, p2);
}
POLL((l << 4) - 1);
len -= l;
}
}
}
/**
* @brief writeBytes
*
* @param data
* @param len
*/
void Arduino_ESP32SPI::writeBytes(uint8_t *data, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
while (len--)
{
write(*data++);
}
}
else // 8-bit SPI
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l, l4;
uint32_t *p;
uint32_t *buf32 = (uint32_t *)_spi->dev->data_buf;
while (len)
{
l = (len > (ESP32SPI_MAX_PIXELS_AT_ONCE << 1)) ? (ESP32SPI_MAX_PIXELS_AT_ONCE << 1) : len;
l4 = (l + 3) >> 2;
p = (uint32_t *)data;
for (uint32_t i = 0; i < l4; ++i)
{
buf32[i] = *p++;
}
POLL((l << 3) - 1);
len -= l;
data += l;
}
}
}
/**
* @brief writeIndexedPixels
*
* @param data
* @param idx
* @param len
*/
void Arduino_ESP32SPI::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
while (len--)
{
write16(idx[*data++]);
}
}
else // 8-bit SPI
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l, l2;
uint16_t p1, p2;
while (len)
{
l = (len > ESP32SPI_MAX_PIXELS_AT_ONCE) ? ESP32SPI_MAX_PIXELS_AT_ONCE : len;
l2 = l >> 1;
for (uint32_t i = 0; i < l2; ++i)
{
p1 = idx[*data++];
p2 = idx[*data++];
MSB_32_16_16_SET(_spi->dev->data_buf[i], p1, p2);
}
if (l & 1)
{
p1 = idx[*data++];
MSB_16_SET(_spi->dev->data_buf[l - 1], p1);
}
POLL((l << 4) - 1);
len -= l;
}
}
}
/**
* @brief writeIndexedPixelsDouble
*
* @param data
* @param idx
* @param len
*/
void Arduino_ESP32SPI::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
uint16_t hi, lo;
while (len--)
{
_data16.value = idx[*data++];
hi = 0x100 | _data16.msb;
lo = 0x100 | _data16.lsb;
WRITE9BIT(hi);
WRITE9BIT(lo);
WRITE9BIT(hi);
WRITE9BIT(lo);
}
}
else // 8-bit SPI
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l;
uint16_t p;
while (len)
{
l = (len > (ESP32SPI_MAX_PIXELS_AT_ONCE >> 1)) ? (ESP32SPI_MAX_PIXELS_AT_ONCE >> 1) : len;
for (uint32_t i = 0; i < l; ++i)
{
p = idx[*data++];
MSB_32_16_16_SET(_spi->dev->data_buf[i], p, p);
}
POLL((l << 5) - 1);
len -= l;
}
}
}
/**
* @brief flush_data_buf
*
*/
void Arduino_ESP32SPI::flush_data_buf()
{
uint32_t len = (_data_buf_bit_idx + 31) / 32;
for (uint32_t i = 0; i < len; i++)
{
_spi->dev->data_buf[i] = _buffer32[i];
}
POLL(_data_buf_bit_idx - 1);
_data_buf_bit_idx = 0;
}
/**
* @brief WRITE8BIT
*
* @param d
* @return INLINE
*/
INLINE void Arduino_ESP32SPI::WRITE8BIT(uint8_t d)
{
uint16_t idx = _data_buf_bit_idx >> 3;
_buffer[idx] = d;
_data_buf_bit_idx += 8;
if (_data_buf_bit_idx >= (ESP32SPI_MAX_PIXELS_AT_ONCE << 4))
{
flush_data_buf();
}
}
/**
* @brief WRITE9BIT
*
* @param d
* @return INLINE
*/
INLINE void Arduino_ESP32SPI::WRITE9BIT(uint32_t d)
{
uint16_t idx = _data_buf_bit_idx >> 3;
uint8_t shift = (_data_buf_bit_idx % 8);
if (shift)
{
_buffer[idx++] |= d >> (shift + 1);
_buffer[idx] = d << (7 - shift);
}
else
{
_buffer[idx++] = d >> 1;
_buffer[idx] = d << 7;
}
_data_buf_bit_idx += 9;
if (_data_buf_bit_idx >= 504) // 56 bytes * 9 bits
{
flush_data_buf();
}
}
/******** low level bit twiddling **********/
/**
* @brief DC_HIGH
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPI::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
/**
* @brief DC_LOW
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPI::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
/**
* @brief CS_HIGH
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPI::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
/**
* @brief CS_LOW
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPI::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
/**
* @brief POLL
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPI::POLL(uint32_t len)
{
#if (CONFIG_IDF_TARGET_ESP32)
_spi->dev->mosi_dlen.usr_mosi_dbitlen = len;
#elif (CONFIG_IDF_TARGET_ESP32S2)
_spi->dev->mosi_dlen.usr_mosi_bit_len = len;
#elif (CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3)
_spi->dev->ms_dlen.ms_data_bitlen = len;
#endif
#if (CONFIG_IDF_TARGET_ESP32)
_spi->dev->miso_dlen.usr_miso_dbitlen = 0;
#elif (CONFIG_IDF_TARGET_ESP32S2)
_spi->dev->miso_dlen.usr_miso_bit_len = 0;
#endif
#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32S3
_spi->dev->cmd.update = 1;
while (_spi->dev->cmd.update)
;
#endif
_spi->dev->cmd.usr = 1;
while (_spi->dev->cmd.usr)
;
}
#endif // #if defined(ESP32)
@@ -0,0 +1,85 @@
#pragma once
#include "Arduino_DataBus.h"
#if defined(ESP32)
#include "soc/spi_struct.h"
#if CONFIG_IDF_TARGET_ESP32S3
#include "driver/periph_ctrl.h"
#elif CONFIG_IDF_TARGET_ESP32C3
#include "driver/periph_ctrl.h"
#include "esp32c3/rom/gpio.h"
#include "soc/periph_defs.h"
#else
#include "soc/dport_reg.h"
#endif
#define ESP32SPI_MAX_PIXELS_AT_ONCE 32
class Arduino_ESP32SPI : public Arduino_DataBus
{
public:
#if CONFIG_IDF_TARGET_ESP32
Arduino_ESP32SPI(int8_t dc = GFX_NOT_DEFINED, int8_t cs = GFX_NOT_DEFINED, int8_t sck = GFX_NOT_DEFINED, int8_t mosi = GFX_NOT_DEFINED, int8_t miso = GFX_NOT_DEFINED, uint8_t spi_num = VSPI, bool is_shared_interface = true); // Constructor
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
Arduino_ESP32SPI(int8_t dc = GFX_NOT_DEFINED, int8_t cs = GFX_NOT_DEFINED, int8_t sck = GFX_NOT_DEFINED, int8_t mosi = GFX_NOT_DEFINED, int8_t miso = GFX_NOT_DEFINED, uint8_t spi_num = HSPI, bool is_shared_interface = true); // Constructor
#else
Arduino_ESP32SPI(int8_t dc = GFX_NOT_DEFINED, int8_t cs = GFX_NOT_DEFINED, int8_t sck = GFX_NOT_DEFINED, int8_t mosi = GFX_NOT_DEFINED, int8_t miso = GFX_NOT_DEFINED, uint8_t spi_num = FSPI, bool is_shared_interface = true); // Constructor
#endif
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = SPI_MODE0) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
void flush_data_buf();
INLINE void WRITE8BIT(uint8_t d);
INLINE void WRITE9BIT(uint32_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
INLINE void POLL(uint32_t len);
private:
int8_t _dc, _cs;
int8_t _sck, _mosi, _miso;
uint8_t _spi_num;
bool _is_shared_interface;
uint32_t _div = 0;
PORTreg_t _dcPortSet; ///< PORT register for data/command SET
PORTreg_t _dcPortClr; ///< PORT register for data/command CLEAR
PORTreg_t _csPortSet; ///< PORT register for chip select SET
PORTreg_t _csPortClr; ///< PORT register for chip select CLEAR
uint32_t _dcPinMask; ///< Bitmask for data/command
uint32_t _csPinMask; ///< Bitmask for chip select
spi_t *_spi;
uint8_t _bitOrder = SPI_MSBFIRST;
union
{
uint8_t _buffer[ESP32SPI_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t _buffer16[ESP32SPI_MAX_PIXELS_AT_ONCE];
uint32_t _buffer32[ESP32SPI_MAX_PIXELS_AT_ONCE / 2];
};
uint16_t _data_buf_bit_idx = 0;
};
#endif // #if defined(ESP32)
@@ -0,0 +1,896 @@
#include "Arduino_ESP32SPIDMA.h"
#if defined(ESP32)
/**
* @brief Arduino_ESP32SPIDMA
*
*/
Arduino_ESP32SPIDMA::Arduino_ESP32SPIDMA(
int8_t dc /* = GFX_NOT_DEFINED */, int8_t cs /* = GFX_NOT_DEFINED */, int8_t sck /* = GFX_NOT_DEFINED */, int8_t mosi /* = GFX_NOT_DEFINED */, int8_t miso /* = GFX_NOT_DEFINED */, uint8_t spi_num /* = VSPI for ESP32, HSPI for S2 & S3, FSPI for C3 */, bool is_shared_interface /* = true */)
: _dc(dc), _spi_num(spi_num), _is_shared_interface(is_shared_interface)
{
#if CONFIG_IDF_TARGET_ESP32
if (
sck == GFX_NOT_DEFINED && miso == GFX_NOT_DEFINED && mosi == GFX_NOT_DEFINED && cs == GFX_NOT_DEFINED)
{
_sck = (_spi_num == VSPI) ? SCK : 14;
_miso = (_spi_num == VSPI) ? MISO : 12;
_mosi = (_spi_num == VSPI) ? MOSI : 13;
_cs = (_spi_num == VSPI) ? SS : 15;
}
else
{
_sck = sck;
_miso = miso;
_mosi = mosi;
_cs = cs;
}
#else
if (sck == GFX_NOT_DEFINED && miso == GFX_NOT_DEFINED && mosi == GFX_NOT_DEFINED && cs == GFX_NOT_DEFINED)
{
_sck = SCK;
_miso = MISO;
_mosi = MOSI;
_cs = SS;
}
else
{
_sck = sck;
_miso = miso;
_mosi = mosi;
_cs = cs;
}
#endif
}
/**
* @brief begin
*
* @param speed
* @param dataMode
* @return true
* @return false
*/
bool Arduino_ESP32SPIDMA::begin(int32_t speed, int8_t dataMode)
{
// set SPI parameters
_speed = (speed == GFX_NOT_DEFINED) ? SPI_DEFAULT_FREQ : speed;
_dataMode = (dataMode == GFX_NOT_DEFINED) ? SPI_MODE0 : dataMode;
if (!_div)
{
_div = spiFrequencyToClockDiv(_speed);
}
// set pin mode
if (_dc != GFX_NOT_DEFINED)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
#if (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
// set fastIO variables
if (_dc >= 32)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
#endif
if (_dc != GFX_NOT_DEFINED)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
#if (CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3)
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
#endif
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
spi_bus_config_t buscfg = {
.mosi_io_num = _mosi,
.miso_io_num = _miso,
.sclk_io_num = _sck,
.quadwp_io_num = -1,
.quadhd_io_num = -1,
.data4_io_num = -1,
.data5_io_num = -1,
.data6_io_num = -1,
.data7_io_num = -1,
.max_transfer_sz = (ESP32SPIDMA_MAX_PIXELS_AT_ONCE * 16) + 8,
.flags = SPICOMMON_BUSFLAG_MASTER | SPICOMMON_BUSFLAG_GPIO_PINS,
.intr_flags = 0};
esp_err_t ret = spi_bus_initialize((spi_host_device_t)_spi_num, &buscfg, DMA_CHANNEL);
if (ret != ESP_OK)
{
ESP_ERROR_CHECK(ret);
return false;
}
spi_device_interface_config_t devcfg = {
.command_bits = 0,
.address_bits = 0,
.dummy_bits = 0,
.mode = (uint8_t)_dataMode,
.duty_cycle_pos = 128,
.cs_ena_pretrans = 0,
.cs_ena_posttrans = 0,
.clock_speed_hz = _speed,
.input_delay_ns = 0,
.spics_io_num = -1, // avoid use system CS control
.flags = (_miso < 0) ? (uint32_t)SPI_DEVICE_NO_DUMMY : 0,
.queue_size = 1,
.pre_cb = nullptr,
.post_cb = nullptr};
ret = spi_bus_add_device((spi_host_device_t)_spi_num, &devcfg, &_handle);
if (ret != ESP_OK)
{
ESP_ERROR_CHECK(ret);
return false;
}
if (!_is_shared_interface)
{
spi_device_acquire_bus(_handle, portMAX_DELAY);
}
memset(&_spi_tran, 0, sizeof(_spi_tran));
return true;
}
/**
* @brief beginWrite
*
*/
void Arduino_ESP32SPIDMA::beginWrite()
{
_data_buf_bit_idx = 0;
_buffer[0] = 0;
if (_is_shared_interface)
{
spi_device_acquire_bus(_handle, portMAX_DELAY);
}
if (_dc != GFX_NOT_DEFINED)
{
DC_HIGH();
}
CS_LOW();
}
/**
* @brief endWrite
*
*/
void Arduino_ESP32SPIDMA::endWrite()
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
if (_is_shared_interface)
{
spi_device_release_bus(_handle);
}
CS_HIGH();
}
/**
* @brief writeCommand
*
* @param c
*/
void Arduino_ESP32SPIDMA::writeCommand(uint8_t c)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(c);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi_tran.length = 8;
_spi_tran.tx_data[0] = c;
_spi_tran.flags = SPI_TRANS_USE_TXDATA;
POLL_START();
POLL_END();
DC_HIGH();
}
}
/**
* @brief writeCommand16
*
* @param c
*/
void Arduino_ESP32SPIDMA::writeCommand16(uint16_t c)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
_data16.value = c;
WRITE9BIT(_data16.msb);
WRITE9BIT(_data16.lsb);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi_tran.length = 16;
MSB_16_SET(_spi_tran.tx_data[0], c);
_spi_tran.flags = SPI_TRANS_USE_TXDATA;
POLL_START();
POLL_END();
DC_HIGH();
}
}
/**
* @brief write
*
* @param d
*/
void Arduino_ESP32SPIDMA::write(uint8_t d)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(0x100 | d);
}
else
{
WRITE8BIT(d);
}
}
/**
* @brief write16
*
* @param d
*/
void Arduino_ESP32SPIDMA::write16(uint16_t d)
{
_data16.value = d;
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(0x100 | _data16.msb);
WRITE9BIT(0x100 | _data16.lsb);
}
else
{
WRITE8BIT(_data16.msb);
WRITE8BIT(_data16.lsb);
}
}
/**
* @brief writeC8D8
*
* @param c
* @param d
*/
void Arduino_ESP32SPIDMA::writeC8D8(uint8_t c, uint8_t d)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(c);
WRITE9BIT(0x100 | d);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi_tran.length = 8;
_spi_tran.tx_data[0] = c;
_spi_tran.flags = SPI_TRANS_USE_TXDATA;
POLL_START();
POLL_END();
DC_HIGH();
_spi_tran.length = 8;
_spi_tran.tx_data[0] = d;
_spi_tran.flags = SPI_TRANS_USE_TXDATA;
POLL_START();
POLL_END();
}
}
/**
* @brief writeC8D16
*
* @param c
* @param d
*/
void Arduino_ESP32SPIDMA::writeC8D16(uint8_t c, uint16_t d)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(c);
_data16.value = d;
WRITE9BIT(0x100 | _data16.msb);
WRITE9BIT(0x100 | _data16.lsb);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi_tran.length = 8;
_spi_tran.tx_data[0] = c;
_spi_tran.flags = SPI_TRANS_USE_TXDATA;
POLL_START();
POLL_END();
DC_HIGH();
_spi_tran.length = 16;
_spi_tran.tx_data[0] = (d >> 8);
_spi_tran.tx_data[1] = (d & 0xff);
_spi_tran.flags = SPI_TRANS_USE_TXDATA;
POLL_START();
POLL_END();
}
}
/**
* @brief writeC8D16D16
*
* @param c
* @param d1
* @param d2
*/
void Arduino_ESP32SPIDMA::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BIT(c);
_data16.value = d1;
WRITE9BIT(0x100 | _data16.msb);
WRITE9BIT(0x100 | _data16.lsb);
_data16.value = d2;
WRITE9BIT(0x100 | _data16.msb);
WRITE9BIT(0x100 | _data16.lsb);
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
DC_LOW();
_spi_tran.length = 8;
_spi_tran.tx_data[0] = c;
_spi_tran.flags = SPI_TRANS_USE_TXDATA;
POLL_START();
POLL_END();
DC_HIGH();
_spi_tran.length = 32;
_spi_tran.tx_data[0] = (d1 >> 8);
_spi_tran.tx_data[1] = (d1 & 0xff);
_spi_tran.tx_data[2] = (d2 >> 8);
_spi_tran.tx_data[3] = (d2 & 0xff);
_spi_tran.flags = SPI_TRANS_USE_TXDATA;
POLL_START();
POLL_END();
}
}
/**
* @brief writeRepeat
*
* @param p
* @param len
*/
void Arduino_ESP32SPIDMA::writeRepeat(uint16_t p, uint32_t len)
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
_data16.value = p;
uint32_t hi = 0x100 | _data16.msb;
uint32_t lo = 0x100 | _data16.lsb;
uint16_t idx;
uint8_t shift;
uint16_t bufLen = (len <= 28) ? len : 28;
int16_t xferLen;
for (uint32_t t = 0; t < bufLen; t++)
{
idx = _data_buf_bit_idx >> 3;
shift = (_data_buf_bit_idx % 8);
if (shift)
{
_buffer[idx++] |= hi >> (shift + 1);
_buffer[idx] = hi << (7 - shift);
}
else
{
_buffer[idx++] = hi >> 1;
_buffer[idx] = hi << 7;
}
_data_buf_bit_idx += 9;
idx = _data_buf_bit_idx >> 3;
shift = (_data_buf_bit_idx % 8);
if (shift)
{
_buffer[idx++] |= lo >> (shift + 1);
_buffer[idx] = lo << (7 - shift);
}
else
{
_buffer[idx++] = lo >> 1;
_buffer[idx] = lo << 7;
}
_data_buf_bit_idx += 9;
}
// Issue pixels in blocks from temp buffer
while (len) // While pixels remain
{
xferLen = (bufLen < len) ? bufLen : len; // How many this pass?
_data_buf_bit_idx = xferLen * 18;
_spi_tran.tx_buffer = _buffer32;
_spi_tran.length = _data_buf_bit_idx;
_spi_tran.flags = 0;
POLL_START();
POLL_END();
len -= xferLen;
}
}
else // 8-bit SPI
{
uint16_t bufLen = (len >= ESP32SPIDMA_MAX_PIXELS_AT_ONCE) ? ESP32SPIDMA_MAX_PIXELS_AT_ONCE : len;
int16_t xferLen, l;
uint32_t c32;
MSB_32_16_16_SET(c32, p, p);
l = (bufLen + 1) / 2;
for (uint32_t i = 0; i < l; i++)
{
_buffer32[i] = c32;
}
// Issue pixels in blocks from temp buffer
while (len) // While pixels remain
{
xferLen = (bufLen <= len) ? bufLen : len; // How many this pass?
_spi_tran.tx_buffer = _buffer32;
_spi_tran.length = xferLen << 4;
_spi_tran.flags = 0;
POLL_START();
POLL_END();
len -= xferLen;
}
}
_data_buf_bit_idx = 0;
}
/**
* @brief writePixels
*
* @param data
* @param len
*/
void Arduino_ESP32SPIDMA::writePixels(uint16_t *data, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
while (len--)
{
write16(*data++);
}
}
else // 8-bit SPI
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l, l2;
uint16_t p1, p2;
while (len)
{
l = (len > ESP32SPIDMA_MAX_PIXELS_AT_ONCE) ? ESP32SPIDMA_MAX_PIXELS_AT_ONCE : len;
l2 = (l + 1) >> 1;
for (uint32_t i = 0; i < l2; ++i)
{
p1 = *data++;
p2 = *data++;
MSB_32_16_16_SET(_buffer32[i], p1, p2);
}
if (l & 1)
{
p1 = *data++;
MSB_16_SET(_buffer16[l - 1], p1);
}
_spi_tran.tx_buffer = _buffer32;
_spi_tran.length = l << 4;
_spi_tran.flags = 0;
POLL_START();
POLL_END();
len -= l;
}
}
}
/**
* @brief writeBytes
*
* @param data
* @param len
*/
void Arduino_ESP32SPIDMA::writeBytes(uint8_t *data, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
while (len--)
{
write(*data++);
}
}
else // 8-bit SPI
{
if (esp_ptr_dma_capable(data))
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l;
while (len)
{
l = (len >= (ESP32SPIDMA_MAX_PIXELS_AT_ONCE << 1)) ? (ESP32SPIDMA_MAX_PIXELS_AT_ONCE << 1) : len;
_spi_tran.tx_buffer = data;
_spi_tran.length = l << 3;
_spi_tran.flags = 0;
POLL_START();
POLL_END();
len -= l;
data += l;
}
}
else
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l, l4;
uint32_t *p;
while (len)
{
l = (len > (ESP32SPIDMA_MAX_PIXELS_AT_ONCE << 1)) ? (ESP32SPIDMA_MAX_PIXELS_AT_ONCE << 1) : len;
l4 = (l + 3) >> 2;
p = (uint32_t *)data;
for (uint32_t i = 0; i < l4; ++i)
{
_buffer32[i] = *p++;
}
_spi_tran.tx_buffer = _buffer32;
_spi_tran.length = l << 3;
_spi_tran.flags = 0;
POLL_START();
POLL_END();
len -= l;
data += l;
}
}
}
}
/**
* @brief writeIndexedPixels
*
* @param data
* @param idx
* @param len
*/
void Arduino_ESP32SPIDMA::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
while (len--)
{
write16(idx[*data++]);
}
}
else // 8-bit SPI
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l, l2;
uint16_t p1, p2;
while (len)
{
l = (len > ESP32SPIDMA_MAX_PIXELS_AT_ONCE) ? ESP32SPIDMA_MAX_PIXELS_AT_ONCE : len;
l2 = l >> 1;
for (uint32_t i = 0; i < l2; ++i)
{
p1 = idx[*data++];
p2 = idx[*data++];
MSB_32_16_16_SET(_buffer32[i], p1, p2);
}
if (l & 1)
{
p1 = idx[*data++];
MSB_16_SET(_buffer16[l - 1], p1);
}
_spi_tran.tx_buffer = _buffer32;
_spi_tran.length = l << 4;
_spi_tran.flags = 0;
POLL_START();
POLL_END();
len -= l;
}
}
}
/**
* @brief writeIndexedPixelsDouble
*
* @param data
* @param idx
* @param len
*/
void Arduino_ESP32SPIDMA::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
uint16_t hi, lo;
while (len--)
{
_data16.value = idx[*data++];
hi = 0x100 | _data16.msb;
lo = 0x100 | _data16.lsb;
WRITE9BIT(hi);
WRITE9BIT(lo);
WRITE9BIT(hi);
WRITE9BIT(lo);
}
}
else // 8-bit SPI
{
if (_data_buf_bit_idx > 0)
{
flush_data_buf();
}
uint32_t l;
uint16_t p;
while (len)
{
l = (len > (ESP32SPIDMA_MAX_PIXELS_AT_ONCE >> 1)) ? (ESP32SPIDMA_MAX_PIXELS_AT_ONCE >> 1) : len;
for (uint32_t i = 0; i < l; ++i)
{
p = idx[*data++];
MSB_32_16_16_SET(_buffer32[i], p, p);
}
_spi_tran.tx_buffer = _buffer32;
_spi_tran.length = l << 5;
_spi_tran.flags = 0;
POLL_START();
POLL_END();
len -= l;
}
}
}
/**
* @brief flush_data_buf
*
*/
void Arduino_ESP32SPIDMA::flush_data_buf()
{
_spi_tran.tx_buffer = _buffer32;
_spi_tran.length = _data_buf_bit_idx;
_spi_tran.flags = 0;
POLL_START();
POLL_END();
_data_buf_bit_idx = 0;
}
/**
* @brief WRITE8BIT
*
* @param d
* @return INLINE
*/
INLINE void Arduino_ESP32SPIDMA::WRITE8BIT(uint8_t d)
{
uint16_t idx = _data_buf_bit_idx >> 3;
_buffer[idx] = d;
_data_buf_bit_idx += 8;
if (_data_buf_bit_idx >= (ESP32SPIDMA_MAX_PIXELS_AT_ONCE << 4))
{
flush_data_buf();
}
}
/**
* @brief WRITE9BIT
*
* @param d
* @return INLINE
*/
INLINE void Arduino_ESP32SPIDMA::WRITE9BIT(uint32_t d)
{
uint16_t idx = _data_buf_bit_idx >> 3;
uint8_t shift = (_data_buf_bit_idx % 8);
if (shift)
{
_buffer[idx++] |= d >> (shift + 1);
_buffer[idx] = d << (7 - shift);
}
else
{
_buffer[idx++] = d >> 1;
_buffer[idx] = d << 7;
}
_data_buf_bit_idx += 9;
if (_data_buf_bit_idx >= 504) // 56 bytes * 9 bits
{
flush_data_buf();
}
}
/******** low level bit twiddling **********/
/**
* @brief DC_HIGH
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPIDMA::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
/**
* @brief DC_LOW
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPIDMA::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
/**
* @brief CS_HIGH
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPIDMA::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
/**
* @brief CS_LOW
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPIDMA::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
/**
* @brief POLL_START
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPIDMA::POLL_START()
{
spi_device_polling_start(_handle, &_spi_tran, portMAX_DELAY);
}
/**
* @brief POLL_END
*
* @return INLINE
*/
INLINE void Arduino_ESP32SPIDMA::POLL_END()
{
spi_device_polling_end(_handle, portMAX_DELAY);
}
#endif // #if defined(ESP32)
@@ -0,0 +1,79 @@
#pragma once
#include "Arduino_DataBus.h"
#if defined(ESP32)
#include <driver/spi_master.h>
#define ESP32SPIDMA_MAX_PIXELS_AT_ONCE 1024
#define DMA_CHANNEL SPI_DMA_CH_AUTO
class Arduino_ESP32SPIDMA : public Arduino_DataBus
{
public:
#if CONFIG_IDF_TARGET_ESP32
Arduino_ESP32SPIDMA(int8_t dc = GFX_NOT_DEFINED, int8_t cs = GFX_NOT_DEFINED, int8_t sck = GFX_NOT_DEFINED, int8_t mosi = GFX_NOT_DEFINED, int8_t miso = GFX_NOT_DEFINED, uint8_t spi_num = VSPI, bool is_shared_interface = false); // Constructor
#elif CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32S3
Arduino_ESP32SPIDMA(int8_t dc = GFX_NOT_DEFINED, int8_t cs = GFX_NOT_DEFINED, int8_t sck = GFX_NOT_DEFINED, int8_t mosi = GFX_NOT_DEFINED, int8_t miso = GFX_NOT_DEFINED, uint8_t spi_num = HSPI, bool is_shared_interface = false); // Constructor
#else
Arduino_ESP32SPIDMA(int8_t dc = GFX_NOT_DEFINED, int8_t cs = GFX_NOT_DEFINED, int8_t sck = GFX_NOT_DEFINED, int8_t mosi = GFX_NOT_DEFINED, int8_t miso = GFX_NOT_DEFINED, uint8_t spi_num = FSPI, bool is_shared_interface = false); // Constructor
#endif
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = SPI_MODE0) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
void flush_data_buf();
INLINE void WRITE8BIT(uint8_t d);
INLINE void WRITE9BIT(uint32_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
INLINE void POLL_START();
INLINE void POLL_END();
private:
int8_t _dc, _cs;
int8_t _sck, _mosi, _miso;
uint8_t _spi_num;
bool _is_shared_interface;
uint32_t _div = 0;
PORTreg_t _dcPortSet; ///< PORT register for data/command SET
PORTreg_t _dcPortClr; ///< PORT register for data/command CLEAR
PORTreg_t _csPortSet; ///< PORT register for chip select SET
PORTreg_t _csPortClr; ///< PORT register for chip select CLEAR
uint32_t _dcPinMask; ///< Bitmask for data/command
uint32_t _csPinMask; ///< Bitmask for chip select
spi_device_handle_t _handle;
spi_transaction_t _spi_tran;
uint8_t _bitOrder = SPI_MSBFIRST;
union
{
uint8_t _buffer[ESP32SPIDMA_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t _buffer16[ESP32SPIDMA_MAX_PIXELS_AT_ONCE];
uint32_t _buffer32[ESP32SPIDMA_MAX_PIXELS_AT_ONCE / 2];
};
uint16_t _data_buf_bit_idx = 0;
};
#endif // #if defined(ESP32)
@@ -0,0 +1,379 @@
/*
* start rewrite from:
* https://github.com/Bodmer/TFT_eSPI.git
*/
#ifdef ESP8266
#include <SPI.h>
#include "Arduino_ESP8266SPI.h"
#define WAIT_SPI_NOT_BUSY while (SPI1CMD & SPIBUSY)
Arduino_ESP8266SPI::Arduino_ESP8266SPI(int8_t dc, int8_t cs /* = GFX_NOT_DEFINED */)
: _dc(dc), _cs(cs)
{
}
bool Arduino_ESP8266SPI::begin(int32_t speed, int8_t dataMode)
{
_speed = (speed == GFX_NOT_DEFINED) ? SPI_DEFAULT_FREQ : speed;
_dataMode = (dataMode == GFX_NOT_DEFINED) ? SPI_MODE0 : dataMode;
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // Deselect
}
_dcPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_dc));
_dcPinMaskSet = digitalPinToBitMask(_dc);
if (_cs != GFX_NOT_DEFINED)
{
_csPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_cs));
_csPinMaskSet = digitalPinToBitMask(_cs);
}
_csPinMaskClr = ~_csPinMaskSet;
_dcPinMaskClr = ~_dcPinMaskSet;
SPI.begin();
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE0;
}
SPI.setBitOrder(MSBFIRST);
SPI.setDataMode(_dataMode);
SPI.setFrequency(_speed);
return true;
}
void Arduino_ESP8266SPI::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_ESP8266SPI::endWrite()
{
CS_HIGH();
}
void Arduino_ESP8266SPI::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_ESP8266SPI::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_ESP8266SPI::write(uint8_t d)
{
WRITE(d);
}
void Arduino_ESP8266SPI::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_ESP8266SPI::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
static uint8_t temp[2];
temp[0] = _data16.msb;
temp[1] = _data16.lsb;
SPI.writePattern((uint8_t *)temp, 2, len);
}
void Arduino_ESP8266SPI::writePixels(uint16_t *data, uint32_t len)
{
uint8_t *data8 = (uint8_t *)data;
uint8_t i;
if (len > 31)
{
SPI1U1 = (511 << SPILMOSI);
while (len > 31)
{
i = 0;
while (i < 16)
{
MSB_32_8_ARRAY_SET(twoPixelBuf[i++], data8);
data8 += 4;
}
len -= 32;
// ESP8266 wait time here at 40MHz SPI is ~5.45us
WAIT_SPI_NOT_BUSY;
SPI1W0 = twoPixelBuf[0];
SPI1W1 = twoPixelBuf[1];
SPI1W2 = twoPixelBuf[2];
SPI1W3 = twoPixelBuf[3];
SPI1W4 = twoPixelBuf[4];
SPI1W5 = twoPixelBuf[5];
SPI1W6 = twoPixelBuf[6];
SPI1W7 = twoPixelBuf[7];
SPI1W8 = twoPixelBuf[8];
SPI1W9 = twoPixelBuf[9];
SPI1W10 = twoPixelBuf[10];
SPI1W11 = twoPixelBuf[11];
SPI1W12 = twoPixelBuf[12];
SPI1W13 = twoPixelBuf[13];
SPI1W14 = twoPixelBuf[14];
SPI1W15 = twoPixelBuf[15];
SPI1CMD |= SPIBUSY;
}
}
if (len)
{
uint32_t bits = ((len << 4) - 1); // bits left to shift - 1
i = 0;
len = (len + 1) >> 1;
WAIT_SPI_NOT_BUSY;
SPI1U1 = (bits << SPILMOSI);
while (len--)
{
MSB_32_8_ARRAY_SET(spi1Reg32[i++], data8);
data8 += 4;
}
SPI1CMD |= SPIBUSY;
}
WAIT_SPI_NOT_BUSY;
}
void Arduino_ESP8266SPI::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_ESP8266SPI::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_ESP8266SPI::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
uint32_t d;
MSB_32_16_16_SET(d, d1, d2);
SPI1U1 = (31 << SPILMOSI);
SPI1W0 = d;
SPI1CMD |= SPIBUSY;
WAIT_SPI_NOT_BUSY;
}
void Arduino_ESP8266SPI::writeBytes(uint8_t *data, uint32_t len)
{
SPI.writeBytes(data, len);
}
void Arduino_ESP8266SPI::writePattern(uint8_t *data, uint8_t len, uint32_t repeat)
{
SPI.writePattern(data, len, repeat);
}
void Arduino_ESP8266SPI::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
uint16_t p1, p2;
uint8_t i;
if (len > 31)
{
SPI1U1 = (511 << SPILMOSI);
while (len > 31)
{
i = 0;
while (i < 16)
{
p1 = idx[*data++];
p2 = idx[*data++];
MSB_32_16_16_SET(twoPixelBuf[i++], p1, p2);
}
len -= 32;
// ESP8266 wait time here at 40MHz SPI is ~5.45us
WAIT_SPI_NOT_BUSY;
SPI1W0 = twoPixelBuf[0];
SPI1W1 = twoPixelBuf[1];
SPI1W2 = twoPixelBuf[2];
SPI1W3 = twoPixelBuf[3];
SPI1W4 = twoPixelBuf[4];
SPI1W5 = twoPixelBuf[5];
SPI1W6 = twoPixelBuf[6];
SPI1W7 = twoPixelBuf[7];
SPI1W8 = twoPixelBuf[8];
SPI1W9 = twoPixelBuf[9];
SPI1W10 = twoPixelBuf[10];
SPI1W11 = twoPixelBuf[11];
SPI1W12 = twoPixelBuf[12];
SPI1W13 = twoPixelBuf[13];
SPI1W14 = twoPixelBuf[14];
SPI1W15 = twoPixelBuf[15];
SPI1CMD |= SPIBUSY;
}
}
if (len)
{
uint32_t bits = ((len << 4) - 1); // bits left to shift - 1
i = 0;
len = (len + 1) >> 1;
WAIT_SPI_NOT_BUSY;
SPI1U1 = (bits << SPILMOSI);
while (len--)
{
p1 = idx[*data++];
p2 = idx[*data++];
MSB_32_16_16_SET(spi1Reg32[i++], p1, p2);
}
SPI1CMD |= SPIBUSY;
}
WAIT_SPI_NOT_BUSY;
}
void Arduino_ESP8266SPI::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
uint16_t p;
uint8_t i;
if (len > 15)
{
SPI1U1 = (511 << SPILMOSI);
while (len > 15)
{
i = 0;
while (i < 16)
{
p = idx[*data++];
MSB_32_16_16_SET(twoPixelBuf[i++], p, p);
}
len -= 16;
// ESP8266 wait time here at 40MHz SPI is ~5.45us
WAIT_SPI_NOT_BUSY;
SPI1W0 = twoPixelBuf[0];
SPI1W1 = twoPixelBuf[1];
SPI1W2 = twoPixelBuf[2];
SPI1W3 = twoPixelBuf[3];
SPI1W4 = twoPixelBuf[4];
SPI1W5 = twoPixelBuf[5];
SPI1W6 = twoPixelBuf[6];
SPI1W7 = twoPixelBuf[7];
SPI1W8 = twoPixelBuf[8];
SPI1W9 = twoPixelBuf[9];
SPI1W10 = twoPixelBuf[10];
SPI1W11 = twoPixelBuf[11];
SPI1W12 = twoPixelBuf[12];
SPI1W13 = twoPixelBuf[13];
SPI1W14 = twoPixelBuf[14];
SPI1W15 = twoPixelBuf[15];
SPI1CMD |= SPIBUSY;
}
}
if (len)
{
uint32_t bits = ((len << 5) - 1); // bits left to shift - 1
i = 0;
WAIT_SPI_NOT_BUSY;
SPI1U1 = (bits << SPILMOSI);
while (len--)
{
p = idx[*data++];
MSB_32_16_16_SET(spi1Reg32[i++], p, p);
}
SPI1CMD |= SPIBUSY;
}
WAIT_SPI_NOT_BUSY;
}
INLINE void Arduino_ESP8266SPI::WRITE(uint8_t d)
{
SPI1U1 = (7 << SPILMOSI);
SPI1W0 = d;
SPI1CMD |= SPIBUSY;
WAIT_SPI_NOT_BUSY;
}
INLINE void Arduino_ESP8266SPI::WRITE16(uint16_t d)
{
MSB_16_SET(d, d);
SPI1U1 = (15 << SPILMOSI);
SPI1W0 = d;
SPI1CMD |= SPIBUSY;
WAIT_SPI_NOT_BUSY;
}
/******** low level bit twiddling **********/
INLINE void Arduino_ESP8266SPI::DC_HIGH(void)
{
*_dcPort |= _dcPinMaskSet;
}
INLINE void Arduino_ESP8266SPI::DC_LOW(void)
{
*_dcPort &= _dcPinMaskClr;
}
INLINE void Arduino_ESP8266SPI::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPort |= _csPinMaskSet;
}
}
INLINE void Arduino_ESP8266SPI::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPort &= _csPinMaskClr;
}
}
#endif // #ifdef ESP8266
@@ -0,0 +1,59 @@
/*
* start rewrite from:
* https://github.com/Bodmer/TFT_eSPI.git
*/
#ifdef ESP8266
#ifndef _ARDUINO_ESP8266SPI_H_
#define _ARDUINO_ESP8266SPI_H_
#include "Arduino_DataBus.h"
class Arduino_ESP8266SPI : public Arduino_DataBus
{
public:
Arduino_ESP8266SPI(int8_t dc, int8_t cs = GFX_NOT_DEFINED); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writePattern(uint8_t *data, uint8_t len, uint32_t repeat) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs;
PORTreg_t _csPort; ///< PORT register for chip select
PORTreg_t _dcPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _csPinMaskSet; ///< Bitmask for chip select SET (OR)
ARDUINOGFX_PORT_t _csPinMaskClr; ///< Bitmask for chip select CLEAR (AND)
ARDUINOGFX_PORT_t _dcPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _dcPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
uint32_t twoPixelBuf[16];
volatile uint32_t *spi1Reg32 = (volatile uint32_t *)(0x60000000 + 0x140); // address of SPI1W0
};
#endif // _ARDUINO_ESP8266SPI_H_
#endif // #ifdef ESP8266
@@ -0,0 +1,494 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#include "Arduino_HWSPI.h"
#if defined(SPI_HAS_TRANSACTION)
#define SPI_BEGIN_TRANSACTION() _spi->beginTransaction(mySPISettings)
#define SPI_END_TRANSACTION() _spi->endTransaction()
#else
#define SPI_BEGIN_TRANSACTION() \
{ \
}
#define SPI_END_TRANSACTION() \
{ \
}
#endif
#if defined(SPI_HAS_TRANSACTION)
static SPISettings mySPISettings;
#elif defined(__AVR__) || defined(CORE_TEENSY)
static uint8_t SPCRbackup;
static uint8_t mySPCR;
#endif
#if defined(ESP32)
Arduino_HWSPI::Arduino_HWSPI(int8_t dc, int8_t cs /* = GFX_NOT_DEFINED */, int8_t sck /* = GFX_NOT_DEFINED */, int8_t mosi /* = GFX_NOT_DEFINED */, int8_t miso /* = GFX_NOT_DEFINED */, SPIClass *spi, bool is_shared_interface /* = true */)
: _dc(dc), _cs(cs), _sck(sck), _mosi(mosi), _miso(miso), _spi(spi), _is_shared_interface(is_shared_interface)
{
#else
Arduino_HWSPI::Arduino_HWSPI(int8_t dc, int8_t cs /* = GFX_NOT_DEFINED */, SPIClass *spi, bool is_shared_interface /* = true */)
: _dc(dc), _cs(cs), _spi(spi), _is_shared_interface(is_shared_interface)
{
#endif
}
bool Arduino_HWSPI::begin(int32_t speed, int8_t dataMode)
{
_speed = (speed == GFX_NOT_DEFINED) ? SPI_DEFAULT_FREQ : speed;
_dataMode = dataMode;
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // Deselect
}
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(ARDUINO_ARCH_NRF52840)
uint32_t pin = digitalPinToPinName((pin_size_t)_dc);
NRF_GPIO_Type *reg = nrf_gpio_pin_port_decode(&pin);
_dcPortSet = &reg->OUTSET;
_dcPortClr = &reg->OUTCLR;
_dcPinMask = 1UL << pin;
if (_cs != GFX_NOT_DEFINED)
{
pin = digitalPinToPinName((pin_size_t)_cs);
reg = nrf_gpio_pin_port_decode(&pin);
_csPortSet = &reg->OUTSET;
_csPortClr = &reg->OUTCLR;
_csPinMask = 1UL << pin;
}
#elif defined(TARGET_RP2040)
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&sio_hw->gpio_set;
_dcPortClr = (PORTreg_t)&sio_hw->gpio_clr;
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&sio_hw->gpio_set;
_csPortClr = (PORTreg_t)&sio_hw->gpio_clr;
}
#elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32C3)
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
#elif defined(ESP32)
_dcPinMask = digitalPinToBitMask(_dc);
if (_dc >= 32)
{
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
#elif defined(CORE_TEENSY)
#if !defined(KINETISK)
_dcPinMask = digitalPinToBitMask(_dc);
#endif
_dcPortSet = portSetRegister(_dc);
_dcPortClr = portClearRegister(_dc);
if (_cs != GFX_NOT_DEFINED)
{
#if !defined(KINETISK)
_csPinMask = digitalPinToBitMask(_cs);
#endif
_csPortSet = portSetRegister(_cs);
_csPortClr = portClearRegister(_cs);
}
#else // !CORE_TEENSY
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = &(PORT->Group[g_APinDescription[_dc].ulPort].OUTSET.reg);
_dcPortClr = &(PORT->Group[g_APinDescription[_dc].ulPort].OUTCLR.reg);
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = &(PORT->Group[g_APinDescription[_cs].ulPort].OUTSET.reg);
_csPortClr = &(PORT->Group[g_APinDescription[_cs].ulPort].OUTCLR.reg);
}
#endif // end !CORE_TEENSY
#else // !HAS_PORT_SET_CLR
_dcPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_dc));
_dcPinMaskSet = digitalPinToBitMask(_dc);
_dcPinMaskClr = ~_dcPinMaskSet;
if (_cs != GFX_NOT_DEFINED)
{
_csPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_cs));
_csPinMaskSet = digitalPinToBitMask(_cs);
}
_csPinMaskClr = ~_csPinMaskSet;
#endif // !HAS_PORT_SET_CLR
#endif // USE_FAST_PINIO
#if defined(ESP32)
_spi->begin(_sck, _miso, _mosi);
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE0;
}
mySPISettings = SPISettings(_speed, MSBFIRST, _dataMode);
#elif defined(ESP8266)
_spi->begin();
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE0;
}
mySPISettings = SPISettings(_speed, MSBFIRST, _dataMode);
// Teensy 4.x
#elif defined(__IMXRT1052__) || defined(__IMXRT1062__)
_spi->begin();
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE0;
}
mySPISettings = SPISettings(_speed, MSBFIRST, _dataMode);
#elif defined(SPI_HAS_TRANSACTION)
_spi->begin();
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE2;
}
mySPISettings = SPISettings(_speed, MSBFIRST, _dataMode);
#elif defined(__AVR__) || defined(CORE_TEENSY)
SPCRbackup = SPCR;
_spi->begin();
_spi->setClockDivider(SPI_CLOCK_DIV2);
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE2;
}
_spi->setDataMode(_dataMode);
mySPCR = SPCR; // save our preferred state
SPCR = SPCRbackup; // then restore
#elif defined(__SAM3X8E__)
_spi->begin();
_spi->setClockDivider(21); // 4MHz
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE2;
}
_spi->setDataMode(_dataMode);
#elif defined(__arm__)
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE2;
}
#endif
return true;
}
void Arduino_HWSPI::beginWrite()
{
if (_is_shared_interface)
{
SPI_BEGIN_TRANSACTION();
}
DC_HIGH();
CS_LOW();
}
void Arduino_HWSPI::endWrite()
{
CS_HIGH();
if (_is_shared_interface)
{
SPI_END_TRANSACTION();
}
}
void Arduino_HWSPI::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_HWSPI::writeCommand16(uint16_t c)
{
DC_LOW();
#if defined(LITTLE_FOOT_PRINT)
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
#else // !defined(LITTLE_FOOT_PRINT)
WRITE16(c);
#endif // !defined(LITTLE_FOOT_PRINT)
DC_HIGH();
}
void Arduino_HWSPI::write(uint8_t d)
{
WRITE(d);
}
void Arduino_HWSPI::write16(uint16_t d)
{
#if defined(LITTLE_FOOT_PRINT)
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
#else // !defined(LITTLE_FOOT_PRINT)
WRITE16(d);
#endif // !defined(LITTLE_FOOT_PRINT)
}
void Arduino_HWSPI::writeRepeat(uint16_t p, uint32_t len)
{
#if defined(LITTLE_FOOT_PRINT)
_data16.value = p;
while (len--)
{
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
#elif defined(ESP8266) || defined(CONFIG_ARCH_CHIP_CXD56XX)
MSB_16_SET(p, p);
uint32_t xferLen = (len < SPI_MAX_PIXELS_AT_ONCE) ? len : SPI_MAX_PIXELS_AT_ONCE;
for (uint32_t i = 0; i < xferLen; i++)
{
_buffer.v16[i] = p;
}
while (len)
{
xferLen = (len < SPI_MAX_PIXELS_AT_ONCE) ? len : SPI_MAX_PIXELS_AT_ONCE;
len -= xferLen;
xferLen += xferLen;
WRITEBUF(_buffer.v8, xferLen);
}
#else // other arch
MSB_16_SET(p, p);
uint32_t xferLen;
while (len)
{
xferLen = (len < SPI_MAX_PIXELS_AT_ONCE) ? len : SPI_MAX_PIXELS_AT_ONCE;
for (uint32_t i = 0; i < xferLen; i++)
{
_buffer.v16[i] = p;
}
len -= xferLen;
xferLen += xferLen;
WRITEBUF(_buffer.v8, xferLen);
}
#endif // other arch
}
void Arduino_HWSPI::writePixels(uint16_t *data, uint32_t len)
{
#if defined(LITTLE_FOOT_PRINT)
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
#else // !defined(LITTLE_FOOT_PRINT)
uint32_t xferLen;
uint8_t *b;
union
{
uint16_t val;
struct
{
uint8_t lsb;
uint8_t msb;
};
} t;
while (len)
{
xferLen = (len < SPI_MAX_PIXELS_AT_ONCE) ? len : SPI_MAX_PIXELS_AT_ONCE;
b = _buffer.v8;
for (uint32_t i = 0; i < xferLen; i++)
{
t.val = *data++;
*b++ = t.msb;
*b++ = t.lsb;
}
len -= xferLen;
xferLen += xferLen; // uint16_t to uint8_t, double length
WRITEBUF(_buffer.v8, xferLen);
}
#endif // !defined(LITTLE_FOOT_PRINT)
}
#if !defined(LITTLE_FOOT_PRINT)
void Arduino_HWSPI::writeBytes(uint8_t *data, uint32_t len)
{
WRITEBUF(data, len);
}
void Arduino_HWSPI::writePattern(uint8_t *data, uint8_t len, uint32_t repeat)
{
#if defined(ESP8266) || defined(ESP32)
_spi->writePattern(data, len, repeat);
#else // !(defined(ESP8266) || defined(ESP32))
while (repeat--)
{
WRITEBUF(data, len);
}
#endif // !(defined(ESP8266) || defined(ESP32))
}
#endif // !defined(LITTLE_FOOT_PRINT)
INLINE void Arduino_HWSPI::WRITE(uint8_t d)
{
#if defined(SPI_HAS_TRANSACTION)
_spi->transfer(d);
#elif defined(__AVR__) || defined(CORE_TEENSY)
SPCRbackup = SPCR;
SPCR = mySPCR;
_spi->transfer(d);
SPCR = SPCRbackup;
#elif defined(__arm__)
_spi->setClockDivider(21); // 4MHz
_spi->setDataMode(_dataMode);
_spi->transfer(d);
#endif
}
#if !defined(LITTLE_FOOT_PRINT)
INLINE void Arduino_HWSPI::WRITE16(uint16_t d)
{
#if defined(ESP8266) || defined(ESP32)
_spi->write16(d);
#elif defined(SPI_HAS_TRANSACTION)
_spi->transfer16(d);
#elif defined(__AVR__) || defined(CORE_TEENSY)
SPCRbackup = SPCR;
SPCR = mySPCR;
_spi->transfer16(d);
SPCR = SPCRbackup;
#elif defined(__arm__)
_spi->setClockDivider(21); // 4MHz
_spi->setDataMode(_dataMode);
_spi->transfer16(d);
#else
_spi->transfer16(d);
#endif
}
INLINE void Arduino_HWSPI::WRITEBUF(uint8_t *buf, size_t count)
{
#if defined(ESP8266) || defined(ESP32)
_spi->writeBytes(buf, count);
#elif defined(CONFIG_ARCH_CHIP_CXD56XX)
_spi->send(buf, count);
#else // other arch.
_spi->transfer(buf, count);
#endif // other arch.
}
#endif // !defined(LITTLE_FOOT_PRINT)
/******** low level bit twiddling **********/
INLINE void Arduino_HWSPI::DC_HIGH(void)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_dcPortSet = 1;
#else // !KINETISK
*_dcPortSet = _dcPinMask;
#endif // end !KINETISK
#else // !HAS_PORT_SET_CLR
*_dcPort |= _dcPinMaskSet;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_dc, HIGH);
#endif // end !USE_FAST_PINIO
}
INLINE void Arduino_HWSPI::DC_LOW(void)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_dcPortClr = 1;
#else // !KINETISK
*_dcPortClr = _dcPinMask;
#endif // end !KINETISK
#else // !HAS_PORT_SET_CLR
*_dcPort &= _dcPinMaskClr;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_dc, LOW);
#endif // end !USE_FAST_PINIO
}
INLINE void Arduino_HWSPI::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_csPortSet = 1;
#else // !KINETISK
*_csPortSet = _csPinMask;
#endif // end !KINETISK
#else // !HAS_PORT_SET_CLR
*_csPort |= _csPinMaskSet;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_cs, HIGH);
#endif // end !USE_FAST_PINIO
}
}
INLINE void Arduino_HWSPI::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_csPortClr = 1;
#else // !KINETISK
*_csPortClr = _csPinMask;
#endif // end !KINETISK
#else // !HAS_PORT_SET_CLR
*_csPort &= _csPinMaskClr;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_cs, LOW);
#endif // end !USE_FAST_PINIO
}
}
+101
View File
@@ -0,0 +1,101 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_HWSPI_H_
#define _ARDUINO_HWSPI_H_
#include <SPI.h>
#include "Arduino_DataBus.h"
#if !defined(LITTLE_FOOT_PRINT)
#define SPI_MAX_PIXELS_AT_ONCE 32
#endif
// HARDWARE CONFIG ---------------------------------------------------------
class Arduino_HWSPI : public Arduino_DataBus
{
public:
#if defined(ESP32)
Arduino_HWSPI(int8_t dc, int8_t cs = GFX_NOT_DEFINED, int8_t sck = GFX_NOT_DEFINED, int8_t mosi = GFX_NOT_DEFINED, int8_t miso = GFX_NOT_DEFINED, SPIClass *spi = &SPI, bool is_shared_interface = true); // Constructor
#elif defined(ARDUINO_ARCH_SAMD) && defined(SEEED_GROVE_UI_WIRELESS)
Arduino_HWSPI(int8_t dc, int8_t cs = GFX_NOT_DEFINED, SPIClass *spi = &LCD_SPI, bool is_shared_interface = true); // Constructor
#elif defined(RTL8722DM) && defined(BOARD_RTL8722DM)
Arduino_HWSPI(int8_t dc, int8_t cs = GFX_NOT_DEFINED, SPIClass *spi = &SPI1, bool is_shared_interface = true); // Constructor
#else
Arduino_HWSPI(int8_t dc, int8_t cs = GFX_NOT_DEFINED, SPIClass *spi = &SPI, bool is_shared_interface = true); // Constructor
#endif
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
#if !defined(LITTLE_FOOT_PRINT)
void writeBytes(uint8_t *data, uint32_t len) override;
void writePattern(uint8_t *data, uint8_t len, uint32_t repeat) override;
#endif // !defined(LITTLE_FOOT_PRINT)
private:
INLINE void WRITE(uint8_t d);
#if !defined(LITTLE_FOOT_PRINT)
INLINE void WRITE16(uint16_t d);
INLINE void WRITEBUF(uint8_t *buf, size_t count);
#endif // !defined(LITTLE_FOOT_PRINT)
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs;
#if defined(ESP32)
int8_t _sck, _mosi, _miso;
#endif
SPIClass *_spi;
bool _is_shared_interface;
// CLASS INSTANCE VARIABLES --------------------------------------------
// Here be dragons! There's a big union of three structures here --
// one each for hardware SPI, software (bitbang) SPI, and parallel
// interfaces. This is to save some memory, since a display's connection
// will be only one of these. The order of some things is a little weird
// in an attempt to get values to align and pack better in RAM.
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
PORTreg_t _csPortSet; ///< PORT register for chip select SET
PORTreg_t _csPortClr; ///< PORT register for chip select CLEAR
PORTreg_t _dcPortSet; ///< PORT register for data/command SET
PORTreg_t _dcPortClr; ///< PORT register for data/command CLEAR
#if !defined(KINETISK)
ARDUINOGFX_PORT_t _csPinMask; ///< Bitmask for chip select
ARDUINOGFX_PORT_t _dcPinMask; ///< Bitmask for data/command
#endif // !KINETISK
#else // !HAS_PORT_SET_CLR
PORTreg_t _csPort; ///< PORT register for chip select
PORTreg_t _dcPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _csPinMaskSet; ///< Bitmask for chip select SET (OR)
ARDUINOGFX_PORT_t _csPinMaskClr; ///< Bitmask for chip select CLEAR (AND)
ARDUINOGFX_PORT_t _dcPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _dcPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
#endif // HAS_PORT_SET_CLR
#endif // !defined(USE_FAST_PINIO)
#if !defined(LITTLE_FOOT_PRINT)
union
{
uint8_t v8[SPI_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t v16[SPI_MAX_PIXELS_AT_ONCE];
} _buffer;
#endif // !defined(LITTLE_FOOT_PRINT)
};
#endif // _ARDUINO_HWSPI_H_
@@ -0,0 +1,280 @@
/*
* start rewrite from:
* https://github.com/arduino/ArduinoCore-mbed/blob/master/libraries/SPI/SPI.cpp
*/
#ifdef ARDUINO_ARCH_NRF52840
#include "Arduino_NRFXSPI.h"
Arduino_NRFXSPI::Arduino_NRFXSPI(int8_t dc, int8_t cs /* = GFX_NOT_DEFINED */, int8_t sck /* = GFX_NOT_DEFINED */, int8_t mosi /* = GFX_NOT_DEFINED */, int8_t miso /* = GFX_NOT_DEFINED */)
: _dc(dc), _cs(cs), _sck(sck), _mosi(mosi), _miso(miso)
{
}
bool Arduino_NRFXSPI::begin(int32_t speed, int8_t dataMode)
{
_speed = (speed == GFX_NOT_DEFINED) ? SPI_DEFAULT_FREQ : speed;
_dataMode = (dataMode == GFX_NOT_DEFINED) ? SPI_MODE2 : dataMode;
// init pin mask
uint32_t pin = digitalPinToPinName((pin_size_t)_dc);
NRF_GPIO_Type *reg = nrf_gpio_pin_port_decode(&pin);
nrf_gpio_cfg_output(pin);
_dcPortSet = &reg->OUTSET;
_dcPortClr = &reg->OUTCLR;
_dcPinMask = 1UL << pin;
if (_cs != GFX_NOT_DEFINED)
{
pin = digitalPinToPinName((pin_size_t)_cs);
reg = nrf_gpio_pin_port_decode(&pin);
nrf_gpio_cfg_output(pin);
_csPortSet = &reg->OUTSET;
_csPortClr = &reg->OUTCLR;
_csPinMask = 1UL << pin;
}
// init SPI pins
_nrfxSpiConfig.sck_pin = digitalPinToPinName((pin_size_t)_sck);
_nrfxSpiConfig.mosi_pin = digitalPinToPinName((pin_size_t)_mosi);
if (_miso > 0)
{
_nrfxSpiConfig.miso_pin = digitalPinToPinName((pin_size_t)_miso);
}
else
{
_nrfxSpiConfig.miso_pin = NRFX_SPI_PIN_NOT_USED;
}
// init speed
if (_speed >= 8000000)
{
_nrfxSpiConfig.frequency = NRF_SPI_FREQ_8M;
}
else if (_speed >= 4000000)
{
_nrfxSpiConfig.frequency = NRF_SPI_FREQ_4M;
}
else if (_speed >= 2000000)
{
_nrfxSpiConfig.frequency = NRF_SPI_FREQ_2M;
}
else if (_speed >= 1000000)
{
_nrfxSpiConfig.frequency = NRF_SPI_FREQ_1M;
}
else if (_speed >= 500000)
{
_nrfxSpiConfig.frequency = NRF_SPI_FREQ_500K;
}
else if (_speed >= 250000)
{
_nrfxSpiConfig.frequency = NRF_SPI_FREQ_250K;
}
else if (_speed >= 125000)
{
_nrfxSpiConfig.frequency = NRF_SPI_FREQ_125K;
}
// init data mode
if (_dataMode == SPI_MODE1)
{
_nrfxSpiConfig.mode = NRF_SPI_MODE_1;
}
else if (_dataMode == SPI_MODE2)
{
_nrfxSpiConfig.mode = NRF_SPI_MODE_2;
}
else if (_dataMode == SPI_MODE3)
{
_nrfxSpiConfig.mode = NRF_SPI_MODE_3;
}
else
{
_dataMode = SPI_MODE0;
_nrfxSpiConfig.mode = NRF_SPI_MODE_0;
}
// init SPI
nrfx_spi_init(&_nrfxSpi, &_nrfxSpiConfig, NULL, NULL);
return true;
}
void Arduino_NRFXSPI::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_NRFXSPI::endWrite()
{
CS_HIGH();
}
void Arduino_NRFXSPI::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_NRFXSPI::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_NRFXSPI::write(uint8_t d)
{
WRITE(d);
}
void Arduino_NRFXSPI::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_NRFXSPI::writeRepeat(uint16_t p, uint32_t len)
{
MSB_16_SET(p, p);
uint32_t bufLen = (len < NRFXSPI_MAX_PIXELS_AT_ONCE) ? len : NRFXSPI_MAX_PIXELS_AT_ONCE;
uint32_t xferLen;
for (uint32_t i = 0; i < bufLen; i++)
{
_buffer16[i] = p;
}
while (len)
{
xferLen = (bufLen < len) ? bufLen : len;
WRITEBUF(_buffer, xferLen * 2);
len -= xferLen;
}
}
void Arduino_NRFXSPI::writePixels(uint16_t *data, uint32_t len)
{
uint32_t xferLen;
uint8_t *p;
union
{
uint16_t val;
struct
{
uint8_t lsb;
uint8_t msb;
};
} t;
while (len)
{
xferLen = (len < NRFXSPI_MAX_PIXELS_AT_ONCE) ? len : NRFXSPI_MAX_PIXELS_AT_ONCE;
p = _buffer;
for (uint32_t i = 0; i < xferLen; i++)
{
t.val = *data++;
*p++ = t.msb;
*p++ = t.lsb;
}
len -= xferLen;
xferLen += xferLen; // uint16_t to uint8_t, double length
WRITEBUF(_buffer, xferLen);
}
}
void Arduino_NRFXSPI::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_NRFXSPI::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_NRFXSPI::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
const nrfx_spi_xfer_desc_t xfer_desc1 = NRFX_SPI_SINGLE_XFER(&c, 1, NULL, 0);
nrfx_spi_xfer(&_nrfxSpi, &xfer_desc1, 0);
DC_HIGH();
uint32_t d;
MSB_32_16_16_SET(d, d1, d2);
const nrfx_spi_xfer_desc_t xfer_desc2 = NRFX_SPI_SINGLE_XFER(&d, 4, NULL, 0);
nrfx_spi_xfer(&_nrfxSpi, &xfer_desc2, 0);
}
void Arduino_NRFXSPI::writeBytes(uint8_t *data, uint32_t len)
{
WRITEBUF(data, len);
}
INLINE void Arduino_NRFXSPI::WRITE(uint8_t d)
{
const nrfx_spi_xfer_desc_t xfer_desc = NRFX_SPI_SINGLE_XFER(&d, 1, NULL, 0);
nrfx_spi_xfer(&_nrfxSpi, &xfer_desc, 0);
}
INLINE void Arduino_NRFXSPI::WRITE16(uint16_t d)
{
MSB_16_SET(d, d);
const nrfx_spi_xfer_desc_t xfer_desc = NRFX_SPI_SINGLE_XFER(&d, 2, NULL, 0);
nrfx_spi_xfer(&_nrfxSpi, &xfer_desc, 0);
}
INLINE void Arduino_NRFXSPI::WRITEBUF(uint8_t *buf, size_t count)
{
const nrfx_spi_xfer_desc_t xfer_desc = NRFX_SPI_SINGLE_XFER(buf, count, NULL, 0);
nrfx_spi_xfer(&_nrfxSpi, &xfer_desc, 0);
}
/******** low level bit twiddling **********/
INLINE void Arduino_NRFXSPI::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_NRFXSPI::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_NRFXSPI::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_NRFXSPI::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #ifdef ARDUINO_ARCH_NRF52840
@@ -0,0 +1,68 @@
/*
* start rewrite from:
* https://github.com/arduino/ArduinoCore-mbed/blob/master/libraries/SPI/SPI.cpp
*/
#ifdef ARDUINO_ARCH_NRF52840
#ifndef _ARDUINO_NRFXSPI_H_
#define _ARDUINO_NRFXSPI_H_
#include <SPI.h>
#include "Arduino_DataBus.h"
#define NRFXSPI_MAX_PIXELS_AT_ONCE 32
class Arduino_NRFXSPI : public Arduino_DataBus
{
public:
Arduino_NRFXSPI(int8_t dc, int8_t cs = GFX_NOT_DEFINED, int8_t sck = GFX_NOT_DEFINED, int8_t mosi = GFX_NOT_DEFINED, int8_t miso = GFX_NOT_DEFINED); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void WRITEBUF(uint8_t *buf, size_t count);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs;
int8_t _sck, _mosi, _miso;
PORTreg_t _csPortSet; ///< PORT register for chip select SET
PORTreg_t _csPortClr; ///< PORT register for chip select CLEAR
PORTreg_t _dcPortSet; ///< PORT register for data/command SET
PORTreg_t _dcPortClr; ///< PORT register for data/command CLEAR
ARDUINOGFX_PORT_t _csPinMask; ///< Bitmask for chip select
ARDUINOGFX_PORT_t _dcPinMask; ///< Bitmask for data/command
nrfx_spi_config_t _nrfxSpiConfig = NRFX_SPI_DEFAULT_CONFIG;
nrfx_spi_t _nrfxSpi = NRFX_SPI_INSTANCE(0);
union
{
uint8_t _buffer[NRFXSPI_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t _buffer16[NRFXSPI_MAX_PIXELS_AT_ONCE];
uint32_t _buffer32[NRFXSPI_MAX_PIXELS_AT_ONCE / 2];
};
};
#endif // _ARDUINO_NRFXSPI_H_
#endif // #ifdef ARDUINO_ARCH_NRF52840
@@ -0,0 +1,249 @@
#if defined(TARGET_RP2040)
#include "Arduino_RPiPicoPAR16.h"
Arduino_RPiPicoPAR16::Arduino_RPiPicoPAR16(int8_t dc, int8_t cs, int8_t wr, int8_t rd)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd)
{
}
bool Arduino_RPiPicoPAR16::begin(int32_t speed, int8_t dataMode)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
_dcPinMask = digitalPinToBitMask(_dc);
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
_csPinMask = digitalPinToBitMask(_cs);
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
_wrPinMask = digitalPinToBitMask(_wr);
_dataClrMask = 0xFFFF | _wrPinMask;
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
_rdPinMask = digitalPinToBitMask(_rd);
}
else
{
_rdPinMask = 0;
}
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
pinMode(14, OUTPUT);
pinMode(15, OUTPUT);
sio_hw->gpio_clr = 0xFFFF;
return true;
}
void Arduino_RPiPicoPAR16::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_RPiPicoPAR16::endWrite()
{
CS_HIGH();
}
void Arduino_RPiPicoPAR16::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_RPiPicoPAR16::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_RPiPicoPAR16::write(uint8_t d)
{
WRITE(d);
}
void Arduino_RPiPicoPAR16::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_RPiPicoPAR16::writeRepeat(uint16_t p, uint32_t len)
{
while (len--)
{
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = p;
sio_hw->gpio_set = _wrPinMask;
}
}
void Arduino_RPiPicoPAR16::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = *data++;
sio_hw->gpio_set = _wrPinMask;
}
}
void Arduino_RPiPicoPAR16::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_RPiPicoPAR16::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_RPiPicoPAR16::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d1);
WRITE16(d2);
}
void Arduino_RPiPicoPAR16::writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_RPiPicoPAR16::writeBytes(uint8_t *data, uint32_t len)
{
while (len > 1)
{
_data16.msb = *data++;
_data16.lsb = *data++;
WRITE16(_data16.value);
len -= 2;
}
if (len)
{
WRITE(*data);
}
}
void Arduino_RPiPicoPAR16::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = idx[*data++];
sio_hw->gpio_set = _wrPinMask;
}
}
void Arduino_RPiPicoPAR16::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = idx[*data++];
sio_hw->gpio_set = _wrPinMask;
sio_hw->gpio_clr = _wrPinMask;
sio_hw->gpio_set = _wrPinMask;
}
}
INLINE void Arduino_RPiPicoPAR16::WRITE(uint8_t d)
{
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = d;
sio_hw->gpio_set = _wrPinMask;
}
INLINE void Arduino_RPiPicoPAR16::WRITE16(uint16_t d)
{
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = d;
sio_hw->gpio_set = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_RPiPicoPAR16::DC_HIGH(void)
{
sio_hw->gpio_set = _dcPinMask;
}
INLINE void Arduino_RPiPicoPAR16::DC_LOW(void)
{
sio_hw->gpio_clr = _dcPinMask;
}
INLINE void Arduino_RPiPicoPAR16::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
sio_hw->gpio_set = _csPinMask;
}
}
INLINE void Arduino_RPiPicoPAR16::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
sio_hw->gpio_clr = _csPinMask;
}
}
#endif // #if defined(TARGET_RP2040)
@@ -0,0 +1,52 @@
#if defined(TARGET_RP2040)
#ifndef _ARDUINO_RPIPICOPAR16_H_
#define _ARDUINO_RPIPICOPAR16_H_
#include "Arduino_DataBus.h"
class Arduino_RPiPicoPAR16 : public Arduino_DataBus
{
public:
Arduino_RPiPicoPAR16(int8_t dc, int8_t cs, int8_t wr, int8_t rd); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
uint32_t _dcPinMask; ///< Bitmask
uint32_t _csPinMask; ///< Bitmask
uint32_t _wrPinMask; ///< Bitmask
uint32_t _rdPinMask; ///< Bitmask
uint32_t _dataClrMask;
};
#endif // _ARDUINO_RPIPICOPAR16_H_
#endif // #if defined(TARGET_RP2040)
@@ -0,0 +1,234 @@
#if defined(TARGET_RP2040)
#include "Arduino_RPiPicoPAR8.h"
Arduino_RPiPicoPAR8::Arduino_RPiPicoPAR8(int8_t dc, int8_t cs, int8_t wr, int8_t rd)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd)
{
}
bool Arduino_RPiPicoPAR8::begin(int32_t speed, int8_t dataMode)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
_dcPinMask = digitalPinToBitMask(_dc);
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
_csPinMask = digitalPinToBitMask(_cs);
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
_wrPinMask = digitalPinToBitMask(_wr);
_dataClrMask = 0xFF | _wrPinMask;
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
_rdPinMask = digitalPinToBitMask(_rd);
}
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
sio_hw->gpio_clr = 0xFF;
return true;
}
void Arduino_RPiPicoPAR8::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_RPiPicoPAR8::endWrite()
{
CS_HIGH();
}
void Arduino_RPiPicoPAR8::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_RPiPicoPAR8::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_RPiPicoPAR8::write(uint8_t d)
{
WRITE(d);
}
void Arduino_RPiPicoPAR8::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_RPiPicoPAR8::writeRepeat(uint16_t p, uint32_t len)
{
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
sio_hw->gpio_clr = 0xFF;
sio_hw->gpio_set = _data16.msb;
while (len--)
{
sio_hw->gpio_clr = _wrPinMask;
sio_hw->gpio_set = _wrPinMask;
sio_hw->gpio_clr = _wrPinMask;
sio_hw->gpio_set = _wrPinMask;
}
}
else
{
while (len--)
{
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = _data16.msb;
sio_hw->gpio_set = _wrPinMask;
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = _data16.lsb;
sio_hw->gpio_set = _wrPinMask;
}
}
}
void Arduino_RPiPicoPAR8::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_RPiPicoPAR8::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_RPiPicoPAR8::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_RPiPicoPAR8::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_RPiPicoPAR8::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_RPiPicoPAR8::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_RPiPicoPAR8::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
INLINE void Arduino_RPiPicoPAR8::WRITE(uint8_t d)
{
sio_hw->gpio_clr = _dataClrMask;
sio_hw->gpio_set = d;
sio_hw->gpio_set = _wrPinMask;
}
/******** low level bit twiddling **********/
INLINE void Arduino_RPiPicoPAR8::DC_HIGH(void)
{
sio_hw->gpio_set = _dcPinMask;
}
INLINE void Arduino_RPiPicoPAR8::DC_LOW(void)
{
sio_hw->gpio_clr = _dcPinMask;
}
INLINE void Arduino_RPiPicoPAR8::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
sio_hw->gpio_set = _csPinMask;
}
}
INLINE void Arduino_RPiPicoPAR8::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
sio_hw->gpio_clr = _csPinMask;
}
}
#endif // #if defined(TARGET_RP2040)
@@ -0,0 +1,50 @@
#if defined(TARGET_RP2040)
#ifndef _ARDUINO_RPIPICOPAR8_H_
#define _ARDUINO_RPIPICOPAR8_H_
#include "Arduino_DataBus.h"
class Arduino_RPiPicoPAR8 : public Arduino_DataBus
{
public:
Arduino_RPiPicoPAR8(int8_t dc, int8_t cs, int8_t wr, int8_t rd); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
uint32_t _dcPinMask; ///< Bitmask
uint32_t _csPinMask; ///< Bitmask
uint32_t _wrPinMask; ///< Bitmask
uint32_t _rdPinMask; ///< Bitmask
uint32_t _dataClrMask;
};
#endif // _ARDUINO_RPIPICOPAR8_H_
#endif // #if defined(TARGET_RP2040)
@@ -0,0 +1,219 @@
#if defined(TARGET_RP2040)
#include "Arduino_DataBus.h"
#include "Arduino_RPiPicoSPI.h"
Arduino_RPiPicoSPI::Arduino_RPiPicoSPI(int8_t dc /* = GFX_NOT_DEFINED */, int8_t cs /* = GFX_NOT_DEFINED */, int8_t sck /* = PIN_SPI0_SCK */, int8_t mosi /* = PIN_SPI0_MOSI */, int8_t miso /* = PIN_SPI0_MISO */, spi_inst_t *spi /* = spi0 */)
: _dc(dc), _cs(cs), _sck(sck), _mosi(mosi), _miso(miso), _spi(spi)
{
}
bool Arduino_RPiPicoSPI::begin(int32_t speed /* = 0 */, int8_t dataMode /* = GFX_NOT_DEFINED */)
{
// set SPI parameters
_speed = (speed == GFX_NOT_DEFINED) ? SPI_DEFAULT_FREQ : speed;
_dataMode = (dataMode != GFX_NOT_DEFINED) ? dataMode : SPI_MODE0;
_spis = SPISettings(_speed, _bitOrder, _dataMode);
// set pin mode
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
}
gpio_set_function(_miso, GPIO_FUNC_SPI);
gpio_set_function(_sck, GPIO_FUNC_SPI);
gpio_set_function(_mosi, GPIO_FUNC_SPI);
// set fastIO variables
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&sio_hw->gpio_set;
_dcPortClr = (PORTreg_t)&sio_hw->gpio_clr;
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&sio_hw->gpio_set;
_csPortClr = (PORTreg_t)&sio_hw->gpio_clr;
}
spi_init(_spi, _spis.getClockFreq());
spi_set_format(_spi, 8, SPI_CPOL_0, SPI_CPHA_0, SPI_MSB_FIRST);
return true;
}
void Arduino_RPiPicoSPI::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_RPiPicoSPI::endWrite()
{
CS_HIGH();
}
void Arduino_RPiPicoSPI::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_RPiPicoSPI::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_RPiPicoSPI::write(uint8_t d)
{
WRITE(d);
}
void Arduino_RPiPicoSPI::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_RPiPicoSPI::writeRepeat(uint16_t p, uint32_t len)
{
MSB_16_SET(p, p);
uint32_t bufLen = (len < RPIPICOSPI_MAX_PIXELS_AT_ONCE) ? len : RPIPICOSPI_MAX_PIXELS_AT_ONCE;
uint32_t xferLen;
for (uint32_t i = 0; i < bufLen; i++)
{
_buffer16[i] = p;
}
while (len)
{
xferLen = (bufLen < len) ? bufLen : len;
WRITEBUF(_buffer, xferLen * 2);
len -= xferLen;
}
}
void Arduino_RPiPicoSPI::writePixels(uint16_t *data, uint32_t len)
{
uint32_t xferLen;
uint8_t *p;
union
{
uint16_t val;
struct
{
uint8_t lsb;
uint8_t msb;
};
} t;
while (len)
{
xferLen = (len < RPIPICOSPI_MAX_PIXELS_AT_ONCE) ? len : RPIPICOSPI_MAX_PIXELS_AT_ONCE;
p = _buffer;
for (uint32_t i = 0; i < xferLen; i++)
{
t.val = *data++;
*p++ = t.msb;
*p++ = t.lsb;
}
len -= xferLen;
xferLen += xferLen; // uint16_t to uint8_t, double length
WRITEBUF(_buffer, xferLen);
}
}
void Arduino_RPiPicoSPI::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_RPiPicoSPI::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_RPiPicoSPI::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d1);
WRITE16(d2);
}
void Arduino_RPiPicoSPI::writeBytes(uint8_t *data, uint32_t len)
{
WRITEBUF(data, len);
}
INLINE void Arduino_RPiPicoSPI::WRITE(uint8_t d)
{
spi_write_blocking(_spi, (const uint8_t *)&d, 1);
}
INLINE void Arduino_RPiPicoSPI::WRITE16(uint16_t d)
{
MSB_16_SET(d, d);
spi_write_blocking(_spi, (const uint8_t *)&d, 2);
}
INLINE void Arduino_RPiPicoSPI::WRITEBUF(uint8_t *buf, size_t count)
{
spi_write_blocking(_spi, (const uint8_t *)buf, count);
}
/******** low level bit twiddling **********/
INLINE void Arduino_RPiPicoSPI::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_RPiPicoSPI::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_RPiPicoSPI::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_RPiPicoSPI::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #if defined(TARGET_RP2040)
@@ -0,0 +1,68 @@
#if defined(TARGET_RP2040)
#ifndef _ARDUINO_RPIPICOSPI_H_
#define _ARDUINO_RPIPICOSPI_H_
#include <api/HardwareSPI.h>
#include <hardware/spi.h>
#include "Arduino_DataBus.h"
#define RPIPICOSPI_MAX_PIXELS_AT_ONCE 32
class Arduino_RPiPicoSPI : public Arduino_DataBus
{
public:
Arduino_RPiPicoSPI(int8_t dc = GFX_NOT_DEFINED, int8_t cs = GFX_NOT_DEFINED, int8_t sck = PIN_SPI0_SCK, int8_t mosi = PIN_SPI0_MOSI, int8_t miso = PIN_SPI0_MISO, spi_inst_t *spi = spi0); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void WRITEBUF(uint8_t *buf, size_t count);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs;
int8_t _sck, _mosi, _miso;
int32_t _speed;
PORTreg_t _dcPortSet; ///< PORT register for data/command SET
PORTreg_t _dcPortClr; ///< PORT register for data/command CLEAR
PORTreg_t _csPortSet; ///< PORT register for chip select SET
PORTreg_t _csPortClr; ///< PORT register for chip select CLEAR
uint32_t _dcPinMask; ///< Bitmask for data/command
uint32_t _csPinMask; ///< Bitmask for chip select
spi_inst_t *_spi;
SPISettings _spis;
BitOrder _bitOrder = MSBFIRST;
union
{
uint8_t _buffer[RPIPICOSPI_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t _buffer16[RPIPICOSPI_MAX_PIXELS_AT_ONCE];
uint32_t _buffer32[RPIPICOSPI_MAX_PIXELS_AT_ONCE / 2];
};
};
#endif // _ARDUINO_RPIPICOSPI_H_
#endif // #if defined(TARGET_RP2040)
@@ -0,0 +1,343 @@
#ifdef RTL8722DM
#include "Arduino_DataBus.h"
#include "Arduino_RTLPAR8.h"
Arduino_RTLPAR8::Arduino_RTLPAR8(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd),
_d0(d0), _d1(d1), _d2(d2), _d3(d3), _d4(d4), _d5(d5), _d6(d6), _d7(d7)
{
}
bool Arduino_RTLPAR8::begin(int32_t, int8_t)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
_dcPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_dc));
_dcPinMaskSet = digitalPinToBitMask(_dc);
_dcPinMaskClr = ~_dcPinMaskSet;
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // disable chip select
_csPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_cs));
_csPinMaskSet = digitalPinToBitMask(_cs);
}
_csPinMaskClr = ~_csPinMaskSet;
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
_wrPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_wr));
_wrPinMaskSet = digitalPinToBitMask(_wr);
_wrPinMaskClr = ~_wrPinMaskSet;
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH);
_rdPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_rd));
_rdPinMaskSet = digitalPinToBitMask(_rd);
}
else
{
_rdPort = _dcPort;
_rdPinMaskSet = 0;
}
_rdPinMaskClr = ~_rdPinMaskSet;
// TODO: check pin in same port
pinMode(_d0, OUTPUT);
digitalWrite(_d0, HIGH);
pinMode(_d1, OUTPUT);
digitalWrite(_d1, HIGH);
pinMode(_d2, OUTPUT);
digitalWrite(_d2, HIGH);
pinMode(_d3, OUTPUT);
digitalWrite(_d3, HIGH);
pinMode(_d4, OUTPUT);
digitalWrite(_d4, HIGH);
pinMode(_d5, OUTPUT);
digitalWrite(_d5, HIGH);
pinMode(_d6, OUTPUT);
digitalWrite(_d6, HIGH);
pinMode(_d7, OUTPUT);
digitalWrite(_d7, HIGH);
// INIT 8-bit mask
_dataPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_d0));
for (int32_t c = 0; c < 256; c++)
{
_xset_mask[c] = 0;
if (c & 0x01)
{
_xset_mask[c] |= digitalPinToBitMask(_d0);
}
if (c & 0x02)
{
_xset_mask[c] |= digitalPinToBitMask(_d1);
}
if (c & 0x04)
{
_xset_mask[c] |= digitalPinToBitMask(_d2);
}
if (c & 0x08)
{
_xset_mask[c] |= digitalPinToBitMask(_d3);
}
if (c & 0x10)
{
_xset_mask[c] |= digitalPinToBitMask(_d4);
}
if (c & 0x20)
{
_xset_mask[c] |= digitalPinToBitMask(_d5);
}
if (c & 0x40)
{
_xset_mask[c] |= digitalPinToBitMask(_d6);
}
if (c & 0x80)
{
_xset_mask[c] |= digitalPinToBitMask(_d7);
}
}
_dataPinMaskClr = ~_xset_mask[255];
return true;
}
void Arduino_RTLPAR8::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_RTLPAR8::endWrite()
{
CS_HIGH();
}
void Arduino_RTLPAR8::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_RTLPAR8::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_RTLPAR8::write(uint8_t d)
{
WRITE(d);
}
void Arduino_RTLPAR8::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_RTLPAR8::writeRepeat(uint16_t p, uint32_t len)
{
uint32_t dataMaskBase = *_dataPort & _dataPinMaskClr;
uint32_t wrMaskBase = *_wrPort & _wrPinMaskClr;
uint32_t wrMaskSet = wrMaskBase | _wrPinMaskSet;
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
*_dataPort = dataMaskBase | _xset_mask[_data16.msb];
while (len--)
{
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
else
{
uint32_t hiMask = _xset_mask[_data16.msb];
uint32_t loMask = _xset_mask[_data16.lsb];
while (len--)
{
*_dataPort = dataMaskBase | hiMask;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_dataPort = dataMaskBase | loMask;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
}
void Arduino_RTLPAR8::writePixels(uint16_t *data, uint32_t len)
{
uint32_t dataMaskBase = *_dataPort & _dataPinMaskClr;
uint32_t wrMaskBase = *_wrPort & _wrPinMaskClr;
uint32_t wrMaskSet = wrMaskBase | _wrPinMaskSet;
while (len--)
{
_data16.value = *(data++);
uint32_t hiMask = _xset_mask[_data16.msb];
uint32_t loMask = _xset_mask[_data16.lsb];
*_dataPort = dataMaskBase | hiMask;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_dataPort = dataMaskBase | loMask;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
void Arduino_RTLPAR8::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_RTLPAR8::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_RTLPAR8::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_RTLPAR8::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_RTLPAR8::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
uint32_t dataMaskBase = *_dataPort & _dataPinMaskClr;
uint32_t wrMaskBase = *_wrPort & _wrPinMaskClr;
uint32_t wrMaskSet = wrMaskBase | _wrPinMaskSet;
while (len--)
{
_data16.value = idx[*data++];
*_dataPort = dataMaskBase | _xset_mask[_data16.msb];
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_dataPort = dataMaskBase | _xset_mask[_data16.lsb];
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
void Arduino_RTLPAR8::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
uint32_t dataMaskBase = *_dataPort & _dataPinMaskClr;
uint32_t wrMaskBase = *_wrPort & _wrPinMaskClr;
uint32_t wrMaskSet = wrMaskBase | _wrPinMaskSet;
while (len--)
{
_data16.value = idx[*data++];
uint32_t hiMask = _xset_mask[_data16.msb];
uint32_t loMask = _xset_mask[_data16.lsb];
*_dataPort = dataMaskBase | hiMask;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_dataPort = dataMaskBase | loMask;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_dataPort = dataMaskBase | hiMask;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
*_dataPort = dataMaskBase | loMask;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
INLINE void Arduino_RTLPAR8::WRITE(uint8_t d)
{
uint32_t dataMaskBase = *_dataPort & _dataPinMaskClr;
uint32_t wrMaskBase = *_wrPort & _wrPinMaskClr;
*_dataPort = dataMaskBase | _xset_mask[d];
*_wrPort = wrMaskBase;
*_wrPort = wrMaskBase | _wrPinMaskSet;
}
/******** low level bit twiddling **********/
INLINE void Arduino_RTLPAR8::DC_HIGH(void)
{
*_dcPort |= _dcPinMaskSet;
}
INLINE void Arduino_RTLPAR8::DC_LOW(void)
{
*_dcPort &= _dcPinMaskClr;
}
INLINE void Arduino_RTLPAR8::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPort |= _csPinMaskSet;
}
}
INLINE void Arduino_RTLPAR8::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPort &= _csPinMaskClr;
}
}
#endif // #ifdef RTL8722DM
@@ -0,0 +1,69 @@
#ifdef RTL8722DM
#ifndef _ARDUINO_RTLPAR8_H_
#define _ARDUINO_RTLPAR8_H_
#include "Arduino_DataBus.h"
class Arduino_RTLPAR8 : public Arduino_DataBus
{
public:
Arduino_RTLPAR8(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
PORTreg_t _dcPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _dcPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _dcPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _csPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _csPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _csPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _wrPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _wrPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _wrPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _rdPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _rdPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _rdPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
PORTreg_t _dataPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _dataPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
// Lookup table for ESP32 parallel bus interface uses 1kbyte RAM,
uint32_t _xset_mask[256];
};
#endif // _ARDUINO_RTLPAR8_H_
#endif // #ifdef RTL8722DM
@@ -0,0 +1,245 @@
#ifdef ARDUINO_ARCH_STM32
#include "Arduino_STM32PAR8.h"
Arduino_STM32PAR8::Arduino_STM32PAR8(int8_t dc, int8_t cs, int8_t wr, int8_t rd, GPIO_TypeDef *port)
: _dc(dc), _cs(cs), _wr(wr), _rd(rd), _port(port)
{
}
bool Arduino_STM32PAR8::begin(int32_t, int8_t)
{
set_GPIO_Port_Clock(STM_PORT(_port)); // Enable data port
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
_dcPORT = digitalPinToPort(_dc);
_dcPinMaskSet = digitalPinToBitMask(_dc);
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // Disable chip select
_csPinMaskSet = digitalPinToBitMask(_cs);
_csPORT = digitalPinToPort(_cs);
}
pinMode(_wr, OUTPUT);
digitalWrite(_wr, HIGH); // Set write strobe high (inactive)
_wrPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_wr));
_wrPORT = digitalPinToPort(_wr);
_wrPinMaskSet = digitalPinToBitMask(_wr);
_wrPinMaskClr = ~_wrPinMaskSet;
if (_rd != GFX_NOT_DEFINED)
{
pinMode(_rd, OUTPUT);
digitalWrite(_rd, HIGH); // Disable RD
_rdPinMaskSet = digitalPinToBitMask(_rd);
}
else
{
_rdPinMaskSet = 0;
}
*(portModeRegister(_port)) = 0x33333333; // Set data port to output at max speed
_port->BSRR = 0xFF << 16; // Clear data port
return true;
}
void Arduino_STM32PAR8::beginWrite()
{
DC_HIGH();
CS_LOW();
}
void Arduino_STM32PAR8::endWrite()
{
CS_HIGH();
}
void Arduino_STM32PAR8::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_STM32PAR8::writeCommand16(uint16_t c)
{
DC_LOW();
_data16.value = c;
WRITE(_data16.msb);
WRITE(_data16.lsb);
DC_HIGH();
}
void Arduino_STM32PAR8::write(uint8_t d)
{
WRITE(d);
}
void Arduino_STM32PAR8::write16(uint16_t d)
{
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_STM32PAR8::writeRepeat(uint16_t p, uint32_t len)
{
uint8_t wrMaskBase = *_wrPort & _wrPinMaskClr;
uint8_t wrMaskSet = wrMaskBase | _wrPinMaskSet;
uint32_t wrMASKCLR = _wrPinMaskSet << 16;
_data16.value = p;
if (_data16.msb == _data16.lsb)
{
_port->BSRR = 0xFF << 16;
_port->BSRR = (_data16.msb) & 0xFF;
while (len--)
{
*_wrPort = wrMaskBase; // For some reason in this case it's faster then BSRR
*_wrPort = wrMaskSet;
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
else
{
while (len--)
{
_port->BSRR = 0xFF << 16;
_port->BSRR = (_data16.msb);
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
_port->BSRR = 0xFF << 16;
_port->BSRR = (_data16.lsb);
*_wrPort = wrMaskBase;
*_wrPort = wrMaskSet;
}
}
}
void Arduino_STM32PAR8::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
_data16.value = *data++;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_STM32PAR8::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_STM32PAR8::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_STM32PAR8::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
WRITE(c);
DC_HIGH();
_data16.value = d1;
WRITE(_data16.msb);
WRITE(_data16.lsb);
_data16.value = d2;
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
void Arduino_STM32PAR8::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
void Arduino_STM32PAR8::writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
void Arduino_STM32PAR8::writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len)
{
while (len--)
{
_data16.value = idx[*data++];
WRITE(_data16.msb);
WRITE(_data16.lsb);
WRITE(_data16.msb);
WRITE(_data16.lsb);
}
}
INLINE void Arduino_STM32PAR8::WRITE(uint8_t d)
{
_port->BSRR = 0xFF << 16;
_port->BSRR = (d)&0xFF;
_wrPORT->BSRR = _wrPinMaskSet << 16; // Set WR LOW
_wrPORT->BSRR = _wrPinMaskSet; // Set WR HIGH
}
/******** low level bit twiddling **********/
INLINE void Arduino_STM32PAR8::DC_HIGH(void)
{
_dcPORT->BSRR = _dcPinMaskSet;
}
INLINE void Arduino_STM32PAR8::DC_LOW(void)
{
_dcPORT->BSRR = _dcPinMaskSet << 16;
}
INLINE void Arduino_STM32PAR8::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
_csPORT->BSRR = _csPinMaskSet;
}
}
INLINE void Arduino_STM32PAR8::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
_csPORT->BSRR = _csPinMaskSet << 16;
}
}
#endif // #ifdef ARDUINO_ARCH_STM32
@@ -0,0 +1,56 @@
#ifdef ARDUINO_ARCH_STM32
#ifndef _ARDUINO_STM32PAR8_H_
#define _ARDUINO_STM32PAR8_H_
#include "Arduino_DataBus.h"
class Arduino_STM32PAR8 : public Arduino_DataBus
{
public:
Arduino_STM32PAR8(int8_t dc, int8_t cs, int8_t wr, int8_t rd, GPIO_TypeDef* port); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs, _wr, _rd;
GPIO_TypeDef* _port;
GPIO_TypeDef* _dcPORT;
GPIO_TypeDef* _csPORT;
GPIO_TypeDef* _wrPORT;
GPIO_TypeDef* _rdPORT;
ARDUINOGFX_PORT_t _dcPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _csPinMaskSet; ///< Bitmask for data/command SET (OR)
PORTreg_t _wrPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _wrPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _wrPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
ARDUINOGFX_PORT_t _rdPinMaskSet; ///< Bitmask for data/command SET (OR)
};
#endif // _ARDUINO_STM32PAR8_H_
#endif // #ifdef ARDUINO_ARCH_STM32
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,222 @@
#ifndef _ARDUINO_SWPAR16_H_
#define _ARDUINO_SWPAR16_H_
#include "Arduino_DataBus.h"
class Arduino_SWPAR16 : public Arduino_DataBus
{
public:
Arduino_SWPAR16(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7,
int8_t d8, int8_t d9, int8_t d10, int8_t d11, int8_t d12, int8_t d13, int8_t d14, int8_t d15); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
#if !defined(LITTLE_FOOT_PRINT)
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeC8D16D16Split(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
#endif // !defined(LITTLE_FOOT_PRINT)
protected:
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void WRITEREPEAT(uint16_t p, uint32_t len);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
INLINE void WR_HIGH(void);
INLINE void WR_LOW(void);
INLINE void RD_HIGH(void);
INLINE void RD_LOW(void);
INLINE void D0_HIGH(void);
INLINE void D0_LOW(void);
INLINE void D1_HIGH(void);
INLINE void D1_LOW(void);
INLINE void D2_HIGH(void);
INLINE void D2_LOW(void);
INLINE void D3_HIGH(void);
INLINE void D3_LOW(void);
INLINE void D4_HIGH(void);
INLINE void D4_LOW(void);
INLINE void D5_HIGH(void);
INLINE void D5_LOW(void);
INLINE void D6_HIGH(void);
INLINE void D6_LOW(void);
INLINE void D7_HIGH(void);
INLINE void D7_LOW(void);
INLINE void D8_HIGH(void);
INLINE void D8_LOW(void);
INLINE void D9_HIGH(void);
INLINE void D9_LOW(void);
INLINE void D10_HIGH(void);
INLINE void D10_LOW(void);
INLINE void D11_HIGH(void);
INLINE void D11_LOW(void);
INLINE void D12_HIGH(void);
INLINE void D12_LOW(void);
INLINE void D13_HIGH(void);
INLINE void D13_LOW(void);
INLINE void D14_HIGH(void);
INLINE void D14_LOW(void);
INLINE void D15_HIGH(void);
INLINE void D15_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
int8_t _d8, _d9, _d10, _d11, _d12, _d13, _d14, _d15;
// CLASS INSTANCE VARIABLES --------------------------------------------
// Here be dragons! There's a big union of three structures here --
// one each for hardware SPI, software (bitbang) SPI, and parallel
// interfaces. This is to save some memory, since a display's connection
// will be only one of these. The order of some things is a little weird
// in an attempt to get values to align and pack better in RAM.
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
PORTreg_t _dcPortSet;
PORTreg_t _dcPortClr;
PORTreg_t _csPortSet;
PORTreg_t _csPortClr;
PORTreg_t _wrPortSet;
PORTreg_t _wrPortClr;
PORTreg_t _rdPortSet;
PORTreg_t _rdPortClr;
PORTreg_t _d0PortSet;
PORTreg_t _d0PortClr;
PORTreg_t _d1PortSet;
PORTreg_t _d1PortClr;
PORTreg_t _d2PortSet;
PORTreg_t _d2PortClr;
PORTreg_t _d3PortSet;
PORTreg_t _d3PortClr;
PORTreg_t _d4PortSet;
PORTreg_t _d4PortClr;
PORTreg_t _d5PortSet;
PORTreg_t _d5PortClr;
PORTreg_t _d6PortSet;
PORTreg_t _d6PortClr;
PORTreg_t _d7PortSet;
PORTreg_t _d7PortClr;
PORTreg_t _d8PortSet;
PORTreg_t _d8PortClr;
PORTreg_t _d9PortSet;
PORTreg_t _d9PortClr;
PORTreg_t _d10PortSet;
PORTreg_t _d10PortClr;
PORTreg_t _d11PortSet;
PORTreg_t _d11PortClr;
PORTreg_t _d12PortSet;
PORTreg_t _d12PortClr;
PORTreg_t _d13PortSet;
PORTreg_t _d13PortClr;
PORTreg_t _d14PortSet;
PORTreg_t _d14PortClr;
PORTreg_t _d15PortSet;
PORTreg_t _d15PortClr;
#if !defined(KINETISK)
ARDUINOGFX_PORT_t _dcPinMask;
ARDUINOGFX_PORT_t _csPinMask;
ARDUINOGFX_PORT_t _wrPinMask;
ARDUINOGFX_PORT_t _rdPinMask;
ARDUINOGFX_PORT_t _d0PinMask;
ARDUINOGFX_PORT_t _d1PinMask;
ARDUINOGFX_PORT_t _d2PinMask;
ARDUINOGFX_PORT_t _d3PinMask;
ARDUINOGFX_PORT_t _d4PinMask;
ARDUINOGFX_PORT_t _d5PinMask;
ARDUINOGFX_PORT_t _d6PinMask;
ARDUINOGFX_PORT_t _d7PinMask;
ARDUINOGFX_PORT_t _d8PinMask;
ARDUINOGFX_PORT_t _d9PinMask;
ARDUINOGFX_PORT_t _d10PinMask;
ARDUINOGFX_PORT_t _d11PinMask;
ARDUINOGFX_PORT_t _d12PinMask;
ARDUINOGFX_PORT_t _d13PinMask;
ARDUINOGFX_PORT_t _d14PinMask;
ARDUINOGFX_PORT_t _d15PinMask;
#endif // !KINETISK
#else // !HAS_PORT_SET_CLR
PORTreg_t _dcPort;
PORTreg_t _csPort;
PORTreg_t _wrPort;
PORTreg_t _rdPort;
PORTreg_t _d0Port;
PORTreg_t _d1Port;
PORTreg_t _d2Port;
PORTreg_t _d3Port;
PORTreg_t _d4Port;
PORTreg_t _d5Port;
PORTreg_t _d6Port;
PORTreg_t _d7Port;
PORTreg_t _d8Port;
PORTreg_t _d9Port;
PORTreg_t _d10Port;
PORTreg_t _d11Port;
PORTreg_t _d12Port;
PORTreg_t _d13Port;
PORTreg_t _d14Port;
PORTreg_t _d15Port;
ARDUINOGFX_PORT_t _dcPinMaskSet;
ARDUINOGFX_PORT_t _dcPinMaskClr;
ARDUINOGFX_PORT_t _csPinMaskSet;
ARDUINOGFX_PORT_t _csPinMaskClr;
ARDUINOGFX_PORT_t _wrPinMaskSet;
ARDUINOGFX_PORT_t _wrPinMaskClr;
ARDUINOGFX_PORT_t _rdPinMaskSet;
ARDUINOGFX_PORT_t _rdPinMaskClr;
ARDUINOGFX_PORT_t _d0PinMaskSet;
ARDUINOGFX_PORT_t _d0PinMaskClr;
ARDUINOGFX_PORT_t _d1PinMaskSet;
ARDUINOGFX_PORT_t _d1PinMaskClr;
ARDUINOGFX_PORT_t _d2PinMaskSet;
ARDUINOGFX_PORT_t _d2PinMaskClr;
ARDUINOGFX_PORT_t _d3PinMaskSet;
ARDUINOGFX_PORT_t _d3PinMaskClr;
ARDUINOGFX_PORT_t _d4PinMaskSet;
ARDUINOGFX_PORT_t _d4PinMaskClr;
ARDUINOGFX_PORT_t _d5PinMaskSet;
ARDUINOGFX_PORT_t _d5PinMaskClr;
ARDUINOGFX_PORT_t _d6PinMaskSet;
ARDUINOGFX_PORT_t _d6PinMaskClr;
ARDUINOGFX_PORT_t _d7PinMaskSet;
ARDUINOGFX_PORT_t _d7PinMaskClr;
ARDUINOGFX_PORT_t _d8PinMaskSet;
ARDUINOGFX_PORT_t _d8PinMaskClr;
ARDUINOGFX_PORT_t _d9PinMaskSet;
ARDUINOGFX_PORT_t _d9PinMaskClr;
ARDUINOGFX_PORT_t _d10PinMaskSet;
ARDUINOGFX_PORT_t _d10PinMaskClr;
ARDUINOGFX_PORT_t _d11PinMaskSet;
ARDUINOGFX_PORT_t _d11PinMaskClr;
ARDUINOGFX_PORT_t _d12PinMaskSet;
ARDUINOGFX_PORT_t _d12PinMaskClr;
ARDUINOGFX_PORT_t _d13PinMaskSet;
ARDUINOGFX_PORT_t _d13PinMaskClr;
ARDUINOGFX_PORT_t _d14PinMaskSet;
ARDUINOGFX_PORT_t _d14PinMaskClr;
ARDUINOGFX_PORT_t _d15PinMaskSet;
ARDUINOGFX_PORT_t _d15PinMaskClr;
#endif // HAS_PORT_SET_CLR
#endif // defined(USE_FAST_PINIO)
};
#endif // _ARDUINO_SWPAR16_H_
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,153 @@
#ifndef _ARDUINO_SWPAR8_H_
#define _ARDUINO_SWPAR8_H_
#include "Arduino_DataBus.h"
class Arduino_SWPAR8 : public Arduino_DataBus
{
public:
Arduino_SWPAR8(
int8_t dc, int8_t cs, int8_t wr, int8_t rd,
int8_t d0, int8_t d1, int8_t d2, int8_t d3, int8_t d4, int8_t d5, int8_t d6, int8_t d7); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
#if !defined(LITTLE_FOOT_PRINT)
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
void writeIndexedPixels(uint8_t *data, uint16_t *idx, uint32_t len) override;
void writeIndexedPixelsDouble(uint8_t *data, uint16_t *idx, uint32_t len) override;
#endif // !defined(LITTLE_FOOT_PRINT)
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITEREPEAT(uint16_t p, uint32_t len);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
INLINE void WR_HIGH(void);
INLINE void WR_LOW(void);
INLINE void RD_HIGH(void);
INLINE void RD_LOW(void);
INLINE void D0_HIGH(void);
INLINE void D0_LOW(void);
INLINE void D1_HIGH(void);
INLINE void D1_LOW(void);
INLINE void D2_HIGH(void);
INLINE void D2_LOW(void);
INLINE void D3_HIGH(void);
INLINE void D3_LOW(void);
INLINE void D4_HIGH(void);
INLINE void D4_LOW(void);
INLINE void D5_HIGH(void);
INLINE void D5_LOW(void);
INLINE void D6_HIGH(void);
INLINE void D6_LOW(void);
INLINE void D7_HIGH(void);
INLINE void D7_LOW(void);
int8_t _dc, _cs, _wr, _rd;
int8_t _d0, _d1, _d2, _d3, _d4, _d5, _d6, _d7;
// CLASS INSTANCE VARIABLES --------------------------------------------
// Here be dragons! There's a big union of three structures here --
// one each for hardware SPI, software (bitbang) SPI, and parallel
// interfaces. This is to save some memory, since a display's connection
// will be only one of these. The order of some things is a little weird
// in an attempt to get values to align and pack better in RAM.
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
PORTreg_t _dcPortSet;
PORTreg_t _dcPortClr;
PORTreg_t _csPortSet;
PORTreg_t _csPortClr;
PORTreg_t _wrPortSet;
PORTreg_t _wrPortClr;
PORTreg_t _rdPortSet;
PORTreg_t _rdPortClr;
PORTreg_t _d0PortSet;
PORTreg_t _d0PortClr;
PORTreg_t _d1PortSet;
PORTreg_t _d1PortClr;
PORTreg_t _d2PortSet;
PORTreg_t _d2PortClr;
PORTreg_t _d3PortSet;
PORTreg_t _d3PortClr;
PORTreg_t _d4PortSet;
PORTreg_t _d4PortClr;
PORTreg_t _d5PortSet;
PORTreg_t _d5PortClr;
PORTreg_t _d6PortSet;
PORTreg_t _d6PortClr;
PORTreg_t _d7PortSet;
PORTreg_t _d7PortClr;
#if !defined(KINETISK)
ARDUINOGFX_PORT_t _dcPinMask;
ARDUINOGFX_PORT_t _csPinMask;
ARDUINOGFX_PORT_t _wrPinMask;
ARDUINOGFX_PORT_t _rdPinMask;
ARDUINOGFX_PORT_t _d0PinMask;
ARDUINOGFX_PORT_t _d1PinMask;
ARDUINOGFX_PORT_t _d2PinMask;
ARDUINOGFX_PORT_t _d3PinMask;
ARDUINOGFX_PORT_t _d4PinMask;
ARDUINOGFX_PORT_t _d5PinMask;
ARDUINOGFX_PORT_t _d6PinMask;
ARDUINOGFX_PORT_t _d7PinMask;
#endif // !KINETISK
#else // !HAS_PORT_SET_CLR
PORTreg_t _dcPort;
PORTreg_t _csPort;
PORTreg_t _wrPort;
PORTreg_t _rdPort;
PORTreg_t _d0Port;
PORTreg_t _d1Port;
PORTreg_t _d2Port;
PORTreg_t _d3Port;
PORTreg_t _d4Port;
PORTreg_t _d5Port;
PORTreg_t _d6Port;
PORTreg_t _d7Port;
ARDUINOGFX_PORT_t _dcPinMaskSet;
ARDUINOGFX_PORT_t _dcPinMaskClr;
ARDUINOGFX_PORT_t _csPinMaskSet;
ARDUINOGFX_PORT_t _csPinMaskClr;
ARDUINOGFX_PORT_t _wrPinMaskSet;
ARDUINOGFX_PORT_t _wrPinMaskClr;
ARDUINOGFX_PORT_t _rdPinMaskSet;
ARDUINOGFX_PORT_t _rdPinMaskClr;
ARDUINOGFX_PORT_t _d0PinMaskSet;
ARDUINOGFX_PORT_t _d0PinMaskClr;
ARDUINOGFX_PORT_t _d1PinMaskSet;
ARDUINOGFX_PORT_t _d1PinMaskClr;
ARDUINOGFX_PORT_t _d2PinMaskSet;
ARDUINOGFX_PORT_t _d2PinMaskClr;
ARDUINOGFX_PORT_t _d3PinMaskSet;
ARDUINOGFX_PORT_t _d3PinMaskClr;
ARDUINOGFX_PORT_t _d4PinMaskSet;
ARDUINOGFX_PORT_t _d4PinMaskClr;
ARDUINOGFX_PORT_t _d5PinMaskSet;
ARDUINOGFX_PORT_t _d5PinMaskClr;
ARDUINOGFX_PORT_t _d6PinMaskSet;
ARDUINOGFX_PORT_t _d6PinMaskClr;
ARDUINOGFX_PORT_t _d7PinMaskSet;
ARDUINOGFX_PORT_t _d7PinMaskClr;
#endif // HAS_PORT_SET_CLR
#endif // defined(USE_FAST_PINIO)
};
#endif // _ARDUINO_SWPAR8_H_
@@ -0,0 +1,693 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#include "Arduino_SWSPI.h"
Arduino_SWSPI::Arduino_SWSPI(int8_t dc, int8_t cs, int8_t sck, int8_t mosi, int8_t miso /* = GFX_NOT_DEFINED */)
: _dc(dc), _cs(cs), _sck(sck), _mosi(mosi), _miso(miso)
{
}
bool Arduino_SWSPI::begin(int32_t, int8_t)
{
if (_dc != GFX_NOT_DEFINED)
{
pinMode(_dc, OUTPUT);
digitalWrite(_dc, HIGH); // Data mode
}
if (_cs != GFX_NOT_DEFINED)
{
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH); // Deselect
}
pinMode(_sck, OUTPUT);
digitalWrite(_sck, LOW);
pinMode(_mosi, OUTPUT);
digitalWrite(_mosi, LOW);
if (_miso != GFX_NOT_DEFINED)
{
pinMode(_miso, INPUT);
}
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(ARDUINO_ARCH_NRF52840)
uint32_t pin;
NRF_GPIO_Type *reg;
if (_dc != GFX_NOT_DEFINED)
{
pin = digitalPinToPinName((pin_size_t)_dc);
reg = nrf_gpio_pin_port_decode(&pin);
_dcPinMask = 1UL << pin;
_dcPortSet = &reg->OUTSET;
_dcPortClr = &reg->OUTCLR;
}
if (_cs != GFX_NOT_DEFINED)
{
pin = digitalPinToPinName((pin_size_t)_cs);
NRF_GPIO_Type *reg = nrf_gpio_pin_port_decode(&pin);
_csPinMask = 1UL << pin;
_csPortSet = &reg->OUTSET;
_csPortClr = &reg->OUTCLR;
}
pin = digitalPinToPinName((pin_size_t)_sck);
reg = nrf_gpio_pin_port_decode(&pin);
_sckPinMask = 1UL << pin;
_sckPortSet = &reg->OUTSET;
_sckPortClr = &reg->OUTCLR;
pin = digitalPinToPinName((pin_size_t)_mosi);
reg = nrf_gpio_pin_port_decode(&pin);
_mosiPinMask = 1UL << pin;
_mosiPortSet = &reg->OUTSET;
_mosiPortClr = &reg->OUTCLR;
if (_miso != GFX_NOT_DEFINED)
{
pin = digitalPinToPinName((pin_size_t)_miso);
reg = nrf_gpio_pin_port_decode(&pin);
_misoPinMask = 1UL << pin;
_misoPort = &reg->IN;
}
#elif defined(TARGET_RP2040)
if (_dc != GFX_NOT_DEFINED)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&sio_hw->gpio_set;
_dcPortClr = (PORTreg_t)&sio_hw->gpio_clr;
}
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&sio_hw->gpio_set;
_csPortClr = (PORTreg_t)&sio_hw->gpio_clr;
}
_sckPinMask = digitalPinToBitMask(_sck);
_sckPortSet = (PORTreg_t)&sio_hw->gpio_set;
_sckPortClr = (PORTreg_t)&sio_hw->gpio_clr;
_mosiPinMask = digitalPinToBitMask(_mosi);
_mosiPortSet = (PORTreg_t)&sio_hw->gpio_set;
_mosiPortClr = (PORTreg_t)&sio_hw->gpio_clr;
if (_miso != GFX_NOT_DEFINED)
{
_misoPinMask = digitalPinToBitMask(_miso);
_misoPort = (PORTreg_t)portInputRegister(digitalPinToPort(_miso));
}
#elif defined(ESP32) && (CONFIG_IDF_TARGET_ESP32C3)
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
_sckPinMask = digitalPinToBitMask(_sck);
_sckPortSet = (PORTreg_t)&GPIO.out_w1ts;
_sckPortClr = (PORTreg_t)&GPIO.out_w1tc;
_mosiPinMask = digitalPinToBitMask(_mosi);
_mosiPortSet = (PORTreg_t)&GPIO.out_w1ts;
_mosiPortClr = (PORTreg_t)&GPIO.out_w1tc;
if (_miso != GFX_NOT_DEFINED)
{
_misoPinMask = digitalPinToBitMask(_miso);
_misoPort = (PORTreg_t)GPIO_IN_REG;
}
#elif defined(ESP32)
_dcPinMask = digitalPinToBitMask(_dc);
if (_dc >= 32)
{
_dcPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_dcPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_dc != GFX_NOT_DEFINED)
{
_dcPortSet = (PORTreg_t)&GPIO.out_w1ts;
_dcPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_cs >= 32)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_csPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = (PORTreg_t)&GPIO.out_w1ts;
_csPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
_sckPinMask = digitalPinToBitMask(_sck);
_mosiPinMask = digitalPinToBitMask(_mosi);
if (_sck >= 32)
{
_sckPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_sckPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_sckPortSet = (PORTreg_t)&GPIO.out_w1ts;
_sckPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_mosi >= 32)
{
_mosiPortSet = (PORTreg_t)&GPIO.out1_w1ts.val;
_mosiPortClr = (PORTreg_t)&GPIO.out1_w1tc.val;
}
else
{
_mosiPortSet = (PORTreg_t)&GPIO.out_w1ts;
_mosiPortClr = (PORTreg_t)&GPIO.out_w1tc;
}
if (_miso != GFX_NOT_DEFINED)
{
_misoPinMask = digitalPinToBitMask(_miso);
_misoPort = (PORTreg_t)portInputRegister(digitalPinToPort(_miso));
}
#elif defined(CORE_TEENSY)
if (_dc != GFX_NOT_DEFINED)
{
#if !defined(KINETISK)
_dcPinMask = digitalPinToBitMask(_dc);
#endif
_dcPortSet = portSetRegister(_dc);
_dcPortClr = portClearRegister(_dc);
}
if (_cs != GFX_NOT_DEFINED)
{
#if !defined(KINETISK)
_csPinMask = digitalPinToBitMask(_cs);
#endif
_csPortSet = portSetRegister(_cs);
_csPortClr = portClearRegister(_cs);
}
#if !defined(KINETISK)
_sckPinMask = digitalPinToBitMask(_sck);
#endif
_sckPortSet = portSetRegister(_sck);
_sckPortClr = portClearRegister(_sck);
#if !defined(KINETISK)
_mosiPinMask = digitalPinToBitMask(_mosi);
#endif
_mosiPortSet = portSetRegister(_mosi);
_mosiPortClr = portClearRegister(_mosi);
if (_miso != GFX_NOT_DEFINED)
{
#if !defined(KINETISK)
_misoPinMask = digitalPinToBitMask(_miso);
#endif
_misoPort = (PORTreg_t)portInputRegister(digitalPinToPort(_miso));
}
#else // !CORE_TEENSY
if (_dc != GFX_NOT_DEFINED)
{
_dcPinMask = digitalPinToBitMask(_dc);
_dcPortSet = &(PORT->Group[g_APinDescription[_dc].ulPort].OUTSET.reg);
_dcPortClr = &(PORT->Group[g_APinDescription[_dc].ulPort].OUTCLR.reg);
}
if (_cs != GFX_NOT_DEFINED)
{
_csPinMask = digitalPinToBitMask(_cs);
_csPortSet = &(PORT->Group[g_APinDescription[_cs].ulPort].OUTSET.reg);
_csPortClr = &(PORT->Group[g_APinDescription[_cs].ulPort].OUTCLR.reg);
}
_sckPinMask = digitalPinToBitMask(_sck);
_sckPortSet = &(PORT->Group[g_APinDescription[_sck].ulPort].OUTSET.reg);
_sckPortClr = &(PORT->Group[g_APinDescription[_sck].ulPort].OUTCLR.reg);
_mosiPinMask = digitalPinToBitMask(_mosi);
_mosiPortSet = &(PORT->Group[g_APinDescription[_mosi].ulPort].OUTSET.reg);
_mosiPortClr = &(PORT->Group[g_APinDescription[_mosi].ulPort].OUTCLR.reg);
if (_miso != GFX_NOT_DEFINED)
{
_misoPinMask = digitalPinToBitMask(_miso);
_misoPort = (PORTreg_t)portInputRegister(digitalPinToPort(_miso));
}
#endif // end !CORE_TEENSY
#else // !HAS_PORT_SET_CLR
if (_dc != GFX_NOT_DEFINED)
{
_dcPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_dc));
_dcPinMaskSet = digitalPinToBitMask(_dc);
_dcPinMaskClr = ~_dcPinMaskSet;
}
if (_cs != GFX_NOT_DEFINED)
{
_csPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_cs));
_csPinMaskSet = digitalPinToBitMask(_cs);
_csPinMaskClr = ~_csPinMaskSet;
}
_sckPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_sck));
_sckPinMaskSet = digitalPinToBitMask(_sck);
_sckPinMaskClr = ~_sckPinMaskSet;
_mosiPort = (PORTreg_t)portOutputRegister(digitalPinToPort(_mosi));
_mosiPinMaskSet = digitalPinToBitMask(_mosi);
_mosiPinMaskClr = ~_mosiPinMaskSet;
if (_miso != GFX_NOT_DEFINED)
{
_misoPort = (PORTreg_t)portInputRegister(digitalPinToPort(_miso));
_misoPinMask = digitalPinToBitMask(_miso);
}
#endif // !HAS_PORT_SET_CLR
#endif // USE_FAST_PINIO
return true;
}
void Arduino_SWSPI::beginWrite()
{
if (_dc != GFX_NOT_DEFINED)
{
DC_HIGH();
}
CS_LOW();
}
void Arduino_SWSPI::endWrite()
{
CS_HIGH();
}
void Arduino_SWSPI::writeCommand(uint8_t c)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BITCOMMAND(c);
}
else
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
}
void Arduino_SWSPI::writeCommand16(uint16_t c)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
_data16.value = c;
WRITE9BITCOMMAND(_data16.msb);
WRITE9BITCOMMAND(_data16.lsb);
}
else
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
}
void Arduino_SWSPI::write(uint8_t d)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
WRITE9BITDATA(d);
}
else
{
WRITE(d);
}
}
void Arduino_SWSPI::write16(uint16_t d)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
_data16.value = d;
WRITE9BITDATA(_data16.msb);
WRITE9BITDATA(_data16.lsb);
}
else
{
WRITE16(d);
}
}
void Arduino_SWSPI::writeRepeat(uint16_t p, uint32_t len)
{
if (_dc == GFX_NOT_DEFINED) // 9-bit SPI
{
// ESP8266 avoid trigger watchdog
#if defined(ESP8266)
while (len > (ESP8266SAFEBATCHBITSIZE / 9))
{
WRITE9BITREPEAT(p, ESP8266SAFEBATCHBITSIZE / 9);
len -= ESP8266SAFEBATCHBITSIZE / 9;
yield();
}
WRITE9BITREPEAT(p, len);
#else
WRITE9BITREPEAT(p, len);
#endif
}
else
{
#if defined(ESP8266)
while (len > (ESP8266SAFEBATCHBITSIZE / 8))
{
WRITEREPEAT(p, ESP8266SAFEBATCHBITSIZE / 8);
len -= ESP8266SAFEBATCHBITSIZE / 8;
yield();
}
WRITEREPEAT(p, len);
#else
WRITEREPEAT(p, len);
#endif
}
}
void Arduino_SWSPI::writePixels(uint16_t *data, uint32_t len)
{
while (len--)
{
WRITE16(*data++);
}
}
#if !defined(LITTLE_FOOT_PRINT)
void Arduino_SWSPI::writeBytes(uint8_t *data, uint32_t len)
{
while (len--)
{
WRITE(*data++);
}
}
#endif // !defined(LITTLE_FOOT_PRINT)
INLINE void Arduino_SWSPI::WRITE9BITCOMMAND(uint8_t c)
{
// D/C bit, command
SPI_MOSI_LOW();
SPI_SCK_HIGH();
SPI_SCK_LOW();
uint8_t bit = 0x80;
while (bit)
{
if (c & bit)
{
SPI_MOSI_HIGH();
}
else
{
SPI_MOSI_LOW();
}
SPI_SCK_HIGH();
bit >>= 1;
SPI_SCK_LOW();
}
}
INLINE void Arduino_SWSPI::WRITE9BITDATA(uint8_t d)
{
// D/C bit, data
SPI_MOSI_HIGH();
SPI_SCK_HIGH();
SPI_SCK_LOW();
uint8_t bit = 0x80;
while (bit)
{
if (d & bit)
{
SPI_MOSI_HIGH();
}
else
{
SPI_MOSI_LOW();
}
SPI_SCK_HIGH();
bit >>= 1;
SPI_SCK_LOW();
}
}
INLINE void Arduino_SWSPI::WRITE(uint8_t d)
{
uint8_t bit = 0x80;
while (bit)
{
if (d & bit)
{
SPI_MOSI_HIGH();
}
else
{
SPI_MOSI_LOW();
}
SPI_SCK_HIGH();
bit >>= 1;
SPI_SCK_LOW();
}
}
INLINE void Arduino_SWSPI::WRITE16(uint16_t d)
{
uint16_t bit = 0x8000;
while (bit)
{
if (d & bit)
{
SPI_MOSI_HIGH();
}
else
{
SPI_MOSI_LOW();
}
SPI_SCK_HIGH();
bit >>= 1;
SPI_SCK_LOW();
}
}
INLINE void Arduino_SWSPI::WRITE9BITREPEAT(uint16_t p, uint32_t len)
{
if (p == 0xffff) // no need to set MOSI level while filling white
{
SPI_MOSI_HIGH();
len *= 18; // 9-bit * 2
while (len--)
{
SPI_SCK_HIGH();
SPI_SCK_LOW();
}
}
else
{
_data16.value = p;
while (len--)
{
WRITE9BITDATA(_data16.msb);
WRITE9BITDATA(_data16.lsb);
}
}
}
INLINE void Arduino_SWSPI::WRITEREPEAT(uint16_t p, uint32_t len)
{
if ((p == 0x0000) || (p == 0xffff)) // no need to set MOSI level while filling black or white
{
if (p)
{
SPI_MOSI_HIGH();
}
else
{
SPI_MOSI_LOW();
}
len *= 16;
while (len--)
{
SPI_SCK_HIGH();
SPI_SCK_LOW();
}
}
else
{
while (len--)
{
WRITE16(p);
}
}
}
/******** low level bit twiddling **********/
INLINE void Arduino_SWSPI::DC_HIGH(void)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_dcPortSet = 1;
#else // !KINETISK
*_dcPortSet = _dcPinMask;
#endif // end !KINETISK
#else // !HAS_PORT_SET_CLR
*_dcPort |= _dcPinMaskSet;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_dc, HIGH);
#endif // end !USE_FAST_PINIO
}
INLINE void Arduino_SWSPI::DC_LOW(void)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_dcPortClr = 1;
#else // !KINETISK
*_dcPortClr = _dcPinMask;
#endif // end !KINETISK
#else // !HAS_PORT_SET_CLR
*_dcPort &= _dcPinMaskClr;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_dc, LOW);
#endif // end !USE_FAST_PINIO
}
INLINE void Arduino_SWSPI::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_csPortSet = 1;
#else // !KINETISK
*_csPortSet = _csPinMask;
#endif // end !KINETISK
#else // !HAS_PORT_SET_CLR
*_csPort |= _csPinMaskSet;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_cs, HIGH);
#endif // end !USE_FAST_PINIO
}
}
INLINE void Arduino_SWSPI::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_csPortClr = 1;
#else // !KINETISK
*_csPortClr = _csPinMask;
#endif // end !KINETISK
#else // !HAS_PORT_SET_CLR
*_csPort &= _csPinMaskClr;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_cs, LOW);
#endif // end !USE_FAST_PINIO
}
}
/*!
@brief Set the software (bitbang) SPI MOSI line HIGH.
*/
INLINE void Arduino_SWSPI::SPI_MOSI_HIGH(void)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_mosiPortSet = 1;
#else // !KINETISK
*_mosiPortSet = _mosiPinMask;
#endif
#else // !HAS_PORT_SET_CLR
*_mosiPort |= _mosiPinMaskSet;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_mosi, HIGH);
#endif // end !USE_FAST_PINIO
}
/*!
@brief Set the software (bitbang) SPI MOSI line LOW.
*/
INLINE void Arduino_SWSPI::SPI_MOSI_LOW(void)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_mosiPortClr = 1;
#else // !KINETISK
*_mosiPortClr = _mosiPinMask;
#endif
#else // !HAS_PORT_SET_CLR
*_mosiPort &= _mosiPinMaskClr;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_mosi, LOW);
#endif // end !USE_FAST_PINIO
}
/*!
@brief Set the software (bitbang) SPI SCK line HIGH.
*/
INLINE void Arduino_SWSPI::SPI_SCK_HIGH(void)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_sckPortSet = 1;
#else // !KINETISK
*_sckPortSet = _sckPinMask;
#if defined(__IMXRT1052__) || defined(__IMXRT1062__) // Teensy 4.x
for (volatile uint8_t i = 0; i < 1; i++)
;
#endif
#endif
#else // !HAS_PORT_SET_CLR
*_sckPort |= _sckPinMaskSet;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_sck, HIGH);
#endif // end !USE_FAST_PINIO
}
/*!
@brief Set the software (bitbang) SPI SCK line LOW.
*/
INLINE void Arduino_SWSPI::SPI_SCK_LOW(void)
{
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
#if defined(KINETISK)
*_sckPortClr = 1;
#else // !KINETISK
*_sckPortClr = _sckPinMask;
#if defined(__IMXRT1052__) || defined(__IMXRT1062__) // Teensy 4.x
for (volatile uint8_t i = 0; i < 1; i++)
;
#endif
#endif
#else // !HAS_PORT_SET_CLR
*_sckPort &= _sckPinMaskClr;
#endif // end !HAS_PORT_SET_CLR
#else // !USE_FAST_PINIO
digitalWrite(_sck, LOW);
#endif // end !USE_FAST_PINIO
}
/*!
@brief Read the state of the software (bitbang) SPI MISO line.
@return true if HIGH, false if LOW.
*/
INLINE bool Arduino_SWSPI::SPI_MISO_READ(void)
{
#if defined(USE_FAST_PINIO)
#if defined(KINETISK)
return *_misoPort;
#else // !KINETISK
return *_misoPort & _misoPinMask;
#endif // end !KINETISK
#else // !USE_FAST_PINIO
return digitalRead(_miso);
#endif // end !USE_FAST_PINIO
}
@@ -0,0 +1,94 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_SWSPI_H_
#define _ARDUINO_SWSPI_H_
#include "Arduino_DataBus.h"
class Arduino_SWSPI : public Arduino_DataBus
{
public:
Arduino_SWSPI(int8_t dc, int8_t cs, int8_t _sck, int8_t _mosi, int8_t _miso = GFX_NOT_DEFINED); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
#if !defined(LITTLE_FOOT_PRINT)
void writeBytes(uint8_t *data, uint32_t len) override;
#endif // !defined(LITTLE_FOOT_PRINT)
private:
INLINE void WRITE9BITCOMMAND(uint8_t c);
INLINE void WRITE9BITDATA(uint8_t d);
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void WRITE9BITREPEAT(uint16_t p, uint32_t len);
INLINE void WRITEREPEAT(uint16_t p, uint32_t len);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
INLINE void SPI_MOSI_HIGH(void);
INLINE void SPI_MOSI_LOW(void);
INLINE void SPI_SCK_HIGH(void);
INLINE void SPI_SCK_LOW(void);
INLINE bool SPI_MISO_READ(void);
int8_t _dc, _cs;
int8_t _sck, _mosi, _miso;
// CLASS INSTANCE VARIABLES --------------------------------------------
// Here be dragons! There's a big union of three structures here --
// one each for hardware SPI, software (bitbang) SPI, and parallel
// interfaces. This is to save some memory, since a display's connection
// will be only one of these. The order of some things is a little weird
// in an attempt to get values to align and pack better in RAM.
#if defined(USE_FAST_PINIO)
#if defined(HAS_PORT_SET_CLR)
PORTreg_t _csPortSet; ///< PORT register for chip select SET
PORTreg_t _csPortClr; ///< PORT register for chip select CLEAR
PORTreg_t _dcPortSet; ///< PORT register for data/command SET
PORTreg_t _dcPortClr; ///< PORT register for data/command CLEAR
PORTreg_t _mosiPortSet; ///< PORT register for MOSI SET
PORTreg_t _mosiPortClr; ///< PORT register for MOSI CLEAR
PORTreg_t _sckPortSet; ///< PORT register for SCK SET
PORTreg_t _sckPortClr; ///< PORT register for SCK CLEAR
#if !defined(KINETISK)
ARDUINOGFX_PORT_t _csPinMask; ///< Bitmask for chip select
ARDUINOGFX_PORT_t _dcPinMask; ///< Bitmask for data/command
ARDUINOGFX_PORT_t _mosiPinMask; ///< Bitmask for MOSI
ARDUINOGFX_PORT_t _sckPinMask; ///< Bitmask for SCK
#endif // !KINETISK
#else // !HAS_PORT_SET_CLR
PORTreg_t _mosiPort; ///< PORT register for MOSI
PORTreg_t _sckPort; ///< PORT register for SCK
PORTreg_t _csPort; ///< PORT register for chip select
PORTreg_t _dcPort; ///< PORT register for data/command
ARDUINOGFX_PORT_t _csPinMaskSet; ///< Bitmask for chip select SET (OR)
ARDUINOGFX_PORT_t _csPinMaskClr; ///< Bitmask for chip select CLEAR (AND)
ARDUINOGFX_PORT_t _dcPinMaskSet; ///< Bitmask for data/command SET (OR)
ARDUINOGFX_PORT_t _dcPinMaskClr; ///< Bitmask for data/command CLEAR (AND)
ARDUINOGFX_PORT_t _mosiPinMaskSet; ///< Bitmask for MOSI SET (OR)
ARDUINOGFX_PORT_t _mosiPinMaskClr; ///< Bitmask for MOSI CLEAR (AND)
ARDUINOGFX_PORT_t _sckPinMaskSet; ///< Bitmask for SCK SET (OR bitmask)
ARDUINOGFX_PORT_t _sckPinMaskClr; ///< Bitmask for SCK CLEAR (AND)
#endif // HAS_PORT_SET_CLR
PORTreg_t _misoPort; ///< PORT (PIN) register for MISO
#if !defined(KINETISK)
ARDUINOGFX_PORT_t _misoPinMask; ///< Bitmask for MISO
#endif // !KINETISK
#endif // defined(USE_FAST_PINIO)
};
#endif // _ARDUINO_SWSPI_H_
@@ -0,0 +1,252 @@
#include "Arduino_XL9535SWSPI.h"
Arduino_XL9535SWSPI::Arduino_XL9535SWSPI(int8_t sda, int8_t scl, int8_t pwd, int8_t cs, int8_t sck, int8_t mosi, TwoWire *wire)
: _sda(sda), _scl(scl), _pwd(pwd), _cs(cs), _sck(sck), _mosi(mosi), _wire(wire)
{
}
bool Arduino_XL9535SWSPI::begin(int32_t, int8_t)
{
_address = XL9535_IIC_ADDRESS;
_wire->beginTransmission(_address);
if (!_wire->endTransmission())
{
Serial.println("Found xl9535");
is_found = true;
this->pinMode8(0, 0xFF, OUTPUT);
if (_pwd != GFX_NOT_DEFINED)
{
// this->pinMode(_pwd, OUTPUT);
this->digitalWrite(_pwd, 1);
}
// this->pinMode(_cs, OUTPUT);
this->digitalWrite(_cs, 1);
// this->pinMode(_sck, OUTPUT);
this->digitalWrite(_sck, 1);
// this->pinMode(_mosi, OUTPUT);
this->digitalWrite(_mosi, 1);
}
else
{
Serial.println("xl9535 not found");
is_found = false;
}
return true;
}
void Arduino_XL9535SWSPI::beginWrite()
{
this->digitalWrite(_cs, 0);
}
void Arduino_XL9535SWSPI::endWrite()
{
this->digitalWrite(_cs, 1);
}
void Arduino_XL9535SWSPI::writeCommand(uint8_t c)
{
// D/C bit, command
this->digitalWrite(_mosi, 0);
this->digitalWrite(_sck, 0);
this->digitalWrite(_sck, 1);
uint8_t bit = 0x80;
while (bit)
{
if (c & bit)
{
this->digitalWrite(_mosi, 1);
}
else
{
this->digitalWrite(_mosi, 0);
}
this->digitalWrite(_sck, 0);
bit >>= 1;
this->digitalWrite(_sck, 1);
}
}
void Arduino_XL9535SWSPI::writeCommand16(uint16_t)
{
}
void Arduino_XL9535SWSPI::write(uint8_t d)
{
// D/C bit, data
this->digitalWrite(_mosi, 1);
this->digitalWrite(_sck, 0);
this->digitalWrite(_sck, 1);
uint8_t bit = 0x80;
while (bit)
{
if (d & bit)
{
this->digitalWrite(_mosi, 1);
}
else
{
this->digitalWrite(_mosi, 0);
}
this->digitalWrite(_sck, 0);
bit >>= 1;
this->digitalWrite(_sck, 1);
}
}
void Arduino_XL9535SWSPI::write16(uint16_t)
{
// not implemented
}
void Arduino_XL9535SWSPI::writeRepeat(uint16_t, uint32_t)
{
// not implemented
}
void Arduino_XL9535SWSPI::writePixels(uint16_t *, uint32_t)
{
// not implemented
}
#if !defined(LITTLE_FOOT_PRINT)
void Arduino_XL9535SWSPI::writeBytes(uint8_t *data, uint32_t len)
{
// not implemented
}
#endif // !defined(LITTLE_FOOT_PRINT)
void Arduino_XL9535SWSPI::writeRegister(uint8_t reg, uint8_t *data, size_t len)
{
_wire->beginTransmission(_address);
_wire->write(reg);
for (size_t i = 0; i < len; i++)
{
_wire->write(data[i]);
}
_wire->endTransmission();
}
uint8_t Arduino_XL9535SWSPI::readRegister(uint8_t reg, uint8_t *data, size_t len)
{
_wire->beginTransmission(_address);
_wire->write(reg);
_wire->endTransmission();
_wire->requestFrom(_address, len);
size_t index = 0;
while (index < len)
data[index++] = _wire->read();
return 0;
}
void Arduino_XL9535SWSPI::pinMode(uint8_t pin, uint8_t mode)
{
if (is_found)
{
uint8_t port = 0;
if (pin > 7)
{
this->readRegister(XL9535_CONFIG_PORT_1_REG, &port, 1);
if (mode == OUTPUT)
{
port = port & (~(1 << (pin - 10)));
}
else
{
port = port | (1 << (pin - 10));
}
this->writeRegister(XL9535_CONFIG_PORT_1_REG, &port, 1);
}
else
{
this->readRegister(XL9535_CONFIG_PORT_0_REG, &port, 1);
if (mode == OUTPUT)
{
port = port & (~(1 << pin));
}
else
{
port = port | (1 << pin);
}
this->writeRegister(XL9535_CONFIG_PORT_0_REG, &port, 1);
}
}
else
{
Serial.println("xl9535 not found");
}
}
void Arduino_XL9535SWSPI::pinMode8(uint8_t port, uint8_t pin, uint8_t mode)
{
if (is_found)
{
uint8_t _pin = (mode != OUTPUT) ? pin : ~pin;
if (port)
{
this->writeRegister(XL9535_CONFIG_PORT_1_REG, &_pin, 1);
}
else
{
this->writeRegister(XL9535_CONFIG_PORT_0_REG, &_pin, 1);
}
}
else
{
Serial.println("xl9535 not found");
}
}
void Arduino_XL9535SWSPI::digitalWrite(uint8_t pin, uint8_t val)
{
if (is_found)
{
uint8_t port = 0;
uint8_t reg_data = 0;
if (pin > 7)
{
this->readRegister(XL9535_OUTPUT_PORT_1_REG, &reg_data, 1);
reg_data = reg_data & (~(1 << (pin - 10)));
port = reg_data | val << (pin - 10);
this->writeRegister(XL9535_OUTPUT_PORT_1_REG, &port, 1);
}
else
{
this->readRegister(XL9535_OUTPUT_PORT_0_REG, &reg_data, 1);
reg_data = reg_data & (~(1 << pin));
port = reg_data | val << pin;
this->writeRegister(XL9535_OUTPUT_PORT_0_REG, &port, 1);
}
}
else
{
Serial.println("xl9535 not found");
}
}
int Arduino_XL9535SWSPI::digitalRead(uint8_t pin)
{
if (is_found)
{
int state = 0;
uint8_t port = 0;
if (pin > 7)
{
this->readRegister(XL9535_INPUT_PORT_1_REG, &port, 1);
state = port & (pin - 10) ? 1 : 0;
}
else
{
this->readRegister(XL9535_INPUT_PORT_0_REG, &port, 1);
state = port & pin ? 1 : 0;
}
return state;
}
else
{
Serial.println("xl9535 not found");
}
return 0;
}
@@ -0,0 +1,57 @@
#ifndef _ARDUINO_XL9535SWSPI_H_
#define _ARDUINO_XL9535SWSPI_H_
#include <Wire.h>
#include "Arduino_DataBus.h"
#define XL9535_IIC_ADDRESS 0X20
#define XL9535_INPUT_PORT_0_REG 0X00
#define XL9535_INPUT_PORT_1_REG 0X01
#define XL9535_OUTPUT_PORT_0_REG 0X02
#define XL9535_OUTPUT_PORT_1_REG 0X03
#define XL9535_INVERSION_PORT_0_REG 0X04
#define XL9535_INVERSION_PORT_1_REG 0X05
#define XL9535_CONFIG_PORT_0_REG 0X06
#define XL9535_CONFIG_PORT_1_REG 0X07
class Arduino_XL9535SWSPI : public Arduino_DataBus
{
public:
Arduino_XL9535SWSPI(int8_t sda, int8_t scl, int8_t pwd, int8_t cs, int8_t sck, int8_t mosi, TwoWire *wire = &Wire);
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
#if !defined(LITTLE_FOOT_PRINT)
void writeBytes(uint8_t *data, uint32_t len) override;
#endif // !defined(LITTLE_FOOT_PRINT)
void pinMode(uint8_t pin, uint8_t mode);
void pinMode8(uint8_t port, uint8_t pin, uint8_t mode);
void digitalWrite(uint8_t pin, uint8_t val);
int digitalRead(uint8_t pin);
protected:
void writeRegister(uint8_t reg, uint8_t *data, size_t len);
uint8_t readRegister(uint8_t reg, uint8_t *data, size_t len);
uint8_t _address;
bool is_found;
int8_t _sda, _scl, _pwd, _cs, _sck, _mosi;
TwoWire *_wire;
private:
};
#endif // _ARDUINO_XL9535SWSPI_H_
@@ -0,0 +1,221 @@
/*
* start rewrite from:
* https://github.com/arduino/ArduinoCore-mbed/blob/master/libraries/SPI/SPI.cpp
*/
#ifdef ARDUINO_ARCH_NRF52840
#include "Arduino_mbedSPI.h"
Arduino_mbedSPI::Arduino_mbedSPI(int8_t dc, int8_t cs /* = GFX_NOT_DEFINED */)
: _dc(dc), _cs(cs)
{
}
bool Arduino_mbedSPI::begin(int32_t speed, int8_t dataMode)
{
_speed = (speed == GFX_NOT_DEFINED) ? SPI_DEFAULT_FREQ : speed;
_dataMode = (dataMode == GFX_NOT_DEFINED) ? SPI_MODE2 : dataMode;
uint32_t pin = digitalPinToPinName((pin_size_t)_dc);
NRF_GPIO_Type *reg = nrf_gpio_pin_port_decode(&pin);
nrf_gpio_cfg_output(pin);
_dcPortSet = &reg->OUTSET;
_dcPortClr = &reg->OUTCLR;
_dcPinMask = 1UL << pin;
if (_cs != GFX_NOT_DEFINED)
{
pin = digitalPinToPinName((pin_size_t)_cs);
reg = nrf_gpio_pin_port_decode(&pin);
nrf_gpio_cfg_output(pin);
_csPortSet = &reg->OUTSET;
_csPortClr = &reg->OUTCLR;
_csPinMask = 1UL << pin;
}
if (_dataMode == GFX_NOT_DEFINED)
{
_dataMode = SPI_MODE0;
}
_dev = new mbed::SPI((PinName)SPI_MOSI, (PinName)SPI_MISO, (PinName)SPI_SCK);
return true;
}
void Arduino_mbedSPI::beginWrite()
{
_dev->lock();
_dev->format(8, _dataMode);
_dev->frequency(_speed);
DC_HIGH();
CS_LOW();
}
void Arduino_mbedSPI::endWrite()
{
CS_HIGH();
_dev->unlock();
}
void Arduino_mbedSPI::writeCommand(uint8_t c)
{
DC_LOW();
WRITE(c);
DC_HIGH();
}
void Arduino_mbedSPI::writeCommand16(uint16_t c)
{
DC_LOW();
WRITE16(c);
DC_HIGH();
}
void Arduino_mbedSPI::write(uint8_t d)
{
WRITE(d);
}
void Arduino_mbedSPI::write16(uint16_t d)
{
WRITE16(d);
}
void Arduino_mbedSPI::writeRepeat(uint16_t p, uint32_t len)
{
MSB_16_SET(p, p);
uint32_t bufLen = (len < MBEDSPI_MAX_PIXELS_AT_ONCE) ? len : MBEDSPI_MAX_PIXELS_AT_ONCE;
uint32_t xferLen;
for (uint32_t i = 0; i < bufLen; i++)
{
_buffer16[i] = p;
}
while (len)
{
xferLen = (bufLen < len) ? bufLen : len;
WRITEBUF(_buffer, xferLen * 2);
len -= xferLen;
}
}
void Arduino_mbedSPI::writePixels(uint16_t *data, uint32_t len)
{
uint32_t xferLen;
uint8_t *p;
union
{
uint16_t val;
struct
{
uint8_t lsb;
uint8_t msb;
};
} t;
while (len)
{
xferLen = (len < MBEDSPI_MAX_PIXELS_AT_ONCE) ? len : MBEDSPI_MAX_PIXELS_AT_ONCE;
p = _buffer;
for (uint32_t i = 0; i < xferLen; i++)
{
t.val = *data++;
*p++ = t.msb;
*p++ = t.lsb;
}
len -= xferLen;
xferLen += xferLen; // uint16_t to uint8_t, double length
WRITEBUF(_buffer, xferLen);
}
}
void Arduino_mbedSPI::writeC8D8(uint8_t c, uint8_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE(d);
}
void Arduino_mbedSPI::writeC8D16(uint8_t c, uint16_t d)
{
DC_LOW();
WRITE(c);
DC_HIGH();
WRITE16(d);
}
void Arduino_mbedSPI::writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2)
{
DC_LOW();
_dev->write((const char *)&c, 1, NULL, 0);
DC_HIGH();
uint32_t d;
MSB_32_16_16_SET(d, d1, d2);
_dev->write((const char *)&d, 4, NULL, 0);
}
void Arduino_mbedSPI::writeBytes(uint8_t *data, uint32_t len)
{
WRITEBUF(data, len);
}
INLINE void Arduino_mbedSPI::WRITE(uint8_t d)
{
_dev->write((const char *)&d, 1, NULL, 0);
}
INLINE void Arduino_mbedSPI::WRITE16(uint16_t d)
{
MSB_16_SET(d, d);
_dev->write((const char *)&d, 2, NULL, 0);
}
INLINE void Arduino_mbedSPI::WRITEBUF(uint8_t *buf, size_t count)
{
_dev->write((const char *)buf, count, NULL, 0);
}
/******** low level bit twiddling **********/
INLINE void Arduino_mbedSPI::DC_HIGH(void)
{
*_dcPortSet = _dcPinMask;
}
INLINE void Arduino_mbedSPI::DC_LOW(void)
{
*_dcPortClr = _dcPinMask;
}
INLINE void Arduino_mbedSPI::CS_HIGH(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortSet = _csPinMask;
}
}
INLINE void Arduino_mbedSPI::CS_LOW(void)
{
if (_cs != GFX_NOT_DEFINED)
{
*_csPortClr = _csPinMask;
}
}
#endif // #ifdef ARDUINO_ARCH_NRF52840
@@ -0,0 +1,69 @@
/*
* start rewrite from:
* https://github.com/arduino/ArduinoCore-mbed/blob/master/libraries/SPI/SPI.cpp
*/
#ifdef ARDUINO_ARCH_NRF52840
#ifndef _ARDUINO_MBEDSPI_H_
#define _ARDUINO_MBEDSPI_H_
#include <SPI.h>
#if !defined(ARDUINO_AS_MBED_LIBRARY)
#include "drivers/SPIMaster.h"
#else
#include "drivers/SPI.h"
#endif
#include "Arduino_DataBus.h"
#define MBEDSPI_MAX_PIXELS_AT_ONCE 32
class Arduino_mbedSPI : public Arduino_DataBus
{
public:
Arduino_mbedSPI(int8_t dc, int8_t cs = GFX_NOT_DEFINED); // Constructor
bool begin(int32_t speed = GFX_NOT_DEFINED, int8_t dataMode = GFX_NOT_DEFINED) override;
void beginWrite() override;
void endWrite() override;
void writeCommand(uint8_t) override;
void writeCommand16(uint16_t) override;
void write(uint8_t) override;
void write16(uint16_t) override;
void writeRepeat(uint16_t p, uint32_t len) override;
void writePixels(uint16_t *data, uint32_t len) override;
void writeC8D8(uint8_t c, uint8_t d) override;
void writeC8D16(uint8_t c, uint16_t d) override;
void writeC8D16D16(uint8_t c, uint16_t d1, uint16_t d2) override;
void writeBytes(uint8_t *data, uint32_t len) override;
private:
INLINE void WRITE(uint8_t d);
INLINE void WRITE16(uint16_t d);
INLINE void WRITEBUF(uint8_t *buf, size_t count);
INLINE void DC_HIGH(void);
INLINE void DC_LOW(void);
INLINE void CS_HIGH(void);
INLINE void CS_LOW(void);
int8_t _dc, _cs;
mbed::SPI *_dev;
PORTreg_t _csPortSet;
PORTreg_t _csPortClr;
PORTreg_t _dcPortSet;
PORTreg_t _dcPortClr;
ARDUINOGFX_PORT_t _dcPinMask;
ARDUINOGFX_PORT_t _csPinMask;
union
{
uint8_t _buffer[MBEDSPI_MAX_PIXELS_AT_ONCE * 2] = {0};
uint16_t _buffer16[MBEDSPI_MAX_PIXELS_AT_ONCE];
uint32_t _buffer32[MBEDSPI_MAX_PIXELS_AT_ONCE / 2];
};
};
#endif // _ARDUINO_MBEDSPI_H_
#endif // #ifdef ARDUINO_ARCH_NRF52840
@@ -0,0 +1,102 @@
#include "Arduino_GC9106.h"
#include "SPI.h"
Arduino_GC9106::Arduino_GC9106(
Arduino_DataBus *bus, int8_t rst, uint8_t r,
bool ips, int16_t w, int16_t h,
uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2)
: Arduino_TFT(bus, rst, r, ips, w, h, col_offset1, row_offset1, col_offset2, row_offset2)
{
}
bool Arduino_GC9106::begin(int32_t speed)
{
_override_datamode = SPI_MODE0; // always use SPI_MODE0
return Arduino_TFT::begin(speed);
}
void Arduino_GC9106::writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h)
{
if ((x != _currentX) || (w != _currentW) || (y != _currentY) || (h != _currentH))
{
_bus->writeC8D16D16(GC9106_CASET, x + _xStart, x + w - 1 + _xStart);
_bus->writeC8D16D16(GC9106_RASET, y + _yStart, y + h - 1 + _yStart);
_currentX = x;
_currentY = y;
_currentW = w;
_currentH = h;
}
_bus->writeCommand(GC9106_RAMWR); // write to RAM
}
/**************************************************************************/
/*!
@brief Set origin of (0,0) and orientation of TFT display
@param m The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Arduino_GC9106::setRotation(uint8_t r)
{
Arduino_TFT::setRotation(r);
switch (_rotation)
{
case 3:
r = GC9106_MADCTL_MY | GC9106_MADCTL_MV | GC9106_MADCTL_BGR;
break;
case 2:
r = GC9106_MADCTL_MY | GC9106_MADCTL_MX | GC9106_MADCTL_BGR;
break;
case 1:
r = GC9106_MADCTL_MX | GC9106_MADCTL_MV | GC9106_MADCTL_BGR;
break;
default: // case 0:
r = GC9106_MADCTL_BGR;
break;
}
_bus->beginWrite();
_bus->writeCommand(GC9106_MADCTL);
_bus->write(r);
_bus->endWrite();
}
void Arduino_GC9106::invertDisplay(bool i)
{
_bus->sendCommand(_ips ? (i ? GC9106_INVOFF : GC9106_INVON) : (i ? GC9106_INVON : GC9106_INVOFF));
}
void Arduino_GC9106::displayOn(void)
{
_bus->sendCommand(GC9106_SLPOUT);
delay(GC9106_SLPOUT_DELAY);
}
void Arduino_GC9106::displayOff(void)
{
_bus->sendCommand(GC9106_SLPIN);
delay(GC9106_SLPIN_DELAY);
}
void Arduino_GC9106::tftInit()
{
if (_rst != GFX_NOT_DEFINED)
{
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(100);
digitalWrite(_rst, LOW);
delay(GC9106_RST_DELAY);
digitalWrite(_rst, HIGH);
delay(GC9106_RST_DELAY);
}
else
{
// Software Rest
}
_bus->batchOperation(GC9106_init_operations, sizeof(GC9106_init_operations));
invertDisplay(false);
}
@@ -0,0 +1,132 @@
#ifndef _ARDUINO_GC9106_H_
#define _ARDUINO_GC9106_H_
#include <Arduino.h>
#include <Print.h>
#include "./Arduino_GFX.h"
#include "../Arduino_TFT.h"
#define GC9106_TFTWIDTH 80
#define GC9106_TFTHEIGHT 160
#define GC9106_RST_DELAY 120 ///< delay ms wait for reset finish
#define GC9106_SLPIN_DELAY 120 ///< delay ms wait for sleep in finish
#define GC9106_SLPOUT_DELAY 120 ///< delay ms wait for sleep out finish
#define GC9106_NOP 0x00
#define GC9106_SWRESET 0x01
#define GC9106_RDDID 0x04
#define GC9106_RDDST 0x09
#define GC9106_SLPIN 0x10
#define GC9106_SLPOUT 0x11
#define GC9106_PTLON 0x12
#define GC9106_NORON 0x13
#define GC9106_INVOFF 0x20
#define GC9106_INVON 0x21
#define GC9106_DISPOFF 0x28
#define GC9106_DISPON 0x29
#define GC9106_CASET 0x2A
#define GC9106_RASET 0x2B
#define GC9106_RAMWR 0x2C
#define GC9106_RAMRD 0x2E
#define GC9106_PTLAR 0x30
#define GC9106_TELON 0x35
#define GC9106_MADCTL 0x36
#define GC9106_COLMOD 0x3A
#define GC9106_SCANLSET 0x44
#define GC9106_FRMCTR1 0xB1
#define GC9106_FRMCTR2 0xB2
#define GC9106_FRMCTR3 0xB3
#define GC9106_INVCTR 0xB4
#define GC9106_VREG1CTL 0xE6
#define GC9106_VREG2CTL 0xE7
#define GC9106_GAMMA1 0xF0
#define GC9106_GAMMA2 0xF1
#define GC9106_INTERRE1 0xFE
#define GC9106_INTERRE2 0xEF
#define GC9106_MADCTL_MY 0x80
#define GC9106_MADCTL_MX 0x40
#define GC9106_MADCTL_MV 0x20
#define GC9106_MADCTL_ML 0x10
#define GC9106_MADCTL_BGR 0x08
#define GC9106_MADCTL_MH 0x04
#define GC9106_MADCTL_RGB 0x00
static const uint8_t GC9106_init_operations[] = {
BEGIN_WRITE,
WRITE_COMMAND_8, GC9106_INTERRE1,
WRITE_COMMAND_8, GC9106_INTERRE1,
WRITE_COMMAND_8, GC9106_INTERRE1,
WRITE_COMMAND_8, GC9106_INTERRE2,
WRITE_C8_D8, GC9106_FRMCTR3, 0x03,
WRITE_C8_D8, GC9106_MADCTL, 0xD8,
WRITE_C8_D8, GC9106_COLMOD, 0x05,
WRITE_C8_D8, 0xB6, 0x11,
WRITE_C8_D8, 0xAC, 0x0B,
WRITE_C8_D8, GC9106_INVCTR, 0x21,
WRITE_C8_D8, GC9106_FRMCTR1, 0xC0,
WRITE_C8_D16, GC9106_VREG1CTL, 0x50, 0x43,
WRITE_C8_D16, GC9106_VREG2CTL, 0x56, 0x43,
WRITE_COMMAND_8, GC9106_GAMMA1,
WRITE_BYTES, 14, 0x1F, 0x41, 0x1B, 0x55, 0x36, 0x3D, 0x3E,
0x00, 0x16, 0x08, 0x09, 0x15, 0x14, 0x0F,
WRITE_COMMAND_8, GC9106_GAMMA2,
WRITE_BYTES, 14, 0x1F, 0x41, 0x1B, 0x55, 0x36, 0x3D, 0x3E,
0x00, 0x16, 0x08, 0x09, 0x15, 0x14, 0x0F,
WRITE_COMMAND_8, GC9106_INTERRE1,
WRITE_COMMAND_8, 0xFF,
WRITE_C8_D8, GC9106_TELON, 0x00,
WRITE_C8_D8, GC9106_SCANLSET, 0x00,
WRITE_COMMAND_8, GC9106_SLPOUT,
END_WRITE,
DELAY, GC9106_SLPOUT_DELAY,
BEGIN_WRITE,
WRITE_COMMAND_8, GC9106_DISPON, // Display on
END_WRITE,
DELAY, 20};
class Arduino_GC9106 : public Arduino_TFT
{
public:
Arduino_GC9106(
Arduino_DataBus *bus, int8_t rst = GFX_NOT_DEFINED, uint8_t r = 0,
bool ips = false, int16_t w = GC9106_TFTWIDTH, int16_t h = GC9106_TFTHEIGHT,
uint8_t col_offset1 = 24, uint8_t row_offset1 = 0, uint8_t col_offset2 = 24, uint8_t row_offset2 = 0);
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) override;
void setRotation(uint8_t r) override;
void invertDisplay(bool) override;
void displayOn() override;
void displayOff() override;
protected:
void tftInit() override;
private:
};
#endif
@@ -0,0 +1,102 @@
#include "Arduino_GC9107.h"
#include "SPI.h"
Arduino_GC9107::Arduino_GC9107(
Arduino_DataBus *bus, int8_t rst, uint8_t r,
bool ips, int16_t w, int16_t h,
uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2)
: Arduino_TFT(bus, rst, r, ips, w, h, col_offset1, row_offset1, col_offset2, row_offset2)
{
}
bool Arduino_GC9107::begin(int32_t speed)
{
_override_datamode = SPI_MODE0; // always use SPI_MODE0
return Arduino_TFT::begin(speed);
}
void Arduino_GC9107::writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h)
{
if ((x != _currentX) || (w != _currentW) || (y != _currentY) || (h != _currentH))
{
_bus->writeC8D16D16(GC9107_CASET, x + _xStart, x + w - 1 + _xStart);
_bus->writeC8D16D16(GC9107_RASET, y + _yStart, y + h - 1 + _yStart);
_currentX = x;
_currentY = y;
_currentW = w;
_currentH = h;
}
_bus->writeCommand(GC9107_RAMWR); // write to RAM
}
/**************************************************************************/
/*!
@brief Set origin of (0,0) and orientation of TFT display
@param m The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Arduino_GC9107::setRotation(uint8_t r)
{
Arduino_TFT::setRotation(r);
switch (_rotation)
{
case 1:
r = GC9107_MADCTL_MY | GC9107_MADCTL_MV | GC9107_MADCTL_BGR;
break;
case 2:
r = GC9107_MADCTL_BGR;
break;
case 3:
r = GC9107_MADCTL_MX | GC9107_MADCTL_MV | GC9107_MADCTL_BGR;
break;
default: // case 0:
r = GC9107_MADCTL_MY | GC9107_MADCTL_MX | GC9107_MADCTL_BGR;
break;
}
_bus->beginWrite();
_bus->writeCommand(GC9107_MADCTL);
_bus->write(r);
_bus->endWrite();
}
void Arduino_GC9107::invertDisplay(bool i)
{
_bus->sendCommand(_ips ? (i ? GC9107_INVOFF : GC9107_INVON) : (i ? GC9107_INVON : GC9107_INVOFF));
}
void Arduino_GC9107::displayOn(void)
{
_bus->sendCommand(GC9107_SLPOUT);
delay(GC9107_SLPOUT_DELAY);
}
void Arduino_GC9107::displayOff(void)
{
_bus->sendCommand(GC9107_SLPIN);
delay(GC9107_SLPIN_DELAY);
}
void Arduino_GC9107::tftInit()
{
if (_rst != GFX_NOT_DEFINED)
{
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(100);
digitalWrite(_rst, LOW);
delay(GC9107_RST_DELAY);
digitalWrite(_rst, HIGH);
delay(GC9107_RST_DELAY);
}
else
{
// Software Rest
}
_bus->batchOperation(GC9107_init_operations, sizeof(GC9107_init_operations));
invertDisplay(false);
}
@@ -0,0 +1,204 @@
#ifndef _ARDUINO_GC9107_H_
#define _ARDUINO_GC9107_H_
#include <Arduino.h>
#include <Print.h>
#include "./Arduino_GFX.h"
#include "../Arduino_TFT.h"
#define GC9107_TFTWIDTH 128
#define GC9107_TFTHEIGHT 128
#define GC9107_RST_DELAY 120 ///< delay ms wait for reset finish
#define GC9107_SLPIN_DELAY 120 ///< delay ms wait for sleep in finish
#define GC9107_SLPOUT_DELAY 120 ///< delay ms wait for sleep out finish
#define GC9107_NOP 0x00
#define GC9107_SWRESET 0x01
#define GC9107_RDDID 0x04
#define GC9107_RDDST 0x09
#define GC9107_SLPIN 0x10
#define GC9107_SLPOUT 0x11
#define GC9107_PTLON 0x12
#define GC9107_NORON 0x13
#define GC9107_INVOFF 0x20
#define GC9107_INVON 0x21
#define GC9107_DISPOFF 0x28
#define GC9107_DISPON 0x29
#define GC9107_CASET 0x2A
#define GC9107_RASET 0x2B
#define GC9107_RAMWR 0x2C
#define GC9107_RAMRD 0x2E
#define GC9107_PTLAR 0x30
#define GC9107_TELON 0x35
#define GC9107_MADCTL 0x36
#define GC9107_COLMOD 0x3A
#define GC9107_SCANLSET 0x44
#define GC9107_FRMCTR1 0xB1
#define GC9107_FRMCTR2 0xB2
#define GC9107_FRMCTR3 0xB3
#define GC9107_INVCTR 0xB4
#define GC9107_VREG1CTL 0xE6
#define GC9107_VREG2CTL 0xE7
#define GC9107_GAMMA1 0xF0
#define GC9107_GAMMA2 0xF1
#define GC9107_INTERRE1 0xFE
#define GC9107_INTERRE2 0xEF
#define GC9107_MADCTL_MY 0x80
#define GC9107_MADCTL_MX 0x40
#define GC9107_MADCTL_MV 0x20
#define GC9107_MADCTL_ML 0x10
#define GC9107_MADCTL_BGR 0x08
#define GC9107_MADCTL_MH 0x04
#define GC9107_MADCTL_RGB 0x00
static const uint8_t GC9107_init_operations[] = {
BEGIN_WRITE,
WRITE_COMMAND_8, 0xEF,
WRITE_C8_D8, 0xEB, 0x14,
WRITE_COMMAND_8, 0xFE,
WRITE_COMMAND_8, 0xEF,
WRITE_C8_D8, 0xEB, 0x14,
WRITE_C8_D8, 0x84, 0x40,
WRITE_C8_D8, 0x85, 0xFF,
WRITE_C8_D8, 0x86, 0xFF,
WRITE_C8_D8, 0x87, 0xFF,
WRITE_C8_D8, 0x88, 0x0A,
WRITE_C8_D8, 0x89, 0x21,
WRITE_C8_D8, 0x8A, 0x00,
WRITE_C8_D8, 0x8B, 0x80,
WRITE_C8_D8, 0x8C, 0x01,
WRITE_C8_D8, 0x8D, 0x01,
WRITE_C8_D8, 0x8E, 0xFF,
WRITE_C8_D8, 0x8F, 0xFF,
WRITE_C8_D16, 0xB6, 0x00, 0x20,
WRITE_C8_D8, 0x3A, 0x05,
WRITE_COMMAND_8, 0x90,
WRITE_BYTES, 4, 0x08, 0x08, 0x08, 0x08,
WRITE_C8_D8, 0xBD, 0x06,
WRITE_C8_D8, 0xBC, 0x00,
WRITE_COMMAND_8, 0xFF,
WRITE_BYTES, 3, 0x60, 0x01, 0x04,
WRITE_C8_D8, 0xC3, 0x13,
WRITE_C8_D8, 0xC4, 0x13,
WRITE_C8_D8, 0xC9, 0x22,
WRITE_C8_D8, 0xBE, 0x11,
WRITE_C8_D16, 0xE1, 0x10, 0x0E,
WRITE_COMMAND_8, 0xDF,
WRITE_BYTES, 3, 0x21, 0x0c, 0x02,
WRITE_COMMAND_8, 0xF0,
WRITE_BYTES, 6,
0x45, 0x09, 0x08, 0x08,
0x26, 0x2A,
WRITE_COMMAND_8, 0xF1,
WRITE_BYTES, 6,
0x43, 0x70, 0x72, 0x36,
0x37, 0x6F,
WRITE_COMMAND_8, 0xF2,
WRITE_BYTES, 6,
0x45, 0x09, 0x08, 0x08,
0x26, 0x2A,
WRITE_COMMAND_8, 0xF3,
WRITE_BYTES, 6,
0x43, 0x70, 0x72, 0x36,
0x37, 0x6F,
WRITE_C8_D16, 0xED, 0x1B, 0x0B,
WRITE_C8_D8, 0xAE, 0x77,
WRITE_C8_D8, 0xCD, 0x63,
WRITE_COMMAND_8, 0x70,
WRITE_BYTES, 9,
0x07, 0x07, 0x04, 0x0E,
0x0F, 0x09, 0x07, 0x08,
0x03,
WRITE_C8_D8, 0xE8, 0x34,
WRITE_COMMAND_8, 0x62,
WRITE_BYTES, 12,
0x18, 0x0D, 0x71, 0xED,
0x70, 0x70, 0x18, 0x0F,
0x71, 0xEF, 0x70, 0x70,
WRITE_COMMAND_8, 0x63,
WRITE_BYTES, 12,
0x18, 0x11, 0x71, 0xF1,
0x70, 0x70, 0x18, 0x13,
0x71, 0xF3, 0x70, 0x70,
WRITE_COMMAND_8, 0x64,
WRITE_BYTES, 7,
0x28, 0x29, 0xF1, 0x01,
0xF1, 0x00, 0x07,
WRITE_COMMAND_8, 0x66,
WRITE_BYTES, 10,
0x3C, 0x00, 0xCD, 0x67,
0x45, 0x45, 0x10, 0x00,
0x00, 0x00,
WRITE_COMMAND_8, 0x67,
WRITE_BYTES, 10,
0x00, 0x3C, 0x00, 0x00,
0x00, 0x01, 0x54, 0x10,
0x32, 0x98,
WRITE_COMMAND_8, 0x74,
WRITE_BYTES, 7,
0x10, 0x85, 0x80, 0x00,
0x00, 0x4E, 0x00,
WRITE_C8_D16, 0x98, 0x3e, 0x07,
WRITE_COMMAND_8, 0x35,
WRITE_COMMAND_8, 0x21,
WRITE_COMMAND_8, 0x11,
END_WRITE,
DELAY, 120,
BEGIN_WRITE,
WRITE_COMMAND_8, 0x29,
END_WRITE,
DELAY, 20};
class Arduino_GC9107 : public Arduino_TFT
{
public:
Arduino_GC9107(
Arduino_DataBus *bus, int8_t rst = GFX_NOT_DEFINED, uint8_t r = 0,
bool ips = false, int16_t w = GC9107_TFTWIDTH, int16_t h = GC9107_TFTHEIGHT,
uint8_t col_offset1 = 2, uint8_t row_offset1 = 1, uint8_t col_offset2 = 2, uint8_t row_offset2 = 1);
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) override;
void setRotation(uint8_t r) override;
void invertDisplay(bool) override;
void displayOn() override;
void displayOff() override;
protected:
void tftInit() override;
private:
};
#endif
@@ -0,0 +1,102 @@
#include "Arduino_GC9A01.h"
#include "SPI.h"
Arduino_GC9A01::Arduino_GC9A01(
Arduino_DataBus *bus, int8_t rst, uint8_t r,
bool ips, int16_t w, int16_t h,
uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2)
: Arduino_TFT(bus, rst, r, ips, w, h, col_offset1, row_offset1, col_offset2, row_offset2)
{
}
bool Arduino_GC9A01::begin(int32_t speed)
{
_override_datamode = SPI_MODE0; // always use SPI_MODE0
return Arduino_TFT::begin(speed);
}
void Arduino_GC9A01::writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h)
{
if ((x != _currentX) || (w != _currentW) || (y != _currentY) || (h != _currentH))
{
_bus->writeC8D16D16(GC9A01_CASET, x + _xStart, x + w - 1 + _xStart);
_bus->writeC8D16D16(GC9A01_RASET, y + _yStart, y + h - 1 + _yStart);
_currentX = x;
_currentY = y;
_currentW = w;
_currentH = h;
}
_bus->writeCommand(GC9A01_RAMWR); // write to RAM
}
/**************************************************************************/
/*!
@brief Set origin of (0,0) and orientation of TFT display
@param m The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Arduino_GC9A01::setRotation(uint8_t r)
{
Arduino_TFT::setRotation(r);
switch (_rotation)
{
case 3:
r = 0xA8;
break;
case 2:
r = 0xC8;
break;
case 1:
r = 0x68;
break;
default: // case 0:
r = 0x08;
break;
}
_bus->beginWrite();
_bus->writeCommand(GC9A01_MADCTL);
_bus->write(r);
_bus->endWrite();
}
void Arduino_GC9A01::invertDisplay(bool i)
{
_bus->sendCommand(_ips ? (i ? GC9A01_INVOFF : GC9A01_INVON) : (i ? GC9A01_INVON : GC9A01_INVOFF));
}
void Arduino_GC9A01::displayOn(void)
{
_bus->sendCommand(GC9A01_SLPOUT);
delay(GC9A01_SLPOUT_DELAY);
}
void Arduino_GC9A01::displayOff(void)
{
_bus->sendCommand(GC9A01_SLPIN);
delay(GC9A01_SLPIN_DELAY);
}
void Arduino_GC9A01::tftInit()
{
if (_rst != GFX_NOT_DEFINED)
{
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(100);
digitalWrite(_rst, LOW);
delay(GC9A01_RST_DELAY);
digitalWrite(_rst, HIGH);
delay(GC9A01_RST_DELAY);
}
else
{
// Software Rest
}
_bus->batchOperation(gc9a01_init_operations, sizeof(gc9a01_init_operations));
invertDisplay(false);
}
@@ -0,0 +1,213 @@
#ifndef _ARDUINO_GC9A01_H_
#define _ARDUINO_GC9A01_H_
#include <Arduino.h>
#include <Print.h>
#include "./Arduino_GFX.h"
#include "../Arduino_TFT.h"
#define GC9A01_TFTWIDTH 240
#define GC9A01_TFTHEIGHT 240
#define GC9A01_RST_DELAY 120 ///< delay ms wait for reset finish
#define GC9A01_SLPIN_DELAY 120 ///< delay ms wait for sleep in finish
#define GC9A01_SLPOUT_DELAY 120 ///< delay ms wait for sleep out finish
#define GC9A01_NOP 0x00
#define GC9A01_SWRESET 0x01
#define GC9A01_RDDID 0x04
#define GC9A01_RDDST 0x09
#define GC9A01_SLPIN 0x10
#define GC9A01_SLPOUT 0x11
#define GC9A01_PTLON 0x12
#define GC9A01_NORON 0x13
#define GC9A01_INVOFF 0x20
#define GC9A01_INVON 0x21
#define GC9A01_DISPOFF 0x28
#define GC9A01_DISPON 0x29
#define GC9A01_CASET 0x2A
#define GC9A01_RASET 0x2B
#define GC9A01_RAMWR 0x2C
#define GC9A01_RAMRD 0x2E
#define GC9A01_PTLAR 0x30
#define GC9A01_COLMOD 0x3A
#define GC9A01_MADCTL 0x36
#define GC9A01_MADCTL_MY 0x80
#define GC9A01_MADCTL_MX 0x40
#define GC9A01_MADCTL_MV 0x20
#define GC9A01_MADCTL_ML 0x10
#define GC9A01_MADCTL_RGB 0x00
#define GC9A01_RDID1 0xDA
#define GC9A01_RDID2 0xDB
#define GC9A01_RDID3 0xDC
#define GC9A01_RDID4 0xDD
static const uint8_t gc9a01_init_operations[] = {
BEGIN_WRITE,
WRITE_COMMAND_8, 0xEF,
WRITE_C8_D8, 0xEB, 0x14,
WRITE_COMMAND_8, 0xFE,
WRITE_COMMAND_8, 0xEF,
WRITE_C8_D8, 0xEB, 0x14,
WRITE_C8_D8, 0x84, 0x40,
WRITE_C8_D8, 0x85, 0xFF,
WRITE_C8_D8, 0x86, 0xFF,
WRITE_C8_D8, 0x87, 0xFF,
WRITE_C8_D8, 0x88, 0x0A,
WRITE_C8_D8, 0x89, 0x21,
WRITE_C8_D8, 0x8A, 0x00,
WRITE_C8_D8, 0x8B, 0x80,
WRITE_C8_D8, 0x8C, 0x01,
WRITE_C8_D8, 0x8D, 0x01,
WRITE_C8_D8, 0x8E, 0xFF,
WRITE_C8_D8, 0x8F, 0xFF,
WRITE_C8_D16, 0xB6, 0x00, 0x20,
WRITE_C8_D8, 0x3A, 0x05,
WRITE_COMMAND_8, 0x90,
WRITE_BYTES, 4, 0x08, 0x08, 0x08, 0x08,
WRITE_C8_D8, 0xBD, 0x06,
WRITE_C8_D8, 0xBC, 0x00,
WRITE_COMMAND_8, 0xFF,
WRITE_BYTES, 3, 0x60, 0x01, 0x04,
WRITE_C8_D8, 0xC3, 0x13,
WRITE_C8_D8, 0xC4, 0x13,
WRITE_C8_D8, 0xC9, 0x22,
WRITE_C8_D8, 0xBE, 0x11,
WRITE_C8_D16, 0xE1, 0x10, 0x0E,
WRITE_COMMAND_8, 0xDF,
WRITE_BYTES, 3, 0x21, 0x0c, 0x02,
WRITE_COMMAND_8, 0xF0,
WRITE_BYTES, 6,
0x45, 0x09, 0x08, 0x08, 0x26,
0x2A,
WRITE_COMMAND_8, 0xF1,
WRITE_BYTES, 6,
0x43, 0x70, 0x72, 0x36, 0x37,
0x6F,
WRITE_COMMAND_8, 0xF2,
WRITE_BYTES, 6,
0x45, 0x09, 0x08, 0x08, 0x26,
0x2A,
WRITE_COMMAND_8, 0xF3,
WRITE_BYTES, 6,
0x43, 0x70, 0x72, 0x36, 0x37,
0x6F,
WRITE_C8_D16, 0xED, 0x1B, 0x0B,
WRITE_C8_D8, 0xAE, 0x77,
WRITE_C8_D8, 0xCD, 0x63,
WRITE_COMMAND_8, 0x70,
WRITE_BYTES, 9,
0x07, 0x07, 0x04, 0x0E, 0x0F,
0x09, 0x07, 0x08, 0x03,
WRITE_C8_D8, 0xE8, 0x34,
WRITE_COMMAND_8, 0x62,
WRITE_BYTES, 12,
0x18, 0x0D, 0x71, 0xED, 0x70,
0x70, 0x18, 0x0F, 0x71, 0xEF,
0x70, 0x70,
WRITE_COMMAND_8, 0x63,
WRITE_BYTES, 12,
0x18, 0x11, 0x71, 0xF1, 0x70,
0x70, 0x18, 0x13, 0x71, 0xF3,
0x70, 0x70,
WRITE_COMMAND_8, 0x64,
WRITE_BYTES, 7,
0x28, 0x29, 0xF1, 0x01, 0xF1,
0x00, 0x07,
WRITE_COMMAND_8, 0x66,
WRITE_BYTES, 10,
0x3C, 0x00, 0xCD, 0x67, 0x45,
0x45, 0x10, 0x00, 0x00, 0x00,
WRITE_COMMAND_8, 0x67,
WRITE_BYTES, 10,
0x00, 0x3C, 0x00, 0x00, 0x00,
0x01, 0x54, 0x10, 0x32, 0x98,
WRITE_COMMAND_8, 0x74,
WRITE_BYTES, 7,
0x10, 0x85, 0x80, 0x00, 0x00,
0x4E, 0x00,
WRITE_C8_D16, 0x98, 0x3e, 0x07,
WRITE_COMMAND_8, 0x35,
WRITE_COMMAND_8, GC9A01_SLPOUT,
END_WRITE,
DELAY, GC9A01_SLPOUT_DELAY,
BEGIN_WRITE,
WRITE_COMMAND_8, GC9A01_DISPON, // Display on
END_WRITE,
DELAY, 20};
class Arduino_GC9A01 : public Arduino_TFT
{
public:
Arduino_GC9A01(
Arduino_DataBus *bus, int8_t rst = GFX_NOT_DEFINED, uint8_t r = 0,
bool ips = false, int16_t w = GC9A01_TFTWIDTH, int16_t h = GC9A01_TFTHEIGHT,
uint8_t col_offset1 = 0, uint8_t row_offset1 = 0, uint8_t col_offset2 = 0, uint8_t row_offset2 = 0);
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) override;
void setRotation(uint8_t r) override;
void invertDisplay(bool) override;
void displayOn() override;
void displayOff() override;
protected:
void tftInit() override;
private:
};
#endif
@@ -0,0 +1,422 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#include "Arduino_HX8347C.h"
Arduino_HX8347C::Arduino_HX8347C(
Arduino_DataBus *bus, int8_t rst, uint8_t r,
bool ips, int16_t w, int16_t h,
uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2)
: Arduino_TFT(bus, rst, r, ips, w, h, col_offset1, row_offset1, col_offset2, row_offset2)
{
_invert = ips;
}
bool Arduino_HX8347C::begin(int32_t speed)
{
return Arduino_TFT::begin(speed);
}
// Companion code to the above tables. Reads and issues
// a series of LCD commands stored in PROGMEM byte array.
void Arduino_HX8347C::tftInit()
{
if (_rst != GFX_NOT_DEFINED)
{
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(100);
digitalWrite(_rst, LOW);
delay(HX8347C_RST_DELAY);
digitalWrite(_rst, HIGH);
delay(HX8347C_RST_DELAY);
}
else
{
// Software Rest
}
// LCD Init For 3.0inch LCD Panel with HX8347C.
// Power Voltage Setting
_bus->sendCommand(0x1A);
_bus->sendData(0x02); // BT
_bus->sendCommand(0x1B);
_bus->sendData(0x8B); // VRH
//****VCOM offset**///
_bus->sendCommand(0x23);
_bus->sendData(0x00); // SEL_VCM
_bus->sendCommand(0x24);
_bus->sendData(0x5D); // VCM
_bus->sendCommand(0x25);
_bus->sendData(0x15); // VDV
_bus->sendCommand(0x2D);
_bus->sendData(0x01); // NOW[2:0]=001
//****OPON**//
_bus->sendCommand(0xE8);
_bus->sendData(0x60);
// Power on Setting
_bus->sendCommand(0x18);
_bus->sendData(0x04); // Frame rate 72Hz
_bus->sendCommand(0x19);
_bus->sendData(0x01); // OSC_EN='1', start Osc
_bus->sendCommand(0x01);
_bus->sendData(0x00); // DP_STB='0', out deep sleep
_bus->sendCommand(0x1F);
_bus->sendData(0x88); // STB=0
delay(5);
_bus->sendCommand(0x1F);
_bus->sendData(0x80); // DK=0
delay(5);
_bus->sendCommand(0x1F);
_bus->sendData(0x90); // PON=1
delay(5);
_bus->sendCommand(0x1F);
_bus->sendData(0xD0); // VCOMG=1
delay(5);
// 262k/65k color selection
_bus->sendCommand(0x17);
_bus->sendData(0x05); // default 0x06 262k color // 0x05 65k color
// SET PANEL
_bus->sendCommand(0x29);
_bus->sendData(0x31); // 400 lines
_bus->sendCommand(0x71);
_bus->sendData(0x1A); // RTN
// Gamma 2.2 Setting
_bus->sendCommand(0x40);
_bus->sendData(0x00);
_bus->sendCommand(0x41);
_bus->sendData(0x77);
_bus->sendCommand(0x42);
_bus->sendData(0x77);
_bus->sendCommand(0x43);
_bus->sendData(0x00);
_bus->sendCommand(0x44);
_bus->sendData(0x04);
_bus->sendCommand(0x45);
_bus->sendData(0x00);
_bus->sendCommand(0x46);
_bus->sendData(0x00);
_bus->sendCommand(0x47);
_bus->sendData(0x00);
_bus->sendCommand(0x48);
_bus->sendData(0x77);
_bus->sendCommand(0x49);
_bus->sendData(0x00);
_bus->sendCommand(0x4A);
_bus->sendData(0x00);
_bus->sendCommand(0x4B);
_bus->sendData(0x08);
_bus->sendCommand(0x4C);
_bus->sendData(0x00);
_bus->sendCommand(0x4D);
_bus->sendData(0x00);
_bus->sendCommand(0x4E);
_bus->sendData(0x00);
// Set DGC
_bus->sendCommand(0xFF);
_bus->sendData(0x01); // Page1
_bus->sendCommand(0x00);
_bus->sendData(0x01); // DGC_EN
_bus->sendCommand(0x01);
_bus->sendData(0x00);
_bus->sendCommand(0x02);
_bus->sendData(0x06);
_bus->sendCommand(0x03);
_bus->sendData(0x0C);
_bus->sendCommand(0x04);
_bus->sendData(0x12);
_bus->sendCommand(0x05);
_bus->sendData(0x16);
_bus->sendCommand(0x06);
_bus->sendData(0x1C);
_bus->sendCommand(0x07);
_bus->sendData(0x23);
_bus->sendCommand(0x08);
_bus->sendData(0x2E);
_bus->sendCommand(0x09);
_bus->sendData(0x36);
_bus->sendCommand(0x0A);
_bus->sendData(0x3F);
_bus->sendCommand(0x0B);
_bus->sendData(0x47);
_bus->sendCommand(0x0C);
_bus->sendData(0x50);
_bus->sendCommand(0x0D);
_bus->sendData(0x57);
_bus->sendCommand(0x0E);
_bus->sendData(0x5F);
_bus->sendCommand(0x0F);
_bus->sendData(0x67);
_bus->sendCommand(0x10);
_bus->sendData(0x6F);
_bus->sendCommand(0x11);
_bus->sendData(0x76);
_bus->sendCommand(0x12);
_bus->sendData(0x7F);
_bus->sendCommand(0x13);
_bus->sendData(0x87);
_bus->sendCommand(0x14);
_bus->sendData(0x90);
_bus->sendCommand(0x15);
_bus->sendData(0x99);
_bus->sendCommand(0x16);
_bus->sendData(0xA3);
_bus->sendCommand(0x17);
_bus->sendData(0xAD);
_bus->sendCommand(0x18);
_bus->sendData(0xB4);
_bus->sendCommand(0x19);
_bus->sendData(0xBB);
_bus->sendCommand(0x1A);
_bus->sendData(0xC4);
_bus->sendCommand(0x1B);
_bus->sendData(0xCE);
_bus->sendCommand(0x1C);
_bus->sendData(0xD9);
_bus->sendCommand(0x1D);
_bus->sendData(0xE3);
_bus->sendCommand(0x1E);
_bus->sendData(0xEC);
_bus->sendCommand(0x1F);
_bus->sendData(0xF3);
_bus->sendCommand(0x20);
_bus->sendData(0xF7);
_bus->sendCommand(0x21);
_bus->sendData(0xFC);
_bus->sendCommand(0x22);
_bus->sendData(0x00);
_bus->sendCommand(0x23);
_bus->sendData(0x06);
_bus->sendCommand(0x24);
_bus->sendData(0x0C);
_bus->sendCommand(0x25);
_bus->sendData(0x12);
_bus->sendCommand(0x26);
_bus->sendData(0x16);
_bus->sendCommand(0x27);
_bus->sendData(0x1C);
_bus->sendCommand(0x28);
_bus->sendData(0x23);
_bus->sendCommand(0x29);
_bus->sendData(0x2E);
_bus->sendCommand(0x2A);
_bus->sendData(0x36);
_bus->sendCommand(0x2B);
_bus->sendData(0x3F);
_bus->sendCommand(0x2C);
_bus->sendData(0x47);
_bus->sendCommand(0x2D);
_bus->sendData(0x50);
_bus->sendCommand(0x2E);
_bus->sendData(0x57);
_bus->sendCommand(0x2F);
_bus->sendData(0x5F);
_bus->sendCommand(0x30);
_bus->sendData(0x67);
_bus->sendCommand(0x31);
_bus->sendData(0x6F);
_bus->sendCommand(0x32);
_bus->sendData(0x76);
_bus->sendCommand(0x33);
_bus->sendData(0x7F);
_bus->sendCommand(0x34);
_bus->sendData(0x87);
_bus->sendCommand(0x35);
_bus->sendData(0x90);
_bus->sendCommand(0x36);
_bus->sendData(0x99);
_bus->sendCommand(0x37);
_bus->sendData(0xA3);
_bus->sendCommand(0x38);
_bus->sendData(0xAD);
_bus->sendCommand(0x39);
_bus->sendData(0xB4);
_bus->sendCommand(0x3A);
_bus->sendData(0xBB);
_bus->sendCommand(0x3B);
_bus->sendData(0xC4);
_bus->sendCommand(0x3C);
_bus->sendData(0xCE);
_bus->sendCommand(0x3D);
_bus->sendData(0xD9);
_bus->sendCommand(0x3E);
_bus->sendData(0xE3);
_bus->sendCommand(0x3F);
_bus->sendData(0xEC);
_bus->sendCommand(0x40);
_bus->sendData(0xF3);
_bus->sendCommand(0x41);
_bus->sendData(0xF7);
_bus->sendCommand(0x42);
_bus->sendData(0xFC);
_bus->sendCommand(0x43);
_bus->sendData(0x00);
_bus->sendCommand(0x44);
_bus->sendData(0x06);
_bus->sendCommand(0x45);
_bus->sendData(0x0C);
_bus->sendCommand(0x46);
_bus->sendData(0x12);
_bus->sendCommand(0x47);
_bus->sendData(0x16);
_bus->sendCommand(0x48);
_bus->sendData(0x1C);
_bus->sendCommand(0x49);
_bus->sendData(0x23);
_bus->sendCommand(0x4A);
_bus->sendData(0x2E);
_bus->sendCommand(0x4B);
_bus->sendData(0x36);
_bus->sendCommand(0x4C);
_bus->sendData(0x3F);
_bus->sendCommand(0x4D);
_bus->sendData(0x47);
_bus->sendCommand(0x4E);
_bus->sendData(0x50);
_bus->sendCommand(0x4F);
_bus->sendData(0x57);
_bus->sendCommand(0x50);
_bus->sendData(0x5F);
_bus->sendCommand(0x51);
_bus->sendData(0x67);
_bus->sendCommand(0x52);
_bus->sendData(0x6F);
_bus->sendCommand(0x53);
_bus->sendData(0x76);
_bus->sendCommand(0x54);
_bus->sendData(0x7F);
_bus->sendCommand(0x55);
_bus->sendData(0x87);
_bus->sendCommand(0x56);
_bus->sendData(0x90);
_bus->sendCommand(0x57);
_bus->sendData(0x99);
_bus->sendCommand(0x58);
_bus->sendData(0xA3);
_bus->sendCommand(0x59);
_bus->sendData(0xAD);
_bus->sendCommand(0x5A);
_bus->sendData(0xB4);
_bus->sendCommand(0x5B);
_bus->sendData(0xBB);
_bus->sendCommand(0x5C);
_bus->sendData(0xC4);
_bus->sendCommand(0x5D);
_bus->sendData(0xCE);
_bus->sendCommand(0x5E);
_bus->sendData(0xD9);
_bus->sendCommand(0x5F);
_bus->sendData(0xE3);
_bus->sendCommand(0x60);
_bus->sendData(0xEC);
_bus->sendCommand(0x61);
_bus->sendData(0xF3);
_bus->sendCommand(0x62);
_bus->sendData(0xF7);
_bus->sendCommand(0x63);
_bus->sendData(0xFC);
_bus->sendCommand(0xFF);
_bus->sendData(0x00); // Page0
// Display ON Setting
_bus->sendCommand(0x28);
_bus->sendData(0x38); // GON=1, DTE=1, D=10
delay(40);
_bus->sendCommand(0x28);
_bus->sendData(0x3C); // GON=1, DTE=1, D=11
_bus->sendCommand(0x22); // Start GRAM write
}
void Arduino_HX8347C::writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h)
{
if ((x != _currentX) || (w != _currentW))
{
int16_t x_start = x + _xStart, x_end = x + w - 1 + _xStart;
_bus->writeCommand(0x02);
_bus->write(x_start >> 8);
_bus->writeCommand(0x03);
_bus->write(x_start & 0xFF);
_bus->writeCommand(0x04);
_bus->write(x_end >> 8);
_bus->writeCommand(0x05);
_bus->write(x_end & 0xFF);
_currentX = x;
_currentW = w;
}
if ((y != _currentY) || (h != _currentH))
{
int16_t y_start = y + _yStart, y_end = y + h - 1 + _yStart;
_bus->writeCommand(0x06);
_bus->write(y_start >> 8);
_bus->writeCommand(0x07);
_bus->write(y_start & 0xFF);
_bus->writeCommand(0x08);
_bus->write(y_end >> 8);
_bus->writeCommand(0x09);
_bus->write(y_end & 0xFF);
_currentY = y;
_currentH = h;
}
_bus->writeCommand(0x22); // write to RAM
}
/**************************************************************************/
/*!
@brief Set origin of (0,0) and orientation of TFT display
@param m The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Arduino_HX8347C::setRotation(uint8_t r)
{
Arduino_TFT::setRotation(r);
switch (_rotation)
{
case 1:
_bus->sendCommand(0x36);
_bus->sendData(_invert ? 0x13 : 0x03);
_bus->sendCommand(0x16);
_bus->sendData(0x60);
break;
case 2:
_bus->sendCommand(0x36);
_bus->sendData(_invert ? 0x13 : 0x03);
_bus->sendCommand(0x16);
_bus->sendData(0x00);
break;
case 3:
_bus->sendCommand(0x36);
_bus->sendData(_invert ? 0x17 : 0x07);
_bus->sendCommand(0x16);
_bus->sendData(0x20);
break;
default: // case 0:
_bus->sendCommand(0x36);
_bus->sendData(_invert ? 0x17 : 0x07);
_bus->sendCommand(0x16);
_bus->sendData(0x40);
break;
}
}
void Arduino_HX8347C::invertDisplay(bool i)
{
_invert = _ips ^ i;
setRotation(_rotation); // set invert by calling setRotation()
}
void Arduino_HX8347C::displayOn(void)
{
_bus->sendCommand(0x28);
_bus->sendData(0x3C); // GON=1, DTE=1, D=11
}
void Arduino_HX8347C::displayOff(void)
{
_bus->sendCommand(0x28);
_bus->sendData(0x34); // GON=1, DTE=1, D=01
delay(40);
}
@@ -0,0 +1,40 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_HX8347C_H_
#define _ARDUINO_HX8347C_H_
#include <Arduino.h>
#include <Print.h>
#include "../Arduino_GFX.h"
#include "../Arduino_TFT.h"
#define HX8347C_TFTWIDTH 240 ///< HX8347C max TFT width
#define HX8347C_TFTHEIGHT 320 ///< HX8347C max TFT height
#define HX8347C_RST_DELAY 120
class Arduino_HX8347C : public Arduino_TFT
{
public:
Arduino_HX8347C(
Arduino_DataBus *bus, int8_t rst = GFX_NOT_DEFINED, uint8_t r = 0,
bool ips = false, int16_t w = HX8347C_TFTWIDTH, int16_t h = HX8347C_TFTHEIGHT,
uint8_t col_offset1 = 0, uint8_t row_offset1 = 0, uint8_t col_offset2 = 0, uint8_t row_offset2 = 0);
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) override;
void setRotation(uint8_t r) override;
void invertDisplay(bool) override;
void displayOn() override;
void displayOff() override;
protected:
void tftInit() override;
bool _invert = false;
private:
};
#endif
@@ -0,0 +1,127 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#include "Arduino_HX8347D.h"
#include "SPI.h"
Arduino_HX8347D::Arduino_HX8347D(
Arduino_DataBus *bus, int8_t rst, uint8_t r,
bool ips, int16_t w, int16_t h,
uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2)
: Arduino_TFT(bus, rst, r, ips, w, h, col_offset1, row_offset1, col_offset2, row_offset2)
{
}
bool Arduino_HX8347D::begin(int32_t speed)
{
#if defined(__AVR__)
_override_datamode = SPI_MODE0;
#endif
return Arduino_TFT::begin(speed);
}
// Companion code to the above tables. Reads and issues
// a series of LCD commands stored in PROGMEM byte array.
void Arduino_HX8347D::tftInit()
{
if (_rst != GFX_NOT_DEFINED)
{
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(100);
digitalWrite(_rst, LOW);
delay(HX8347D_RST_DELAY);
digitalWrite(_rst, HIGH);
delay(HX8347D_RST_DELAY);
}
else
{
// Software Rest
}
_bus->batchOperation(hx8347d_init_operations, sizeof(hx8347d_init_operations));
invertDisplay(false);
}
void Arduino_HX8347D::writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h)
{
if ((x != _currentX) || (w != _currentW))
{
int16_t x_start = x + _xStart, x_end = x + w - 1 + _xStart;
_bus->writeC8D8(0x02, x_start >> 8);
_bus->writeC8D8(0x03, x_start & 0xFF);
_bus->writeC8D8(0x04, x_end >> 8);
_bus->writeC8D8(0x05, x_end & 0xFF);
_currentX = x;
_currentW = w;
}
if ((y != _currentY) || (h != _currentH))
{
int16_t y_start = y + _yStart, y_end = y + h - 1 + _yStart;
_bus->writeC8D8(0x06, y_start >> 8);
_bus->writeC8D8(0x07, y_start & 0xFF);
_bus->writeC8D8(0x08, y_end >> 8);
_bus->writeC8D8(0x09, y_end & 0xFF);
_currentY = y;
_currentH = h;
}
_bus->writeCommand(0x22); // write to RAM
}
/**************************************************************************/
/*!
@brief Set origin of (0,0) and orientation of TFT display
@param m The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Arduino_HX8347D::setRotation(uint8_t r)
{
Arduino_TFT::setRotation(r);
_bus->beginWrite();
switch (_rotation)
{
case 1:
_bus->writeC8D8(0x36, 0x03);
_bus->writeC8D8(0x16, 0x20);
break;
case 2:
_bus->writeC8D8(0x36, 0x07);
_bus->writeC8D8(0x16, 0x00);
break;
case 3:
_bus->writeC8D8(0x36, 0x07);
_bus->writeC8D8(0x16, 0x60);
break;
default: // case 0:
_bus->writeC8D8(0x36, 0x03);
_bus->writeC8D8(0x16, 0x40);
break;
}
_bus->endWrite();
}
void Arduino_HX8347D::invertDisplay(bool i)
{
_bus->beginWrite();
_bus->writeC8D8(HX8347D_DISPLAY_MODE_CONTROL, (_ips ^ i) ? HX8347D_INV_ON : HX8347D_INV_OFF);
_bus->endWrite();
}
void Arduino_HX8347D::displayOn(void)
{
_bus->sendCommand(0x28);
_bus->sendData(0x3C); // GON=1, DTE=1, D=11
}
void Arduino_HX8347D::displayOff(void)
{
_bus->sendCommand(0x28);
_bus->sendData(0x34); // GON=1, DTE=1, D=01
delay(40);
}
@@ -0,0 +1,99 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_HX8347D_H_
#define _ARDUINO_HX8347D_H_
#include <Arduino.h>
#include <Print.h>
#include "../Arduino_GFX.h"
#include "../Arduino_TFT.h"
#define HX8347D_TFTWIDTH 240 ///< HX8347D max TFT width
#define HX8347D_TFTHEIGHT 320 ///< HX8347D max TFT height
#define HX8347D_RST_DELAY 120
#define HX8347D_DISPLAY_MODE_CONTROL 0x01 // Display Mode control
#define HX8347D_INV_OFF 0x00 // INV_ON disable
#define HX8347D_INV_ON 0x02 // INV_ON enable
static const uint8_t hx8347d_init_operations[] = {
BEGIN_WRITE,
WRITE_C8_D8, 0xEA, 0x00,
WRITE_C8_D8, 0xEB, 0x20,
WRITE_C8_D8, 0xEC, 0x0C,
WRITE_C8_D8, 0xED, 0xC4,
WRITE_C8_D8, 0xE8, 0x38,
WRITE_C8_D8, 0xE9, 0x10,
WRITE_C8_D8, 0xF1, 0x01,
WRITE_C8_D8, 0xF2, 0x10,
WRITE_C8_D8, 0x40, 0x01,
WRITE_C8_D8, 0x41, 0x00,
WRITE_C8_D8, 0x42, 0x00,
WRITE_C8_D8, 0x43, 0x10,
WRITE_C8_D8, 0x44, 0x0E,
WRITE_C8_D8, 0x45, 0x24,
WRITE_C8_D8, 0x46, 0x04,
WRITE_C8_D8, 0x47, 0x50,
WRITE_C8_D8, 0x48, 0x02,
WRITE_C8_D8, 0x49, 0x13,
WRITE_C8_D8, 0x4A, 0x19,
WRITE_C8_D8, 0x4B, 0x19,
WRITE_C8_D8, 0x4C, 0x16,
WRITE_C8_D8, 0x50, 0x1B,
WRITE_C8_D8, 0x51, 0x31,
WRITE_C8_D8, 0x52, 0x2F,
WRITE_C8_D8, 0x53, 0x3F,
WRITE_C8_D8, 0x54, 0x3F,
WRITE_C8_D8, 0x55, 0x3E,
WRITE_C8_D8, 0x56, 0x2F,
WRITE_C8_D8, 0x57, 0x7B,
WRITE_C8_D8, 0x58, 0x09,
WRITE_C8_D8, 0x59, 0x06,
WRITE_C8_D8, 0x5A, 0x06,
WRITE_C8_D8, 0x5B, 0x0C,
WRITE_C8_D8, 0x5C, 0x1D,
WRITE_C8_D8, 0x5D, 0xCC,
WRITE_C8_D8, 0x1B, 0x1B,
WRITE_C8_D8, 0x1A, 0x01,
WRITE_C8_D8, 0x24, 0x2F,
WRITE_C8_D8, 0x25, 0x57,
WRITE_C8_D8, 0x23, 0x88,
WRITE_C8_D8, 0x18, 0x34,
WRITE_C8_D8, 0x19, 0x01,
WRITE_C8_D8, 0x1F, 0x88,
WRITE_C8_D8, 0x1F, 0x80,
WRITE_C8_D8, 0x1F, 0x90,
WRITE_C8_D8, 0x1F, 0xD0,
WRITE_C8_D8, 0x17, 0x05,
WRITE_C8_D8, 0x28, 0x38,
WRITE_C8_D8, 0x28, 0x3F,
WRITE_C8_D8, 0x16, 0x18,
END_WRITE};
class Arduino_HX8347D : public Arduino_TFT
{
public:
Arduino_HX8347D(
Arduino_DataBus *bus, int8_t rst = GFX_NOT_DEFINED, uint8_t r = 0,
bool ips = false, int16_t w = HX8347D_TFTWIDTH, int16_t h = HX8347D_TFTHEIGHT,
uint8_t col_offset1 = 0, uint8_t row_offset1 = 0, uint8_t col_offset2 = 0, uint8_t row_offset2 = 0);
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) override;
void setRotation(uint8_t r) override;
void invertDisplay(bool) override;
void displayOn() override;
void displayOff() override;
protected:
void tftInit() override;
bool _invert = false;
private:
};
#endif
@@ -0,0 +1,422 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#include "Arduino_HX8352C.h"
Arduino_HX8352C::Arduino_HX8352C(
Arduino_DataBus *bus, int8_t rst, uint8_t r,
bool ips, int16_t w, int16_t h,
uint8_t col_offset1, uint8_t row_offset1, uint8_t col_offset2, uint8_t row_offset2)
: Arduino_TFT(bus, rst, r, ips, w, h, col_offset1, row_offset1, col_offset2, row_offset2)
{
_invert = ips;
}
bool Arduino_HX8352C::begin(int32_t speed)
{
return Arduino_TFT::begin(speed);
}
// Companion code to the above tables. Reads and issues
// a series of LCD commands stored in PROGMEM byte array.
void Arduino_HX8352C::tftInit()
{
if (_rst != GFX_NOT_DEFINED)
{
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(100);
digitalWrite(_rst, LOW);
delay(HX8352C_RST_DELAY);
digitalWrite(_rst, HIGH);
delay(HX8352C_RST_DELAY);
}
else
{
// Software Rest
}
// LCD Init For 3.0inch LCD Panel with HX8352C.
// Power Voltage Setting
_bus->sendCommand(0x1A);
_bus->sendData(0x02); // BT
_bus->sendCommand(0x1B);
_bus->sendData(0x8B); // VRH
//****VCOM offset**///
_bus->sendCommand(0x23);
_bus->sendData(0x00); // SEL_VCM
_bus->sendCommand(0x24);
_bus->sendData(0x5D); // VCM
_bus->sendCommand(0x25);
_bus->sendData(0x15); // VDV
_bus->sendCommand(0x2D);
_bus->sendData(0x01); // NOW[2:0]=001
//****OPON**//
_bus->sendCommand(0xE8);
_bus->sendData(0x60);
// Power on Setting
_bus->sendCommand(0x18);
_bus->sendData(0x04); // Frame rate 72Hz
_bus->sendCommand(0x19);
_bus->sendData(0x01); // OSC_EN='1', start Osc
_bus->sendCommand(0x01);
_bus->sendData(0x00); // DP_STB='0', out deep sleep
_bus->sendCommand(0x1F);
_bus->sendData(0x88); // STB=0
delay(5);
_bus->sendCommand(0x1F);
_bus->sendData(0x80); // DK=0
delay(5);
_bus->sendCommand(0x1F);
_bus->sendData(0x90); // PON=1
delay(5);
_bus->sendCommand(0x1F);
_bus->sendData(0xD0); // VCOMG=1
delay(5);
// 262k/65k color selection
_bus->sendCommand(0x17);
_bus->sendData(0x05); // default 0x06 262k color // 0x05 65k color
// SET PANEL
_bus->sendCommand(0x29);
_bus->sendData(0x31); // 400 lines
_bus->sendCommand(0x71);
_bus->sendData(0x1A); // RTN
// Gamma 2.2 Setting
_bus->sendCommand(0x40);
_bus->sendData(0x00);
_bus->sendCommand(0x41);
_bus->sendData(0x77);
_bus->sendCommand(0x42);
_bus->sendData(0x77);
_bus->sendCommand(0x43);
_bus->sendData(0x00);
_bus->sendCommand(0x44);
_bus->sendData(0x04);
_bus->sendCommand(0x45);
_bus->sendData(0x00);
_bus->sendCommand(0x46);
_bus->sendData(0x00);
_bus->sendCommand(0x47);
_bus->sendData(0x00);
_bus->sendCommand(0x48);
_bus->sendData(0x77);
_bus->sendCommand(0x49);
_bus->sendData(0x00);
_bus->sendCommand(0x4A);
_bus->sendData(0x00);
_bus->sendCommand(0x4B);
_bus->sendData(0x08);
_bus->sendCommand(0x4C);
_bus->sendData(0x00);
_bus->sendCommand(0x4D);
_bus->sendData(0x00);
_bus->sendCommand(0x4E);
_bus->sendData(0x00);
// Set DGC
_bus->sendCommand(0xFF);
_bus->sendData(0x01); // Page1
_bus->sendCommand(0x00);
_bus->sendData(0x01); // DGC_EN
_bus->sendCommand(0x01);
_bus->sendData(0x00);
_bus->sendCommand(0x02);
_bus->sendData(0x06);
_bus->sendCommand(0x03);
_bus->sendData(0x0C);
_bus->sendCommand(0x04);
_bus->sendData(0x12);
_bus->sendCommand(0x05);
_bus->sendData(0x16);
_bus->sendCommand(0x06);
_bus->sendData(0x1C);
_bus->sendCommand(0x07);
_bus->sendData(0x23);
_bus->sendCommand(0x08);
_bus->sendData(0x2E);
_bus->sendCommand(0x09);
_bus->sendData(0x36);
_bus->sendCommand(0x0A);
_bus->sendData(0x3F);
_bus->sendCommand(0x0B);
_bus->sendData(0x47);
_bus->sendCommand(0x0C);
_bus->sendData(0x50);
_bus->sendCommand(0x0D);
_bus->sendData(0x57);
_bus->sendCommand(0x0E);
_bus->sendData(0x5F);
_bus->sendCommand(0x0F);
_bus->sendData(0x67);
_bus->sendCommand(0x10);
_bus->sendData(0x6F);
_bus->sendCommand(0x11);
_bus->sendData(0x76);
_bus->sendCommand(0x12);
_bus->sendData(0x7F);
_bus->sendCommand(0x13);
_bus->sendData(0x87);
_bus->sendCommand(0x14);
_bus->sendData(0x90);
_bus->sendCommand(0x15);
_bus->sendData(0x99);
_bus->sendCommand(0x16);
_bus->sendData(0xA3);
_bus->sendCommand(0x17);
_bus->sendData(0xAD);
_bus->sendCommand(0x18);
_bus->sendData(0xB4);
_bus->sendCommand(0x19);
_bus->sendData(0xBB);
_bus->sendCommand(0x1A);
_bus->sendData(0xC4);
_bus->sendCommand(0x1B);
_bus->sendData(0xCE);
_bus->sendCommand(0x1C);
_bus->sendData(0xD9);
_bus->sendCommand(0x1D);
_bus->sendData(0xE3);
_bus->sendCommand(0x1E);
_bus->sendData(0xEC);
_bus->sendCommand(0x1F);
_bus->sendData(0xF3);
_bus->sendCommand(0x20);
_bus->sendData(0xF7);
_bus->sendCommand(0x21);
_bus->sendData(0xFC);
_bus->sendCommand(0x22);
_bus->sendData(0x00);
_bus->sendCommand(0x23);
_bus->sendData(0x06);
_bus->sendCommand(0x24);
_bus->sendData(0x0C);
_bus->sendCommand(0x25);
_bus->sendData(0x12);
_bus->sendCommand(0x26);
_bus->sendData(0x16);
_bus->sendCommand(0x27);
_bus->sendData(0x1C);
_bus->sendCommand(0x28);
_bus->sendData(0x23);
_bus->sendCommand(0x29);
_bus->sendData(0x2E);
_bus->sendCommand(0x2A);
_bus->sendData(0x36);
_bus->sendCommand(0x2B);
_bus->sendData(0x3F);
_bus->sendCommand(0x2C);
_bus->sendData(0x47);
_bus->sendCommand(0x2D);
_bus->sendData(0x50);
_bus->sendCommand(0x2E);
_bus->sendData(0x57);
_bus->sendCommand(0x2F);
_bus->sendData(0x5F);
_bus->sendCommand(0x30);
_bus->sendData(0x67);
_bus->sendCommand(0x31);
_bus->sendData(0x6F);
_bus->sendCommand(0x32);
_bus->sendData(0x76);
_bus->sendCommand(0x33);
_bus->sendData(0x7F);
_bus->sendCommand(0x34);
_bus->sendData(0x87);
_bus->sendCommand(0x35);
_bus->sendData(0x90);
_bus->sendCommand(0x36);
_bus->sendData(0x99);
_bus->sendCommand(0x37);
_bus->sendData(0xA3);
_bus->sendCommand(0x38);
_bus->sendData(0xAD);
_bus->sendCommand(0x39);
_bus->sendData(0xB4);
_bus->sendCommand(0x3A);
_bus->sendData(0xBB);
_bus->sendCommand(0x3B);
_bus->sendData(0xC4);
_bus->sendCommand(0x3C);
_bus->sendData(0xCE);
_bus->sendCommand(0x3D);
_bus->sendData(0xD9);
_bus->sendCommand(0x3E);
_bus->sendData(0xE3);
_bus->sendCommand(0x3F);
_bus->sendData(0xEC);
_bus->sendCommand(0x40);
_bus->sendData(0xF3);
_bus->sendCommand(0x41);
_bus->sendData(0xF7);
_bus->sendCommand(0x42);
_bus->sendData(0xFC);
_bus->sendCommand(0x43);
_bus->sendData(0x00);
_bus->sendCommand(0x44);
_bus->sendData(0x06);
_bus->sendCommand(0x45);
_bus->sendData(0x0C);
_bus->sendCommand(0x46);
_bus->sendData(0x12);
_bus->sendCommand(0x47);
_bus->sendData(0x16);
_bus->sendCommand(0x48);
_bus->sendData(0x1C);
_bus->sendCommand(0x49);
_bus->sendData(0x23);
_bus->sendCommand(0x4A);
_bus->sendData(0x2E);
_bus->sendCommand(0x4B);
_bus->sendData(0x36);
_bus->sendCommand(0x4C);
_bus->sendData(0x3F);
_bus->sendCommand(0x4D);
_bus->sendData(0x47);
_bus->sendCommand(0x4E);
_bus->sendData(0x50);
_bus->sendCommand(0x4F);
_bus->sendData(0x57);
_bus->sendCommand(0x50);
_bus->sendData(0x5F);
_bus->sendCommand(0x51);
_bus->sendData(0x67);
_bus->sendCommand(0x52);
_bus->sendData(0x6F);
_bus->sendCommand(0x53);
_bus->sendData(0x76);
_bus->sendCommand(0x54);
_bus->sendData(0x7F);
_bus->sendCommand(0x55);
_bus->sendData(0x87);
_bus->sendCommand(0x56);
_bus->sendData(0x90);
_bus->sendCommand(0x57);
_bus->sendData(0x99);
_bus->sendCommand(0x58);
_bus->sendData(0xA3);
_bus->sendCommand(0x59);
_bus->sendData(0xAD);
_bus->sendCommand(0x5A);
_bus->sendData(0xB4);
_bus->sendCommand(0x5B);
_bus->sendData(0xBB);
_bus->sendCommand(0x5C);
_bus->sendData(0xC4);
_bus->sendCommand(0x5D);
_bus->sendData(0xCE);
_bus->sendCommand(0x5E);
_bus->sendData(0xD9);
_bus->sendCommand(0x5F);
_bus->sendData(0xE3);
_bus->sendCommand(0x60);
_bus->sendData(0xEC);
_bus->sendCommand(0x61);
_bus->sendData(0xF3);
_bus->sendCommand(0x62);
_bus->sendData(0xF7);
_bus->sendCommand(0x63);
_bus->sendData(0xFC);
_bus->sendCommand(0xFF);
_bus->sendData(0x00); // Page0
// Display ON Setting
_bus->sendCommand(0x28);
_bus->sendData(0x38); // GON=1, DTE=1, D=10
delay(40);
_bus->sendCommand(0x28);
_bus->sendData(0x3C); // GON=1, DTE=1, D=11
_bus->sendCommand(0x22); // Start GRAM write
}
void Arduino_HX8352C::writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h)
{
if ((x != _currentX) || (w != _currentW))
{
int16_t x_start = x + _xStart, x_end = x + w - 1 + _xStart;
_bus->writeCommand(0x02);
_bus->write(x_start >> 8);
_bus->writeCommand(0x03);
_bus->write(x_start & 0xFF);
_bus->writeCommand(0x04);
_bus->write(x_end >> 8);
_bus->writeCommand(0x05);
_bus->write(x_end & 0xFF);
_currentX = x;
_currentW = w;
}
if ((y != _currentY) || (h != _currentH))
{
int16_t y_start = y + _yStart, y_end = y + h - 1 + _yStart;
_bus->writeCommand(0x06);
_bus->write(y_start >> 8);
_bus->writeCommand(0x07);
_bus->write(y_start & 0xFF);
_bus->writeCommand(0x08);
_bus->write(y_end >> 8);
_bus->writeCommand(0x09);
_bus->write(y_end & 0xFF);
_currentY = y;
_currentH = h;
}
_bus->writeCommand(0x22); // write to RAM
}
/**************************************************************************/
/*!
@brief Set origin of (0,0) and orientation of TFT display
@param m The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Arduino_HX8352C::setRotation(uint8_t r)
{
Arduino_TFT::setRotation(r);
switch (_rotation)
{
case 1:
_bus->sendCommand(0x36);
_bus->sendData(_invert ? 0x13 : 0x03);
_bus->sendCommand(0x16);
_bus->sendData(0x60);
break;
case 2:
_bus->sendCommand(0x36);
_bus->sendData(_invert ? 0x13 : 0x03);
_bus->sendCommand(0x16);
_bus->sendData(0x00);
break;
case 3:
_bus->sendCommand(0x36);
_bus->sendData(_invert ? 0x17 : 0x07);
_bus->sendCommand(0x16);
_bus->sendData(0x20);
break;
default: // case 0:
_bus->sendCommand(0x36);
_bus->sendData(_invert ? 0x17 : 0x07);
_bus->sendCommand(0x16);
_bus->sendData(0x40);
break;
}
}
void Arduino_HX8352C::invertDisplay(bool i)
{
_invert = _ips ^ i;
setRotation(_rotation); // set invert by calling setRotation()
}
void Arduino_HX8352C::displayOn(void)
{
_bus->sendCommand(0x28);
_bus->sendData(0x3C); // GON=1, DTE=1, D=11
}
void Arduino_HX8352C::displayOff(void)
{
_bus->sendCommand(0x28);
_bus->sendData(0x34); // GON=1, DTE=1, D=01
delay(40);
}
@@ -0,0 +1,40 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_HX8352C_H_
#define _ARDUINO_HX8352C_H_
#include <Arduino.h>
#include <Print.h>
#include "../Arduino_GFX.h"
#include "../Arduino_TFT.h"
#define HX8352C_TFTWIDTH 240 ///< HX8352C max TFT width
#define HX8352C_TFTHEIGHT 400 ///< HX8352C max TFT height
#define HX8352C_RST_DELAY 120
class Arduino_HX8352C : public Arduino_TFT
{
public:
Arduino_HX8352C(
Arduino_DataBus *bus, int8_t rst = GFX_NOT_DEFINED, uint8_t r = 0,
bool ips = false, int16_t w = HX8352C_TFTWIDTH, int16_t h = HX8352C_TFTHEIGHT,
uint8_t col_offset1 = 0, uint8_t row_offset1 = 0, uint8_t col_offset2 = 0, uint8_t row_offset2 = 0);
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) override;
void setRotation(uint8_t r) override;
void invertDisplay(bool) override;
void displayOn() override;
void displayOff() override;
protected:
void tftInit() override;
bool _invert = false;
private:
};
#endif
@@ -0,0 +1,145 @@
#include "Arduino_HX8357A.h"
Arduino_HX8357A::Arduino_HX8357A(Arduino_DataBus *bus, int8_t rst, uint8_t r, bool ips)
: Arduino_TFT(bus, rst, r, ips, HX8357A_TFTWIDTH, HX8357A_TFTHEIGHT, 0, 0, 0, 0)
{
}
bool Arduino_HX8357A::begin(int32_t speed)
{
return Arduino_TFT::begin(speed);
}
/**************************************************************************/
/*!
@brief Set origin of (0,0) and orientation of TFT display
@param m The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Arduino_HX8357A::setRotation(uint8_t r)
{
Arduino_TFT::setRotation(r);
switch (_rotation)
{
case 3:
// TODO: not working
r = (HX8357A_MADCTL_MY | HX8357A_MADCTL_MV | HX8357A_MADCTL_BGR);
break;
case 2:
r = (HX8357A_MADCTL_MX | HX8357A_MADCTL_BGR);
break;
case 1:
// TODO: not working
r = (HX8357A_MADCTL_MX | HX8357A_MADCTL_MV | HX8357A_MADCTL_BGR);
break;
default: // case 0:
r = (HX8357A_MADCTL_MY | HX8357A_MADCTL_BGR);
break;
}
_bus->beginWrite();
_bus->writeC8D8(HX8357A_MEMORY_ACCESS_CONTROL, r);
_bus->endWrite();
}
void Arduino_HX8357A::writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h)
{
if ((x != _currentX) || (w != _currentW))
{
_currentX = x;
_currentW = w;
x += _xStart;
_data16.value = x;
_bus->writeC8D8(HX8357A_COLUMN_ADDRESS_COUNTER_2, _data16.msb);
_bus->writeC8D8(HX8357A_COLUMN_ADDRESS_COUNTER_1, _data16.lsb);
_bus->writeC8D8(HX8357A_COLUMN_ADDRESS_START_2, _data16.msb);
_bus->writeC8D8(HX8357A_COLUMN_ADDRESS_START_1, _data16.lsb);
_data16.value = x + w - 1;
_bus->writeC8D8(HX8357A_COLUMN_ADDRESS_END_2, _data16.msb);
_bus->writeC8D8(HX8357A_COLUMN_ADDRESS_END_1, _data16.lsb);
}
if ((y != _currentY) || (h != _currentH))
{
_currentY = y;
_currentH = h;
y += _yStart;
_data16.value = y;
_bus->writeC8D8(HX8357A_ROW_ADDRESS_COUNTER_2, _data16.msb);
_bus->writeC8D8(HX8357A_ROW_ADDRESS_COUNTER_1, _data16.lsb);
_bus->writeC8D8(HX8357A_ROW_ADDRESS_START_2, _data16.msb);
_bus->writeC8D8(HX8357A_ROW_ADDRESS_START_1, _data16.lsb);
_data16.value = y + h - 1;
_bus->writeC8D8(HX8357A_ROW_ADDRESS_END_2, _data16.msb);
_bus->writeC8D8(HX8357A_ROW_ADDRESS_END_1, _data16.lsb);
}
_bus->writeCommand(HX8357A_SRAM_CONTROL);
}
void Arduino_HX8357A::invertDisplay(bool i)
{
_bus->beginWrite();
_bus->writeC8D8(HX8357A_DISPLAY_MODE_CONTROL, (_ips ^ i) ? HX8357A_INV_ON : HX8357A_INV_OFF);
_bus->endWrite();
}
void Arduino_HX8357A::displayOn(void)
{
_bus->beginWrite();
_bus->writeC8D8(HX8357A_OSC_CONTROL_2, 0x01); // OSC_EN=1
_bus->endWrite();
delay(5);
_bus->beginWrite();
_bus->writeC8D8(HX8357A_POWER_CONTROL_1, 0x88); // PON=0, DK=1
_bus->writeC8D8(HX8357A_DISPLAY_MODE_CONTROL, 0x00); // DP_STB=00
_bus->writeC8D8(HX8357A_POWER_CONTROL_4, 0x03); // AP=011
_bus->writeC8D8(HX8357A_POWER_CONTROL_1, 0x80); // DK=0
_bus->endWrite();
delay(3);
_bus->beginWrite();
_bus->writeC8D8(HX8357A_POWER_CONTROL_1, 0x90); // PON=1
_bus->endWrite();
delay(3);
_bus->beginWrite();
_bus->writeC8D8(HX8357A_POWER_CONTROL_1, 0xD0); // VCOMG=1
_bus->writeC8D8(HX8357A_DISPLAY_CONTROL_3, 0x3C); // GON=1, DTE=1, D[1:0]=11
_bus->endWrite();
}
void Arduino_HX8357A::displayOff(void)
{
_bus->beginWrite();
_bus->writeC8D8(HX8357A_DISPLAY_CONTROL_3, 0x34); // GON=1, DTE=1, D[1:0]=01
_bus->writeC8D8(HX8357A_POWER_CONTROL_1, 0x90); // VCOMG=0
_bus->endWrite();
delay(1);
_bus->beginWrite();
_bus->writeC8D8(HX8357A_POWER_CONTROL_1, 0x88); // PON=0, DK=1
_bus->writeC8D8(HX8357A_POWER_CONTROL_4, 0x00); // AP=000
_bus->writeC8D8(HX8357A_POWER_CONTROL_1, 0x89); // STB=1
_bus->endWrite();
}
// Companion code to the above tables. Reads and issues
// a series of LCD commands stored in PROGMEM byte array.
void Arduino_HX8357A::tftInit()
{
if (_rst != GFX_NOT_DEFINED)
{
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(100);
digitalWrite(_rst, LOW);
delay(HX8357A_RST_DELAY);
digitalWrite(_rst, HIGH);
delay(HX8357A_RST_DELAY);
}
else
{
// Software Rest
}
_bus->batchOperation(hx8357a_init_operations, sizeof(hx8357a_init_operations));
invertDisplay(false);
}
@@ -0,0 +1,456 @@
#ifndef _ARDUINO_HX8357A_H_
#define _ARDUINO_HX8357A_H_
#include <Arduino.h>
#include <Print.h>
#include "../Arduino_GFX.h"
#include "../Arduino_TFT.h"
#define HX8357A_TFTWIDTH 320 // HX8357A max TFT width
#define HX8357A_TFTHEIGHT 480 // HX8357A max TFT height
#define HX8357A_RST_DELAY 1200 // delay ms wait for reset finish
#define HX8357A_HIMAX_ID 0x00 // Himax ID
#define HX8357A_DISPLAY_MODE_CONTROL 0x01 // Display Mode control
#define HX8357A_COLUMN_ADDRESS_START_2 0x02 // Column address start 2
#define HX8357A_COLUMN_ADDRESS_START_1 0x03 // Column address start 1
#define HX8357A_COLUMN_ADDRESS_END_2 0x04 // Column address end 2
#define HX8357A_COLUMN_ADDRESS_END_1 0x05 // Column address end 1
#define HX8357A_ROW_ADDRESS_START_2 0x06 // Row address start 2
#define HX8357A_ROW_ADDRESS_START_1 0x07 // Row address start 1
#define HX8357A_ROW_ADDRESS_END_2 0x08 // Row address end 2
#define HX8357A_ROW_ADDRESS_END_1 0x09 // Row address end 1
#define HX8357A_PARTIAL_ASREA_START_ROW_2 0x0A // Partial area start row 2
#define HX8357A_PARTIAL_AREA_START_ROW_1 0x0B // Partial area start row 1
#define HX8357A_PARTIAL_AREA_END_ROW_2 0x0C // Partial area end row 2
#define HX8357A_PARTIAL_AREA_END_ROW_1 0x0D // Partial area end row 1
#define HX8357A_VERTICAL_SCROLL_TOP_FIXED_AREA_2 0x0E // Vertical Scroll Top fixed area 2
#define HX8357A_VERTICAL_SCROLL_TOP_FIXED_AREA_1 0x0F // Vertical Scroll Top fixed area 1
#define HX8357A_VERTICAL_SCROLL_HEIGHT_AREA_2 0x10 // Vertical Scroll height area 2
#define HX8357A_VERTICAL_SCROLL_HEIGHT_AREA_1 0x11 // Vertical Scroll height area 1
#define HX8357A_VERTICAL_SCROLL_BUTTON_AREA_2 0x12 // Vertical Scroll Button area 2
#define HX8357A_VERTICAL_SCROLL_BUTTON_AREA_1 0x13 // Vertical Scroll Button area 1
#define HX8357A_VERTICAL_SCROLL_START_ADDRESS_2 0x14 // Vertical Scroll Start address 2
#define HX8357A_VERTICAL_SCROLL_START_ADDRESS_1 0x15 // Vertical Scroll Start address 1
#define HX8357A_MEMORY_ACCESS_CONTROL 0x16 // Memory Access control
#define HX8357A_COLMOD 0x17 // COLMOD
#define HX8357A_OSC_CONTROL_1 0x18 // OSC Control 1
#define HX8357A_OSC_CONTROL_2 0x19 // OSC Control 2
#define HX8357A_POWER_CONTROL_6 0x1A // Power Control 6
#define HX8357A_POWER_CONTROL_5 0x1B // Power Control 5
#define HX8357A_POWER_CONTROL_4 0x1C // Power Control 4
#define HX8357A_POWER_CONTROL_3 0x1D // Power Control 3
#define HX8357A_POWER_CONTROL_2 0x1E // Power Control 2
#define HX8357A_POWER_CONTROL_1 0x1F // Power Control 1
#define HX8357A_SRAM_CONTROL 0x22 // SRAM Control
#define HX8357A_VCOM_CONTROL_1 0x23 // VCOM Control 1
#define HX8357A_VCOM_CONTROL_2 0x24 // VCOM Control 2
#define HX8357A_VCOM_CONTROL_3 0x25 // VCOM Control 3
#define HX8357A_DISPLAY_CONTROL_1 0x26 // Display Control 1
#define HX8357A_DISPLAY_CONTROL_2 0x27 // Display Control 2
#define HX8357A_DISPLAY_CONTROL_3 0x28 // Display Control 3
#define HX8357A_FRAME_RATE_CONTROL_1 0x29 // Frame Rate control 1
#define HX8357A_FRAME_RATE_CONTROL_2 0x2A // Frame Rate Control 2
#define HX8357A_FRAME_RATE_CONTROL_3 0x2B // Frame Rate Control 3
#define HX8357A_FRAME_RATE_CONTROL_4 0x2C // Frame Rate Control 4
#define HX8357A_CYCLE_CONTROL_2 0x2D // Cycle Control 2
#define HX8357A_CYCLE_CONTROL_3 0x2E // Cycle Control 3
#define HX8357A_DISPLAY_INVERSION 0x2F // Display inversion
#define HX8357A_RGB_INTERFACE_CONTROL_1 0x31 // RGB interface control 1
#define HX8357A_RGB_INTERFACE_CONTROL_2 0x32 // RGB interface control 2
#define HX8357A_RGB_INTERFACE_CONTROL_3 0x33 // RGB interface control 3
#define HX8357A_RGB_INTERFACE_CONTROL_4 0x34 // RGB interface control 4
#define HX8357A_PANEL_CHARACTERIC 0x36 // Panel Characteric
#define HX8357A_OTP_CONTROL_1 0x38 // OTP Control 1
#define HX8357A_OTP_CONTROL_2 0x39 // OTP Control 2
#define HX8357A_OTP_CONTROL_3 0x3A // OTP Control 3
#define HX8357A_OTP_CONTROL_4 0x3B // OTP Control 4
#define HX8357A_CABC_CONTROL_1 0x3C // CABC Control 1
#define HX8357A_CABC_CONTROL_2 0x3D // CABC Control 2
#define HX8357A_CABC_CONTROL_3 0x3E // CABC Control 3
#define HX8357A_CABC_CONTROL_4 0x3F // CABC Control 4
#define HX8357A_R1_CONTROL_1 0x40 // r1 Control (1)
#define HX8357A_R1_CONTROL_2 0x41 // r1 Control (2)
#define HX8357A_R1_CONTROL_3 0x42 // r1 Control (3)
#define HX8357A_R1_CONTROL_4 0x43 // r1 Control (4)
#define HX8357A_R1_CONTROL_5 0x44 // r1 Control (5)
#define HX8357A_R1_CONTROL_6 0x45 // r1 Control (6)
#define HX8357A_R1_CONTROL_7 0x46 // r1 Control (7)
#define HX8357A_R1_CONTROL_8 0x47 // r1 Control (8)
#define HX8357A_R1_CONTROL_9 0x48 // r1 Control (9)
#define HX8357A_R1_CONTROL_10 0x49 // r1 Control (10)
#define HX8357A_R1_CONTROL_11 0x4A // r1 Control (11)
#define HX8357A_R1_CONTROL_12 0x4B // r1 Control (12)
#define HX8357A_R1_CONTROL_13 0x4C // r1 Control (13)
#define HX8357A_R1_CONTROL_18 0x50 // r1 Control (18)
#define HX8357A_R1_CONTROL_19 0x51 // r1 Control (19)
#define HX8357A_R1_CONTROL_20 0x52 // r1 Control (20)
#define HX8357A_R1_CONTROL_21 0x53 // r1 Control (21)
#define HX8357A_R1_CONTROL_22 0x54 // r1 Control (22)
#define HX8357A_R1_CONTROL_23 0x55 // r1 Control (23)
#define HX8357A_R1_CONTROL_24 0x56 // r1 Control (24)
#define HX8357A_R1_CONTROL_25 0x57 // r1 Control (25)
#define HX8357A_R1_CONTROL_26 0x58 // r1 Control (26)
#define HX8357A_R1_CONTROL_27 0x59 // r1 Control (27)
#define HX8357A_R1_CONTROL_28 0x5A // r1 Control (28)
#define HX8357A_R1_CONTROL_29 0x5B // r1 Control (29)
#define HX8357A_R1_CONTROL_30 0x5C // r1 Control (30)
#define HX8357A_R1_CONTROL_35 0x5D // r1 Control (35)
#define HX8357A_TE_CONTROL 0x60 // TE Control
#define HX8357A_ID1 0x61 // ID1
#define HX8357A_ID2 0x62 // ID2
#define HX8357A_ID3 0x63 // ID3
#define HX8357A_ID4 0x64 // ID4
#define HX8357A_MDDI_CONTROL_4 0x68 // MDDI Control 4
#define HX8357A_MDDI_CONTROL_5 0x69 // MDDI Control 5
#define HX8357A_GPIO_CONTROL_1 0x6B // GPIO Control 1
#define HX8357A_GPIO_CONTROL_2 0x6C // GPIO Control 2
#define HX8357A_GPIO_CONTROL_3 0x6D // GPIO Control 3
#define HX8357A_GPIO_CONTROL_4 0x6E // GPIO Control 4
#define HX8357A_GPIO_CONTROL_5 0x6F // GPIO Control 5
#define HX8357A_SUB_PANEL_CONTROL_1 0x70 // SUB_PANEL Control 1
#define HX8357A_SUB_PANEL_CONTROL_2 0x71 // SUB_PANEL Control 2
#define HX8357A_SUB_PANEL_CONTROL_3 0x72 // SUB_PANEL Control 3
#define HX8357A_SUB_PANEL_CONTROL_4 0x73 // SUB_PANEL Control 4
#define HX8357A_COLUMN_ADDRESS_COUNTER_2 0x80 // Column address counter 2
#define HX8357A_COLUMN_ADDRESS_COUNTER_1 0x81 // Column address counter 1
#define HX8357A_ROW_ADDRESS_COUNTER_2 0x82 // Row address counter 2
#define HX8357A_ROW_ADDRESS_COUNTER_1 0x83 // Row address counter 1
#define HX8357A_SET_VREF 0xE2 // Set VREF
#define HX8357A_POWER_SAVING_COUNTER_1 0xE4 // Power saving counter 1
#define HX8357A_POWER_SAVING_COUNTER_2 0xE5 // Power saving counter 2
#define HX8357A_POWER_SAVING_COUNTER_3 0xE6 // Power saving counter 3
#define HX8357A_POWER_SAVING_COUNTER_4 0xE7 // Power saving counter 4
#define HX8357A_OPON_CONTROL_1 0xE8 // OPON Control 1
#define HX8357A_OPON_CONTROL_2 0xE9 // OPON Control 2
#define HX8357A_CENON_CONTROL 0xF2 // GENON Control
#define HX8357A_SET_SPI_RRAD_INDEX 0xFD // Set SPI Rrad Index
#define HX8357A_GET_SPI_INDEX_DATA 0xFE // Get SPI Index data
#define HX8357A_PAGE_SELECT 0xFF // Page select
#define HX8357A_MADCTL_MY 0x80 // PAGE ADDRESS ORDER
#define HX8357A_MADCTL_MX 0x40 // COLUMN ADDRESS ORDER
#define HX8357A_MADCTL_MV 0x20 // PAGE/COLUMN SELECTION
#define HX8357A_MADCTL_BGR 0x08 // RGB-BGR ORDER
#define HX8357A_MADCTL_SS 0x02 // SOURCE OUTPUT ORDER
#define HX8357A_MADCTL_GS 0x01 // GATE OUTPUT ORDER
#define HX8357A_INV_ON 0x20 // INV_ON enable
#define HX8357A_INV_OFF 0x00 // INV_ON disable
static const uint8_t hx8357a_init_operations[] = {
BEGIN_WRITE,
WRITE_C8_D8, HX8357A_PAGE_SELECT, 0x00, // Command page 0
END_WRITE,
DELAY, 15,
BEGIN_WRITE,
WRITE_C8_D8, HX8357A_POWER_CONTROL_6, 0x04, // VGH VGL VCL DDVDH
WRITE_C8_D8, HX8357A_POWER_CONTROL_5, 0x1C,
// Power Settng
WRITE_C8_D8, HX8357A_VCOM_CONTROL_1, 0x94, // Set VCOM offset, VMF=0x52
WRITE_C8_D8, HX8357A_VCOM_CONTROL_2, 0x69, // Set VCOMH voltage, VHH=0x64
WRITE_C8_D8, HX8357A_VCOM_CONTROL_3, 0x63, // Set VCOML voltage, VML=0x71
WRITE_C8_D8, HX8357A_OSC_CONTROL_2, 0x01,
END_WRITE,
DELAY, 10,
BEGIN_WRITE,
WRITE_C8_D8, HX8357A_POWER_CONTROL_6, 0x00, // VGH VGL VCL DDVDH
WRITE_C8_D8, HX8357A_POWER_CONTROL_1, 0x8A, //
WRITE_C8_D8, HX8357A_DISPLAY_MODE_CONTROL, 0x00, //
WRITE_C8_D8, HX8357A_POWER_CONTROL_4, 0x05, //
WRITE_C8_D8, HX8357A_POWER_CONTROL_1, 0x82, //
END_WRITE,
DELAY, 10,
BEGIN_WRITE,
WRITE_C8_D8, HX8357A_POWER_CONTROL_1, 0x92, //
END_WRITE,
DELAY, 10,
BEGIN_WRITE,
WRITE_C8_D8, HX8357A_POWER_CONTROL_1, 0xD4, //
WRITE_C8_D8, HX8357A_COLMOD, 0x55, // 16-bit/pixel
WRITE_C8_D8, HX8357A_OSC_CONTROL_1, 0x21, // Fosc=130%*5.2MHZ 21
WRITE_C8_D8, HX8357A_POWER_CONTROL_3, 0x00, // FS0[1:0]=01, Set the operating frequency of the step-up circuit 1
WRITE_C8_D8, HX8357A_POWER_CONTROL_2, 0x00,
WRITE_C8_D8, HX8357A_DISPLAY_CONTROL_1, 0x33,
WRITE_C8_D8, HX8357A_DISPLAY_CONTROL_2, 0x01,
WRITE_C8_D8, HX8357A_FRAME_RATE_CONTROL_1, 0x00,
WRITE_C8_D8, HX8357A_FRAME_RATE_CONTROL_2, 0x00,
WRITE_C8_D8, HX8357A_FRAME_RATE_CONTROL_3, 0x01, // 0A
WRITE_C8_D8, HX8357A_FRAME_RATE_CONTROL_4, 0x0A,
WRITE_C8_D8, HX8357A_CYCLE_CONTROL_2, 0x20,
WRITE_C8_D8, HX8357A_CYCLE_CONTROL_3, 0xA3,
WRITE_C8_D8, HX8357A_DISPLAY_INVERSION, 0x00, // 00 100416
WRITE_C8_D8, HX8357A_RGB_INTERFACE_CONTROL_1, 0x00, // RGB MODE1 0X03=RGB MODE2
WRITE_C8_D8, HX8357A_RGB_INTERFACE_CONTROL_2, 0x00,
WRITE_C8_D8, HX8357A_RGB_INTERFACE_CONTROL_3, 0x08,
WRITE_C8_D8, HX8357A_RGB_INTERFACE_CONTROL_4, 0x08,
WRITE_C8_D8, HX8357A_PANEL_CHARACTERIC, 0x02, // REV
// Gamma
WRITE_C8_D8, HX8357A_R1_CONTROL_1, 0x01,
WRITE_C8_D8, HX8357A_R1_CONTROL_2, 0x0F,
WRITE_C8_D8, HX8357A_R1_CONTROL_3, 0x0F,
WRITE_C8_D8, HX8357A_R1_CONTROL_4, 0x26,
WRITE_C8_D8, HX8357A_R1_CONTROL_5, 0x2C,
WRITE_C8_D8, HX8357A_R1_CONTROL_6, 0x3C,
WRITE_C8_D8, HX8357A_R1_CONTROL_7, 0x0B,
WRITE_C8_D8, HX8357A_R1_CONTROL_8, 0x5F,
WRITE_C8_D8, HX8357A_R1_CONTROL_9, 0x00,
WRITE_C8_D8, HX8357A_R1_CONTROL_10, 0x06,
WRITE_C8_D8, HX8357A_R1_CONTROL_11, 0x09,
WRITE_C8_D8, HX8357A_R1_CONTROL_12, 0x0E,
WRITE_C8_D8, HX8357A_R1_CONTROL_13, 0x16,
WRITE_C8_D8, HX8357A_R1_CONTROL_18, 0x01,
WRITE_C8_D8, HX8357A_R1_CONTROL_19, 0x1D,
WRITE_C8_D8, HX8357A_R1_CONTROL_20, 0x21,
WRITE_C8_D8, HX8357A_R1_CONTROL_21, 0x3A,
WRITE_C8_D8, HX8357A_R1_CONTROL_22, 0x39,
WRITE_C8_D8, HX8357A_R1_CONTROL_23, 0x3F,
WRITE_C8_D8, HX8357A_R1_CONTROL_24, 0x2D,
WRITE_C8_D8, HX8357A_R1_CONTROL_25, 0x7F,
WRITE_C8_D8, HX8357A_R1_CONTROL_26, 0x02,
WRITE_C8_D8, HX8357A_R1_CONTROL_27, 0x15,
WRITE_C8_D8, HX8357A_R1_CONTROL_28, 0x1B,
WRITE_C8_D8, HX8357A_R1_CONTROL_29, 0x1B,
WRITE_C8_D8, HX8357A_R1_CONTROL_30, 0x1A,
WRITE_C8_D8, HX8357A_R1_CONTROL_35, 0x55,
// #if 1
WRITE_C8_D8, 0xff, 0x01,
WRITE_C8_D8, 0x00, 0x01,
WRITE_C8_D8, 0x01, 0x00,
WRITE_C8_D8, 0x02, 0x01,
WRITE_C8_D8, 0x03, 0x03,
WRITE_C8_D8, 0x04, 0x05,
WRITE_C8_D8, 0x05, 0x06,
WRITE_C8_D8, 0x06, 0x08,
WRITE_C8_D8, 0x07, 0x0C,
WRITE_C8_D8, 0x08, 0x0E,
WRITE_C8_D8, 0x09, 0x11,
WRITE_C8_D8, 0x0A, 0x12,
WRITE_C8_D8, 0x0B, 0x14,
WRITE_C8_D8, 0x0C, 0x1B,
WRITE_C8_D8, 0x0D, 0x23,
WRITE_C8_D8, 0x0E, 0x29,
WRITE_C8_D8, 0x0F, 0x2F,
WRITE_C8_D8, 0x10, 0x34,
WRITE_C8_D8, 0x11, 0x39,
WRITE_C8_D8, 0x12, 0x3E,
WRITE_C8_D8, 0x13, 0x43,
WRITE_C8_D8, 0x14, 0x48,
WRITE_C8_D8, 0x15, 0x4C,
WRITE_C8_D8, 0x16, 0x51,
WRITE_C8_D8, 0x17, 0x55,
WRITE_C8_D8, 0x18, 0x59,
WRITE_C8_D8, 0x19, 0x5D,
WRITE_C8_D8, 0x1A, 0x60,
WRITE_C8_D8, 0x1B, 0x64,
WRITE_C8_D8, 0x1C, 0x68,
WRITE_C8_D8, 0x1D, 0x6C,
WRITE_C8_D8, 0x1E, 0x70,
WRITE_C8_D8, 0x1F, 0x73,
WRITE_C8_D8, 0x20, 0x77,
WRITE_C8_D8, 0x21, 0x7B,
WRITE_C8_D8, 0x22, 0x7F,
WRITE_C8_D8, 0x23, 0x83,
WRITE_C8_D8, 0x24, 0x87,
WRITE_C8_D8, 0x25, 0x8A,
WRITE_C8_D8, 0x26, 0x8E,
WRITE_C8_D8, 0x27, 0x92,
WRITE_C8_D8, 0x28, 0x96,
WRITE_C8_D8, 0x29, 0x9A,
WRITE_C8_D8, 0x2A, 0x9F,
WRITE_C8_D8, 0x2B, 0xA3,
WRITE_C8_D8, 0x2C, 0xA7,
WRITE_C8_D8, 0x2D, 0xAC,
WRITE_C8_D8, 0x2E, 0xAF,
WRITE_C8_D8, 0x2F, 0xB3,
WRITE_C8_D8, 0x30, 0xB7,
WRITE_C8_D8, 0x31, 0xBA,
WRITE_C8_D8, 0x32, 0xBE,
WRITE_C8_D8, 0x33, 0xC3,
WRITE_C8_D8, 0x34, 0xC7,
WRITE_C8_D8, 0x35, 0xCC,
WRITE_C8_D8, 0x36, 0xD1,
WRITE_C8_D8, 0x37, 0xD7,
WRITE_C8_D8, 0x38, 0xDD,
WRITE_C8_D8, 0x39, 0xE3,
WRITE_C8_D8, 0x3A, 0xE8,
WRITE_C8_D8, 0x3B, 0xEA,
WRITE_C8_D8, 0x3C, 0xEC,
WRITE_C8_D8, 0x3D, 0xEF,
WRITE_C8_D8, 0x3E, 0xF3,
WRITE_C8_D8, 0x3F, 0xF6,
WRITE_C8_D8, 0x40, 0xFE,
WRITE_C8_D8, 0x41, 0x00,
WRITE_C8_D8, 0x42, 0x01,
WRITE_C8_D8, 0x43, 0x03,
WRITE_C8_D8, 0x44, 0x05,
WRITE_C8_D8, 0x45, 0x06,
WRITE_C8_D8, 0x46, 0x08,
WRITE_C8_D8, 0x47, 0x0C,
WRITE_C8_D8, 0x48, 0x0E,
WRITE_C8_D8, 0x49, 0x11,
WRITE_C8_D8, 0x4A, 0x12,
WRITE_C8_D8, 0x4B, 0x14,
WRITE_C8_D8, 0x4C, 0x1B,
WRITE_C8_D8, 0x4D, 0x23,
WRITE_C8_D8, 0x4E, 0x29,
WRITE_C8_D8, 0x4F, 0x2F,
WRITE_C8_D8, 0x50, 0x34,
WRITE_C8_D8, 0x51, 0x39,
WRITE_C8_D8, 0x52, 0x3E,
WRITE_C8_D8, 0x53, 0x43,
WRITE_C8_D8, 0x54, 0x48,
WRITE_C8_D8, 0x55, 0x4C,
WRITE_C8_D8, 0x56, 0x51,
WRITE_C8_D8, 0x57, 0x55,
WRITE_C8_D8, 0x58, 0x59,
WRITE_C8_D8, 0x59, 0x5D,
WRITE_C8_D8, 0x5A, 0x60,
WRITE_C8_D8, 0x5B, 0x64,
WRITE_C8_D8, 0x5C, 0x68,
WRITE_C8_D8, 0x5D, 0x6C,
WRITE_C8_D8, 0x5E, 0x70,
WRITE_C8_D8, 0x5F, 0x73,
WRITE_C8_D8, 0x60, 0x77,
WRITE_C8_D8, 0x61, 0x7B,
WRITE_C8_D8, 0x62, 0x7F,
WRITE_C8_D8, 0x63, 0x83,
WRITE_C8_D8, 0x64, 0x87,
WRITE_C8_D8, 0x65, 0x8A,
WRITE_C8_D8, 0x66, 0x8E,
WRITE_C8_D8, 0x67, 0x92,
WRITE_C8_D8, 0x68, 0x96,
WRITE_C8_D8, 0x69, 0x9A,
WRITE_C8_D8, 0x6A, 0x9F,
WRITE_C8_D8, 0x6B, 0xA3,
WRITE_C8_D8, 0x6C, 0xA7,
WRITE_C8_D8, 0x6D, 0xAC,
WRITE_C8_D8, 0x6E, 0xAF,
WRITE_C8_D8, 0x6F, 0xB3,
WRITE_C8_D8, 0x70, 0xB7,
WRITE_C8_D8, 0x71, 0xBA,
WRITE_C8_D8, 0x72, 0xBE,
WRITE_C8_D8, 0x73, 0xC3,
WRITE_C8_D8, 0x74, 0xC7,
WRITE_C8_D8, 0x75, 0xCC,
WRITE_C8_D8, 0x76, 0xD1,
WRITE_C8_D8, 0x77, 0xD7,
WRITE_C8_D8, 0x78, 0xDD,
WRITE_C8_D8, 0x79, 0xE3,
WRITE_C8_D8, 0x7A, 0xE8,
WRITE_C8_D8, 0x7B, 0xEA,
WRITE_C8_D8, 0x7C, 0xEC,
WRITE_C8_D8, 0x7D, 0xEF,
WRITE_C8_D8, 0x7E, 0xF3,
WRITE_C8_D8, 0x7F, 0xF6,
WRITE_C8_D8, 0x80, 0xFE,
WRITE_C8_D8, 0x81, 0x00,
WRITE_C8_D8, 0x82, 0x01,
WRITE_C8_D8, 0x83, 0x03,
WRITE_C8_D8, 0x84, 0x05,
WRITE_C8_D8, 0x85, 0x06,
WRITE_C8_D8, 0x86, 0x08,
WRITE_C8_D8, 0x87, 0x0C,
WRITE_C8_D8, 0x88, 0x0E,
WRITE_C8_D8, 0x89, 0x11,
WRITE_C8_D8, 0x8A, 0x12,
WRITE_C8_D8, 0x8B, 0x14,
WRITE_C8_D8, 0x8C, 0x1B,
WRITE_C8_D8, 0x8D, 0x23,
WRITE_C8_D8, 0x8E, 0x29,
WRITE_C8_D8, 0x8F, 0x2F,
WRITE_C8_D8, 0x90, 0x34,
WRITE_C8_D8, 0x91, 0x39,
WRITE_C8_D8, 0x92, 0x3E,
WRITE_C8_D8, 0x93, 0x43,
WRITE_C8_D8, 0x94, 0x48,
WRITE_C8_D8, 0x95, 0x4C,
WRITE_C8_D8, 0x96, 0x51,
WRITE_C8_D8, 0x97, 0x55,
WRITE_C8_D8, 0x98, 0x59,
WRITE_C8_D8, 0x99, 0x5D,
WRITE_C8_D8, 0x9A, 0x60,
WRITE_C8_D8, 0x9B, 0x64,
WRITE_C8_D8, 0x9C, 0x68,
WRITE_C8_D8, 0x9D, 0x6C,
WRITE_C8_D8, 0x9E, 0x70,
WRITE_C8_D8, 0x9F, 0x73,
WRITE_C8_D8, 0xA0, 0x77,
WRITE_C8_D8, 0xA1, 0x7B,
WRITE_C8_D8, 0xA2, 0x7F,
WRITE_C8_D8, 0xA3, 0x83,
WRITE_C8_D8, 0xA4, 0x87,
WRITE_C8_D8, 0xA5, 0x8A,
WRITE_C8_D8, 0xA6, 0x8E,
WRITE_C8_D8, 0xA7, 0x92,
WRITE_C8_D8, 0xA8, 0x96,
WRITE_C8_D8, 0xA9, 0x9A,
WRITE_C8_D8, 0xAA, 0x9F,
WRITE_C8_D8, 0xAB, 0xA3,
WRITE_C8_D8, 0xAC, 0xA7,
WRITE_C8_D8, 0xAD, 0xAC,
WRITE_C8_D8, 0xAE, 0xAF,
WRITE_C8_D8, 0xAF, 0xB3,
WRITE_C8_D8, 0xB0, 0xB7,
WRITE_C8_D8, 0xB1, 0xBA,
WRITE_C8_D8, 0xB2, 0xBE,
WRITE_C8_D8, 0xB3, 0xC3,
WRITE_C8_D8, 0xB4, 0xC7,
WRITE_C8_D8, 0xB5, 0xCC,
WRITE_C8_D8, 0xB6, 0xD1,
WRITE_C8_D8, 0xB7, 0xD7,
WRITE_C8_D8, 0xB8, 0xDD,
WRITE_C8_D8, 0xB9, 0xE3,
WRITE_C8_D8, 0xBA, 0xE8,
WRITE_C8_D8, 0xBB, 0xEA,
WRITE_C8_D8, 0xBC, 0xEC,
WRITE_C8_D8, 0xBD, 0xEF,
WRITE_C8_D8, 0xBE, 0xF3,
WRITE_C8_D8, 0xBF, 0xF6,
WRITE_C8_D8, 0xC0, 0xFE,
WRITE_C8_D8, 0xff, 0x00,
WRITE_C8_D8, HX8357A_TE_CONTROL, 0x08,
WRITE_C8_D8, HX8357A_CENON_CONTROL, 0x00,
WRITE_C8_D8, HX8357A_POWER_SAVING_COUNTER_1, 0x1F, // EQVCI_M1=0x00
WRITE_C8_D8, HX8357A_POWER_SAVING_COUNTER_2, 0x1F, // EQGND_M1=0x1C
WRITE_C8_D8, HX8357A_POWER_SAVING_COUNTER_3, 0x20, // EQVCI_M0=0x1C
WRITE_C8_D8, HX8357A_POWER_SAVING_COUNTER_4, 0x00, // EQGND_M0=0x1C
WRITE_C8_D8, HX8357A_OPON_CONTROL_1, 0xD1,
WRITE_C8_D8, HX8357A_OPON_CONTROL_2, 0xC0,
WRITE_C8_D8, HX8357A_DISPLAY_CONTROL_3, 0x38,
END_WRITE,
DELAY, 80,
BEGIN_WRITE,
WRITE_C8_D8, HX8357A_DISPLAY_CONTROL_3, 0x3C, // GON=1, DTE=1, D[1:0]=11
END_WRITE,
DELAY, 100};
class Arduino_HX8357A : public Arduino_TFT
{
public:
Arduino_HX8357A(Arduino_DataBus *bus, int8_t rst = GFX_NOT_DEFINED, uint8_t r = 0, bool ips = false);
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void setRotation(uint8_t r) override;
void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) override;
void invertDisplay(bool) override;
void displayOn() override;
void displayOff() override;
protected:
void tftInit() override;
private:
};
#endif
@@ -0,0 +1,102 @@
#include "Arduino_HX8357B.h"
Arduino_HX8357B::Arduino_HX8357B(Arduino_DataBus *bus, int8_t rst, uint8_t r, bool ips /* = false */)
: Arduino_TFT(bus, rst, r, ips, HX8357B_TFTWIDTH, HX8357B_TFTHEIGHT, 0, 0, 0, 0)
{
}
bool Arduino_HX8357B::begin(int32_t speed)
{
return Arduino_TFT::begin(speed);
}
/**************************************************************************/
/*!
@brief Set origin of (0,0) and orientation of TFT display
@param m The index for rotation, from 0-3 inclusive
*/
/**************************************************************************/
void Arduino_HX8357B::setRotation(uint8_t r)
{
Arduino_TFT::setRotation(r);
switch (_rotation)
{
case 3:
r = (HX8357B_MADCTL_MX | HX8357B_MADCTL_MY | HX8357B_MADCTL_MV | HX8357B_MADCTL_BGR);
break;
case 2:
r = (HX8357B_MADCTL_MY | HX8357B_MADCTL_BGR);
break;
case 1:
r = (HX8357B_MADCTL_MV | HX8357B_MADCTL_BGR);
break;
default: // case 0:
r = (HX8357B_MADCTL_MX | HX8357B_MADCTL_BGR);
break;
}
_bus->beginWrite();
_bus->writeC8D8(HX8357B_SET_ADDRESS_MODE, r);
_bus->endWrite();
}
void Arduino_HX8357B::writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h)
{
if ((x != _currentX) || (w != _currentW))
{
_currentX = x;
_currentW = w;
x += _xStart;
_bus->writeC8D16D16(HX8357B_SET_COLUMN_ADDRESS, x, x + w - 1);
}
if ((y != _currentY) || (h != _currentH))
{
_currentY = y;
_currentH = h;
y += _yStart;
_bus->writeC8D16D16(HX8357B_SET_PAGE_ADDRESS, y, y + h - 1);
}
_bus->writeCommand(HX8357B_WRITE_MEMORY_START); // write to RAM
}
void Arduino_HX8357B::invertDisplay(bool i)
{
_bus->sendCommand((_ips ^ i) ? HX8357B_ENTER_INVERSION_MODE : HX8357B_EXIT_INVERSION_MODE);
}
void Arduino_HX8357B::displayOn(void)
{
_bus->sendCommand(HX8357B_EXIT_SLEEP_MODE);
delay(HX8357B_SLPOUT_DELAY);
}
void Arduino_HX8357B::displayOff(void)
{
_bus->sendCommand(HX8357B_ENTER_SLEEP_MODE);
delay(HX8357B_SLPIN_DELAY);
}
void Arduino_HX8357B::tftInit()
{
if (_rst != GFX_NOT_DEFINED)
{
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(100);
digitalWrite(_rst, LOW);
delay(HX8357B_RST_DELAY);
digitalWrite(_rst, HIGH);
delay(HX8357B_RST_DELAY);
}
else
{
// Software Rest
_bus->sendCommand(HX8357B_SOFTWARE_RESET);
delay(HX8357B_RST_DELAY);
}
_bus->batchOperation(hx8357b_init_operations, sizeof(hx8357b_init_operations));
invertDisplay(false);
}
@@ -0,0 +1,179 @@
/*
* start rewrite from:
* https://github.com/adafruit/Adafruit-GFX-Library.git
*/
#ifndef _ARDUINO_HX8357B_H_
#define _ARDUINO_HX8357B_H_
#include <Arduino.h>
#include <Print.h>
#include "../Arduino_GFX.h"
#include "../Arduino_TFT.h"
#define HX8357B_TFTWIDTH 320 ///< HX8357B max TFT width
#define HX8357B_TFTHEIGHT 480 ///< HX8357B max TFT height
#define HX8357B_RST_DELAY 120 ///< delay ms wait for reset finish
#define HX8357B_SLPIN_DELAY 120 ///< delay ms wait for sleep in finish
#define HX8357B_SLPOUT_DELAY 120 ///< delay ms wait for sleep out finish
#define HX8357B_NOP 0x00 // 6.2.1 NOP
#define HX8357B_SOFTWARE_RESET 0x01 // 6.2.2 Software Reset (01h)
#define HX8357B_GET_RED_CHANNEL 0x06 // 6.2.3 Get_red_channel (06h)
#define HX8357B_GET_GREEN_CHANNEL 0x07 // 6.2.4 Get_green_channel (07h)
#define HX8357B_GET_BLUE_CHANNEL 0x08 // 6.2.5 Get_blue_channel (08h)
#define HX8357B_GET_POWER_MODE 0x0A // 6.2.6 Get_power_mode (0Ah)
#define HX8357B_READ_DISPLAY_MADCTL 0x0B // 6.2.7 Read Display MADCTL (0Bh)
#define HX8357B_GET_PIXEL_FORMAT 0x0C // 6.2.8 Get_pixel_format (0Ch)
#define HX8357B_GET_DISPLAY_MODE 0x0D // 6.2.9 Get_display_mode (0Dh)
#define HX8357B_GET_SIGNAL_MODE 0x0E // 6.2.10 Get_signal_mode (0Eh)
#define HX8357B_GET_DIAGNOSTIC_RESULT 0x0F // 6.2.11 Get_diagnostic_result (0Fh)
#define HX8357B_ENTER_SLEEP_MODE 0x10 // 6.2.12 Enter_sleep_mode (10h)
#define HX8357B_EXIT_SLEEP_MODE 0x11 // 6.2.13 Exit_sleep_mode (11h)
#define HX8357B_ENTER_PARTIAL_MODE 0x12 // 6.2.14 Enter_partial_mode (12h)
#define HX8357B_ENTER_NORMAL_MODE 0x13 // 6.2.15 Enter_normal_mode (13h)
#define HX8357B_EXIT_INVERSION_MODE 0x20 // 6.2.16 Exit_inversion_mode (20h)
#define HX8357B_ENTER_INVERSION_MODE 0x21 // 6.2.17 Enter_inversion_mode (21h)
#define HX8357B_SET_DISPLAY_OFF 0x28 // 6.2.18 Set_display_off (28h)
#define HX8357B_SET_DISPLAY_ON 0x29 // 6.2.19 Set_display_on (29h)
#define HX8357B_SET_COLUMN_ADDRESS 0x2A // 6.2.20 Set_column_address (2Ah)
#define HX8357B_SET_PAGE_ADDRESS 0x2B // 6.2.21 Set_page_address (2Bh)
#define HX8357B_WRITE_MEMORY_START 0x2C // 6.2.22 Write_memory_start (2Ch)
#define HX8357B_READ_MEMORY_START 0x2E // 6.2.23 Read_memory_start (2Eh)
#define HX8357B_SET_PARTIAL_AREA 0x30 // 6.2.24 Set_partial_area (30h)
#define HX8357B_SET_SCROLL_AREA 0x33 // 6.2.25 Set_scroll_area (33h)
#define HX8357B_SET_TEAR_OFF 0x34 // 6.2.26 Set_tear_off (34h)
#define HX8357B_SET_TEAR_ON 0x35 // 6.2.27 Set_tear_on (35h)
#define HX8357B_SET_ADDRESS_MODE 0x36 // 6.2.28 Set_address_mode (36h)
#define HX8357B_SET_SCROLL_START 0x37 // 6.2.29 Set_scroll_start (37h)
#define HX8357B_EXIT_IDLE_MODE 0x38 // 6.2.30 Exit_idle_mode (38h)
#define HX8357B_ENTER_IDLE_MODE 0x39 // 6.2.31 Enter_Idle_mode (39h)
#define HX8357B_SET_PIXEL_FORMAT 0x3A // 6.2.32 Set_pixel_format (3Ah)
#define HX8357B_WRITE_MEMORY_CONTINUE 0x3C // 6.2.33 Write_memory_contiune (3Ch)
#define HX8357B_READ_MEMORY_CONTINUE 0x3E // 6.2.34 Read_memory_continue (3Eh)
#define HX8357B_SET_TEAR_SCAN_LINES 0x44 // 6.2.35 Set tear scan lines(44h)
#define HX8357B_GET_SCAN_LINES 0x45 // 6.2.36 Get scan lines(45h)
#define HX8357B_READ_DDB_START 0xA1 // 6.2.37 Read_DDB_start (A1h)
#define HX8357B_WRITE_DISPLAY_BRIGHTNESS 0x51 // 6.2.38 Write Display Brightness (51h)
#define HX8357B_READ_DISPLAY_BRIGHTNESS 0x52 // 6.2.39 Read Display Brightness Value (52h)
#define HX8357B_WRITE_CTRL_DISPLAY 0x53 // 6.2.40 Write CTRL Display (53h)
#define HX8357B_READ_CTRL_DISPLAY 0x54 // 6.2.41 Read CTRL Value Display (54h)
#define HX8357B_WRITE_CONTENT_ADAPTIVE_BRIGHTNESS 0x55 // 6.2.42 Write Content Adaptive Brightness Control (55h)
#define HX8357B_READ_CONTENT_ADAPTIVE_BRIGHTNESS 0x56 // 6.2.43 Read Content Adaptive Brightness Control (56h)
#define HX8357B_WRITE_CABC_MINIMUM_BRIGHTNESS 0x5E // 6.2.44 Write CABC minimum brightness (5Eh)
#define HX8357B_READ_CABC_MINIMUM_BRIGHTNESS 0x5F // 6.2.45 Read CABC minimum brightness (5Fh)
#define HX8357B_READ_AUTO_BRIGHTNESS_SD_RESULT 0x68 // 6.2.46 Read Automatic Brightness Control Self-Diagnostic Result (68h)
#define HX8357B_SET_EXTENDED_COMMAND_SET 0xB0 // 6.2.47 Set extended command set (B0h)
#define HX8357B_SET_DEEP_STANDBY_MODE 0xB1 // 6.2.48 Set Deep Standby mode (B1h)
#define HX8357B_SET_GRAM_ACCESS_INTERFACE 0xB3 // 6.2.49 Set GRAM access and Interface (B3h)
#define HX8357B_SET_DISPLAY_MODE 0xB4 // 6.2.50 Set Display mode (B4h)
#define HX8357B_GET_DEVICE_ID 0xBF // 6.2.51 Get Device ID (BFh)
#define HX8357B_SET_PANEL_DRIVING 0xC0 // 6.2.52 Set Panel Driving (C0h)
#define HX8357B_SET_DISPLAY_TIMING_NORMAL 0xC1 // 6.2.53 Set display timing for Normal mode (C1h)
#define HX8357B_SET_DISPLAY_TIMING_PARTIAL 0xC2 // 6.2.54 Set display timing for Partial mode (C2h)
#define HX8357B_SET_DISPLAY_TIMING_IDLE 0xC3 // 6.2.55 Set display timing for Idle mode (C3h)
#define HX8357B_SET_DISPLAY_FRAME 0xC5 // 6.2.56 Set display frame (C5h)
#define HX8357B_SET_RGB_INTERFACE 0xC6 // 6.2.57 Set RGB Interface (C6h)
#define HX8357B_SET_GAMMA 0xC8 // 6.2.58 Set Gamma (C8h)
#define HX8357B_SET_POWER 0xD0 // 6.2.59 Set Power (D0h)
#define HX8357B_SET_VCOM 0xD1 // 6.2.60 Set VCOM (D1h)
#define HX8357B_SET_POWER_NORMAL 0xD2 // 6.2.61 Set Power for Normal mode (D2h)
#define HX8357B_SET_POWER_PARTIAL 0xD3 // 6.2.62 Set Power for Partial mode (D3h)
#define HX8357B_SET_POWER_IDLE 0xD4 // 6.2.63 Set Power for Idle mode (D4h)
#define HX8357B_SET_ID 0xE0 // 6.2.64 Set ID (E0h)
#define HX8357B_SET_OTP_SETTING 0xE2 // 6.2.65 Set OTP Related Setting (E2h)
#define HX8357B_SETOPKEY 0xE3 // 6.2.66 SETOTPKEY (E3h)
#define HX8357B_SETCABC 0xE4 // 6.2.67 SETCABC(E4h)
#define HX8357B_SET_PANEL_RELATED 0xE9 // 6.2.68 Set Panel related (E9h)
#define HX8357B_SET_EP_FUNCTION 0xEE // 6.2.69 Set EQ function (EEh)
#define HX8357B_MADCTL_MY 0x80 ///< Bottom to top
#define HX8357B_MADCTL_MX 0x40 ///< Right to left
#define HX8357B_MADCTL_MV 0x20 ///< Reverse Mode
#define HX8357B_MADCTL_ML 0x10 ///< LCD refresh Bottom to top
#define HX8357B_MADCTL_RGB 0x00 ///< Red-Green-Blue pixel order
#define HX8357B_MADCTL_BGR 0x08 ///< Blue-Green-Red pixel order
#define HX8357B_MADCTL_MH 0x04 ///< LCD refresh right to left
static const uint8_t hx8357b_init_operations[] = {
BEGIN_WRITE,
WRITE_COMMAND_8, HX8357B_EXIT_SLEEP_MODE,
END_WRITE,
DELAY, HX8357B_SLPOUT_DELAY,
BEGIN_WRITE,
WRITE_COMMAND_8, HX8357B_SET_EP_FUNCTION,
WRITE_BYTES, 4, 0x02, 0x01, 0x02, 0x01,
WRITE_C8_D8, HX8357B_SET_DISPLAY_MODE, 0x00, // Set RM, DM
WRITE_COMMAND_8, HX8357B_SET_PANEL_DRIVING,
WRITE_BYTES, 5,
0x10, // REV SM GS
0x3B, // NL[5:0]
0x00, // SCN[6:0]
0x02, // NDL 0 PTS[2:0]
0x11, // PTG ISC[3:0]
WRITE_C8_D8, HX8357B_SET_DISPLAY_TIMING_NORMAL, 0x10, // ne inversion
WRITE_COMMAND_8, HX8357B_SET_GAMMA,
WRITE_BYTES, 12,
0x00, // KP1,KP0
0x32, // KP3,KP2
0x36, // KP5,KP4
0x45, // RP1,RP0
0x06, // VRP0 01
0x16, // VRP1
0x37, // KN1,KN0
0x75, // KN3,KN2
0x77, // KN5,KN4
0x54, // RN1,RN0
0x0c, // VRN0
0x00, // VRN1 01
WRITE_COMMAND_8, HX8357B_SET_POWER,
WRITE_BYTES, 3,
0x44, // DDVDH :5.28
0x42, // BT VGH:15.84 VGL:-7.92
0x06, // VREG1 4.625V
WRITE_C8_D16, HX8357B_SET_VCOM, 0x43, 0x16, // VCOMH
WRITE_C8_D16, HX8357B_SET_POWER_NORMAL, 0x04, 0x22, // 12
WRITE_C8_D16, HX8357B_SET_POWER_PARTIAL, 0x04, 0x12,
WRITE_C8_D16, HX8357B_SET_POWER_IDLE, 0x07, 0x12,
WRITE_C8_D8, HX8357B_SET_PANEL_RELATED, 0x00,
WRITE_C8_D8, HX8357B_SET_DISPLAY_FRAME, 0x08, // 61.51Hz
WRITE_C8_D8, HX8357B_SET_PIXEL_FORMAT, 0X55,
END_WRITE,
DELAY, HX8357B_SLPOUT_DELAY,
BEGIN_WRITE,
WRITE_COMMAND_8, HX8357B_SET_DISPLAY_ON, // Display On
END_WRITE,
DELAY, 50};
class Arduino_HX8357B : public Arduino_TFT
{
public:
Arduino_HX8357B(Arduino_DataBus *bus, int8_t rst = GFX_NOT_DEFINED, uint8_t r = 0, bool ips = false);
bool begin(int32_t speed = GFX_NOT_DEFINED) override;
void writeAddrWindow(int16_t x, int16_t y, uint16_t w, uint16_t h) override;
void setRotation(uint8_t r) override;
void invertDisplay(bool) override;
void displayOn() override;
void displayOff() override;
protected:
void tftInit() override;
private:
};
#endif

Some files were not shown because too many files have changed in this diff Show More