retroClock

Driving the Display Array with an ESP32

The Raspberry Pi Pico is a very capable microcontroller, good enough to drive the Display Array, easy to program, a lot of memory and speed but it does not have WiFi, That is why I have checked the ESP32 and it is also fast and with a lot of memory.

I have found that the ESP32-S2 is a nice option for the display array as it has a USB interface for the programming and not a real need for a USB-Serial converter, it has enough GPIOs even for an 8 display board.

I am very new with the ESP32 so I have tried with MicroPython, CircuitPython, Arduino, and Espressif repository running in Visual Studio Code, and the easiest for me was this last one, so I took the SNTP example located at the protocols example folder. In Visual Studio Code is the Espressif plug-in which makes it very easy and fast to get started with the ESP32.

After installing and opening the example we just need to configure the example for the Wifi credentials.

And now is as easy as adding the SPI configurations for the displays.

/* LwIP SNTP example

   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_attr.h"
#include "esp_sleep.h"
#include "nvs_flash.h"
#include "protocol_examples_common.h"
#include "esp_sntp.h"

//#include "clock14SEG.h"
#include "clockBINA.h"
//#include "clockDigital.h"
//#include "clockFlip.h"
//#include "clockInk.h"
#include "clockLixieCyan.h"
#include "clockLixiePurple.h"
//#include "clockMatrix.h"
#include "clockNIMO.h"
//#include "clockNixie.h"
//#include "clockVFD.h"
//#include "clockWood.h"

#include "clockFlags.h"

#define zero_Theme      zero_BINA
#define one_Theme       one_BINA
#define two_Theme       two_BINA
#define three_Theme     three_BINA
#define four_Theme      four_BINA
#define five_Theme      five_BINA
#define six_Theme       six_BINA
#define seven_Theme     seven_BINA
#define eight_Theme     eight_BINA
#define nine_Theme      nine_BINA
#define colon_Theme     colon_BINA
#define space_Theme     space_BINA

#define zero_Theme3      zero_LixiePurple
#define one_Theme3       one_LixiePurple
#define two_Theme3       two_LixiePurple
#define three_Theme3     three_LixiePurple
#define four_Theme3      four_LixiePurple
#define five_Theme3      five_LixiePurple
#define six_Theme3       six_LixiePurple
#define seven_Theme3     seven_LixiePurple
#define eight_Theme3     eight_LixiePurple
#define nine_Theme3      nine_LixiePurple
#define colon_Theme3     colon_LixiePurple
#define space_Theme3     space_LixiePurple

#define zero_Theme2      zero_LixieCyan
#define one_Theme2       one_LixieCyan
#define two_Theme2       two_LixieCyan
#define three_Theme2     three_LixieCyan
#define four_Theme2      four_LixieCyan
#define five_Theme2      five_LixieCyan
#define six_Theme2       six_LixieCyan
#define seven_Theme2     seven_LixieCyan
#define eight_Theme2     eight_LixieCyan
#define nine_Theme2      nine_LixieCyan
#define colon_Theme2     colon_LixieCyan
#define space_Theme2     space_LixieCyan

#define zero_Theme1      zero_NIMO
#define one_Theme1       one_NIMO
#define two_Theme1       two_NIMO
#define three_Theme1     three_NIMO
#define four_Theme1      four_NIMO
#define five_Theme1      five_NIMO
#define six_Theme1       six_NIMO
#define seven_Theme1     seven_NIMO
#define eight_Theme1     eight_NIMO
#define nine_Theme1      nine_NIMO
#define colon_Theme1     colon_NIMO
#define space_Theme1     space_NIMO

#define PIN_NUM_BLK     37
#define PIN_NUM_RST     33
#define PIN_NUM_DC      34
#define PIN_NUM_MOSI    35
#define PIN_NUM_CLK     36
#define PIN_NUM_MISO    -1

#define PIN_NUM_CS1     1
#define PIN_NUM_CS2     2
#define PIN_NUM_CS3     3
#define PIN_NUM_CS4     4
#define PIN_NUM_CS5     5
#define PIN_NUM_CS6     6

#define PIN_NUM_BTA     10
#define PIN_NUM_BTB     11
#define PIN_NUM_BTC     12 
#define PIN_NUM_BTD     13
#define PIN_NUM_BTE     0
/*
 The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct.
*/
typedef struct {
    uint8_t cmd;
    uint8_t data[16];
    uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
} lcd_init_cmd_t;

