Automatické zalévání květin — řízení přes web (verze 0.2)

cmake_minimum_required(VERSION 3.13)

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

set(HOSTNAME kytka1)

if(DEFINED HOSTNAME)
    add_compile_definitions(CYW43_HOST_NAME=\"${HOSTNAME}\")
endif()

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

project(${PROJECT_NAME} C CXX ASM)

pico_sdk_init()


message("Running makefsdata python script")
execute_process(COMMAND
    python3 makefsdata.py
    WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
)

add_executable(${PROJECT_NAME}
    main.c
    ssd1306.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_cyw43_arch_lwip_threadsafe_background
    pico_lwip_http
    pico_stdlib
    hardware_adc
    hardware_i2c
)

# volby pro linker
target_link_options( ${PROJECT_NAME} PRIVATE -Xlinker --print-memory-usage)

pico_enable_stdio_usb( ${PROJECT_NAME} TRUE)
pico_enable_stdio_uart(${PROJECT_NAME} FALSE)
pico_add_extra_outputs(${PROJECT_NAME})

/* Based on GCC ARM embedded samples.
   Defines the following symbols for use by code:
    __exidx_start
    __exidx_end
    __etext
    __data_start__
    __preinit_array_start
    __preinit_array_end
    __init_array_start
    __init_array_end
    __fini_array_start
    __fini_array_end
    __data_end__
    __bss_start__
    __bss_end__
    __end__
    end
    __HeapLimit
    __StackLimit
    __StackTop
    __stack (== StackTop)
*/

__PERSISTENT_STORAGE_LEN = 16k ;

MEMORY
{
    FLASH(rx) : ORIGIN = 0x10000000, LENGTH = 2048k - __PERSISTENT_STORAGE_LEN
    FLASH_PERSISTENT(rw) : ORIGIN = 0x10000000 + (2048k - __PERSISTENT_STORAGE_LEN) , LENGTH = __PERSISTENT_STORAGE_LEN
    RAM(rwx) : ORIGIN =  0x20000000, LENGTH = 256k
    SCRATCH_X(rwx) : ORIGIN = 0x20040000, LENGTH = 4k
    SCRATCH_Y(rwx) : ORIGIN = 0x20041000, LENGTH = 4k
}

ENTRY(_entry_point)

SECTIONS
{
    /* Second stage bootloader is prepended to the image. It must be 256 bytes big
       and checksummed. It is usually built by the boot_stage2 target
       in the Raspberry Pi Pico SDK
    */

    .flash_begin : {
        __flash_binary_start = .;
    } > FLASH

    .boot2 : {
        __boot2_start__ = .;
        KEEP (*(.boot2))
        __boot2_end__ = .;
    } > FLASH

    ASSERT(__boot2_end__ - __boot2_start__ == 256,
        "ERROR: Pico second stage bootloader must be 256 bytes in size")

    /* The second stage will always enter the image at the start of .text.
       The debugger will use the ELF entry point, which is the _entry_point
       symbol if present, otherwise defaults to start of .text.
       This can be used to transfer control back to the bootrom on debugger
       launches only, to perform proper flash setup.
    */

    .text : {
        __logical_binary_start = .;
        KEEP (*(.vectors))
        KEEP (*(.binary_info_header))
        __binary_info_header_end = .;
        KEEP (*(.reset))
        /* TODO revisit this now memset/memcpy/float in ROM */
        /* bit of a hack right now to exclude all floating point and time critical (e.g. memset, memcpy) code from
         * FLASH ... we will include any thing excluded here in .data below by default */
        *(.init)
        *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .text*)
        *(.fini)
        /* Pull all c'tors into .text */
        *crtbegin.o(.ctors)
        *crtbegin?.o(.ctors)
        *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
        *(SORT(.ctors.*))
        *(.ctors)
        /* Followed by destructors */
        *crtbegin.o(.dtors)
        *crtbegin?.o(.dtors)
        *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
        *(SORT(.dtors.*))
        *(.dtors)

        *(.eh_frame*)
        . = ALIGN(4);
    } > FLASH

    .rodata : {
        *(EXCLUDE_FILE(*libgcc.a: *libc.a:*lib_a-mem*.o *libm.a:) .rodata*)
        . = ALIGN(4);
        *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.flashdata*)))
        . = ALIGN(4);
    } > FLASH

    .ARM.extab :
    {
        *(.ARM.extab* .gnu.linkonce.armextab.*)
    } > FLASH

    __exidx_start = .;
    .ARM.exidx :
    {
        *(.ARM.exidx* .gnu.linkonce.armexidx.*)
    } > FLASH
    __exidx_end = .;

    /* Machine inspectable binary information */
    . = ALIGN(4);
    __binary_info_start = .;
    .binary_info :
    {
        KEEP(*(.binary_info.keep.*))
        *(.binary_info.*)
    } > FLASH
    __binary_info_end = .;
    . = ALIGN(4);

    /* End of .text-like segments */
    __etext = .;


    .section_persisitent : {
        "ADDR_PERSISTENT" = .;  
    } > FLASH_PERSISTENT
    
   .ram_vector_table (COPY): {
        *(.ram_vector_table)
    } > RAM

    .data : {
        __data_start__ = .;
        *(vtable)

        *(.time_critical*)

        /* remaining .text and .rodata; i.e. stuff we exclude above because we want it in RAM */
        *(.text*)
        . = ALIGN(4);
        *(.rodata*)
        . = ALIGN(4);

        *(.data*)

        . = ALIGN(4);
        *(.after_data.*)
        . = ALIGN(4);
        /* preinit data */
        PROVIDE_HIDDEN (__mutex_array_start = .);
        KEEP(*(SORT(.mutex_array.*)))
        KEEP(*(.mutex_array))
        PROVIDE_HIDDEN (__mutex_array_end = .);

        . = ALIGN(4);
        /* preinit data */
        PROVIDE_HIDDEN (__preinit_array_start = .);
        KEEP(*(SORT(.preinit_array.*)))
        KEEP(*(.preinit_array))
        PROVIDE_HIDDEN (__preinit_array_end = .);

        . = ALIGN(4);
        /* init data */
        PROVIDE_HIDDEN (__init_array_start = .);
        KEEP(*(SORT(.init_array.*)))
        KEEP(*(.init_array))
        PROVIDE_HIDDEN (__init_array_end = .);

        . = ALIGN(4);
        /* finit data */
        PROVIDE_HIDDEN (__fini_array_start = .);
        *(SORT(.fini_array.*))
        *(.fini_array)
        PROVIDE_HIDDEN (__fini_array_end = .);

        *(.jcr)
        . = ALIGN(4);
        /* All data end */
        __data_end__ = .;
    } > RAM AT> FLASH

    .uninitialized_data (COPY): {
        . = ALIGN(4);
        *(.uninitialized_data*)
    } > RAM

    /* Start and end symbols must be word-aligned */
    .scratch_x : {
        __scratch_x_start__ = .;
        *(.scratch_x.*)
        . = ALIGN(4);
        __scratch_x_end__ = .;
    } > SCRATCH_X AT > FLASH
    __scratch_x_source__ = LOADADDR(.scratch_x);

    .scratch_y : {
        __scratch_y_start__ = .;
        *(.scratch_y.*)
        . = ALIGN(4);
        __scratch_y_end__ = .;
    } > SCRATCH_Y AT > FLASH
    __scratch_y_source__ = LOADADDR(.scratch_y);

    .bss  : {
        . = ALIGN(4);
        __bss_start__ = .;
        *(SORT_BY_ALIGNMENT(SORT_BY_NAME(.bss*)))
        *(COMMON)
        . = ALIGN(4);
        __bss_end__ = .;
    } > RAM

    .heap (COPY):
    {
        __end__ = .;
        end = __end__;
        *(.heap*)
        __HeapLimit = .;
    } > RAM

    /* .stack*_dummy section doesn't contains any symbols. It is only
     * used for linker to calculate size of stack sections, and assign
     * values to stack symbols later
     *
     * stack1 section may be empty/missing if platform_launch_core1 is not used */

    /* by default we put core 0 stack at the end of scratch Y, so that if core 1
     * stack is not used then all of SCRATCH_X is free.
     */
    .stack1_dummy (COPY):
    {
        *(.stack1*)
    } > SCRATCH_X
    .stack_dummy (COPY):
    {
        *(.stack*)
    } > SCRATCH_Y

    .flash_end : {
        __flash_binary_end = .;
    } > FLASH


    /* stack limit is poorly named, but historically is maximum heap ptr */
    __StackLimit = ORIGIN(RAM) + LENGTH(RAM);
    __StackOneTop = ORIGIN(SCRATCH_X) + LENGTH(SCRATCH_X);
    __StackTop = ORIGIN(SCRATCH_Y) + LENGTH(SCRATCH_Y);
    __StackOneBottom = __StackOneTop - SIZEOF(.stack1_dummy);
    __StackBottom = __StackTop - SIZEOF(.stack_dummy);
    PROVIDE(__stack = __StackTop);

    /* Check if data + heap + stack exceeds RAM limit */
    ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed")

    ASSERT( __binary_info_header_end - __logical_binary_start <= 256, "Binary info must be in first 256 bytes of the binary")
    /* todo assert on extra code */
}

