esp32 firmware for a toaster reflow oven WIP!!!!!
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.
reflower/main/graphics/nokia.c

487 lines
15 KiB

5 years ago
#include <driver/gpio.h>
#include <arch/cc.h>
#include <driver/spi_master.h>
5 years ago
#include "nokia.h"
#include "utf8.h"
#include "font.h"
5 years ago
#include <string.h>
5 years ago
/* 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. */
5 years ago
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.
5 years ago
static const int sclkPin = 13; // SCLK - Serial clock, pin 7 on LCD.
/* PCD8544-specific defines: */
#define LCD_COMMAND 0
#define LCD_DATA 1
5 years ago
#define DEFAULT_CONTRAST 48
5 years ago
static spi_device_handle_t hSPI;
5 years ago
/* 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. */
5 years ago
static uint8_t displayMap[LCD_WIDTH * LCD_HEIGHT / 8];
5 years ago
// 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
5 years ago
static void LCD_SendBytes(bool data_or_command, const uint8_t *data, size_t len)
5 years ago
{
5 years ago
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.
}
5 years ago
5 years ago
// 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.
5 years ago
}
// This function sets a pixel on displayMap to your preferred
// color. 1=Black, 0= white.
5 years ago
void LCD_setPixel(int x, int y, bool bw)
5 years ago
{
5 years ago
// 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);
}
5 years ago
}
// 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)
{
5 years ago
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;
5 years ago
}
5 years ago
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);
}
5 years ago
}
}
// 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)
{
5 years ago
// check if the rectangle is to be filled
if (fill == 1) {
int xDiff;
5 years ago
5 years ago
if (x0 > x1)
xDiff = x0 - x1; //Find the difference between the x vars
else
xDiff = x1 - x0;
5 years ago
5 years ago
while (xDiff > 0) {
LCD_setLine(x0, y0, x0, y1, bw);
5 years ago
5 years ago
if (x0 > x1)
x0--;
else
x0++;
5 years ago
5 years ago
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);
5 years ago
}
}
// 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.
5 years ago
void LCD_setCircle(int x0, int y0, int radius, bool bw, int lineThickness)
5 years ago
{
5 years ago
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--;
5 years ago
}
}
// 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)
5 years ago
{
const struct FontSymbol *symbol = Font_GetSymbol(character);
bool backfill = size &0x80;
size &= 0x7F;
5 years ago
uint8_t column; // temp byte to store character's column bitmap
for (int i = 0; i < 5; i++) // 5 columns (x) per character
5 years ago
{
column = symbol->graphic[i];
5 years ago
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);
}
}
5 years ago
}
5 years ago
}
}
// 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)
5 years ago
{
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;
}
5 years ago
}
5 years ago
}
}
// 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.
5 years ago
void LCD_setBitmap(const char *bitArray)
5 years ago
{
5 years ago
for (int i = 0; i < (LCD_WIDTH * LCD_HEIGHT / 8); i++) {
char c = bitArray[i];
displayMap[i] = c;
}
5 years ago
}
// 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)
{
5 years ago
for (int i = 0; i < (LCD_WIDTH * LCD_HEIGHT / 8); i++) {
if (bw)
displayMap[i] = 0xFF;
else
displayMap[i] = 0;
}
5 years ago
}
// 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);
5 years ago
}
// This will actually draw on the display, whatever is currently
// in the displayMap array.
void LCD_updateDisplay()
{
5 years ago
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);
5 years ago
}
// 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)
{
5 years ago
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);
5 years ago
spi_device_release_bus(hSPI);
5 years ago
}
void LCD_invertDisplay(bool invert)
5 years ago
{
LCD_SendByte(LCD_COMMAND, 0x0C | invert);
}
5 years ago
void LCD_invertDisplayData()
{
5 years ago
/* Indirect, swap bits in displayMap option: */
for (int i = 0; i < (LCD_WIDTH * LCD_HEIGHT / 8); i++) {
displayMap[i] ^= 0xFF;
5 years ago
}
}
//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);
5 years ago
}
//This sends the magical commands to the PCD8544
void LCD_setup(void)
{
5 years ago
// clear the display array
LCD_clearDisplay(0);
5 years ago
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
5 years ago
// 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);
5 years ago
{
//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);
}
5 years ago
spi_device_release_bus(hSPI);
5 years ago
// show the blank screen (display is in indefined state after boot)
LCD_updateDisplay();
5 years ago
}