//Place data into DRAM. Constant data gets placed into DROM by default, which is not accessible by DMA.
DRAM_ATTR static const lcd_init_cmd_t st_init_cmds[]={
     /* Sleep Out */
    {0x11, {0}, 0x80},
    /* Memory Data Access Control, MX=MV=1, MY=ML=MH=0, RGB=0 */
    {0x36, {0xC8}, 1},
    /* Interface Pixel Format, 16bits/pixel for RGB/MCU interface */
    {0x3A, {0x05}, 1},
    /* Porch Setting */
    {0xB1, {0x01, 0x2C, 0x2D}, 3},
    {0xB2, {0x01, 0x2C, 0x2D}, 3},
    {0xB3, {0x01, 0x2C, 0x2D, 0x01, 0x2C, 0x2D}, 6},
    {0xB4, {0x07}, 1},
    /* LCM Control, XOR: BGR, MX, MH */
    {0xC0, {0xA2,0x02,0x84}, 3},
    {0xC1, {0xC5}, 1},
    /* VDV and VRH Command Enable, enable=1 */
    {0xC2, {0x0A, 0x00}, 2},
    /* VRH Set, Vap=4.4+... */
    {0xC3, {0x8A,0xEE}, 2},
    /* VDV Set, VDV=0 */
    {0xC5, {0x0E}, 1},
    /* Column Address */
    {0x2A, {0x00, 0x1A, 0x00, 0x69}, 4},
    /* Row Address */
    {0x2B, {0x00, 0x01, 0x00, 0xA0}, 4},
    /* Positive Voltage Gamma Control */
    {0xE0, {0x02, 0x1C, 0x07, 0x12, 0x37, 0x32, 0x29, 0x2D, 0x29, 0x25, 0x2B, 0x39, 0x00, 0x01, 0x03, 0x10}, 16},
    /* Negative Voltage Gamma Control */
    {0xE1, {0x03, 0x1D, 0x07, 0x06, 0x2E, 0x2C, 0x29, 0x2D, 0x2E, 0x2E, 0x37, 0x3F, 0x00, 0x00, 0x02, 0x10}, 16},
    /* Inversion ON */
    {0x21, {0}, 0x80},
    /* Normal Display */
    {0x13, {0}, 0x80},
    /* Display On */
    {0x29, {0}, 0x80},
    /* Write Data */
    {0x2C, {0}, 0x80},
    {0, {0}, 0xff}
};



/* Send a command to the LCD. Uses spi_device_polling_transmit, which waits
 * until the transfer is complete.
 *
 * Since command transactions are usually small, they are handled in polling
 * mode for higher speed. The overhead of interrupt transactions is more than
 * just waiting for the transaction to complete.
 */
void lcd_cmd(spi_device_handle_t spi, const uint8_t cmd)
{
    esp_err_t ret;
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));       //Zero out the transaction
    t.length=8;                     //Command is 8 bits
    t.tx_buffer=&cmd;               //The data is the cmd itself
    t.user=(void*)0;                //D/C needs to be set to 0
    ret=spi_device_polling_transmit(spi, &t);  //Transmit!
    assert(ret==ESP_OK);            //Should have had no issues.
}

/* Send data to the LCD. Uses spi_device_polling_transmit, which waits until the
 * transfer is complete.
 *
 * Since data transactions are usually small, they are handled in polling
 * mode for higher speed. The overhead of interrupt transactions is more than
 * just waiting for the transaction to complete.
 */
void lcd_data(spi_device_handle_t spi, const uint8_t *data, int 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*)1;                //D/C needs to be set to 1
    ret=spi_device_polling_transmit(spi, &t);  //Transmit!
    assert(ret==ESP_OK);            //Should have had no issues.
}

//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(PIN_NUM_DC, dc);
}

