Hodiny s ePaper displejem

cmake_minimum_required(VERSION 3.13)

set(PICO_BOARD pico_w)
set (CMAKE_C_STANDARD 11)
set (CMAKE_CXX_STANDARD 17)

include($ENV{PICO_SDK_PATH}/external/pico_sdk_import.cmake)

set(PROJECT_NAME hodiny_epaper)
project(${PROJECT_NAME} C CXX ASM)

pico_sdk_init()

add_subdirectory(lib/Config)
add_subdirectory(lib/e-Paper)
add_subdirectory(lib/Driver)
add_subdirectory(lib/Fonts)
add_subdirectory(lib/GUI)
add_subdirectory(lib/ds3231)

include_directories(./lib/Config)
include_directories(./lib/e-Paper)
include_directories(./lib/Driver)
include_directories(./lib/GUI)
include_directories(./lib/ds3231)


add_executable(${PROJECT_NAME}
    main.c
)
# nastaveni vyhrazeneho mista ve XIP flash pro konfiguracni data
pico_set_linker_script(${PROJECT_NAME} ${CMAKE_SOURCE_DIR}/memmap_custom.ld)

target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries( ${PROJECT_NAME}
    pico_stdlib
    pico_cyw43_arch_lwip_threadsafe_background
    hardware_flash
    hardware_sync
    hardware_rtc
    hardware_i2c
    ePaper
    Driver
    GUI
    Fonts
    Config
    ds3231
)
# volby pro linker
target_link_options( ${PROJECT_NAME} PRIVATE -Xlinker --print-memory-usage)

pico_enable_stdio_usb(${PROJECT_NAME} 1)
pico_enable_stdio_uart(${PROJECT_NAME} 0)
pico_add_extra_outputs(${PROJECT_NAME})

/* Pico W hodiny s nastavením času SNTP, ePaper display
 * SNTP klient a seřízení času (jenom IPv6)
 * (c) Jirka Chráska 2025; <jirka@lixis.cz
 * BSD licence 3 clause
 */

// https://www.waveshare.com/wiki/Pico-CapTouch-ePaper-2.9

#include <stdio.h>
#include <string.h>
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "flash_utils.h"
#include "hardware/flash.h"
#include "hardware/sync.h"
#include "lwip/pbuf.h"
#include "lwip/ip6_addr.h"
#include "lwip/udp.h"
#include "lwip/dns.h"
#include "hardware/rtc.h"
#include "time.h"
#include "setupWifi.h"
#include <signal.h>     //signal()
#include <math.h>

#include "ICNT86X.h"
#include "EPD_2in9_V2.h"
#include "GUI_Paint.h"
#include "ds3231.h"

#define HOSTNAME    "ehodiny3"

// hodiny DS3231
ds3231_t ds3231;
// nastavení času
ds3231_data_t ds3231_data;
// piny
uint8_t ds3231_sda_pin = 20;
uint8_t ds3231_scl_pin = 21;
uint8_t ds3231_int_pin = 22;
#define ds3231_i2c  i2c0

void ds3231_nastaveni()
{
    ds3231_init(&ds3231, ds3231_i2c, DS3231_DEVICE_ADRESS, AT24C32_EEPROM_ADRESS_0);
    sleep_ms(200);
    gpio_init(ds3231_sda_pin);
    gpio_init(ds3231_scl_pin);
    gpio_set_function(ds3231_sda_pin, GPIO_FUNC_I2C);
    gpio_set_function(ds3231_scl_pin, GPIO_FUNC_I2C);
    gpio_pull_up(ds3231_sda_pin);
    gpio_pull_up(ds3231_scl_pin);
    i2c_init(ds3231_i2c, 400 * 1000);    
}

// ePaper
extern ICNT86_Dev ICNT86_Dev_Now, ICNT86_Dev_Old;

void pthread_irq(void)
{
	if(!DEV_Digital_Read(TP_INT_PIN))
		ICNT86_Dev_Now.Touch = 1;
	else
		ICNT86_Dev_Now.Touch = 0;
}