/* Web server na Pico W -- automatické zalévání květin
 * version 0.2
 * (c) Jirka Chráska 2026, <jirka@lixis.cz>
 * BSD-licence
 */
#include "lwip/apps/httpd.h"
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "flash_utils.h"
#include "hardware/flash.h"
#include "lwip/netif.h"
#include "lwipopts.h"

// hranice sucha
// #define SUCHO 1.0	// nad 1V napětí na čidlu vlhkosti je sucho
// #define PORUCHA_CIDLA 0.3 // pod 0.3V budeme považovat za poruchu
float SUCHO = 1.0;
float PORUCHA_CIDLA = 0.3;

#include "ssi.h"
#include "cgi.h"
#include "ssd1306.h"
#include "font_spleen_8x5.h"
#include "font_spleen_16x8a.h"
#include "setupWifi.h"

// hostname
const char MY_HOSTNAME[] = "kytky";

// ---------------------------------------------------------------------------
// nastavení OLED displeje
#define DISPLAY_WIDTH 128
#define DISPLAY_HEIGHT 64
#define I2C_ADDRESS 0x3C
#define I2C_FREQ 400000
#define SLEEPTIME 55

void setup_gpios(void) {
    i2c_init(i2c_default, I2C_FREQ);
    gpio_set_function(PICO_DEFAULT_I2C_SDA_PIN, GPIO_FUNC_I2C);
    gpio_set_function(PICO_DEFAULT_I2C_SCL_PIN, GPIO_FUNC_I2C);
    gpio_pull_up(PICO_DEFAULT_I2C_SDA_PIN);
    gpio_pull_up(PICO_DEFAULT_I2C_SCL_PIN);
}

