422 lines
15 KiB
C++
422 lines
15 KiB
C++
|
/*!
|
||
|
|
* @file Adafruit_GrayOLED.cpp
|
||
|
|
*
|
||
|
|
* This is documentation for Adafruit's generic library for grayscale
|
||
|
|
* OLED displays: http://www.adafruit.com/category/63_98
|
||
|
|
*
|
||
|
|
* These displays use I2C or SPI to communicate. I2C requires 2 pins
|
||
|
|
* (SCL+SDA) and optionally a RESET pin. SPI requires 4 pins (MOSI, SCK,
|
||
|
|
* select, data/command) and optionally a reset pin. Hardware SPI or
|
||
|
|
* 'bitbang' software SPI are both supported.
|
||
|
|
*
|
||
|
|
* Adafruit invests time and resources providing this open source code,
|
||
|
|
* please support Adafruit and open-source hardware by purchasing
|
||
|
|
* products from Adafruit!
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#if !defined(__AVR_ATtiny85__) // Not for ATtiny, at all
|
||
|
|
|
||
|
|
#include "Adafruit_GrayOLED.h"
|
||
|
|
#include <Adafruit_GFX.h>
|
||
|
|
|
||
|
|
// SOME DEFINES AND STATIC VARIABLES USED INTERNALLY -----------------------
|
||
|
|
|
||
|
|
#define grayoled_swap(a, b) \
|
||
|
|
(((a) ^= (b)), ((b) ^= (a)), ((a) ^= (b))) ///< No-temp-var swap operation
|
||
|
|
|
||
|
|
// CONSTRUCTORS, DESTRUCTOR ------------------------------------------------
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Constructor for I2C-interfaced OLED displays.
|
||
|
|
@param bpp Bits per pixel, 1 for monochrome, 4 for 16-gray
|
||
|
|
@param w
|
||
|
|
Display width in pixels
|
||
|
|
@param h
|
||
|
|
Display height in pixels
|
||
|
|
@param twi
|
||
|
|
Pointer to an existing TwoWire instance (e.g. &Wire, the
|
||
|
|
microcontroller's primary I2C bus).
|
||
|
|
@param rst_pin
|
||
|
|
Reset pin (using Arduino pin numbering), or -1 if not used
|
||
|
|
(some displays might be wired to share the microcontroller's
|
||
|
|
reset pin).
|
||
|
|
@param clkDuring
|
||
|
|
Speed (in Hz) for Wire transmissions in library calls.
|
||
|
|
Defaults to 400000 (400 KHz), a known 'safe' value for most
|
||
|
|
microcontrollers, and meets the OLED datasheet spec.
|
||
|
|
Some systems can operate I2C faster (800 KHz for ESP32, 1 MHz
|
||
|
|
for many other 32-bit MCUs), and some (perhaps not all)
|
||
|
|
Many OLED's can work with this -- so it's optionally be specified
|
||
|
|
here and is not a default behavior. (Ignored if using pre-1.5.7
|
||
|
|
Arduino software, which operates I2C at a fixed 100 KHz.)
|
||
|
|
@param clkAfter
|
||
|
|
Speed (in Hz) for Wire transmissions following library
|
||
|
|
calls. Defaults to 100000 (100 KHz), the default Arduino Wire
|
||
|
|
speed. This is done rather than leaving it at the 'during' speed
|
||
|
|
because other devices on the I2C bus might not be compatible
|
||
|
|
with the faster rate. (Ignored if using pre-1.5.7 Arduino
|
||
|
|
software, which operates I2C at a fixed 100 KHz.)
|
||
|
|
@note Call the object's begin() function before use -- buffer
|
||
|
|
allocation is performed there!
|
||
|
|
*/
|
||
|
|
Adafruit_GrayOLED::Adafruit_GrayOLED(uint8_t bpp, uint16_t w, uint16_t h,
|
||
|
|
TwoWire *twi, int8_t rst_pin,
|
||
|
|
uint32_t clkDuring, uint32_t clkAfter)
|
||
|
|
: Adafruit_GFX(w, h), i2c_preclk(clkDuring), i2c_postclk(clkAfter),
|
||
|
|
buffer(NULL), dcPin(-1), csPin(-1), rstPin(rst_pin), _bpp(bpp) {
|
||
|
|
i2c_dev = NULL;
|
||
|
|
_theWire = twi;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Constructor for SPI GrayOLED displays, using software (bitbang)
|
||
|
|
SPI.
|
||
|
|
@param bpp Bits per pixel, 1 for monochrome, 4 for 16-gray
|
||
|
|
@param w
|
||
|
|
Display width in pixels
|
||
|
|
@param h
|
||
|
|
Display height in pixels
|
||
|
|
@param mosi_pin
|
||
|
|
MOSI (master out, slave in) pin (using Arduino pin numbering).
|
||
|
|
This transfers serial data from microcontroller to display.
|
||
|
|
@param sclk_pin
|
||
|
|
SCLK (serial clock) pin (using Arduino pin numbering).
|
||
|
|
This clocks each bit from MOSI.
|
||
|
|
@param dc_pin
|
||
|
|
Data/command pin (using Arduino pin numbering), selects whether
|
||
|
|
display is receiving commands (low) or data (high).
|
||
|
|
@param rst_pin
|
||
|
|
Reset pin (using Arduino pin numbering), or -1 if not used
|
||
|
|
(some displays might be wired to share the microcontroller's
|
||
|
|
reset pin).
|
||
|
|
@param cs_pin
|
||
|
|
Chip-select pin (using Arduino pin numbering) for sharing the
|
||
|
|
bus with other devices. Active low.
|
||
|
|
@note Call the object's begin() function before use -- buffer
|
||
|
|
allocation is performed there!
|
||
|
|
*/
|
||
|
|
Adafruit_GrayOLED::Adafruit_GrayOLED(uint8_t bpp, uint16_t w, uint16_t h,
|
||
|
|
int8_t mosi_pin, int8_t sclk_pin,
|
||
|
|
int8_t dc_pin, int8_t rst_pin,
|
||
|
|
int8_t cs_pin)
|
||
|
|
: Adafruit_GFX(w, h), dcPin(dc_pin), csPin(cs_pin), rstPin(rst_pin),
|
||
|
|
_bpp(bpp) {
|
||
|
|
|
||
|
|
spi_dev = new Adafruit_SPIDevice(cs_pin, sclk_pin, -1, mosi_pin, 1000000);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Constructor for SPI GrayOLED displays, using native hardware SPI.
|
||
|
|
@param bpp Bits per pixel, 1 for monochrome, 4 for 16-gray
|
||
|
|
@param w
|
||
|
|
Display width in pixels
|
||
|
|
@param h
|
||
|
|
Display height in pixels
|
||
|
|
@param spi
|
||
|
|
Pointer to an existing SPIClass instance (e.g. &SPI, the
|
||
|
|
microcontroller's primary SPI bus).
|
||
|
|
@param dc_pin
|
||
|
|
Data/command pin (using Arduino pin numbering), selects whether
|
||
|
|
display is receiving commands (low) or data (high).
|
||
|
|
@param rst_pin
|
||
|
|
Reset pin (using Arduino pin numbering), or -1 if not used
|
||
|
|
(some displays might be wired to share the microcontroller's
|
||
|
|
reset pin).
|
||
|
|
@param cs_pin
|
||
|
|
Chip-select pin (using Arduino pin numbering) for sharing the
|
||
|
|
bus with other devices. Active low.
|
||
|
|
@param bitrate
|
||
|
|
SPI clock rate for transfers to this display. Default if
|
||
|
|
unspecified is 8000000UL (8 MHz).
|
||
|
|
@note Call the object's begin() function before use -- buffer
|
||
|
|
allocation is performed there!
|
||
|
|
*/
|
||
|
|
Adafruit_GrayOLED::Adafruit_GrayOLED(uint8_t bpp, uint16_t w, uint16_t h,
|
||
|
|
SPIClass *spi, int8_t dc_pin,
|
||
|
|
int8_t rst_pin, int8_t cs_pin,
|
||
|
|
uint32_t bitrate)
|
||
|
|
: Adafruit_GFX(w, h), dcPin(dc_pin), csPin(cs_pin), rstPin(rst_pin),
|
||
|
|
_bpp(bpp) {
|
||
|
|
|
||
|
|
spi_dev = new Adafruit_SPIDevice(cs_pin, bitrate, SPI_BITORDER_MSBFIRST,
|
||
|
|
SPI_MODE0, spi);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Destructor for Adafruit_GrayOLED object.
|
||
|
|
*/
|
||
|
|
Adafruit_GrayOLED::~Adafruit_GrayOLED(void) {
|
||
|
|
if (buffer) {
|
||
|
|
free(buffer);
|
||
|
|
buffer = NULL;
|
||
|
|
}
|
||
|
|
if (spi_dev)
|
||
|
|
delete spi_dev;
|
||
|
|
if (i2c_dev)
|
||
|
|
delete i2c_dev;
|
||
|
|
}
|
||
|
|
|
||
|
|
// LOW-LEVEL UTILS ---------------------------------------------------------
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Issue single command byte to OLED, using I2C or hard/soft SPI as
|
||
|
|
needed.
|
||
|
|
@param c The single byte command
|
||
|
|
*/
|
||
|
|
void Adafruit_GrayOLED::oled_command(uint8_t c) {
|
||
|
|
if (i2c_dev) { // I2C
|
||
|
|
uint8_t buf[2] = {0x00, c}; // Co = 0, D/C = 0
|
||
|
|
i2c_dev->write(buf, 2);
|
||
|
|
} else { // SPI (hw or soft) -- transaction started in calling function
|
||
|
|
digitalWrite(dcPin, LOW);
|
||
|
|
spi_dev->write(&c, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Issue list of commands to GrayOLED
|
||
|
|
/*!
|
||
|
|
@brief Issue multiple bytes of commands OLED, using I2C or hard/soft SPI as
|
||
|
|
needed.
|
||
|
|
@param c Pointer to the command array
|
||
|
|
@param n The number of bytes in the command array
|
||
|
|
@returns True for success on ability to write the data in I2C.
|
||
|
|
*/
|
||
|
|
|
||
|
|
bool Adafruit_GrayOLED::oled_commandList(const uint8_t *c, uint8_t n) {
|
||
|
|
if (i2c_dev) { // I2C
|
||
|
|
uint8_t dc_byte = 0x00; // Co = 0, D/C = 0
|
||
|
|
if (!i2c_dev->write((uint8_t *)c, n, true, &dc_byte, 1)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
} else { // SPI -- transaction started in calling function
|
||
|
|
digitalWrite(dcPin, LOW);
|
||
|
|
if (!spi_dev->write((uint8_t *)c, n)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// ALLOCATE & INIT DISPLAY -------------------------------------------------
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Allocate RAM for image buffer, initialize peripherals and pins.
|
||
|
|
Note that subclasses must call this before other begin() init
|
||
|
|
@param addr
|
||
|
|
I2C address of corresponding oled display.
|
||
|
|
SPI displays (hardware or software) do not use addresses, but
|
||
|
|
this argument is still required. Default if unspecified is 0x3C.
|
||
|
|
@param reset
|
||
|
|
If true, and if the reset pin passed to the constructor is
|
||
|
|
valid, a hard reset will be performed before initializing the
|
||
|
|
display. If using multiple oled displays on the same bus, and
|
||
|
|
if they all share the same reset pin, you should only pass true
|
||
|
|
on the first display being initialized, false on all others,
|
||
|
|
else the already-initialized displays would be reset. Default if
|
||
|
|
unspecified is true.
|
||
|
|
@return true on successful allocation/init, false otherwise.
|
||
|
|
Well-behaved code should check the return value before
|
||
|
|
proceeding.
|
||
|
|
@note MUST call this function before any drawing or updates!
|
||
|
|
*/
|
||
|
|
bool Adafruit_GrayOLED::_init(uint8_t addr, bool reset) {
|
||
|
|
|
||
|
|
// attempt to malloc the bitmap framebuffer
|
||
|
|
if ((!buffer) &&
|
||
|
|
!(buffer = (uint8_t *)malloc(_bpp * WIDTH * ((HEIGHT + 7) / 8)))) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Reset OLED if requested and reset pin specified in constructor
|
||
|
|
if (reset && (rstPin >= 0)) {
|
||
|
|
pinMode(rstPin, OUTPUT);
|
||
|
|
digitalWrite(rstPin, HIGH);
|
||
|
|
delay(10); // VDD goes high at start, pause
|
||
|
|
digitalWrite(rstPin, LOW); // Bring reset low
|
||
|
|
delay(10); // Wait 10 ms
|
||
|
|
digitalWrite(rstPin, HIGH); // Bring out of reset
|
||
|
|
delay(10);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Setup pin directions
|
||
|
|
if (_theWire) { // using I2C
|
||
|
|
i2c_dev = new Adafruit_I2CDevice(addr, _theWire);
|
||
|
|
// look for i2c address:
|
||
|
|
if (!i2c_dev || !i2c_dev->begin()) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
} else { // Using one of the SPI modes, either soft or hardware
|
||
|
|
if (!spi_dev || !spi_dev->begin()) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
pinMode(dcPin, OUTPUT); // Set data/command pin as output
|
||
|
|
}
|
||
|
|
|
||
|
|
clearDisplay();
|
||
|
|
|
||
|
|
// set max dirty window
|
||
|
|
window_x1 = 0;
|
||
|
|
window_y1 = 0;
|
||
|
|
window_x2 = WIDTH - 1;
|
||
|
|
window_y2 = HEIGHT - 1;
|
||
|
|
|
||
|
|
return true; // Success
|
||
|
|
}
|
||
|
|
|
||
|
|
// DRAWING FUNCTIONS -------------------------------------------------------
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Set/clear/invert a single pixel. This is also invoked by the
|
||
|
|
Adafruit_GFX library in generating many higher-level graphics
|
||
|
|
primitives.
|
||
|
|
@param x
|
||
|
|
Column of display -- 0 at left to (screen width - 1) at right.
|
||
|
|
@param y
|
||
|
|
Row of display -- 0 at top to (screen height -1) at bottom.
|
||
|
|
@param color
|
||
|
|
Pixel color, one of: MONOOLED_BLACK, MONOOLED_WHITE or
|
||
|
|
MONOOLED_INVERT.
|
||
|
|
@note Changes buffer contents only, no immediate effect on display.
|
||
|
|
Follow up with a call to display(), or with other graphics
|
||
|
|
commands as needed by one's own application.
|
||
|
|
*/
|
||
|
|
void Adafruit_GrayOLED::drawPixel(int16_t x, int16_t y, uint16_t color) {
|
||
|
|
if ((x >= 0) && (x < width()) && (y >= 0) && (y < height())) {
|
||
|
|
// Pixel is in-bounds. Rotate coordinates if needed.
|
||
|
|
switch (getRotation()) {
|
||
|
|
case 1:
|
||
|
|
grayoled_swap(x, y);
|
||
|
|
x = WIDTH - x - 1;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
x = WIDTH - x - 1;
|
||
|
|
y = HEIGHT - y - 1;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
grayoled_swap(x, y);
|
||
|
|
y = HEIGHT - y - 1;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// adjust dirty window
|
||
|
|
window_x1 = min(window_x1, x);
|
||
|
|
window_y1 = min(window_y1, y);
|
||
|
|
window_x2 = max(window_x2, x);
|
||
|
|
window_y2 = max(window_y2, y);
|
||
|
|
|
||
|
|
if (_bpp == 1) {
|
||
|
|
switch (color) {
|
||
|
|
case MONOOLED_WHITE:
|
||
|
|
buffer[x + (y / 8) * WIDTH] |= (1 << (y & 7));
|
||
|
|
break;
|
||
|
|
case MONOOLED_BLACK:
|
||
|
|
buffer[x + (y / 8) * WIDTH] &= ~(1 << (y & 7));
|
||
|
|
break;
|
||
|
|
case MONOOLED_INVERSE:
|
||
|
|
buffer[x + (y / 8) * WIDTH] ^= (1 << (y & 7));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (_bpp == 4) {
|
||
|
|
uint8_t *pixelptr = &buffer[x / 2 + (y * WIDTH / 2)];
|
||
|
|
// Serial.printf("(%d, %d) -> offset %d\n", x, y, x/2 + (y * WIDTH / 2));
|
||
|
|
if (x % 2 == 0) { // even, left nibble
|
||
|
|
uint8_t t = pixelptr[0] & 0x0F;
|
||
|
|
t |= (color & 0xF) << 4;
|
||
|
|
pixelptr[0] = t;
|
||
|
|
} else { // odd, right lower nibble
|
||
|
|
uint8_t t = pixelptr[0] & 0xF0;
|
||
|
|
t |= color & 0xF;
|
||
|
|
pixelptr[0] = t;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Clear contents of display buffer (set all pixels to off).
|
||
|
|
@note Changes buffer contents only, no immediate effect on display.
|
||
|
|
Follow up with a call to display(), or with other graphics
|
||
|
|
commands as needed by one's own application.
|
||
|
|
*/
|
||
|
|
void Adafruit_GrayOLED::clearDisplay(void) {
|
||
|
|
memset(buffer, 0, _bpp * WIDTH * ((HEIGHT + 7) / 8));
|
||
|
|
// set max dirty window
|
||
|
|
window_x1 = 0;
|
||
|
|
window_y1 = 0;
|
||
|
|
window_x2 = WIDTH - 1;
|
||
|
|
window_y2 = HEIGHT - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Return color of a single pixel in display buffer.
|
||
|
|
@param x
|
||
|
|
Column of display -- 0 at left to (screen width - 1) at right.
|
||
|
|
@param y
|
||
|
|
Row of display -- 0 at top to (screen height -1) at bottom.
|
||
|
|
@return true if pixel is set (usually MONOOLED_WHITE, unless display invert
|
||
|
|
mode is enabled), false if clear (MONOOLED_BLACK).
|
||
|
|
@note Reads from buffer contents; may not reflect current contents of
|
||
|
|
screen if display() has not been called.
|
||
|
|
*/
|
||
|
|
bool Adafruit_GrayOLED::getPixel(int16_t x, int16_t y) {
|
||
|
|
if ((x >= 0) && (x < width()) && (y >= 0) && (y < height())) {
|
||
|
|
// Pixel is in-bounds. Rotate coordinates if needed.
|
||
|
|
switch (getRotation()) {
|
||
|
|
case 1:
|
||
|
|
grayoled_swap(x, y);
|
||
|
|
x = WIDTH - x - 1;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
x = WIDTH - x - 1;
|
||
|
|
y = HEIGHT - y - 1;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
grayoled_swap(x, y);
|
||
|
|
y = HEIGHT - y - 1;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return (buffer[x + (y / 8) * WIDTH] & (1 << (y & 7)));
|
||
|
|
}
|
||
|
|
return false; // Pixel out of bounds
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Get base address of display buffer for direct reading or writing.
|
||
|
|
@return Pointer to an unsigned 8-bit array, column-major, columns padded
|
||
|
|
to full byte boundary if needed.
|
||
|
|
*/
|
||
|
|
uint8_t *Adafruit_GrayOLED::getBuffer(void) { return buffer; }
|
||
|
|
|
||
|
|
// OTHER HARDWARE SETTINGS -------------------------------------------------
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Enable or disable display invert mode (white-on-black vs
|
||
|
|
black-on-white). Handy for testing!
|
||
|
|
@param i
|
||
|
|
If true, switch to invert mode (black-on-white), else normal
|
||
|
|
mode (white-on-black).
|
||
|
|
@note This has an immediate effect on the display, no need to call the
|
||
|
|
display() function -- buffer contents are not changed, rather a
|
||
|
|
different pixel mode of the display hardware is used. When
|
||
|
|
enabled, drawing MONOOLED_BLACK (value 0) pixels will actually draw
|
||
|
|
white, MONOOLED_WHITE (value 1) will draw black.
|
||
|
|
*/
|
||
|
|
void Adafruit_GrayOLED::invertDisplay(bool i) {
|
||
|
|
oled_command(i ? GRAYOLED_INVERTDISPLAY : GRAYOLED_NORMALDISPLAY);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*!
|
||
|
|
@brief Adjust the display contrast.
|
||
|
|
@param level The contrast level from 0 to 0x7F
|
||
|
|
@note This has an immediate effect on the display, no need to call the
|
||
|
|
display() function -- buffer contents are not changed.
|
||
|
|
*/
|
||
|
|
void Adafruit_GrayOLED::setContrast(uint8_t level) {
|
||
|
|
uint8_t cmd[] = {GRAYOLED_SETCONTRAST, level};
|
||
|
|
oled_commandList(cmd, 2);
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif /* ATTIN85 not supported */
|