UBYTE get_key(UBYTE *key_value)
{
	if(DEV_Digital_Read(KEY0) == 0) {
		*key_value = 1;
		// printf("KEY0 ...\r\n");
	}
	else if(DEV_Digital_Read(KEY1) == 0) {
		*key_value = 2;
		// printf("KEY1 ...\r\n");
	}
	else if(DEV_Digital_Read(KEY2) == 0) {
		*key_value = 3;
		// printf("KEY2 ...\r\n");
	}
	else {
		*key_value = 0;
		return 1;
	}
	return 0;
}

// --------------------------------------------------------------------------
// SNTP
#define NTP_SERVER  "tik.cesnet.cz"
#define TIMEZONE    3600
// ---------------------------------------------------------------------------
// známé sítě

const uint8_t *flash_target_content; 

// struktura údajů o známé síti
typedef struct wifi_zname {
        char* ssid;     // jméno sítě
        char* pass;     // heslo v otevřeném textu
        char* auth;     // způsob autorizace
        char* ipv6;     // umí síť IPv6 (y/n)
        char* ipv4;     // umí síť IPv4 (y/n)
        int   rssi;     // aktuální síla signálu
        struct wifi_zname * next; // ukazatel na další prvek seznamu
} ZNAME_WIFI;

// ukazatel na počátek seznamu známých sítí
ZNAME_WIFI* zwifi = NULL;

// vytvoří seznam známých Wifi, ke kterým se můžeme připojit 
void napln_zname_wifi(void)
{
char *wifidata; // pomocný ukazatel do XIP flash
ZNAME_WIFI *zw;

    flash_target_content = (const uint8_t *) getAddressPersistent();
    for( int i=0; i<8; i++ ){
        wifidata = (char*) flash_target_content+(i*128);
        zw = malloc(sizeof(ZNAME_WIFI));
        if(zw != NULL) {
            zw->ssid = wifidata+5;
            // printf("%p ssid='%s' ", wifidata, zw->ssid);
            int len = strlen(zw->ssid)+6;
            zw->pass = wifidata+len+5;
            // printf("%p pass='%s' ", wifidata, zw->pass);
            len += strlen(zw->pass)+6;
            zw->auth = wifidata+len+5;
            // printf("%p auth='%s' ", wifidata, zw->auth);
            len += strlen(zw->auth)+6;
            zw->ipv6 = wifidata+len+5;
            //printf("%p ipv6='%s' ", wifidata, zw->ipv6);
            len += strlen(zw->ipv6)+6;
            zw->ipv4 = wifidata+len+5;
            // printf("%p ipv4='%s'\n", wifidata, zw->ipv4);
            // počáteční signál -120 dBm 
            zw->rssi = -120;
            if( zwifi != NULL ) { // v seznamu už něco máme
                zw->next = zwifi;
            } else {              // vkládáme první prvek (v seznamu bude poslední) 
                zw->next = NULL;
            }
            zwifi = zw;
        } else {
            printf("Nedostatek paměti.\n");
            break;
        }
    }
}

// najde v seznamu známou WiFi podle ssid
ZNAME_WIFI * najdi_wifi(const char *ssid) 
{
    for( ZNAME_WIFI *zw = zwifi; zw!=NULL; zw=zw->next ) {
        if(strcmp(zw->ssid, ssid) == 0 ) {
            return zw;
        }
    }
return NULL;
}

// najde v seznamu Wifi s nejlepším signálem
ZNAME_WIFI *najdi_nejvetsi_rssi( void )
{
int rssi = -120;
ZNAME_WIFI *res = NULL;
    for( ZNAME_WIFI *zw = zwifi; zw!=NULL; zw=zw->next ) {
        if(zw->rssi > rssi) {
            res = zw;
            rssi = zw->rssi;
        }
    }
return res;
}

// uvolní seznam známých wifi
void zrus_zname_wifi( void )
{
    for( ZNAME_WIFI *ptr=zwifi; ptr!=NULL;  ) {
        ZNAME_WIFI *ptr2 = ptr;
        ptr = ptr->next;
        free(ptr2);
    }
}