// buffery pro zobrazení na displeji
#define BUFLEN 128

char buf[BUFLEN];
char ip4adresa[BUFLEN];
char hostname_ssid[BUFLEN];
char msg1[BUFLEN];
char msg2[BUFLEN];
char msg3[BUFLEN];
// struktura displeje SSD1306
ssd1306_t disp;
// ---------------------------------------------------------------------------
// 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;
}
// připojení k AP
int connect( ZNAME_WIFI *zw, const 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;
    return  setup(country, zw->ssid, zw->pass, auth, hostname );
}
// --------------------------------------------------------------------------------------------
// teplota na Picu
float tempC   = 0.0;
// naměřená vlhkost pomocí čidla
// vyšší napětí nad 1 V znamená sucho v misce květináče
float vlhkost = 0.0;
bool porucha = false;
// pomocná proměnná
float voltage = 0.0;
// --------------------------------------------------------------------------------------------
// relé má obrácenou logiku: zapnuto 0, vypnuto 1
#define RELE_VYPNUTO 1
#define RELE_ZAPNUTO 0
#define MAX_CAS_ZALEVANI 10000 // v milisekundách

volatile bool casovac_vyprsel = false;
// obsluha časovače
int64_t zalevani_alarm_callback( alarm_id_t id, __unused void *user_data )
{
    casovac_vyprsel = true;
    gpio_put(RELE_PIN,RELE_VYPNUTO); // vypínáme čerpadlo
    return 0;
}