//Initialize the display
void lcd_init(spi_device_handle_t spi){
    int cmd=0;
    const lcd_init_cmd_t* lcd_init_cmds;
    lcd_init_cmds = st_init_cmds;

    //Initialize non-SPI GPIOs
    gpio_set_direction(PIN_NUM_DC, GPIO_MODE_OUTPUT);
    gpio_set_direction(PIN_NUM_RST, GPIO_MODE_OUTPUT);
    gpio_set_direction(PIN_NUM_BLK, GPIO_MODE_OUTPUT);

    gpio_set_direction(PIN_NUM_CS1, GPIO_MODE_OUTPUT);
    gpio_set_direction(PIN_NUM_CS2, GPIO_MODE_OUTPUT);
    gpio_set_direction(PIN_NUM_CS3, GPIO_MODE_OUTPUT);
    gpio_set_direction(PIN_NUM_CS4, GPIO_MODE_OUTPUT);
    gpio_set_direction(PIN_NUM_CS5, GPIO_MODE_OUTPUT);
    gpio_set_direction(PIN_NUM_CS6, GPIO_MODE_OUTPUT);

    gpio_set_direction(PIN_NUM_BTA, GPIO_MODE_INPUT);
    gpio_set_direction(PIN_NUM_BTB, GPIO_MODE_INPUT);
    gpio_set_direction(PIN_NUM_BTC, GPIO_MODE_INPUT);
    gpio_set_direction(PIN_NUM_BTD, GPIO_MODE_INPUT);
    gpio_set_direction(PIN_NUM_BTE, GPIO_MODE_INPUT);

    gpio_set_level(PIN_NUM_CS1, 0);
    gpio_set_level(PIN_NUM_CS2, 0);
    gpio_set_level(PIN_NUM_CS3, 0);
    gpio_set_level(PIN_NUM_CS4, 0);
    gpio_set_level(PIN_NUM_CS5, 0);
    gpio_set_level(PIN_NUM_CS6, 0);
    gpio_set_level(PIN_NUM_BLK, 0);

    //Reset the display
    gpio_set_level(PIN_NUM_RST, 0);
    vTaskDelay(100 / portTICK_RATE_MS);
    gpio_set_level(PIN_NUM_RST, 1);
    vTaskDelay(100 / portTICK_RATE_MS);

    //Send all the commands
    while (lcd_init_cmds[cmd].databytes!=0xff) {
        lcd_cmd(spi, lcd_init_cmds[cmd].cmd);
        lcd_data(spi, lcd_init_cmds[cmd].data, lcd_init_cmds[cmd].databytes&0x1F);
        if (lcd_init_cmds[cmd].databytes&0x80) {
            vTaskDelay(100 / portTICK_RATE_MS);
        }
        cmd++;
    }
}

uint8_t clockTheme = 0;
uint8_t prevHours,prevMinutes,prevSeconds;
uint8_t imgBuffer[100];

uint8_t backlightStatus = 1;
uint8_t secondsCounter = 0;
uint8_t secondsStatus = 0;

void selectDisplay(uint8_t);
void lcdDrawNumber(spi_device_handle_t,uint8_t,uint8_t);
void lcdDrawFlag(spi_device_handle_t,uint8_t,uint8_t);

static void obtain_time(void);
static void initialize_sntp(void);