// callback, výsledky skenování
static int scan_result(void *env, const cyw43_ev_scan_result_t *result)
{
    if (result)
    {
        ZNAME_WIFI *znam = najdi_wifi( result->ssid );
        if( znam != NULL) {
            if( result->rssi > znam->rssi ) {
                znam->rssi = result->rssi;
            }
            printf("ssid: %-32s rssi: %4d chan: %3d mac: %02x:%02x:%02x:%02x:%02x:%02x sec: %s known: %s\n",
               result->ssid, result->rssi, result->channel,
               result->bssid[0], result->bssid[1], result->bssid[2],
               result->bssid[3], result->bssid[4], result->bssid[5],
               (result->auth_mode == 5) ? "WPA2_MIXED_PSK" : 
               (result->auth_mode == 7) ? "WPA_TKIP_PSK" : 
               (result->auth_mode == 0) ? "OPEN" : "UNKNOWN",
               "yes" );
        } else {
            printf("ssid: %-32s rssi: %4d chan: %3d mac: %02x:%02x:%02x:%02x:%02x:%02x sec: %s known: %s\n",
               result->ssid, result->rssi, result->channel,
               result->bssid[0], result->bssid[1], result->bssid[2],
               result->bssid[3], result->bssid[4], result->bssid[5],
               (result->auth_mode == 5) ? "WPA2_MIXED_PSK" : 
               (result->auth_mode == 7) ? "WPA_TKIP_PSK" : 
               (result->auth_mode == 0) ? "OPEN" : "UNKNOWN",
               "no" );
        }
    }
    return 0;
}
// --------------------------------------------------------------------------------------------
// SNTP
// připojení k AP
int connect( ZNAME_WIFI *zw, char * hostname )
{
    uint32_t country = CYW43_COUNTRY_CZECH_REPUBLIC;
    uint32_t auth;
    if( strcmp(zw->auth,"WPA2_MIXED_PSK") == 0) auth = CYW43_AUTH_WPA2_MIXED_PSK;
    if( strcmp(zw->auth,"WPA_TKIP_PSK") == 0)   auth = CYW43_AUTH_WPA_TKIP_PSK;
    // používá se nastavení pomocí SLAAC+RD 
    return  setup(country, zw->ssid, zw->pass, auth, hostname );
}
// získání času z hodin Pica
bool getDateNow(struct tm *t)
{
datetime_t rtc;
    bool state = rtc_get_datetime(&rtc);
    if (state)
    {
        t->tm_sec = rtc.sec;
        t->tm_min = rtc.min;
        t->tm_hour = rtc.hour;
        t->tm_mday = rtc.day;
        t->tm_mon = rtc.month - 1;
        t->tm_year = rtc.year - 1900;
        t->tm_wday = rtc.dotw;
        t->tm_yday = 0;
        t->tm_isdst = -1;
    }
    return state;
}

// nastavení hodin reálného času na Picu
void setRTC(struct tm *datetime)
{
datetime_t t;
    t.year = datetime->tm_year + 1900;
    t.month = datetime->tm_mon + 1;
    t.day = datetime->tm_mday;
    t.dotw = datetime->tm_wday;
    t.hour = datetime->tm_hour;
    t.min = datetime->tm_min;
    t.sec = datetime->tm_sec;
    rtc_init();
    rtc_set_datetime(&t);
}

struct timeStatus
{
    bool ready;
    struct udp_pcb *pcb;
};

// příjem SNTP odpovědi
void recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port)
{
struct timeStatus *tstatus = (struct timeStatus *)arg;
    printf("SNTP odpovídá\n");
    if (p != NULL)
    {
        uint8_t seconds_buf[4];
        pbuf_copy_partial(p, seconds_buf, sizeof(seconds_buf), 40);
        uint32_t seconds_since_1900 = seconds_buf[0] << 24 | seconds_buf[1] << 16 | seconds_buf[2] << 8 | seconds_buf[3];
        time_t seconds_since_1970 = seconds_since_1900 - 2208988800 + TIMEZONE;
        struct tm *datetime = gmtime(&seconds_since_1970);
        setRTC(datetime);
        pbuf_free(p);
        udp_remove(pcb);
        tstatus->pcb=NULL;
        tstatus->ready = true;
    }
}

bool pollSNTP(struct timeStatus *tstatus)
{
    if (tstatus == NULL)
        return true;
    if (tstatus->ready)
    {
        free(tstatus);
        tstatus = NULL;
        return true;
    }
    return false;
}

