You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
486 lines
15 KiB
486 lines
15 KiB
#include <driver/gpio.h>
|
|
#include <arch/cc.h>
|
|
#include <driver/spi_master.h>
|
|
#include "nokia.h"
|
|
#include "utf8.h"
|
|
#include "font.h"
|
|
#include <string.h>
|
|
|
|
/* Pin definitions:
|
|
Most of these pins can be moved to any digital or analog pin.
|
|
DN(MOSI)and SCLK should be left where they are (SPI pins). The
|
|
LED (backlight) pin should remain on a PWM-capable pin. */
|
|
static const int scePin = 17; // SCE - Chip select, pin 3 on LCD.
|
|
static const int rstPin = 16; // RST - Reset, pin 4 on LCD.
|
|
static const int dcPin = 4; // DC - Data/Command, pin 5 on LCD.
|
|
static const int sdinPin = 15; // DN(MOSI) - Serial data, pin 6 on LCD.
|
|
static const int sclkPin = 13; // SCLK - Serial clock, pin 7 on LCD.
|
|
|
|
/* PCD8544-specific defines: */
|
|
#define LCD_COMMAND 0
|
|
#define LCD_DATA 1
|
|
|
|
#define DEFAULT_CONTRAST 48
|
|
|
|
static spi_device_handle_t hSPI;
|
|
|
|
/* The displayMap variable stores a buffer representation of the
|
|
pixels on our display. There are 504 total bits in this array,
|
|
same as how many pixels there are on a 84 x 48 display.
|
|
|
|
Each byte in this array covers a 8-pixel vertical block on the
|
|
display. Each successive byte covers the next 8-pixel column over
|
|
until you reach the right-edge of the display and step down 8 rows.
|
|
|
|
To update the display, we first have to write to this array, then
|
|
call the updateDisplay() function, which sends this whole array
|
|
to the PCD8544.
|
|
|
|
Because the PCD8544 won't let us write individual pixels at a
|
|
time, this is how we can make targeted changes to the display. */
|
|
static uint8_t displayMap[LCD_WIDTH * LCD_HEIGHT / 8];
|
|
|
|
// There are two memory banks in the LCD, data/RAM and commands.
|
|
// This function sets the DC pin high or low depending, and then
|
|
// sends the data byte
|
|
static void LCD_SendBytes(bool data_or_command, const uint8_t *data, size_t len)
|
|
{
|
|
esp_err_t ret;
|
|
spi_transaction_t t;
|
|
if (len == 0) return; //no need to send anything
|
|
memset(&t, 0, sizeof(t)); //Zero out the transaction
|
|
t.length = len * 8; //Len is in bytes, transaction length is in bits.
|
|
t.tx_buffer = data; //Data
|
|
t.user = (void *) data_or_command; //D/C
|
|
ret = spi_device_polling_transmit(hSPI, &t); //Transmit!
|
|
assert(ret == ESP_OK); //Should have had no issues.
|
|
}
|
|
|
|
// There are two memory banks in the LCD, data/RAM and commands.
|
|
// This function sets the DC pin high or low depending, and then
|
|
// sends the data byte
|
|
static void LCD_SendByte(bool data_or_command, uint8_t data)
|
|
{
|
|
esp_err_t ret;
|
|
spi_transaction_t t;
|
|
memset(&t, 0, sizeof(t)); //Zero out the transaction
|
|
t.length = 8; // transaction length is in bits.
|
|
t.tx_data[0] = data; //Data
|
|
t.flags = SPI_TRANS_USE_TXDATA;
|
|
t.user = (void *) data_or_command; //D/C
|
|
ret = spi_device_polling_transmit(hSPI, &t); //Transmit!
|
|
assert(ret == ESP_OK); //Should have had no issues.
|
|
}
|
|
|
|
// This function sets a pixel on displayMap to your preferred
|
|
// color. 1=Black, 0= white.
|
|
void LCD_setPixel(int x, int y, bool bw)
|
|
{
|
|
// First, double check that the coordinate is in range.
|
|
if ((x >= 0) && (x < LCD_WIDTH) && (y >= 0) && (y < LCD_HEIGHT)) {
|
|
uint8_t shift = y % 8;
|
|
|
|
if (bw) // If black, set the bit.
|
|
displayMap[x + (y / 8) * LCD_WIDTH] |= 1 << shift;
|
|
else // If white clear the bit.
|
|
displayMap[x + (y / 8) * LCD_WIDTH] &= ~(1 << shift);
|
|
}
|
|
}
|
|
|
|
// setLine draws a line from x0,y0 to x1,y1 with the set color.
|
|
// This function was grabbed from the SparkFun ColorLCDShield
|
|
// library.
|
|
void LCD_setLine(int x0, int y0, int x1, int y1, bool bw)
|
|
{
|
|
int dy = y1 - y0; // Difference between y0 and y1
|
|
int dx = x1 - x0; // Difference between x0 and x1
|
|
int stepx, stepy;
|
|
|
|
if (dy < 0) {
|
|
dy = -dy;
|
|
stepy = -1;
|
|
}
|
|
else
|
|
stepy = 1;
|
|
|
|
if (dx < 0) {
|
|
dx = -dx;
|
|
stepx = -1;
|
|
}
|
|
else
|
|
stepx = 1;
|
|
|
|
dy <<= 1; // dy is now 2*dy
|
|
dx <<= 1; // dx is now 2*dx
|
|
LCD_setPixel(x0, y0, bw); // Draw the first pixel.
|
|
|
|
if (dx > dy) {
|
|
int fraction = dy - (dx >> 1);
|
|
while (x0 != x1) {
|
|
if (fraction >= 0) {
|
|
y0 += stepy;
|
|
fraction -= dx;
|
|
}
|
|
x0 += stepx;
|
|
fraction += dy;
|
|
LCD_setPixel(x0, y0, bw);
|
|
}
|
|
}
|
|
else {
|
|
int fraction = dx - (dy >> 1);
|
|
while (y0 != y1) {
|
|
if (fraction >= 0) {
|
|
x0 += stepx;
|
|
fraction -= dy;
|
|
}
|
|
y0 += stepy;
|
|
fraction += dx;
|
|
LCD_setPixel(x0, y0, bw);
|
|
}
|
|
}
|
|
}
|
|
|
|
// setRect will draw a rectangle from x0,y0 top-left corner to
|
|
// a x1,y1 bottom-right corner. Can be filled with the fill
|
|
// parameter, and colored with bw.
|
|
// This function was grabbed from the SparkFun ColorLCDShield
|
|
// library.
|
|
void LCD_setRect(int x0, int y0, int x1, int y1, bool fill, bool bw)
|
|
{
|
|
// check if the rectangle is to be filled
|
|
if (fill == 1) {
|
|
int xDiff;
|
|
|
|
if (x0 > x1)
|
|
xDiff = x0 - x1; //Find the difference between the x vars
|
|
else
|
|
xDiff = x1 - x0;
|
|
|
|
while (xDiff > 0) {
|
|
LCD_setLine(x0, y0, x0, y1, bw);
|
|
|
|
if (x0 > x1)
|
|
x0--;
|
|
else
|
|
x0++;
|
|
|
|
xDiff--;
|
|
}
|
|
}
|
|
else {
|
|
// best way to draw an unfilled rectangle is to draw four lines
|
|
LCD_setLine(x0, y0, x1, y0, bw);
|
|
LCD_setLine(x0, y1, x1, y1, bw);
|
|
LCD_setLine(x0, y0, x0, y1, bw);
|
|
LCD_setLine(x1, y0, x1, y1, bw);
|
|
}
|
|
}
|
|
|
|
// setCircle draws a circle centered around x0,y0 with a defined
|
|
// radius. The circle can be black or white. And have a line
|
|
// thickness ranging from 1 to the radius of the circle.
|
|
// This function was grabbed from the SparkFun ColorLCDShield
|
|
// library.
|
|
void LCD_setCircle(int x0, int y0, int radius, bool bw, int lineThickness)
|
|
{
|
|
for (int r = 0; r < lineThickness; r++) {
|
|
int f = 1 - radius;
|
|
int ddF_x = 0;
|
|
int ddF_y = -2 * radius;
|
|
int x = 0;
|
|
int y = radius;
|
|
|
|
LCD_setPixel(x0, y0 + radius, bw);
|
|
LCD_setPixel(x0, y0 - radius, bw);
|
|
LCD_setPixel(x0 + radius, y0, bw);
|
|
LCD_setPixel(x0 - radius, y0, bw);
|
|
|
|
while (x < y) {
|
|
if (f >= 0) {
|
|
y--;
|
|
ddF_y += 2;
|
|
f += ddF_y;
|
|
}
|
|
x++;
|
|
ddF_x += 2;
|
|
f += ddF_x + 1;
|
|
|
|
LCD_setPixel(x0 + x, y0 + y, bw);
|
|
LCD_setPixel(x0 - x, y0 + y, bw);
|
|
LCD_setPixel(x0 + x, y0 - y, bw);
|
|
LCD_setPixel(x0 - x, y0 - y, bw);
|
|
LCD_setPixel(x0 + y, y0 + x, bw);
|
|
LCD_setPixel(x0 - y, y0 + x, bw);
|
|
LCD_setPixel(x0 + y, y0 - x, bw);
|
|
LCD_setPixel(x0 - y, y0 - x, bw);
|
|
}
|
|
radius--;
|
|
}
|
|
}
|
|
|
|
// This function will draw a char (defined in the ASCII table
|
|
// near the beginning of this sketch) at a defined x and y).
|
|
// The color can be either black (1) or white (0).
|
|
void LCD_setChar(struct Utf8Char character, int x, int y, bool bw)
|
|
{
|
|
LCD_setCharEx(character, x, y, bw, 1);
|
|
}
|
|
|
|
void LCD_setCharEx(struct Utf8Char character, int x, int y, bool bw, uint8_t size)
|
|
{
|
|
const struct FontSymbol *symbol = Font_GetSymbol(character);
|
|
bool backfill = size &0x80;
|
|
size &= 0x7F;
|
|
|
|
uint8_t column; // temp byte to store character's column bitmap
|
|
for (int i = 0; i < 5; i++) // 5 columns (x) per character
|
|
{
|
|
column = symbol->graphic[i];
|
|
for (int j = 0; j < 8; j++) // 8 rows (y) per character
|
|
{
|
|
bool bit = column & (0x01 << j);
|
|
|
|
if (size == 1) {
|
|
if (bit) {// test bits to set pixels
|
|
LCD_setPixel(x + i, y + j, bw);
|
|
} else if(backfill) {
|
|
LCD_setPixel(x + i, y + j, !bw);
|
|
}
|
|
} else if (size == 2) {
|
|
if (bit) {// test bits to set pixels
|
|
LCD_setPixel(x + i * 2, y + j * 2, bw);
|
|
LCD_setPixel(x + i * 2 + 1, y + j * 2, bw);
|
|
LCD_setPixel(x + i * 2, y + j * 2 + 1, bw);
|
|
LCD_setPixel(x + i * 2 + 1, y + j * 2 + 1, bw);
|
|
} else if(backfill) {
|
|
LCD_setPixel(x + i * 2, y + j * 2, !bw);
|
|
LCD_setPixel(x + i * 2 + 1, y + j * 2, !bw);
|
|
LCD_setPixel(x + i * 2, y + j * 2 + 1, !bw);
|
|
LCD_setPixel(x + i * 2 + 1, y + j * 2 + 1, !bw);
|
|
}
|
|
} else if (size == 3) {
|
|
if (bit) {// test bits to set pixels
|
|
LCD_setPixel(x + i, y + j, bw);
|
|
LCD_setPixel(x + i + 1, y + j, bw);
|
|
} else if(backfill) {
|
|
LCD_setPixel(x + i, y + j, !bw);
|
|
LCD_setPixel(x + i + 1, y + j, !bw);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// setStr draws a string of characters, calling setChar with
|
|
// progressive coordinates until it's done.
|
|
// This function was grabbed from the SparkFun ColorLCDShield
|
|
// library.
|
|
void LCD_setStr(const char *dString, int x, int y, bool bw)
|
|
{
|
|
LCD_setStrEx(dString, x, y, bw, 1);
|
|
}
|
|
|
|
// setStr draws a string of characters, calling setChar with
|
|
// progressive coordinates until it's done.
|
|
// This function was grabbed from the SparkFun ColorLCDShield
|
|
// library.
|
|
void LCD_setStrEx(const char *dString, int x, int y, bool bw, uint8_t size)
|
|
{
|
|
struct Utf8Iterator iter;
|
|
Utf8Iterator_Start(&iter, dString);
|
|
bool backfill = size & 0x80;
|
|
uint8_t size_real = size & 0x7F;
|
|
|
|
struct Utf8Char uchar;
|
|
while ((uchar = Utf8Iterator_Next(&iter)).uint) {
|
|
LCD_setCharEx(uchar, x, y, bw, size);
|
|
|
|
if (size_real == 1) {
|
|
x += 5;
|
|
if (backfill) {
|
|
for (int i = y; i < y + 8; i++) {
|
|
LCD_setPixel(x, i, !bw);
|
|
}
|
|
}
|
|
x++;
|
|
if (x > (LCD_WIDTH - 5)) // Enables wrap around
|
|
{
|
|
x = 0;
|
|
y += 8;
|
|
}
|
|
} else if (size_real == 2) {
|
|
x += 10;
|
|
if (backfill) {
|
|
for (int i = y; i < y + 16; i++) {
|
|
LCD_setPixel(x, i, !bw);
|
|
LCD_setPixel(x + 1, i, !bw);
|
|
}
|
|
}
|
|
x+=2;
|
|
if (x > (LCD_WIDTH - 10)) // Enables wrap around
|
|
{
|
|
x = 0;
|
|
y += 16;
|
|
}
|
|
} else if (size_real == 3) {
|
|
x += 6;
|
|
if (backfill) {
|
|
for (int i = y; i < y + 8; i++) {
|
|
LCD_setPixel(x, i, !bw);
|
|
LCD_setPixel(x + 1, i, !bw);
|
|
}
|
|
}
|
|
x+=1;
|
|
if (x > (LCD_WIDTH - 6)) // Enables wrap around
|
|
{
|
|
x = 0;
|
|
y += 8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// This function will draw an array over the screen. (For now) the
|
|
// array must be the same size as the screen, covering the entirety
|
|
// of the display.
|
|
// Also, the array must reside in FLASH and declared with PROGMEM.
|
|
void LCD_setBitmap(const char *bitArray)
|
|
{
|
|
for (int i = 0; i < (LCD_WIDTH * LCD_HEIGHT / 8); i++) {
|
|
char c = bitArray[i];
|
|
displayMap[i] = c;
|
|
}
|
|
}
|
|
|
|
// This function clears the entire display either white (0) or
|
|
// black (1).
|
|
// The screen won't actually clear until you call updateDisplay()!
|
|
void LCD_clearDisplay(bool bw)
|
|
{
|
|
for (int i = 0; i < (LCD_WIDTH * LCD_HEIGHT / 8); i++) {
|
|
if (bw)
|
|
displayMap[i] = 0xFF;
|
|
else
|
|
displayMap[i] = 0;
|
|
}
|
|
}
|
|
|
|
// Helpful function to directly command the LCD to go to a
|
|
// specific x,y coordinate.
|
|
static void gotoXY(int x, int y)
|
|
{
|
|
const uint8_t cmd[2] = {
|
|
0x80 | x,
|
|
0x40 | y,
|
|
};
|
|
LCD_SendBytes(LCD_COMMAND, cmd, 2);
|
|
}
|
|
|
|
// This will actually draw on the display, whatever is currently
|
|
// in the displayMap array.
|
|
void LCD_updateDisplay()
|
|
{
|
|
spi_device_acquire_bus(hSPI, portMAX_DELAY);
|
|
gotoXY(0, 0);
|
|
LCD_SendBytes(LCD_DATA, &displayMap[0], LCD_WIDTH * (LCD_HEIGHT / 8));
|
|
spi_device_release_bus(hSPI);
|
|
}
|
|
|
|
// Set contrast can set the LCD Vop to a value between 0 and 127.
|
|
// 40-60 is usually a pretty good range.
|
|
void LCD_setContrast(uint8_t contrast)
|
|
{
|
|
spi_device_acquire_bus(hSPI, portMAX_DELAY);
|
|
const uint8_t cmd[3] = {
|
|
0x21, //Tell LCD that extended commands follow
|
|
0x80 | contrast,//Set LCD Vop (Contrast): Try 0xB1(good @ 3.3V) or 0xBF if your display is too dark
|
|
0x20,//Set display mode
|
|
};
|
|
LCD_SendBytes(LCD_COMMAND, cmd, 3);
|
|
spi_device_release_bus(hSPI);
|
|
}
|
|
|
|
void LCD_invertDisplay(bool invert)
|
|
{
|
|
LCD_SendByte(LCD_COMMAND, 0x0C | invert);
|
|
}
|
|
|
|
void LCD_invertDisplayData()
|
|
{
|
|
/* Indirect, swap bits in displayMap option: */
|
|
for (int i = 0; i < (LCD_WIDTH * LCD_HEIGHT / 8); i++) {
|
|
displayMap[i] ^= 0xFF;
|
|
}
|
|
}
|
|
|
|
//This function is called (in irq context!) just before a transmission starts. It will
|
|
//set the D/C line to the value indicated in the user field.
|
|
void lcd_spi_pre_transfer_callback(spi_transaction_t *t)
|
|
{
|
|
int dc = (int) t->user;
|
|
gpio_set_level(dcPin, dc);
|
|
}
|
|
|
|
//This sends the magical commands to the PCD8544
|
|
void LCD_setup(void)
|
|
{
|
|
// clear the display array
|
|
LCD_clearDisplay(0);
|
|
|
|
gpio_config_t output = {
|
|
.pin_bit_mask = (1<<scePin) | (1<<rstPin) | (1<<dcPin) | (1<<sdinPin) | (1<<sclkPin),
|
|
.mode = GPIO_MODE_OUTPUT
|
|
};
|
|
gpio_config(&output);
|
|
|
|
esp_err_t ret;
|
|
spi_bus_config_t buscfg = {
|
|
.miso_io_num=-1,
|
|
.mosi_io_num=sdinPin,
|
|
.sclk_io_num=sclkPin,
|
|
.quadwp_io_num=-1,
|
|
.quadhd_io_num=-1,
|
|
.max_transfer_sz=LCD_WIDTH * LCD_HEIGHT, // ??? this doesnt seem to do anything in the driver
|
|
};
|
|
spi_device_interface_config_t devcfg = {
|
|
.clock_speed_hz=4 * 1000 * 1000, // Hz
|
|
// enable signal lead/lag
|
|
.cs_ena_pretrans = 0,
|
|
.cs_ena_posttrans = 0,
|
|
.mode=0, //SPI mode 0
|
|
.spics_io_num=scePin, //CS pin
|
|
.queue_size=1, // we use the polling mode, so this does not matter
|
|
.pre_cb=lcd_spi_pre_transfer_callback, //Specify pre-transfer callback to handle D/C line
|
|
};
|
|
|
|
//Initialize the SPI bus
|
|
ret = spi_bus_initialize(HSPI_HOST, &buscfg, 1);
|
|
ESP_ERROR_CHECK(ret);
|
|
//Attach the LCD to the SPI bus
|
|
ret = spi_bus_add_device(HSPI_HOST, &devcfg, &hSPI);
|
|
ESP_ERROR_CHECK(ret);
|
|
|
|
spi_device_acquire_bus(hSPI, portMAX_DELAY);
|
|
{
|
|
//Reset the LCD to a known state
|
|
gpio_set_level(rstPin, 0);
|
|
gpio_set_level(rstPin, 1);
|
|
|
|
const uint8_t magic[6] = {
|
|
0x21, // Tell LCD extended commands follow
|
|
0x80 + DEFAULT_CONTRAST, // Set LCD Vop (Contrast)
|
|
0x04, // Set Temp coefficent
|
|
0x14, // LCD bias mode 1:48 (try 0x13)
|
|
//We must send 0x20 before modifying the display control mode
|
|
0x20, // Clear extended option
|
|
0x0C, // Set display control, normal mode.
|
|
};
|
|
LCD_SendBytes(LCD_COMMAND, &magic[0], 6);
|
|
}
|
|
spi_device_release_bus(hSPI);
|
|
|
|
// show the blank screen (display is in indefined state after boot)
|
|
LCD_updateDisplay();
|
|
}
|
|
|
|
|
|
|