void app_main(void)
{
    esp_err_t ret;
    spi_device_handle_t spi;
    spi_bus_config_t buscfg={
        .miso_io_num=PIN_NUM_MISO,
        .mosi_io_num=PIN_NUM_MOSI,
        .sclk_io_num=PIN_NUM_CLK,
        .quadwp_io_num=-1,
        .quadhd_io_num=-1,
        .max_transfer_sz=100
    };
    spi_device_interface_config_t devcfg={
        .clock_speed_hz=40*1000*1000,           //Clock out at 10 MHz
        .mode=0,                                //SPI mode 0
        //.spics_io_num=PIN_NUM_CS1,            //CS pin
        .queue_size=7,                          //We want to be able to queue 7 transactions at a time
        .pre_cb=lcd_spi_pre_transfer_callback,  //Specify pre-transfer callback to handle D/C line
    };
    //Initialize the SPI bus
    ret=spi_bus_initialize(SPI2_HOST, &buscfg, SPI2_HOST);
    ESP_ERROR_CHECK(ret);
    //Attach the LCD to the SPI bus
    ret=spi_bus_add_device(SPI2_HOST, &devcfg, &spi);
    ESP_ERROR_CHECK(ret);
    //Initialize the LCD
    lcd_init(spi);
    lcdDrawNumber(spi,0,11);
    ///Enable backlight
    gpio_set_level(PIN_NUM_BLK, 1);
   
    time_t now;
    struct tm timeinfo;
    time(&now);
    localtime_r(&now, &timeinfo);
    if (timeinfo.tm_year < (2016 - 1900)) { // Is time set? If not, tm_year will be (1970 - 1900).
        obtain_time();
        time(&now); // update 'now' variable with current time
    }

    // Set timezone to Mexico City Central Standard Time 
    setenv("TZ", "CST6CDT,M4.1.0/2,M10.5.0", 1); //EST5EDT,M3.2.0/2,M11.1.0
    tzset();
    localtime_r(&now, &timeinfo);

    prevHours = 0;
    prevMinutes = 0;
    prevSeconds = 0;


    lcdDrawFlag(spi,6,0);

    while(1){
        
        if(timeinfo.tm_hour != prevHours){
            prevHours = timeinfo.tm_hour;
    
            if(timeinfo.tm_hour < 10){
                lcdDrawNumber(spi,1,0);
                lcdDrawNumber(spi,2,timeinfo.tm_hour);
            }else if (timeinfo.tm_hour < 20){
                lcdDrawNumber(spi,1,1);
                lcdDrawNumber(spi,2,timeinfo.tm_hour-10);
            }else{
                lcdDrawNumber(spi,1,2);
                lcdDrawNumber(spi,2,timeinfo.tm_hour-20);
            }
        }     

        if(timeinfo.tm_min != prevMinutes){
            prevMinutes = timeinfo.tm_min;

            if(timeinfo.tm_min < 10){
                lcdDrawNumber(spi,4,0);
                lcdDrawNumber(spi,5,timeinfo.tm_min);
            }else if (timeinfo.tm_min < 20){
                lcdDrawNumber(spi,4,1);
                lcdDrawNumber(spi,5,timeinfo.tm_min-10);
            }else if (timeinfo.tm_min < 30){
                lcdDrawNumber(spi,4,2);
                lcdDrawNumber(spi,5,timeinfo.tm_min-20);
            }else if (timeinfo.tm_min < 40){
                lcdDrawNumber(spi,4,3);
                lcdDrawNumber(spi,5,timeinfo.tm_min-30);
            }else if (timeinfo.tm_min < 50){
                lcdDrawNumber(spi,4,4);
                lcdDrawNumber(spi,5,timeinfo.tm_min-40);
            }else{
                lcdDrawNumber(spi,4,5);
                lcdDrawNumber(spi,5,timeinfo.tm_min-50);
            }
        } 

        vTaskDelay(20 / portTICK_PERIOD_MS);
        secondsCounter++;
        time(&now);                     // update 'now' variable with current time
        localtime_r(&now, &timeinfo);

        if(gpio_get_level(PIN_NUM_BTA) == 0){
            clockTheme = 0;
            setenv("TZ", "CST6CDT,M4.1.0/2,M10.5.0", 1); // Mexico City
            tzset();
            localtime_r(&now, &timeinfo);
            prevHours = 0;
            prevMinutes = 0;
            prevSeconds = 0;
            lcdDrawNumber(spi,1,0);
            lcdDrawNumber(spi,2,0);
            lcdDrawNumber(spi,4,0);
            lcdDrawNumber(spi,5,0);
            lcdDrawFlag(spi,6,0);
            lcdDrawNumber(spi,3,10);
            vTaskDelay(120 / portTICK_PERIOD_MS);
        }

        if(gpio_get_level(PIN_NUM_BTB) == 0){
            clockTheme = 1;
            setenv("TZ", "CET1CEST,M3.5.0/2,M10.5.0", 1); // Germany Berlin
            tzset();
            localtime_r(&now, &timeinfo);
            prevHours = 0;
            prevMinutes = 0;
            prevSeconds = 0;
            lcdDrawNumber(spi,1,0);
            lcdDrawNumber(spi,2,0);
            lcdDrawNumber(spi,4,0);
            lcdDrawNumber(spi,5,0);
            lcdDrawFlag(spi,6,1);
            lcdDrawNumber(spi,3,10);
            vTaskDelay(120 / portTICK_PERIOD_MS);
        }

        if(gpio_get_level(PIN_NUM_BTC) == 0){
            clockTheme = 2;
            setenv("TZ", "EST5EDT,M3.2.0/2,M11.1.0", 1); // USA New York
            tzset();
            localtime_r(&now, &timeinfo);
            prevHours = 0;
            prevMinutes = 0;
            prevSeconds = 0;
            lcdDrawNumber(spi,1,0);
            lcdDrawNumber(spi,2,0);
            lcdDrawNumber(spi,4,0);
            lcdDrawNumber(spi,5,0);
            lcdDrawFlag(spi,6,2);
            lcdDrawNumber(spi,3,10);
            vTaskDelay(120 / portTICK_PERIOD_MS);
        }

        if (gpio_get_level(PIN_NUM_BTD) == 0){
            clockTheme = 3;
            setenv("TZ", "GMT0BST,M3.5.0/2,M10.5.0", 1); // UK London 
            tzset();
            localtime_r(&now, &timeinfo);
            prevHours = 0;
            prevMinutes = 0;
            prevSeconds = 0;
            lcdDrawNumber(spi,1,0);
            lcdDrawNumber(spi,2,0);
            lcdDrawNumber(spi,4,0);
            lcdDrawNumber(spi,5,0);
            lcdDrawFlag(spi,6,3);
            lcdDrawNumber(spi,3,10);
            vTaskDelay(120 / portTICK_PERIOD_MS);
        }

        if((secondsCounter > 25) & (secondsStatus == 0)){
            lcdDrawNumber(spi,3,10); 
            secondsStatus = 1;
            secondsCounter = 0;
        } else if((secondsCounter > 25) & (secondsStatus == 1)){
            lcdDrawNumber(spi,3,11); 
            secondsStatus = 0;
            secondsCounter = 0;
        }

        if((gpio_get_level(PIN_NUM_BTE) == 0) & (backlightStatus == 1)){
            backlightStatus = 0;
            gpio_set_level(PIN_NUM_BLK, 0);
            vTaskDelay(120 / portTICK_PERIOD_MS);
        } else if((gpio_get_level(PIN_NUM_BTE) == 0) & (backlightStatus == 0)){
            backlightStatus = 1;
            gpio_set_level(PIN_NUM_BLK, 1);
            vTaskDelay(120 / portTICK_PERIOD_MS);
        }
    }
}