// získání IP adresy NTP serveru z DNS
void dns_found(const char *name, const ip6_addr_t *ip, void *arg)
{
    struct timeStatus *tstatus = (struct timeStatus *)arg;
    printf("IP NTP serveru z DNS %s\n", ip6addr_ntoa(ip));
    struct udp_pcb *pcb = udp_new_ip_type(6);
    tstatus->pcb = pcb;
    udp_recv(pcb, recv, arg);
    udp_bind(pcb, IP_ADDR_ANY, 123);
    udp_connect(pcb, ip, 123);
    struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, 48, PBUF_RAM);
    uint8_t *payload = (uint8_t *)p->payload;
    memset(payload, 0, 48);
    *payload = 0x1b;
    err_t er = udp_send(pcb, p);
    pbuf_free(p);
}

struct timeStatus *getSNTP()
{
    struct timeStatus *tstatus = malloc(sizeof(struct timeStatus));
    tstatus->ready = false;
    tstatus->pcb=NULL;
    ip6_addr_t ip;
    cyw43_arch_lwip_begin();
    // err_t err = dns_gethostbyname(xstr(NTP_SERVER), &ip, dns_found, tstatus);
    err_t err = dns_gethostbyname_addrtype(NTP_SERVER, &ip, dns_found, tstatus, LWIP_DNS_ADDRTYPE_IPV6);
    cyw43_arch_lwip_end();
    if (err == ERR_OK)
    {
        printf("DNS %s\n", ip6addr_ntoa(&ip));
        dns_found("", &ip, tstatus);
    } else {
        printf("DNS %s err=%s\n", ip6addr_ntoa(&ip), err==-5?"ERR_INPROGRESS":"ERR_ARG");
        
    }
    return tstatus;
}

void cancelSNTP(struct timeStatus *tstatus)
{
    if (tstatus != NULL)
    {
        udp_remove(tstatus->pcb);
        free(tstatus);
        tstatus = NULL;
        printf("zrušeno\n");
    }
}