// obsluha zalévání
void zalevej( bool ano )
{
    if( porucha ) {
        gpio_put(RELE_PIN, RELE_VYPNUTO);
        return;
    }
    if( ano == true && gpio_get(RELE_PIN)== RELE_VYPNUTO ) {
	gpio_put(RELE_PIN, RELE_ZAPNUTO);
	// nastavení časovače  maximální doby zalévání
	// po uplynutí časovače se čerpadlo vypne v každém případě
	add_alarm_in_ms( MAX_CAS_ZALEVANI, zalevani_alarm_callback, NULL, false);
    }
    // je dosaženo dostatečné hladiny zalití
    if( ano == false ) {
	gpio_put(RELE_PIN, RELE_VYPNUTO);
    }
}
// --------------------------------------------------------------------------------------------
int main() {
    gpio_init(RELE_PIN);
    gpio_set_dir(RELE_PIN, GPIO_OUT);
    gpio_put(RELE_PIN,RELE_VYPNUTO);

    stdio_init_all();
    memset(buf,'\0', BUFLEN);
    memset(ip4adresa,'\0', BUFLEN);
    memset(hostname_ssid,'\0', BUFLEN);
    memset(msg1,'\0', BUFLEN);
    memset(msg2,'\0', BUFLEN);
    memset(msg3,'\0', BUFLEN);
    // pauza na nahození sériové linky při ladění
    // sleep_ms(20000);
    adc_init();
    adc_set_temp_sensor_enabled(true);

    setup_gpios();
    disp.external_vcc = false;
    ssd1306_init(&disp, DISPLAY_WIDTH, DISPLAY_HEIGHT, I2C_ADDRESS, i2c_default);
    ssd1306_clear(&disp);

    // mastavení WiFi
    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 sítě
    int err = cyw43_wifi_scan(&cyw43_state, &scan_options, NULL, scan_result);

    while (true)
    {
        printf("Skenujeme ... \n");
        snprintf(msg1,128,"Wifi scan");
        ssd1306_draw_string_with_font(&disp, 0, 39, 1, font_spleen_8x5, msg1);
        ssd1306_show(&disp);
        if (!cyw43_wifi_scan_active(&cyw43_state))
            break;
        sleep_ms(1000);
    }
    printf("Scan je hotov.\n");
    cyw43_arch_deinit();

    ssd1306_clear(&disp);
    snprintf(msg1,128,"Wifi scan OK");
    ssd1306_draw_string_with_font(&disp, 0, 39, 1, font_spleen_8x5, msg1);
    ssd1306_show(&disp);

    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);
        ssd1306_clear(&disp);
        snprintf(msg1,128,"%s: signal %d dBm", zw->ssid, zw->rssi);
        ssd1306_draw_string_with_font(&disp, 0, 0, 1, font_spleen_8x5, msg1);
        ssd1306_show(&disp);
        
        int connection_status = 0;
        
        int cekani = 0;
        
        do {
            printf("Připojuji se k AP %s.\n",zw->ssid);
            ssd1306_clear(&disp);
            snprintf(msg1,128,"%s: signal %d dBm", zw->ssid, zw->rssi);
            snprintf(msg2,128,"Connecting ...");
            ssd1306_draw_string_with_font(&disp, 0, 0, 1, font_spleen_8x5, msg1);
            ssd1306_draw_string_with_font(&disp, 0, 16, 1, font_spleen_8x5, msg2);
            ssd1306_show(&disp);
            connection_status = connect(zw, MY_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); 
            ssd1306_clear(&disp);
            snprintf(msg1,128,"%s: signal %d dBm", zw->ssid, zw->rssi);
            snprintf(msg2,128,"Cannot connect.");
            ssd1306_draw_string_with_font(&disp, 0, 0, 1, font_spleen_8x5, msg1);
            ssd1306_draw_string_with_font(&disp, 0, 16, 1, font_spleen_8x5, msg2);
            ssd1306_show(&disp);
        } 
        if( connection_status == CYW43_LINK_UP ) {
            struct netif *n = &cyw43_state.netif[CYW43_ITF_STA];
            cyw43_arch_lwip_begin();
            netif_set_hostname(n,MY_HOSTNAME);
            netif_set_up(n);
            cyw43_arch_lwip_end();
            snprintf(hostname_ssid,BUFLEN-1,"Hostname:%s", MY_HOSTNAME);
            ssd1306_draw_string_with_font(&disp, 0, 30, 1, font_spleen_8x5, hostname_ssid);
            // Jsem připojen
            snprintf(ip4adresa,20,ip4addr_ntoa(netif_ip4_addr(netif_list)));
            printf("Připojen k %s: %s  IP: %s\n", zw->ssid, MY_HOSTNAME, buf );
            ssd1306_draw_string_with_font(&disp, 0,  0,  1, font_spleen_16x8a, ip4adresa);
            ssd1306_draw_string_with_font(&disp, 0,  16, 1, font_spleen_8x5, zw->ssid );
            ssd1306_show(&disp);
            ssd1306_show(&disp);
            // Initializace web serveru
            httpd_init();
            printf("Http server nahozen.\n");
            snprintf(msg1,128,"Http %s OK", MY_HOSTNAME);
            ssd1306_draw_string_with_font(&disp, 0, 39, 1, font_spleen_8x5, msg1);
            ssd1306_show(&disp);

            // Konfigurace SSI a CGI handleru
            ssi_init(); 
            printf("SSI Handler nahozen.\n");
            snprintf(msg2,128,"SSI handler OK");
            ssd1306_draw_string_with_font(&disp, 0, 47, 1, font_spleen_8x5, msg2);
            ssd1306_show(&disp);
            cgi_init();
            printf("CGI Handler nahozen.\n");
            snprintf(msg3,128,"CGI handler OK");
            ssd1306_draw_string_with_font(&disp, 0, 55, 1, font_spleen_8x5, msg3);
            ssd1306_show(&disp);
        } else {
            sprintf(msg1,"Wifi %s nefunguje.\n",zw->ssid);
            ssd1306_draw_string_with_font(&disp, 0, 39, 1, font_spleen_8x5, msg1);
            ssd1306_show(&disp);            
        }
        
    } else { // nenalezena žádná wifi, kam se možno připojit
        sprintf(msg1,"Nemame wifi.\n",zw->ssid);
        ssd1306_draw_string_with_font(&disp, 0, 39, 1, font_spleen_8x5, msg1);
        ssd1306_show(&disp);                    
    }
    
    // Nekonečná smyčka měření a zalévání
    while(1) {
        // měření vlhkosti
        adc_select_input(0);
        vlhkost = adc_read() * REF_VOLT / (1 << 12);
        sleep_ms(50);
        // měření interní teploty Pica (dost nepřené)
        adc_select_input(4);
        voltage = adc_read() * REF_VOLT / (1 << 12);
        tempC = 22.0f - (voltage - 0.706f) / 0.001721f;
        sleep_ms(50);
        // zobrazení na displeji
        ssd1306_clear(&disp);
        ssd1306_draw_string_with_font(&disp, 0,  0,  1, font_spleen_16x8a, ip4adresa);
        snprintf(msg1, 128, "%s SSID: %s",  MY_HOSTNAME, zw->ssid);
        ssd1306_draw_string_with_font(&disp, 0,  16, 1, font_spleen_8x5, msg1);
        if(vlhkost > PORUCHA_CIDLA) {
            snprintf(msg2, 128, "Vlhkost: %5.3f", vlhkost);
        } else {
            snprintf(msg2, 128, "Porucha!", vlhkost);            
        }
        ssd1306_draw_string_with_font(&disp, 0, 32, 1, font_spleen_16x8a, msg2);
        ssd1306_show(&disp);
        snprintf(msg3, 128, "Teplota: %5.1f", tempC);
        ssd1306_draw_string_with_font(&disp, 0, 48, 1, font_spleen_16x8a, msg3);
        ssd1306_show(&disp);
        // rozhodnutí zda zalévat
        if( vlhkost > PORUCHA_CIDLA ) {
            porucha = false;
            if( vlhkost > SUCHO ) { // mělo by se zalít
                cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
                zalevej(true);
            } else {
                cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
                zalevej(false);
            }
        } else {
            // detekována porucha čidla
            porucha = true;
            gpio_put(RELE_PIN, RELE_VYPNUTO);
        }
        sleep_ms(500);
    }
}
// eof