static void obtain_time(void){

    ESP_ERROR_CHECK( nvs_flash_init() );
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK( esp_event_loop_create_default() );

    /* This helper function configures Wi-Fi or Ethernet, as selected in menuconfig.
     * Read "Establishing Wi-Fi or Ethernet Connection" section in
     * examples/protocols/README.md for more information about this function.
     */
    ESP_ERROR_CHECK(example_connect());

    initialize_sntp();
    
    time_t now = 0;                     // wait for time to be set
    struct tm timeinfo = { 0 };
    int retry = 0;
    const int retry_count = 10;
    while (sntp_get_sync_status() == SNTP_SYNC_STATUS_RESET && ++retry < retry_count) {
        vTaskDelay(2000 / portTICK_PERIOD_MS);}
    time(&now);
    localtime_r(&now, &timeinfo);
    ESP_ERROR_CHECK( example_disconnect() );
}

static void initialize_sntp(void){
    sntp_setoperatingmode(SNTP_OPMODE_POLL);
    sntp_setservername(0, "pool.ntp.org");
    sntp_init();
}

void selectDisplay(uint8_t display){
    switch(display){
        case 0:
            gpio_set_level(PIN_NUM_CS1, 0);
            gpio_set_level(PIN_NUM_CS2, 0);
            gpio_set_level(PIN_NUM_CS3, 0);
            gpio_set_level(PIN_NUM_CS4, 0);
            gpio_set_level(PIN_NUM_CS5, 0);
            gpio_set_level(PIN_NUM_CS6, 0);
        break;
        case 1:
            gpio_set_level(PIN_NUM_CS1, 0);
            gpio_set_level(PIN_NUM_CS2, 1);
            gpio_set_level(PIN_NUM_CS3, 1);
            gpio_set_level(PIN_NUM_CS4, 1);
            gpio_set_level(PIN_NUM_CS5, 1);
            gpio_set_level(PIN_NUM_CS6, 1);
        break;
        case 2:
            gpio_set_level(PIN_NUM_CS1, 1);
            gpio_set_level(PIN_NUM_CS2, 0);
            gpio_set_level(PIN_NUM_CS3, 1);
            gpio_set_level(PIN_NUM_CS4, 1);
            gpio_set_level(PIN_NUM_CS5, 1);
            gpio_set_level(PIN_NUM_CS6, 1);
        break;
        case 3:
            gpio_set_level(PIN_NUM_CS1, 1);
            gpio_set_level(PIN_NUM_CS2, 1);
            gpio_set_level(PIN_NUM_CS3, 0);
            gpio_set_level(PIN_NUM_CS4, 1);
            gpio_set_level(PIN_NUM_CS5, 1);
            gpio_set_level(PIN_NUM_CS6, 1);
        break;
        case 4:
            gpio_set_level(PIN_NUM_CS1, 1);
            gpio_set_level(PIN_NUM_CS2, 1);
            gpio_set_level(PIN_NUM_CS3, 1);
            gpio_set_level(PIN_NUM_CS4, 0);
            gpio_set_level(PIN_NUM_CS5, 1);
            gpio_set_level(PIN_NUM_CS6, 1);
        break;
        case 5:
            gpio_set_level(PIN_NUM_CS1, 1);
            gpio_set_level(PIN_NUM_CS2, 1);
            gpio_set_level(PIN_NUM_CS3, 1);
            gpio_set_level(PIN_NUM_CS4, 1);
            gpio_set_level(PIN_NUM_CS5, 0);
            gpio_set_level(PIN_NUM_CS6, 1);
        break;
        case 6:
            gpio_set_level(PIN_NUM_CS1, 1);
            gpio_set_level(PIN_NUM_CS2, 1);
            gpio_set_level(PIN_NUM_CS3, 1);
            gpio_set_level(PIN_NUM_CS4, 1);
            gpio_set_level(PIN_NUM_CS5, 1);
            gpio_set_level(PIN_NUM_CS6, 0);
        break;
        case 9:
            gpio_set_level(PIN_NUM_CS1, 0);
            gpio_set_level(PIN_NUM_CS2, 0);
            gpio_set_level(PIN_NUM_CS3, 0);
            gpio_set_level(PIN_NUM_CS4, 0);
            gpio_set_level(PIN_NUM_CS5, 0);
            gpio_set_level(PIN_NUM_CS6, 0);
        break;
        default:
            gpio_set_level(PIN_NUM_CS1, 1);
            gpio_set_level(PIN_NUM_CS2, 1);
            gpio_set_level(PIN_NUM_CS3, 1);
            gpio_set_level(PIN_NUM_CS4, 1);
            gpio_set_level(PIN_NUM_CS5, 1);
            gpio_set_level(PIN_NUM_CS6, 1);
        break;
    }
}