// ----------------------------------------------------------------------------------------
int main()
{
char buf1[256];
char buf2[256];
char buf3[256];
struct tm t1, t2;
char Date[100];
const char *dny[7] = {"Neděle", "Pondělí", "Úterý", "Středa", "Čtvrtek", "Pátek", "Sobota" };
const char *ds3231_dny[7] = { "Pondělí", "Úterý", "Středa", "Čtvrtek", "Pátek", "Sobota", "Neděle" };
const char *mesice[12] = {"ledna", "února", "března", "dubna", "května", "června", "července", "srpna", "září", "října", "listopadu", "prosince"};

    stdio_init_all();
    memset(buf1,'\0',256);
    memset(buf2,'\0',256);
    memset(buf3,'\0',256);
    sleep_ms(1000);
    ds3231_nastaveni();
    
    // ePaper
    DEV_Module_Init();
	// ICNT_Init();	
    EPD_2IN9_V2_Init();
	EPD_2IN9_V2_Clear();
	
	// gpio_set_irq_enabled_with_callback(TP_INT_PIN, 0b0100, true, pthread_irq);
	
	sleep_ms(100);
    //Create a new image cache
    UBYTE *BlackImage;
    
    UWORD Imagesize = ((EPD_2IN9_V2_WIDTH % 8 == 0)? (EPD_2IN9_V2_WIDTH / 8 ): (EPD_2IN9_V2_WIDTH / 8 + 1)) * EPD_2IN9_V2_HEIGHT;
    if((BlackImage = (UBYTE *)malloc(Imagesize)) == NULL) {
        printf("Failed to apply for black memory...\r\n");
        return -1;
    }
    printf("Paint_NewImage\r\n");
    Paint_NewImage(BlackImage, EPD_2IN9_V2_WIDTH, EPD_2IN9_V2_HEIGHT, 90, WHITE);
    Paint_SelectImage(BlackImage);
    Paint_Clear(WHITE);
    printf("Skenuji AP...\n");
   	Paint_DrawString_UTF8(8, 8, "Hledám Wifi AP", &font_spleen_8x16, WHITE, BLACK);
	EPD_2IN9_V2_Display_Base(BlackImage);
    napln_zname_wifi();
    
    // inicializace cyw43 chipu
    if (cyw43_arch_init())
    {
        printf("failed to initialise\n");
        return 1;
    }

    // Picow nastavíme jako stanici
    cyw43_arch_enable_sta_mode();
    cyw43_wifi_set_up(&cyw43_state, CYW43_ITF_STA, true, CYW43_COUNTRY_CZECH_REPUBLIC);
    cyw43_wifi_scan_options_t scan_options = {0};
    // začínáme skenovat
    int err = cyw43_wifi_scan(&cyw43_state, &scan_options, NULL, scan_result);

    while (true)
    {
        if (!cyw43_wifi_scan_active(&cyw43_state))
            break;
        sleep_ms(1000);
        printf("Skenujeme ... \n");
    }
    printf("Scan je hotov.\n");
    cyw43_arch_deinit();

    // najdeme nejlepší signál mezi známými WiFi
    ZNAME_WIFI *zw = najdi_nejvetsi_rssi();
    if( zw != NULL ) { // máme wifi k připojení
        bool error = false;
        printf("Nejlepší signál %d má ssid %s sem se připojíme.\n", zw->rssi, zw->ssid);
        printf("\nSNTP klient IPv6\n");
        int connection_status = 0;
        
        int cekani = 0;
        
        do {
            printf("Připojuji se k AP %s.\n",zw->ssid);
            connection_status = connect(zw, HOSTNAME );
            
        } while ( connection_status != CYW43_LINK_UP && !timer_fired);
        
        if( timer_fired ) {
            printf("Problém s připojením AP %s, není přidělena adresa.\n",zw->ssid); 
        } 
        if( connection_status == CYW43_LINK_UP ) {
            printf("Připojeno.\n");
            printf("Linková IPv6 adresa:  %s\n", 
                   ip6addr_ntoa(netif_ip6_addr(netif_default,0)));
            printf("Globální IPv6 adresa: %s\n", 
                   ip6addr_ntoa(netif_ip6_addr(netif_default,1)));
            printf("Host Name: %s\n", netif_get_hostname(netif_default));
            sprintf(buf1,"Připojeno AP: %s",zw->ssid );
            sprintf(buf2,"IPv6: %s",ip6addr_ntoa(netif_ip6_addr(netif_default,1)) );
                    
            // nechce-li chodit automatické nastavení DNS serveru
            // dá se nastavit ručně
            //    ip6_addr_t dnsserver_ip ;
            //    ip6addr_aton("2a0e:5340:4:1::1", &dnsserver_ip);
            //    IP_SET_TYPE_VAL(&dnsserver_ip, IPADDR_TYPE_V6);
            //    dns_setserver(0,&dnsserver_ip);
            //    OpenDNS  2620:0:ccc::2 2620:0:ccd::2
            //    Quad9 2620:fe::10, 2620:fe::fe:10
        
            const ip6_addr_t *dnsip = dns_getserver(0);
            printf("DNS_MAX_SERVERS=%d\n", DNS_MAX_SERVERS);
            printf("DNS server 1:           %s\n", ip6addr_ntoa(dnsip));
            if( DNS_MAX_SERVERS > 1 ) {
                const ip6_addr_t *dnsip2 = dns_getserver(1);
                printf("DNS server 2:           %s\n", ip6addr_ntoa(dnsip2));
            }
            printf("ERR_ARG=%d, ERR_OK=%d ERR_INPROGRESS=%d\n", 
                   ERR_ARG, ERR_OK, ERR_INPROGRESS);
            sprintf(buf3, "DNS server: %s", ip6addr_ntoa(dnsip));
            cekani = 0;
            while (cekani <= 20) {
                struct timeStatus *tstatus = getSNTP();
                sleep_ms(500);
                if (pollSNTP(tstatus))
                    break;
                cancelSNTP(tstatus);
                cekani++;
            }

            bool rtc_status = getDateNow(&t1);
            if(rtc_status) {  // nastavíme čas na hodinách DS3231 podle RTC
                printf("Čas podle struct tm: %d.%d.%d %02d:%02d:%02d wday %d \n",
                       t1.tm_mday, t1.tm_mon, t1.tm_year, 
                       t1.tm_hour, t1.tm_min, t1.tm_sec, t1.tm_wday);
                ds3231_data.seconds = t1.tm_sec;
                ds3231_data.minutes = t1.tm_min;
                ds3231_data.hours   = t1.tm_hour;
                ds3231_data.day     = t1.tm_wday; // den v týdnu se na DS3231 počítá od 1
                ds3231_data.date    = t1.tm_mday; 
                ds3231_data.month   = t1.tm_mon+1; // měsíc se počítá od jedničky
                ds3231_data.year    = t1.tm_year-100; // rok se počítá od 0 do 99
                ds3231_data.century = 1;
                ds3231_data.am_pm   = false;
                ds3231_enable_am_pm_mode( &ds3231, false);
                ds3231_configure_time( &ds3231, &ds3231_data);
            }
        } else {
            sprintf(buf1,"Wifi %s nefunguje.\n",zw->ssid);
            if( ds3231_read_current_time( &ds3231, &ds3231_data) ) {
                printf("Nedostal jsem data ze záložních hodin.\n");
            } else {
                // nastavíme RTC podle záložních hodin DS3231
                sprintf(buf2,"Čas nastaven ze záložních hodin DS3231.");
                printf("%02u:%02u:%02u  %10s    %02u.%02u.20%02u\r", 
                    ds3231_data.hours, ds3231_data.minutes, ds3231_data.seconds,
                    ds3231_dny[ds3231_data.day-1], ds3231_data.date, 
                    ds3231_data.month, ds3231_data.year);
                t1.tm_sec  = ds3231_data.seconds;
                t1.tm_min  = ds3231_data.minutes;
                t1.tm_hour = ds3231_data.hours;
                t1.tm_wday = ds3231_data.day;
                t1.tm_mday = ds3231_data.date;
                t1.tm_mon  = ds3231_data.month - 1;
                t1.tm_year = ds3231_data.year + 100;
                setRTC(&t1);
            } 
            
        }
        
    } else { // žádná Wifi není v dosahu, budeme používat záložní hodiny DS3231 
             // a podle nich nastavíme RTC
        printf("Nemohu se připojit, žádná známá Wifi není v dosahu.\n");
        sprintf(buf1,"Nenalezl jsem žádnou Wifi.\n",zw->ssid);
        if( ds3231_read_current_time( &ds3231, &ds3231_data) ) {
                printf("Nedostal jsem data ze záložních hodin.\n");
        } else {
            sprintf(buf2,"Čas nastaven ze záložních hodin DS3231.");
            printf("%02u:%02u:%02u  %10s    %02u.%02u.20%02u\r", 
                    ds3231_data.hours, ds3231_data.minutes, ds3231_data.seconds,
                    ds3231_dny[ds3231_data.day-1], ds3231_data.date, ds3231_data.month, ds3231_data.year);
            t1.tm_sec  = ds3231_data.seconds;
            t1.tm_min  = ds3231_data.minutes;
            t1.tm_hour = ds3231_data.hours;
            t1.tm_wday = ds3231_data.day;
            t1.tm_mday = ds3231_data.date;
            t1.tm_mon  = ds3231_data.month - 1;
            t1.tm_year = ds3231_data.year + 100;
            setRTC(&t1);
        } 
        
    }
    // úklid seznamu (uvolnění paměti)
    zrus_zname_wifi();
    
    // vymazání ePaperu
    Paint_Clear(WHITE);
    Paint_DrawString_UTF8(6, 2,  buf1, &font_spleen_8x16, WHITE, BLACK);
    Paint_DrawString_UTF8(6, 17, buf2, &font_tahoma_10, WHITE, BLACK);
    Paint_DrawString_UTF8(6, 28, buf3, &font_tahoma_10, WHITE, BLACK);
        
    sprintf(buf3,"%s %d.%s %d",dny[t1.tm_wday], t1.tm_mday, mesice[t1.tm_mon], t1.tm_year+1900);
    Paint_DrawString_UTF8(6, 40,  buf3, &font_spleen_12x24, WHITE, BLACK);
        
    EPD_2IN9_V2_Display_Base(BlackImage);
    // zobrazení času na ePaperu každou sekundu
    // obnovují se jenom změněné části, protože obnova
    // celého ePaperu trvá dlouho
    while (true)
    {
        // obnova ePaperu trvá dlouho a nevíme přesně jak dlouho
        // proto si nastavíme přesný timeout 1s
        absolute_time_t cekam = make_timeout_time_ms(1000);
        getDateNow(&t1);
        strftime(Date, sizeof(Date), "%a, %d %b %Y %k:%M:%S %Z", &t1);
        strftime(buf1, sizeof(buf1), "%a, %d %b %Y", &t1);
        strftime(buf2, sizeof(buf2), "%k:%M:%S", &t1);
        printf("Čas RTC: %s DS3231: ", Date);
        if( ds3231_read_current_time( &ds3231, &ds3231_data) ) {
            printf("Nedostal jsem data ze záložních hodin.\r");
        } else {
            printf("%02u:%02u:%02u  %10s    %02u.%02u.20%02u\r", 
                   ds3231_data.hours, ds3231_data.minutes, ds3231_data.seconds,
                   ds3231_dny[ds3231_data.day-1], ds3231_data.date, ds3231_data.month, 
                   ds3231_data.year);
        }
        // aktualizace datumu
	    if(t1.tm_year != t2.tm_year || t1.tm_mon != t2.tm_mon || t1.tm_mday != t2.tm_mday ) { 
            sprintf(buf3,"%s %d.%s %d",
                    dny[t1.tm_wday], t1.tm_mday, mesice[t1.tm_mon], t1.tm_year+1900);
            Paint_ClearWindows(6, 40, 286, 64, WHITE);
            Paint_DrawString_UTF8(6, 40,  buf3, &font_spleen_12x24, WHITE, BLACK);
        }
        // aktualizace času na ePaperu
        Paint_ClearWindows(16, 64, 286, 127, WHITE);
        Paint_DrawString_UTF8(16, 64, buf2, &font_spleen_32x64, WHITE, BLACK);
        EPD_2IN9_V2_Display_Partial(BlackImage);
        if( t1.tm_sec != t2.tm_sec) { 
            memcpy(&t2,&t1,sizeof(struct tm));
        }
        // čekání do uplynutí timeoutu, celý cyklus bude trvat přesně 1s
        busy_wait_until(cekam);
    }
    free(BlackImage);
    return 0;
}
// --------------------------------------------------------------------------------------------