/* 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;
}

#include "lwip/apps/httpd.h"
#include "pico/cyw43_arch.h"

#define RELE_PIN	15

// CGI handler which is run when a request for /led.cgi is detected
const char * cgi_led_handler(int iIndex, int iNumParams, char *pcParam[], char *pcValue[])
{
    // Check if an request for LED has been made (/led.cgi?led=x)
    if (strcmp(pcParam[0] , "led") == 0){
        // Look at the argument to check if LED is to be turned on (x=1) or off (x=0)
        if(strcmp(pcValue[0], "0") == 0) {
//            cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 0);
            gpio_put(RELE_PIN, 1);
	}  else if(strcmp(pcValue[0], "1") == 0) {
//            cyw43_arch_gpio_put(CYW43_WL_GPIO_LED_PIN, 1);
            gpio_put(RELE_PIN, 0);
	}
    }
    
    // Send the index page back to the user
    return "/index.shtml";
}

// tCGI Struct
// Fill this with all of the CGI requests and their respective handlers
static const tCGI cgi_handlers[] = {
    {
        // Html request for "/led.cgi" triggers cgi_handler
        "/led.cgi", cgi_led_handler
    },
};

void cgi_init(void)
{
    http_set_cgi_handlers(cgi_handlers, 1);
}

#include "lwip/apps/httpd.h"
#include "pico/cyw43_arch.h"
#include "hardware/adc.h"

#define REF_VOLT 3.3f
#define RELE_PIN	15


// SSI tags - tag length limited to 8 bytes by default
const char * ssi_tags[] = {"volt","temp","led"};

u16_t ssi_handler(int iIndex, char *pcInsert, int iInsertLen) {
  size_t printed;
  switch (iIndex) {
  case 0: // vlhkost
    {
      adc_select_input(0);
      const float voltage = adc_read() * REF_VOLT / (1 << 12);
      if( voltage > SUCHO ) {
        printed = snprintf(pcInsert, iInsertLen, "%f V, sucho", voltage);
      } else if( voltage <= SUCHO && voltage > PORUCHA_CIDLA ) {
        printed = snprintf(pcInsert, iInsertLen, "%f V, normální", voltage);
      } else {
        printed = snprintf(pcInsert, iInsertLen, "%f V, porucha čidla!", voltage);
      }
    }
    break;
  case 1: // teplota
    {
    adc_select_input(4);
    const float voltage = adc_read() * REF_VOLT / (1 << 12);
    const float tempC = 22.0f - (voltage - 0.706f) / 0.001721f;
    printed = snprintf(pcInsert, iInsertLen, "%f", tempC);
    }
    break;
  case 2: // led
    {
      bool cerpadlo = gpio_get(RELE_PIN);
      if(cerpadlo == true){
        printed = snprintf(pcInsert, iInsertLen, "vypnuto");
      }
      else{
        printed = snprintf(pcInsert, iInsertLen, "zapnuto");
      }
    }
    break;
  default:
    printed = 0;
    break;
  }

  return (u16_t)printed;
}

// Initialise the SSI handler
void ssi_init() 
{
  http_set_ssi_handler(ssi_handler, ssi_tags, LWIP_ARRAYSIZE(ssi_tags));
}

// 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                   1
#define LWIP_IPV4                   1
#define LWIP_TCP                    1
#define LWIP_UDP                    1
#define LWIP_DNS                    1
#define LWIP_TCP_KEEPALIVE          1
#define LWIP_NETIF_TX_SINGLE_PBUF   1
#define DHCP_DOES_ARP_CHECK         0
#define LWIP_DHCP_DOES_ACD_CHECK    0

#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

// This section enables HTTPD server with SSI, SGI
// and tells server which converted HTML files to use
#define LWIP_HTTPD 1
#define LWIP_HTTPD_SSI 1
#define LWIP_HTTPD_CGI 1
#define LWIP_HTTPD_SSI_INCLUDE_TAG 0
#define HTTPD_FSDATA_FILE "htmldata.c"

<!DOCTYPE html>
<html>
    <head> 
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta name="author" content="Mgr. Ing. Jiří Chráska">
        <title>Automatické zalévání květin</title> 
	    <style>
	        *      {margin 0; padding: 0; font-size: 1em; font-family: 'Segoe UI', Tahoma, sans-serif;}
	        body   {background-color: #dcdcdc;}
	        h1     {color: #00008b; font-family: verdana; font-size: 120%;}
	        h2     {color: #00008b; font-family: verdana; font-size: 100%;}
	        button {margin: 5px; padding: 10px;}
	    </style>
	    <script>
		setTimeout(() => { document.location.reload(true);}, 5000);
	    </script>
    </head>
    <body> <h1>Automatické zalévání květin</h1>
        <br>
        <h2>Stav na květině:</h2>
        <p>Vlhkost: <!--#volt--> V</p>
        <p>Teplota: <!--#temp--> °C</p>
        <p>Čerpadlo je: <!--#led--></p>
        <div><a href="/index.shtml"><button>Aktualizovat měření</button></a></div>
        <br>
        <h2>Ruční zalití:</h2>
        <div><a href="/led.cgi?led=1"><button>Ručně zalít</button></a></div>
        <div><a href="/led.cgi?led=0"><button>Vypnout zalévání</button></a></div>
        <br>
        <br>
   </body>
</html>