reflower/main/graphics/nokia.c

#include <driver/gpio.h>
#include <driver/spi_master.h>
#include "nokia.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. */
uint8_t LCD_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.
}


// 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, &LCD_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);
}

//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)
{
    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 an undefined state after boot)
    LCD_updateDisplay();
}