/* Nastavení Wifi karty */

volatile bool timer_fired = false;

int64_t alarm_callback( alarm_id_t id, __unused void *user_data )
{
    printf("Timer %d fired!\n", (int) id);
    timer_fired = true;
    return 0;
}

int setup(uint32_t country, const char *ssid, const char *pass, uint32_t auth, const char *hostname)
{

    if (cyw43_arch_init_with_country(country))
    {
         return 1;
    }
     
    cyw43_arch_enable_sta_mode();
    if (hostname != NULL)
    {
        netif_set_hostname(netif_default, hostname);
    }
    if (cyw43_arch_wifi_connect_async(ssid, pass, auth))
    {
        return 2;
    }
    int flashrate = 1000;
    int status = CYW43_LINK_UP + 1;
    // k připojení na Wifi nastavíme timeout 10s
    add_alarm_in_ms(10000, alarm_callback, NULL, false);
    while (status >= 0 && !timer_fired && status != CYW43_LINK_UP)
    {
        int new_status = cyw43_tcpip_link_status(&cyw43_state, CYW43_ITF_STA);
        if (new_status != status)
        {
            status = new_status;
            flashrate = flashrate / (status + 1);
            printf("Stav připojení: %d %d\n", status, flashrate);
        }
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
        sleep_ms(flashrate);
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
        sleep_ms(flashrate);
    }
    if (status < 0)
    {
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
    }
    else
    {
        cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
        
    }
    return status;
}