void lcdDrawNumber(spi_device_handle_t spi, uint8_t Display, uint8_t Number){
    selectDisplay(Display);
    switch(Number){
        case 0:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = zero_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = zero_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = zero_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = zero_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 1:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = one_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = one_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = one_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = one_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 2:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = two_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = two_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = two_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = two_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 3:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = three_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = three_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = three_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = three_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 4:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = four_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = four_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = four_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = four_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 5:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = five_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = five_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = five_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = five_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 6:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = six_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = six_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = six_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = six_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 7:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = seven_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = seven_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = seven_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = seven_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 8:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = eight_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = eight_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = eight_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = eight_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 9:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = nine_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = nine_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = nine_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = nine_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 10:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = colon_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = colon_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = colon_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = colon_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 11:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                    if(clockTheme == 0)
                        imgBuffer[j] = space_Theme[j+(100*k)];
                    else if (clockTheme == 1)
                        imgBuffer[j] = space_Theme1[j+(100*k)];
                    else if (clockTheme == 2)
                        imgBuffer[j] = space_Theme2[j+(100*k)];
                    else if (clockTheme == 3)
                        imgBuffer[j] = space_Theme3[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
    }
}

void lcdDrawFlag(spi_device_handle_t spi, uint8_t Display, uint8_t Flag){
    selectDisplay(Display);
    switch (Flag){
        case 0:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                        imgBuffer[j] = mex_Flag[j+(100*k)];  
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 1:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                        imgBuffer[j] = deu_Flag[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 2:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                        imgBuffer[j] = usa_Flag[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
        case 3:
            for(int k = 0; k < 256; k++){
                for(int j = 0; j < 100; j++){
                        imgBuffer[j] = gbr_Flag[j+(100*k)];
                }
                lcd_data(spi, imgBuffer,100);
            }
        break;
    }
}

For this new firmware version, I have drawn some flags to set different time zones available with the A, B, C, and D buttons.

After having the code ready and tested It is time to design a case for it. I am also a newbie in 3D design but this is what I manage to design.

This case makes it possible to add your own controller board and USB power to one side or at the back of the case. I will also make available the 3D design file ( Fusion 360 ). These files can be printed without any supports if you want, but maybe the main case will need a few of them.


Downloads