#ifndef _LWIPOPTS_EXAMPLE_COMMONH_H
#define _LWIPOPTS_EXAMPLE_COMMONH_H

// Common settings used in most of the pico_w examples
// (see https://www.nongnu.org/lwip/2_1_x/group__lwip__opts.html for details)

// allow override in some examples
#ifndef NO_SYS
#define NO_SYS 1
#endif
// allow override in some examples
#ifndef LWIP_SOCKET
#define LWIP_SOCKET 0
#endif
#if PICO_CYW43_ARCH_POLL
#define MEM_LIBC_MALLOC 1
#else
// MEM_LIBC_MALLOC is incompatible with non polling versions
#define MEM_LIBC_MALLOC 0
#endif
#define MEM_ALIGNMENT 4
#define MEM_SIZE 4000
#define MEMP_NUM_TCP_SEG 32
#define MEMP_NUM_ARP_QUEUE 10
#define PBUF_POOL_SIZE 24
#define LWIP_ARP 1
#define LWIP_ETHERNET 1
#define LWIP_ICMP 1
#define LWIP_RAW 1
#define TCP_WND (8 * TCP_MSS)
#define TCP_MSS 1460
#define TCP_SND_BUF (8 * TCP_MSS)
#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1)) / (TCP_MSS))
#define LWIP_NETIF_STATUS_CALLBACK 1
#define LWIP_NETIF_LINK_CALLBACK 1
#define LWIP_NETIF_HOSTNAME 1
#define LWIP_NETCONN 0
#define MEM_STATS 0
#define SYS_STATS 0
#define MEMP_STATS 0
#define LINK_STATS 0
// #define ETH_PAD_SIZE 2
#define LWIP_CHKSUM_ALGORITHM 3
#define LWIP_DHCP 0
#define LWIP_IPV4 0
#define LWIP_IPV6 1
#define LWIP_IPV6_AUTOCONFIG 1
#define LWIP_ND6_RDNSS_MAX_DNS_SERVERS 1
#define LWIP_TCP 0
#define LWIP_UDP 1
#define LWIP_DNS 1
#define LWIP_TCP_KEEPALIVE 0
#define LWIP_NETIF_TX_SINGLE_PBUF 1
#define DHCP_DOES_ARP_CHECK 0
#define LWIP_DHCP_DOES_ACD_CHECK 0
#define DNS_TABLE_SIZE 1

#ifndef NDEBUG
#define LWIP_DEBUG 1
#define LWIP_STATS 1
#define LWIP_STATS_DISPLAY 1
#endif

#define ETHARP_DEBUG        LWIP_DBG_OFF
#define NETIF_DEBUG         LWIP_DBG_OFF
#define PBUF_DEBUG          LWIP_DBG_OFF
#define API_LIB_DEBUG       LWIP_DBG_OFF
#define API_MSG_DEBUG       LWIP_DBG_OFF
#define SOCKETS_DEBUG       LWIP_DBG_OFF
#define ICMP_DEBUG          LWIP_DBG_OFF
#define INET_DEBUG          LWIP_DBG_OFF
#define IP_DEBUG            LWIP_DBG_OFF
#define IP_REASS_DEBUG      LWIP_DBG_OFF
#define RAW_DEBUG           LWIP_DBG_OFF
#define MEM_DEBUG           LWIP_DBG_OFF
#define MEMP_DEBUG          LWIP_DBG_OFF
#define SYS_DEBUG           LWIP_DBG_OFF
#define TCP_DEBUG           LWIP_DBG_OFF
#define TCP_INPUT_DEBUG     LWIP_DBG_OFF
#define TCP_OUTPUT_DEBUG    LWIP_DBG_OFF
#define TCP_RTO_DEBUG       LWIP_DBG_OFF
#define TCP_CWND_DEBUG      LWIP_DBG_OFF
#define TCP_WND_DEBUG       LWIP_DBG_OFF
#define TCP_FR_DEBUG        LWIP_DBG_OFF
#define TCP_QLEN_DEBUG      LWIP_DBG_OFF
#define TCP_RST_DEBUG       LWIP_DBG_OFF
#define UDP_DEBUG           LWIP_DBG_OFF
#define TCPIP_DEBUG         LWIP_DBG_OFF
#define PPP_DEBUG           LWIP_DBG_OFF
#define SLIP_DEBUG          LWIP_DBG_OFF
#define DHCP_DEBUG          LWIP_DBG_OFF

#endif /* __LWIPOPTS_H__ */