Arduino w modelarstwie kolejowym

[prezesedi]

2 minuty temu, ethanak napisał:

Pytanie: możemy przejść na priv?

Oczywiście

[ethanak]

No to wracamy na forum publiczne

Jako że temat semaforów na razie został wyczerpany dopóki nie będziemy próbować łączyć to bez kabli, spróbujmy w ramach odpoczynku zająć się wyświetlaczem. Wybrałem popularny (i co najważniejsze: tani) wyświetlacz 1.8" na układzie ST7735. Biblioteka Adafruit_GFX bardzo dobrze z nim współpracuje, wielkość co prawda w przeliczeniu na skalę H0 jest gigantyczna, ale do wyboru były tylko małe OLED-y albo (zupełnie bez sensu) wyświetlacze TFT 1.44" (rozdzielczość 128 x 128). OLED ma wadę polegającą na wypalaniu się pikseli (co jakiś czas trzeba by było wymieniać wyświetlacz), ma trochę za małą rozdzielczość, poza tym nawet gdyby sterować nim bez pośrednictwa Adafruitowych driverów jest trochę wolny...

Użyty przeze mnie wyświetlacz ma rozdzielczość 160x128 i wbudowany czytnik kart SD, czyli będzie można w przyszłości w prosty sposób zmieniać rozkład.

Zacznijmy od podłączenia wyświetlacza do ESP8266.

Ponieważ będziemy wykorzystywać zarówno czytnik, jak i wyświetlacz na jednym interfejsie SPI, a nie będziemy sterować podświetleniem, możemy na samej płytce wyświetlacza połączyć:

• VCC i LED (diody będą zawsze zapalone)
• SD_SCK i SCK (wspólna linia zegarowa)
• SD_MOSI i SDA (wspólna linia odbioru danych)

Pozwoli nam to zmniejszyć ilość potrzebnych przewodów i użyć płytki (np. Wemos D1 Mini) łącząc przewody bezpośrednio do jej pinów bez konieczności używania jakichś płytek stykowych.

Przy okazji jedna uwaga: w przypadku Wemosa warto wlutować w tym przypadku przelotowe piny do płytki. Pozwoli nam to w przyszłości łatwo podłączyć zasilanie.

Ale wróćmy do pinologii.

Łączymy teraz płytkę wyświetlacza z ESP8266:

• VCC - 3.3V
• GND - GND
• CS - GPIO4 (D2)
• RESET - GPIO16 (D0)
• AD - GPIO5 (D1)
• SD_CS - GPIO15 (D8)
• SD_MISO - GPIO12 (D6)
• SD_MOSI - GPIO13 (D7)
• SD_SCK - GPIO14 (D5)

Po podłączeniu kabla USB powinno zapalić się podświetlenie ekranu.

Spróbujmy teraz wgrać do ESP prosty program testowy:

#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>
#include <SD.h>

#define SCREEN_CS 4
#define SCREEN_DC 5
#define SCREEN_RS 16
#define CARD_CS 15

Adafruit_ST7735 tft(SCREEN_CS, SCREEN_DC, SCREEN_RS);
File plik;

void setup()
{
    Serial.begin(115200);
    delay(1000); // o tak żeby się monitor obudził
    printf("\r\n\r\n"); // śmieci won z monitora

    // test wyświetlacza
    
    tft.initR(INITR_BLACKTAB);
    tft.setRotation(3); // lub 1 jeśli chcemy mieć gniazdo karty na dole
    tft.fillScreen(ST77XX_BLACK);
    tft.setTextColor(ST77XX_WHITE);
    tft.setTextSize(2);
    tft.print("Hello world");

    // test czytnika kart

    if (!SD.begin(CARD_CS)) {
        printf("Brak karty lub karta nieczytelna\r\n");
        return;
    }
    plik = SD.open("/rozklad1.txt");
    if (!plik) {
        printf("Brak pliku rozklad1.txt\r\n");
    }
    else {
        printf("Plik rozklad1.txt rozmiar %d\r\n", plik.size());
    }
    plik.close();
    SD.end();
}

void loop()
{
    delay(100); // nie robimy nic
}

Po jego uruchomieniu na wyświetlaczu powinien pojawić się napis "Hello world", a ma monitorze Serial wyświetlio się odpowiedni komunikat:

• w przypadku braku karty "Brak karty lub karta nieczytelna"
• W przypadku jeśli na karcie nie ma pliku rozklad1.txt "Brak pliku rozklad1.txt"
• W przypadku jeśli plik istnieje podana zostanie jego wielkość.

To wszystko co nasz testowy program potrafi... jeśli więc wszystko działa możemy przejść dalej.

Przede wszystkim: wykorzystam tu możliwość wyświetlania polskich (i nie tylko) literak opisywaną w artykule o Arduino_GFX i i18n. Zachęcam do przeczytania (krótki). Potrzebne pliki załączam również dzisiaj - przypominam o podmienieniu pliku glcdfont.c w bibliotece!

Zacznijmy jednak od formatu, w jakim będzie zapisywany rozkład jazdy na karcie SD. Początkowo myślałem o formacie CSV, ale nie zawsze mamy pod ręką Excela czy Calca. Dlateho postanowiłem zapisywać po prostu kolejne pozycje rozkładu w kolejnych liniach, trzymając się formatu:

• Typ pociągu (pospieszny, osobowy, co tam chcemy) - jedna litera
• Nazwa stacji docelowej - max 30 liter
• Informacja o torze i peronie - cyfra/cyfra
• Informacja o godzinie odjazdu w formacie HH:MM

Tak więc fragment rozkładu może wyglądać tak:

P Małkinia 2/1 12:30
E Szczecin Główny 3/2 13:15

Na początku dla uproszczenia nie będziemy korzystać z karty SD, rozkład będzie po prostu wkompilowany w program. Spróbujmy więc napisać parser do tego formatu.

Na początek zdeklarujmy sobie strukturę opisującą pozycję rozkładu i stwórzmy tablicę, pozwalającą na operowanie w łatwy spowób wyświetlaniem:

#define SCHED_SIZE 6

extern struct SchedTrain {
    uint8_t type;
    uint8_t tor;
    uint8_t hour;
    uint8_t minute;
    char name[32];
} SchedTrain[SCHED_SIZE];

Funkcja parsera razem z potrzebnmi dodatkami będzie wyglądać następująco:

struct SchedTrain SchedTrain[SCHED_SIZE];

static uint8_t skipSpaces(const char **str)
{
    for (;**str;(*str)++) {
        if (!isspace(**str)) return 1;
        if (**str == '\r' || **str=='\n') break;
    }
    return 0;
}

uint8_t parseScheduleLine(struct SchedTrain *sch, const char **str)
{
    const char *strin = *str;
    const char *name=NULL;
    int namelen=0;
    char namebuf[64];
    while (*strin && isspace(*strin)) strin++;
    if (!*strin) return 0;
    // pierwsza litera - typ  pociągu
    sch->type = *strin++;
    if (!skipSpaces(&strin)) return 0;

    // teraz nazwa
    name=strin;
    while (*strin) {
        if (*strin == '\r' || *strin == '\n') return 0;
        if (isdigit(*strin) && strin[1] == '/' && isdigit(strin[2])) break;
        strin++;
    }
    namelen = strin-name;
    
    // tor i peron zajmują jeden bajt
    sch->tor = ((*strin++) - '0') << 4;
    strin++;
    sch->tor |= (*strin++) - '0';
    if (!isspace(*strin)) return 0;
    if (!skipSpaces(&strin)) return 0;

    // godzina i minuta
    if (!isdigit(*strin)) return 0;
    sch->hour = strtol(strin,(char **)&strin, 10);
    if (sch->hour > 23) return 0;
    if (*strin++ !=':') return 0;
    if (!isdigit(*strin)) return 0;
    sch->minute = strtol(strin,(char **)&strin, 10);
    if (sch->minute > 59) return 0;
    for(;*strin;strin++) {
        if (!isspace(*strin)) return 0; // śmieci!
        if (*strin == '\n' || *strin == '\r') break;
        
    }
    if (namelen > 63) namelen=63;
    strncpy(namebuf,name,namelen);
    namebuf[namelen]=0;
    utf2local(namebuf,sch->name,32, LOCALCONV_COMPACT);
    *str=strin;
    return 1;
}

Jak widać. funkcja pobiera linię z rozkładu, wypełnia pola struktury i przesuwa wskaźnik rozkładu do następnej pozycji. Zwraca 1 jeśli wszystko było w porządku lub 0 jeśli rozkład się skończył (lub ktoś zrobił błąd wpisując dane do rozkładu). Możemy więc teraz napisać program sterujący wyświetlaniem. Zacznijmy od pomocniczej funkcji, zwracającej nam początkową linię rozkładu:

static int schedPos;

static const char *textLine(const char *txt, int pos)
{
    int i;
    for (i=0; i<pos; i++) {
        txt=strchr(txt,'\n');
        if (!txt) return NULL;
        txt++;
    }
    return txt;
}

Funkcja jest bardzo prosta: zwraca nam n-tą linię z tekstu lub NULL jeśli takiej linii nie ma. Możemy więc napisać funkcję sterującą wyświetlaniem:

void displaySched(const char *txt)
{
    const char *c=textLine(txt,schedPos);
    if (!c) {
        // jesteśmy poza rozkładem, wracamy do początku
        schedPos=0;
        c=txt;
    }
    int i;
    for (i=0; i< SCHED_SIZE; i++) {
        if (parseScheduleLine(&SchedTrain[i], &c)) continue;
        // wyszliśmy poza rozkład, musimy kontynuować od początku
        c=txt;
        parseScheduleLine(&SchedTrain[i], &c);
    }
    for (i=0; i<SCHED_SIZE; i++) displayTrain(i,&SchedTrain[i]);
}

void initSched()
{
    schedPos = 0;
    displaySched(sched);
}

Jak widać, użyliśmy tu funkcji displayTrain realizującą wyświetlanie, którą to funkcję trzeba teraz napisać. Zajmijmy się więc wyświetlaczem.

Na początek inicjalizacja. Musimy tu znaleźć rozmiar wyświetlacza i obliczyć wszystkie pozycje. Nie chcę wkompilowywać ich na sztywno, bo przecież można użyć innego wyświetlacza o innych wymiarach. A więc zaczynamy:

static int wscreen, hscreen;
Adafruit_ST7735 tft(4, 5, 16);

static int pos_name, pos_hour, pos_tor, max_namelen;

void initDisplay()
{
    tft.initR(INITR_BLACKTAB);
    tft.setRotation(3);
    tft.cp437();
    tft.fillScreen(ST77XX_BLACK);
    tft.setTextColor(ST77XX_WHITE);
    tft.setTextWrap(0);

// trochę obliczeń

    wscreen = tft.width();
    hscreen = tft.height();

    pos_name = 10;  // pozycja wyświetlania nazwy
    pos_hour = wscreen - 5 * 6; // pozycja wyświetlania godziny
    pos_tor = pos_hour - 10; // pozycja wyświetlania toru i peronu
    max_namelen = (pos_tor -14) / 6; // maksymalna długość nazwy
    
}

Ponieważ całość wyświetlania zależy od obliczeń w tej funkcji, wywołamy ją na początku programu. Ale zajmijmy się wyświetlaniem pozycji:

void displayTrain(int pos, struct SchedTrain *sch)
{
    int y=pos*21+2;
    tft.fillRect(0,y,wscreen,16,ST77XX_BLACK);
    tft.setTextSize(1,2);
    tft.setTextColor(ST77XX_WHITE);
    tft.setCursor(0,y);
    tft.printf("%c", sch->type);
    tft.setCursor(pos_hour,y);
    tft.printf("%02d:%02d", sch->hour, sch->minute);
    tft.setTextSize(1,1);
    tft.setCursor(pos_tor,y);tft.printf("%d",(sch->tor >> 4) & 15);
    tft.setCursor(pos_tor,y+8);tft.printf("%d",(sch->tor) & 15);
    tft.setTextSize(1,2);
    tft.setCursor(pos_name, y);
    tft.printf("%-*.*s", max_namelen, max_namelen, sch->name);
}

Funkcja jest tak prosta że nie wymaga chyba żadnych uwag. Dodajmy do tego zawartość głównego pliku ino:

void setup()
{
    Serial.begin(115200);
    delay(1000); // tak z przyzwyczajenia
    initDisplay();
    initSched();
}

void loop()
{
    delay(1); // ESP8266 to lubi
}

Właściwie to już wszystko, trzeba by to było jakoś ładnie opakować w resztę kodu, ale... ale rozkład byłby strasznie nudny, równie dobrze można by go było wydrukować i przykleić do ściany. Spróbujmy go więc ożywić. Niech więc rozkład co jakiś czas presuwa się o jedną pozycję.

Dodajmy więc jakąś zmienną, w której będziemy przechowywać informację, kiedy był wyświetlony rozkład:

static uint32_t lastSched;

a w funkcji displaySched dodamy na końcu linię:

    lastSched = millis();

Teraz wystarczy napisać dwie proste funkcje:

void nextSched()
{
    schedPos += 1;
    displaySched(sched);
}

void schedLoop()
{
    if (millis() - lastSched < 120000UL) return;
    nextSched();
}

i w funkcji loop() wprowadzić wywołanie:

void loop()
{
    schedLoop();
    delay(1); // ESP8266 to lubi
}

Teraz rozkład będzie co dwie minuty przesuwał się do następnej pozycji.

Kod jak zwykle dołączony:rozklad1.zip

Niestety - jeśli wrzucimy ten program na naszego ESP możemy zobaczyć, że nie jest to jeszcze takie ładne jak powinno być. Długie nazwy są po prostu poucinane, przydałoby się coś więcej... obiecane wczytywanie z SD, czy jakaś możliwość sterowania...

Powoli. Ja chcę pokazać całą drogę tworzenia programu, a nie podawać gotowca! Będzie SD, będzie możliwość sterowania, będzie ładny scrolling, a ten tryb przeskakiwania co jakiś czas do następnej pozycji może być przydatny jeśli np. w makiecie w ogóle nie przewidujemy sterowania a wyświetlacz pełni po prostu funkcję dekoracyjną, albo do czasu kiedy uruchomimy panel sterujący. Wszystko będzie... czyli: stay tuned!
 

Edytowano Lipiec 5, 2023 przez ethanak

[matsobdev]

Ciekawy by mógł być też 1,14" 135x240.

[ethanak]

Przed chwilą, matsobdev napisał:

Ciekawy by mógł być też 1,14" 135x240.

Dawaj namiary! To TFT czy OLED?

 

[matsobdev]

IPS (czyli jakaś tam odmiana TFT). W jedynym słusznym sklepie. Gdzie indziej mają na stanie. A na Ali to wszystkie tanie.

Edytowano Lipiec 5, 2023 przez matsobdev

[ethanak]

Znalazłem w sklepie na K... Pewnie by ruszył na tym programie co mam (parę linijek do zmiany), ale nie chce mi się stówki wydawać na coś co mi się nie przyda

Ale dobrze wiedzieć, czasem potrzebuję takich maleństw a o tym nawet nie wiedziałem

 

[ethanak]

Jakoś mnie dzisiaj wena dopadła i postanowiłem trochę pójść dalej z kodem.

Na początek spróbujmy jakoś zaradzić temu ucinaniu nazw. 

Ponieważ ani nie zwiększymy wyświetlacza (chyba że zastosujemy taki, o którym pisał kol. @matsobdev, ale to wymagałoby drobnej zmiany w programie a bez wyświetlacza nie jestem w stanie tego zrobić), jedynym sposobem jest skrolowanie nazwy, Czyli: nazwa wyświetla się przez kilka sekund, potem przesuwa się tak, aby dało się wygodnie ją odczytać, po dojściu do końca zamiera na chwilę i wraca do pozycji początkowej.

W strukturze SchedTrain musimy dodać kilka dodatkowych pól, odpowiedzialnych za skrolowanie nazwy Teraz będzie wyglądać tak:

extern struct SchedTrain {
    uint8_t type;
    uint8_t tor;
    uint8_t hour;
    uint8_t minute;

    uint8_t scrollsize; // wielkość scrollingu
    uint8_t scrollphase; // faza skrolowania (początek, przesuwanie, koniec)
    uint8_t scrollpos; // pozycja skrolowania
    uint8_t namelen; // długość nazwy

    uint32_t timer; // ogólny timer
    
    char name[32];
} SchedTrain[SCHED_SIZE];

a w funkcji parseScheduleLine dodamy przed kończącym return:

    sch->namelen = strlen(sch->name);
    if (sch->namelen > max_namelen) {
        sch->scrollsize = sch->namelen - max_namelen;
    }
    else {
        sch->scrollsize = 0;
    }

Jak widać, pole scrollsize zawiera albo 0 (nie trzeba skrolować), albo ilość liter która nie zmieściła się na ekranie. Przy okazji musimy mieć dostęp do zmiennej max_namelen: najprostszym sposobem jest uczynienie jej globalną. A więc e pliku rozklad.h dodajemy linijkę:

extern int max_namelen;

a w display.cpp zmieniamy definicje zmiennych na:

static int pos_name, pos_hour, pos_tor;
int max_namelen;

Ale to dopiero początek zmian w display.cpp.

Zdefiniujmy sobie pewne stałe, których będziemy używać do określenia sposobu skrolowania:

enum {
    SCROLL_START = 0,
    SCROLL_SCROLLING,
    SCROLL_END
};

Ponieważ wywołanie funkcji displayTrain powinno ustawić skrolowanie w pozycji początkowej, na końcu funkcji trzeba dopisać:

    sch->scrollphase=SCROLL_START;
    sch->scrollpos=0;
    sch->timer = millis();

Stwórzmy teraz funkcję, która będzie odpowiedzialna za wyświetlenie odpowiednio przesuniętej nazwy:

static void displayTrainName(int pos, struct SchedTrain *sch)
{
    int y=pos*21+2;
    tft.setTextSize(1,2);
    // musimy ustawić tło liter, aby usunąć poprzednią treść
    tft.setTextColor(ST77XX_WHITE, ST77XX_BLACK);
    tft.setCursor(pos_name, y);
    // wypisać odpowiednio przesuniętą nazwę...
    tft.printf("%-*.*s", max_namelen, max_namelen, sch->name+sch->scrollpos);
    // i przywrócić poprzerni tryb tła
    tft.setTextColor(ST77XX_WHITE);
    
}

oraz funkcję kontrolującą owo wyświetlanie:

static void redisplayTrain(int pos, struct SchedTrain *sch)
{
    // jeśli nie  trzebaskrolować nie robimy nic
    if (!sch->scrollsize) return;

    
    switch(sch->scrollphase) {
        case SCROLL_START:
        // jeśli jesteśmy w pozycji początkowej
        // czekamy trzy sekundy
        if (millis() - sch->timer < 3000UL) return;

        // albo przełączamy się w tryb skrolowania
        sch->scrollphase = SCROLL_SCROLLING;
        sch->scrollpos = 1;

        // pass thru

        case SCROLL_SCROLLING:

        // jeśli doszliśmy do końca, zmieniamy stan na końcowy
        if (sch->scrollpos > sch->scrollsize) {
            sch->scrollphase = SCROLL_END;
            sch->timer = millis();
            return;
        }
        // w przeciwnym razie wyświetlamy przesuniętą nazwę
        // i zwiększamy przesunięcie
        displayTrainName(pos, sch);
        sch->scrollpos ++;
        break;

        case SCROLL_END:
        // i znów czekamy trzy sekundy...
        if (millis() - sch->timer < 3000UL) return;
        // a potem przywracamy stan do pozycji początkowej
        sch->scrollphase = SCROLL_START;
        sch->timer = millis();
        sch->scrollpos = 0;
        // i wyświetlamy nazwę bez przesunięcia
        displayTrainName(pos, sch);
        break;

    }
}

Ta funkcja musi być wywoływana co jakiś czas (arbitralnie przyjąłem 300msec), aby skrolowanie odbywało się z jakąś sensowną prędkością i zachodziło równocześnie na wszystkich pozycjach:

static uint32_t lastScroll = 0;
void displayLoop()
{
    if (millis() - lastScroll < 300UL) return;
    int i;
    lastScroll=millis();
    for (i=0;i<SCHED_SIZE;i++) redisplayTrain(i, &SchedTrain[i]);
}

Pozostaje jedynie dopisanie deklaracji funkcji do pliku rozklad.h:

extern void displayLoop();

i wstawienie jej wywołania w głównym pliku ino:

void loop()
{
    schedLoop();
    displayLoop();
    delay(1); // ESP8266 to lubi
}

Jeśli nic nie pominęliśmy (tzn. zarówno ja pisząc, jak i Wy dopisując kod) po skompilowaniu i uruchomieniu programu zobaczymy, że nie mieszcząca się w poku nazwa stacji "Bielsko-Biała Komorowice" przesuwa się umożliwiając jej odczytanie w całości.

Przyjrzyjmy się jednak kodowi. Zauważmy co najmniej dwa miejsca, które mogą być przyczyną powstania błędów. Pierwsza to obliczenie pozycji linii na wyświetlaczu: liczona jest w dwóch różnych funkcjach. Jeśli chcielibyśmy to zmienić (a zaręczam, że będziemy chcieli) musielibyśmy pamiętać o zmianie w dwóch miejscach...

Spróbujmy to rozwiązać inaczej.

W pliku display.cpp dodamy na początku definicję:

#define YPOS(pos) ((pos) * 21 + 2)

a w fukcjach displayTrain i displayTrainName zamieńmy linię:

    int y=pos*21+2;

na:

    int y=YPOS(pos);

W ten sposób możemy w każdej chwili zmienić sposób obliczania pozycji (np. gdybyśmy chcieli wprowadzić jakąś linię nagłówkową) bez szukania po wszystkich funkcjach.

Druga sprawa to podawanie zarówno pozycji, jak i elementu tablicy SchedTrain o indeksie równym tej pozycji. Jest to absolutnie niepotrzebne, bo znając pozycję możemy odwołać się do tej tablicy. Zostawmy jednak na wszelki wypadek taką możliwość, zmieniając lekko funkcje displayTrain i redisplayTrain. W przypadku redisplayTrain (która jest funkcją lokalną dla pliku display.cpp) początek będzie wyglądał tak:

static void redisplayTrain(int pos, struct SchedTrain *sch = NULL)
{
    if (!sch) sch=&SchedTrain[pos];

W przypadku displayTrain musimy zmienić jej deklarację w pliku rozklad.h:

void displayTrain(int pos, struct SchedTrain *sch = NULL);

i oczywiście wpisać pokazaną wcześniej linię jako pierwszą.

I dalej w displayLoop upraszczamy ostatnią linijkę:

    for (i=0;i<SCHED_SIZE;i++) redisplayTrain(i);

a w rozklad.cpp w funkcji displaySched odpowiednio upraszczamy:

    for (i=0; i<SCHED_SIZE; i++) displayTrain(i);

Czyli pierwszą część już mamy. Spróbujmy się teraz zająć kartą SD.

Stwórzmy sobie jakis przykładowy rozkład:

E Katowice 4/2 10:40
O Bielsko-Biała Komorowice 1/1 12:10
S Český Těšín 2/1 13:50
S Żywiec 1/1 13:52
E Šibenik 3/2 14:30
E Katowice Piotrowice 4/2 15:40
O Bielsko-Biała Główna 1/1 16:10
E Berlin Östbahnhoff 2/1 16:50
P Kraków 1/1 16:52
P Tychy Lodowisko 3/2 17:30
E Hradec Králové 4/2 18:40
P Szczecin Dąbie 1/1 19:10
P Częstochowa 2/1 19:50
S Zamość 1/1 19:52
P Tychy 3/2 20:30

Zapiszmy to do pliku rozklad1.txt na karcie. Musimy pamiętać, aby nie pozostawiać żadnych pustych linii oraz (jeśli edytor tekstu ma taką możliwość) zapisania go w kodowaniu UTF-8 (na szczęście w więksszości systemów natywne) oraz wyłączyć zapisywanie BOM. Znaczeniem tych pierwszych literek zajmiemy się później; na razie przyjmijmy P:pospieszny, O:osobowy, S:przyspieszony, E:ekspres.

Stwórzmy teraz nowy plik o nazwie sd.cpp z następującą zawartością:

#include <Arduino.h>
#include <SD.h>
#include "rozklad.h"

const char *getSD()
{
    File plik;
    if (!SD.begin(15)) {
        printf("Brak karty lub karta nieczytelna\r\n");
        return NULL;
    }
    uint8_t *txt = NULL;
    plik = SD.open("/rozklad1.txt");
    if (!plik) {
        printf("Brak pliku rozklad1.txt\r\n");
    }
    else {
        printf("Plik rozklad1.txt rozmiar %d\r\n", plik.size());
        int s=plik.size();
        txt=(uint8_t *)malloc(s+1);
        plik.read(txt,s);
        plik.close();
        txt[s]=0;
    }
    SD.end(false);
    return (const char *) txt;
}

Jak widać, plik na razie zawiera tylko jedną funkcję. Musimy jej deklarację dopisać do rozklad.h:

extern const char *getSD();

W pliku rozklad.cpp dodamy jej wywołanie, modyfikując funkcję:

void initSched()
{
    const char *newsched = getSD();
    if (newsched) sched = newsched;
    schedPos = 0;
    displaySched(sched);
}

Po wprowadzeniu powyższych zmian i skompilowaniu programu powinien nam się pokazać rozkład czytany z karty!

No dobra, program działa, a co będzie jeśli w pliku będzie jakiś błąd? Albo w ogóle będzie to jakiś przypadkowy plik? Ponadto nawet w przypadku prawidłowego pliku trzeba pamiętać o jakichś BOM-ach (kto wie co to jest?) i uważaniu żeby się jakaś pusta linia tam nie znalazła...

Spróbujmy najpierw stworzyć funkcję która usuwa BOM oraz niepotrzebne białe znaki (ze znakami nowej linii włącznie):

static void compactSched(char *txt)
{
    char *dst=txt;
    bool blank=false;
    // pomijamy BOM jeśli wystąpił
    if (!memcmp(txt,"\xEF\xBB\xFF", 3)) txt += 3;
    //pomijamy wiodące białe znaki    while (*txt && isspace(*txt)) txt++;
    
    while (*txt) {
        if (*txt == '\r' || *txt == '\n') {
            // pomijamy wszystkie kolejne białe znaki
            while (*txt && isspace(*txt)) txt++;
            if (!*txt) break;
            *dst++='\n';
            blank=false;
            continue;
        }
        if (isspace(*txt)) {
            // zapamiętujemy że była spacja, ale jej nie kopiujemy
            blank=true;
        }
        else {
            if (blank) {
                // dopiero teraz kopiujemy spację
                *dst++=' ';
                blank=false;
            }
            *dst++=*txt;
            
        }
        txt++;
    }
    *dst=0;
}

Jak widać, funkcja po prostu modyfikuje napis podany jako parametr.

Drugą funkcją będzie sprawdzenie poprawności pliku:

static bool checkSched(const char *txt)
{
    struct SchedTrain st;
    int n;
    for (n=0;parseScheduleLine(&st,&txt);n++) ;
    while (*txt && isspace(*txt)) txt++;
    if (*txt) {
        printf("Śmieci w pliku rozklad1: %s\r\n", txt);
        return false;
    }
    if (n < 7) {
        printf("Za mało pozycji w rozkładzie\r\n");
        return false;
    }
    return true;
}

Użyliśmy tu znanej już funkcji parseScheduleLine do sprawdzenia, czy linia jest poprawna. Nawet w przypadku, jeśli zmienimy kiedyś (co możliwe) format zapisywanego rozkładu, nie będzie to miało wpływu na sprawdzanie poprawności.

Obie te funkcje wrzucamy do pliku sd.cpp (przed funkcją getSD), a w sameh funkcji getSD zmieniamy nieco fragment kodu - końcówka funkcji będzie wyglądała tak:

        plik.close();
        txt[s]=0;
        compactSched((char *)txt);
        if (!checkSched((const char *)txt)) {
            free(txt);
            txt=NULL;
        }
    }
    SD.end(false);
    return (const char *) txt;
}

No i teraz nie straszne nam BOM-y ani dodatkowe nowe linie, a mamy pewność że nieprawidłowy rozkład nie zostanie zaakceptowany.

Kompletny kod jak zwykle w załączniku:rozklad2.zip

Oczywiście już można się do czegoś przyczepić.

Takie "biedne skrolowanie" po literce wygląda raczej niespecjalnie estetycznie. Poza tym jet tu jedna niedogodność: w czasie startu programu karta SD musi siedzieć w czytniku..

Spróbuję temu zaradzić - więc jak zwykle: stay tuned!

[ethanak]

Muszę przeprosić - jeśli ktoś to czyta to po prostu materiału byłoby za dużo, a przecież nie chodzi tu aby zrobić gotową makietę, tylko aby pokazać jak się to robi...

Ale w zamian kol. @prezesedi pewnie opisze swoje boje  z uruchomieniem czytnika na NodeMCU i podzieli się uwagami co do karty. Czekamy!

[prezesedi]

Tak, więc zacznę od tego, że chyba zmienię nick na "problem". Bo te od początku projektu mnie nie opuszczają. Część to moja wina, część sprzętu.

W tej chwili opiszę ostatni problem - spowodowany sprzętem.

Tak więc okazało się, że ESP nie widzi karty - w żaden sposób. Nie radził sobie z wczytywaniem kodu, gdy karta była w slocie (wyrzucał komunikat, że ESP nie jest podłączone - dziwne). Dzięki podpowiedzi kol. @ethanak spiąłem pin D8 poprzez rezystor 10k z masą - i nagle ESP zaczęło widzieć kartę podczas wczytywania kodu.

Żeby nie było łatwo, to mimo wgrania pliku .txt na kartę (8GB Nokia), ESP nie potrafiło go "przeczytać". Formatowanie karty na FAT32, potem na NTFS i powrotnie na FAT32 nie pomagało. Wziąłem kartę 64GB z systemem plików exFAT - to samo. Wpadłem na pomysł by programem do partycjonowania nadać karcie system plików FAT32. Program się burzył ale na wymusiłem na nim ten system, wgrałem plik z zapowiedziami - I DZIAŁA! Przywróciłem exFAT - nie działa. Tak więc znów na siłę FAT32 i możemy działać dalej.

[ethanak]

11 godzin temu, prezesedi napisał:

spiąłem pin D8 poprzez rezystor 10k z masą

A to w ogóle ciekawa sprawa. Ten rezystor powinien być na płytce NodeMCU i bez niego ESP8266 raczej nie ruszy.  Ponieważ po odłączeniu D8 (czyli GPIO15) od czytnika ESP działał pomyślałem, że jedyna możliwość to ta, że nasz żółty przyjaciel pomylił np. 103 i 104 (bo te znaczki co je Długie Nosy wymyśliły to takie dziwne i podobne do siebie) i wsadził tam 100k albo coś podobnego... jak się okazało chyba miałem rację

Ale wróćmy do dalszego ciągu zabawy z rozkładem jazdy.

Zacznijmy od lekkiej kosmetyki.

Wspominałem wcześniej, że chcę oznaczyć typ pociągu "przyspieszony" literą "S". Dlaczego? Bo po pierwsze P jest już zajęte na "pospieszny", po drugie jeden z takich znanych mi pociągów nosi miano "Strzała"

Tyle że wyświetlenie literki S na rozkładzie jazdy nie jest chyba tym, co tygrysy lubią najbardziej. Prosiłoby się o wyświetlenie dwóch literek "Pr", ale wtedy tracimy miejsce na nazwę.

Na szczęście biblioteka pozwala nakładać jeden znak na drugi, a "P" o wysokości 2 połączone z lekko przesuniętym "r" o wysokości 1 daje bardzo ciekawy efekt. Zamieńmy więc w pliku display.cpp linię:

    tft.printf("%c", sch->type);

na taki kod: 

  if (sch->type == 'S') {
        tft.print('P');
        tft.setCursor(2,y+8);
        tft.setTextSize(1);
        tft.print('r');
        tft.setTextSize(1,2);
    }
    else tft.print((char )sch->type);

Jak widać, przy okazji pozbyłem się jednego printf na rzecz prostszego print (niestety, przyzwyczajenie).

Po drodze zróbmy trochę porządku.

Ponieważ jak już pisałem, program powinien działać na dowolnym wyświetlaczu TFT SPI, trzeba pozbyć się z kodu wszystkich fragmentów zależnych od wyświetlacza. Oprócz oczywistych definicji wyświetlacza i wywołań funkcji inicjalizacji pozostały tylko nazwy kolorów. Ponieważ wyświetlacze (a przynajmniej większość z nich) pracuje w trybie RGB565, warto chyba móc wybrać sobie dowolne kolory. Co prawda biblioteka Adafruit_GFX przewiduje funkcję rgb565, ale tylko jako metodę instancji displaya. Zacznijmy więc od definicji makra:

#define RGB565(r,g,b) ((((r) & 0b11111000) << 8) | (((g) & 0b11111100) << 3) | ((b) >> 3))

Teraz możemy zdefiniować sobnie dwa podstawowe kolory:

#define SC_BGCOLOR RGB565(0,0,96)
#define SC_FGCOLOR 0xffff

Teraz wystarczy tylko podstawić SD_FGCOLOR i SD_BGCOLOR we wszystkich miejscach gdzie występowały ST77XX_cośtam i już mamy kod niezależny od wyświetlacza. Dodatkowo możemy precyzyjniej sobie ustalić kolor - ja wybrałem ciemnoniebieski na kolor tła, wygląda dużo lepiej niż czarny.

Jak już jesteśmy przy kolorkach - czasem może istnieć potrzeba wyświetlenia jakiejś linii nagłówkowej (np. "ODJAZDY"). Spróbujmy wprowadzić traką możliwość.

Na początki zdefiniujmy sobie w pliku display.cpp ową linię nagłówkową oraz kolory tła i napisu - przykładowo:

#define SC_HEADER_LINE "ODJAZDY"

#define SC_HDRFGCOL 0
#define SC_HDRBGCOL RGB565(192,192,192)

Teraz musimy zmienić położenie na ekranie każdej pozycji rozkładu. Ponieważ robimy to teraz w jednym miejscu, możemy w łatwy sposób umożliwić prawidłowe wyświetlanie w obu sytuacjach (tzn. z linia nagłówkową i bez):

#ifdef SC_HEADER_LINE
#define YPOS(pos) ((pos) * 18 + 20)
#else
#define YPOS(pos) ((pos) * 21 + 2)
#endif

Teraz w funkcji initDisplay trzeba wstawić kod wyświetlający tę linię. Ponieważ linijki się trochę poprzestawiły, teraz kod funkcji będzie wyglądać tak:
void initDisplay()
{
    tft.initR(INITR_BLACKTAB);

    tft.setRotation(3);
    tft.cp437();
    wscreen = tft.width();
    hscreen = tft.height();
    tft.fillScreen(SC_BGCOLOR);
    tft.setTextWrap(0);
#ifdef SC_HEADER_LINE
    tft.fillRect(0,0,wscreen,18,SC_HDRBGCOL);
    tft.setTextColor(SC_HDRFGCOL);
    tft.setTextSize(2);
    tft.setCursor(wscreen/2-strlen(SC_HEADER_LINE) * 6,1);
    tft.print(SC_HEADER_LINE);
    tft.setCursor(wscreen/2-strlen(SC_HEADER_LINE) * 6+1,1);
    tft.print(SC_HEADER_LINE);
#endif
    tft.setTextColor(SC_FGCOLOR);
    
// trochę obliczeń

    pos_name = 10;  // pozycja wyświetlania nazwy
    pos_hour = wscreen - 5 * 6; // pozycja wyświetlania godziny
    pos_tor = pos_hour - 10; // pozycja wyświetlania toru i peronu
    max_namelen = (pos_tor -14) / 6; // maksymalna długość nazwy
}

Po dokonaniu tych zmian możemy się już bawić we włączanie i wyłączanie linii nagłówkowej (poprzez zakomentowanie definicji SC_HEADER_LINE), zmiany kolorów i tak dalej. Ale zajmijmy się czymś poważniejszym, mianowicie skrolowaniem.

Idealnym rozwiązaniem byłoby skrolowanie po pikselu zamiast po znakach. Niestety - biblioteka nie zapewnia bezpośrednio takiej możliwości (a przynajmniej nie przy tym wyświetlaczu). Spróbujmy więc podejść do problemu inaczej.

Można stworzyć obiekt typy canvas (taki wirtualny jednobitowy ekran) na którym będziemy sypisywać odpowiednio przesuniętą nazwę, a potem przygotowany fragment obrazu wyświetlić na ekranie. Tu już bblioteka ma wbudowane potrzebne mechanizmy, a więc zaczynamy.

Dodajmy gdzieś przed funkcją initDisplay następujący kod:

int wcanvas, hcanvas;
GFXcanvas1 *canvas;

a na końcu funkcji initDisplay:

    wcanvas = max_namelen*6;
    hcanvas = 16;
    canvas = new GFXcanvas1(wcanvas, hcanvas);
    canvas->setTextColor(1);
    canvas->setTextSize(1,2);
    canvas->setTextWrap(0);
    canvas->cp437();

W ten sposób mamy już obiekt, który będzie nam służył jako prowizoryczna tablica do wpisywania przesuniętej nazwy.

Teraz musimy zrobić kilka modyfikacji. Zmienimy całkowicie kod funkcji displayTrain:

static void displayTrainName(int pos, struct SchedTrain *sch)
{
    int y=YPOS(pos);

    // przygotowujemy tekst
    
    canvas->fillScreen(0);
    canvas->setCursor(-sch->scrollpos,0);
    canvas->print(sch->name);

    // i wzięte z podręcznika:
    
    tft.drawBitmap(pos_name,y,canvas->getBuffer(),wcanvas, hcanvas, SC_FGCOLOR, SC_BGCOLOR);
}

w funkcji redisplayTrain zmieniamy dosłownie jedną linijkę, dodając mnożenie przez szerokość znaku:

 

       // jeśli doszliśmy do końca, zmieniamy stan na końcowy
        if (sch->scrollpos > sch->scrollsize * 6) {

Różnież w displayLoop konieczna będzie zmiana (teraz przerysowanie musi odbywać się częściej):

void displayLoop()
{
    if (millis() - lastScroll < 60UL) return;

No i po skompilowaniu cieszymy się pięknym, płynnym scrollingiem...

E... znaczy się tego... miał być płynny, ale jeśli poruszają się dwie linijki to scrolling lekko zwalnia, a przy trzech jednocześnie staje się strasznie niemrawy... dlaczego???

Sprawdźmy co tam się dzieje. Podejrzenie pada na funkcję wyświetlania bitmapy, sprawdźmy więc ile to trwa. Zmodyfikujmy nieco kod:

    uint32_t m=millis();
    tft.drawBitmap(pos_name,y,canvas->getBuffer(),wcanvas, hcanvas, SC_FGCOLOR, SC_BGCOLOR);
    printf("TIME %d\r\n", millis() - m);

Po uruchomieniu okazuje się, że wrzucenie tej nieszczęsnej bitmapy do wyświetlacza trwa około 50 msec. No to faktycznie,nie ma prawa działać przy więcej niż jednej skrolowanej linii.

Może zwiększyć prędkość SPI? Można próbować tylko po to, że przy 64 MHz zyskujemy całe dwie milisekundy, a przy 80 MHz (max co może ESP8266) wyświetlacz prezentuje coś w rodzaju rozgwieżdżonego nieba...

Trzeba więc znależć przyczynę. Popatrzmy w kod funkcji drawBitmap... o, ciekawe! Funkcja pobiera sobie wartości pikseli z bitmapy (to jest akurat szybkie), przekształca je na jedną z dwóch wartości (fgcolor, bgcolor) i wykonuje operację writePixel().

Zaraz moment. Jeśli ktoś ma ochotę pooglądać sobie kod to może policzyć, ile bajtów trzeba wysłać do wyświetlacza aby postawić jedną durną kropkę. Pewnie nikomu się nie będzie chciało, więc powiem: dziesięć. Dlaczego tak dużo???

Przyjrzyjmy się funkcji writePixel. W skrócie wygląda tak:

1. rozpocznij komunikację
2. ustaw okno robocze o wymiarach 1x1 na pozycji x/y (czyli wysłanie 8 bajtów do wyświetlacza)
3. wyślij dwa bjty koloru piksela
4. zakończ komunikację

A gdyby tak ustawić okno robocze na wielkość bitmapy i przesłąć longiem wartości wszystkich pikseli? Spróbujmy!

Utwórzmy funkcję szybkiego kopiowania umieszczając kod przed funkcją displayTrainName:

static void drawBitmapFast(int x, int y, uint16_t fgcolor, uint16_t bgcolor)
{
    tft.startWrite();
    tft.setAddrWindow(x,y,wcanvas,hcanvas);
    int i,j;
    for (j=0;j<hcanvas;j++) for (i=0;i<wcanvas;i++) {
        uint16_t color = canvas->getPixel(i,j) ? fgcolor: bgcolor;
        tft.SPI_WRITE16(color);
    }
    tft.endWrite();
}

Teraz w displayTrainName zakomentujmy linię zawierającą wywołanie drawBitmap i wpiszmy w jej miejsce:

    drawBitmapFast(pos_name, y, SC_FGCOLOR, SC_BGCOLOR);

Kompilujemy, uruchamiamy i... mogliśmy się spodziewać pięciokrotnego skrócenia czasu a jest nawet lepiej: wywołanie tej funkcji trwa poniżej 8 msec!

Możemy teraz usunąć lub zakomentować kod pomiarowy. Ponieważ w przyszłości będziemy używać WiFi - warto dodać na końcu funkcji displayTrainName wywołanie yield - tak więc cały kod będzie się przedstawiał następująco:

static void displayTrainName(int pos, struct SchedTrain *sch)
{
    int y=YPOS(pos);

    // przygotowujemy tekst
    
    canvas->fillScreen(0);
    canvas->setCursor(-sch->scrollpos,0);
    canvas->print(sch->name);

    // i wysyłamy do wyświetlacza

    drawBitmapFast(pos_name, y, SC_FGCOLOR, SC_BGCOLOR);

    yield();
}

Tak więc kwestię wyświetlacza możemy uznać za na razie rozwiązaną, przejdźmy więc do odczytu rozkładu z karty. Powinien działać w ten sposób:

Jeśli nie odczytano pliku z karty, następuje próba odczytu z wewnętrznej pamięci flash. W przypadku jego braku zastosowany będzie rozkład demo wkompilowany w program.

Jeśli odczytano plik z karty, również następuje próba odczytu z wewnętrznej pamięci. Jeśli próba się powiodła i rozkłady są identyczne, nie robimy nic. W przeciwnym przypadku nowy rozkład będzie skopiowany do pamięci wewnętrznej.

Zacznijmy więc od kodu odpowiedzialnego za obsługę tej wewnętrznej pamięci. Zastosujemy tu LittleFS jako wskazany do stosowania w nowych aplikacjach. Czyli - bierzemy na warsztat plik sd.cpp.

Przede wszystkim musimy włączyć obsługę LittleFS. W tym celu dodajemy kolejną dyrektywę include:

#include <Arduino.h>
#include <SD.h>
#include <LittleFS.h>
#include "rozklad.h"

Dalej przyszła kolej na rozwiązanie dylematu. Mam funkcję getSD, która zwraca odczytany plik i do której odwołuję się w innej części programu. Teraz jednak ta funkcja będzie bardziej skomplikowana - musi obsługiwać odczyt z LittleFS i ewentualne kopiowanie. Miałem do wyboru:

modyfikację kodu getSD (totalnie bez sensu, ta funkcja robi jedną konkretną rzecz)
napisanie innej funkcji korzystającej z getSD (wymagałoby to zmian w kolku miejscach poza tym plikiem)
pozostawienie funkcji jak jest, zmienienie tylko jej nazwy i zakresu oraz napisanie nowej funkcji getSD

Wybrałem trzecie rozwiązanie. Tak więc dawna funkcja getSD otrzymuje nową nazwę i nie będzie widoczna spoza pliku sd.cpp, czyli zmieniamy:

const char *getSD()

na

static const char *readSD()

Teraz można napisać nową funkcję getSD(), czyli coś w rodzaju:

const char *getSD()
{
    const char *txt = readSD();
    const char *txt2 = readLittleFS();

 // i tu sprawa byłaby prosta...

Tak, byłaby prosta gdyby nie możliwość skopiowania zawartości txt do pliku na LittleFS. Jako że funkcja odczytująca rozkład powinna zamknąć filesystem, trzeba by go było otwierać na nowo, a ja nie lubię czynności niepotrzebnych. Postanowiłem inaczej: do funkcji readLittleFS przekażę wartość odczytaną z karty i potem się będę zastanawiał co robić. Tak więc funkcja getSD będzie wyglądać tak:

const char *getSD()
{
    const char *txt = readSD();
    return readLFS(txt);
}

Spróbuję teraz napisać funkcję readLFS. Będzie bardzo podobna do readSD, a więc zaczynamy:

const char *readLFS(const char *sch)
{
    File plik;
    if (!LittleFS.begin()) {
        printf("Nie mogę zamontować LittleFS\r\n");
        return sch;
    }
    char *txt = NULL;
    plik=LittleFS.open("/rozklad1.txt","r");
    if (!plik) {
        printf("Brak pliku na LittleFS\r\n");
    }
    else {
        int size=plik.size();
        printf("LFS rozklad1.txt rozmiar %d\r\n", size);
        txt=(char *)malloc(size+1);
        plik.read((uint8_t *)txt, size);
        plik.close();
        txt[size]=0;
    }

... i w tym miejscu mamy już oba rozkłady przeczytane, a LittleFS nie jest jeszcze zamknięty. Pozostało napisać kod, który wybierze właściwą wersję. Ponieważ lubię, gdy dana funkcja robi jedną dobrze określoną rzecz, zakończę funkcję readLFS:

    sch = selectVersion(sch, txt);
    LittleFS.end();
    return sch;
}

Kolej na funkcję selectVersion.

static const char *selectVersion(const char *sch, const char *txt)
{
    // nie było karty i nie ma z czego wybierać?
    if (!sch) return txt;
    
    if (txt && !strcmp(txt,sch)) {
        printf("Pliki są identyczne\r\n");
        free((void *)txt); // już niepotrzebne
        return sch;
    }
    // teraz mamy sytuację, że albo nie było pliku txt
    // albo różni się on od nowego pliku z karty. W oby
    // tych przypadkach należy zawartość sch wpisać
    // do pliku na LittleFS
    
    if (txt) free((void *)txt); // już niepotrzebne
    printf("Kopiuję rozkład do LittleFS\r\n");
    File plik=LittleFS.open("/rozklad1.txt","w");
    if (!plik) {
        printf("Nie mogę otworzyć pliku do zapisu\r\n");
    }
    else {
        plik.write((uint8_t *)sch, strlen(sch));
        plik.close();
    }
    return sch;
}

Funkcje umieszczamy w kodzie w kolejności umożliwiającej ich prawidłową widoczność bez konieczności oddzielnego deklarowania, czyli będą to kolejno:

1. checkSched
2. compactSched
3. readSD
4. selectVersion
5. readLFS
6. getSD

Po skompilowaniu i wgraniu możemy sprawdzić, jak zachowa się nasz program. Kod jak zwykle w załączniku: rozklad3.zip

Cóż - to jeszcze nie wszystko. Program co prawda działa, ale warto parę rzeczy jeszcze ulepszyć, a więc: stay tuned!

 

[farmaceuta]

Ale się zawzioles @ethanak ...ja już na samym początku odpadłem z powodu zbyt wysokiego poziomu i nie wiem co Ty tu tworzysz, ale widać że chcesz to ogarnąć na najwyższym poziomie...gratuluję samozaparcia

[ethanak]

50 minut temu, farmaceuta napisał:

ja już na samym początku odpadłem z powodu zbyt wysokiego poziomu i nie wiem co Ty tu tworzysz

To wcale nie jest taki wysoki poziom, wydaje Ci się. A co ja tworzę? Chcę na przykładzie pokazać, jak drobnymi krokami ze stosunkowo prostej aplikacji (pierwsza moja wersja) dojść do czegoś bardziej skomplikowanego. Radzę na spokojnie sobie poczytać, zacząć od pierwszej wersji kodu i podpatrywać, w jaki sposób go poprawiam czy dopisuję nowe rzeczy.

 

[ethanak]

No dobra - trzeba wreszcie skończyć z tym rozkładem jazdy, bo ja osobiście mam już go dość. 

Ale do rzeczy.

Przede wszystkim - wychodzimy z radosnego założenia, że plik jak już jest to się zawsze wczyta. Tymczasem to nie do końca prawda - różne czynniki mogą wpłynąć na błędy odczytu Spróbujmy więc temu zaradzić.

Wiadomo, że funkcja read(buf, size) zwraca ilość rzeczywiście wczytanych znaków. Znając rozmiar pliku na karcie czy lokalnym systemie plików w bardzo prosty sposób możemy sprawdzić, czy nie było błędów odczytu, po prostu porównując wartość zwracaną przez read z oczekiwaną długością pliku. Spróbujmy więc lekko zmodyfikować funkcję readSD. Zamieniamy fragment kodu:

        plik.read(txt,s);
        plik.close();
        txt[s]=0;
        compactSched((char *)txt);
        if (!checkSched((const char *)txt)) {
            free(txt);
            txt=NULL;
        }

na nieco bardziej skomplikowany:

        // czy plik wczytał się prawidłowo?
        if (plik.read(txt,s) != s) {
            printf("Błąd wczytania pliku\r\n");
            free(txt);
            txt=NULL;
        }
        else {
            txt[s]=0;
            compactSched((char *)txt);
            if (!checkSched((const char *)txt)) {
                free(txt);
                txt=NULL;
            }
        }
        plik.close();

Podobnie zrobimy w funkcji readLFS, zamieniając istniejący fragment:

   

        plik.read((uint8_t *)txt, size);
        plik.close();
        txt[size]=0;

 
na:

        if (plik.read((uint8_t *)txt, size) != size) {
            printf("Błąd czytania z LittleFS\r\n");
            free(txt);
            txt=NULL;
        } else {
            txt[size]=0;
        }
        plik.close();
 

Prawdopodobnie trudno nam będzie sprawdzić reakcję programu na błąd - po prostu skompilujmy poprawiony program aby upewnić się że gdzieś nie popełniliśmy błędu i przejdźmy do następnego problemu, mianowicie skrolowania.

Nie wszystkim podoba się taki sposób jak zastosowany przeze mnie. Lepiej, aby tekst po prostu przewinął się do pozyzji początkowej i tam na chwilę pozostał. Spróbujmy więc zmodyfikować plik display.cpp tak, aby można było wybrać pasującą możliwość.

Niech wyznacznikiem sposobu skrolowania będzie wystąpienie jakiejś definicji. Tak więc gdzieś na początku umieśćmy linię:

#define SC_MODE_ROLL

oznaczającą, że korzystamy z drugiego sposobu skrolowania. Teraz musimy to tylko wykorzystać.

W funkcji displayTrainName musimy zaraz za linią

    canvas->print(sch->name);

dopisać:

#ifdef SC_MODE_ROLL
    if (sch->scrollsize) {
        canvas->print(" \xb7 ");
        canvas->print(sch->name);
    }
#endif

Jak widać, przy nowych ustawieniach funkcja dopisuje znak podziału i powiela tekst. Można to zrobić w inny sposób, ale ten jest akurat najprostszy.

Musimy też zmienić sposób wykrywania zakończenia skrolowania. Odpowiednia gałąź w funkcji redisplayTrain będzie teraz wyglądać tak:

        case SCROLL_SCROLLING:

#ifdef SC_MODE_ROLL
        // jeśli doszliśmy do końca, zmieniamy stan na początkowy
        if (sch->scrollpos > sch->namelen * 6 + 18) {
            sch->scrollphase = SCROLL_START;
            sch->scrollpos=0;
            sch->timer = millis();
            displayTrainName(pos, sch);
#else
        // jeśli doszliśmy do końca, zmieniamy stan na końcowy
        if (sch->scrollpos > sch->scrollsize * 6) {
            sch->scrollphase = SCROLL_END;
            sch->timer = millis();
#endif
            return;
        }
        // w przeciwnym razie wyświetlamy przesuniętą nazwę
        // i zwiększamy przesunięcie
        displayTrainName(pos, sch);
        sch->scrollpos ++;
        break;

I to wszystko. Możemy teraz skompilować program, wgrać go na płytkę i wybrać odpowiadający nam sposób skrolowania.

Teraz jeszcze wrócę do odczytu plików. Co prawda program nam pięknie wypisuje na wyjściu Serial co robi, ale w rzeczywistych warunkach raczej nie będziemy mieli podłączonego tam komputera. A dobrze by było wiedzieć, czy coś nieprzewidzianego się nie stało...

Niech więc przy starcie programu na wyświetlaczu znajdą się informacje o plikach a dopiero po chwili program przejdzie do właściwego wyświetlania rozkładu.

Zacznijmy jednak od koniecznych poprawek. W pliku rozklad.cpp mamy sobie funkcję displaySched. Mało tego, że nieco niefortunnie nazwana (bo nazwa sugeruje funkcję bezpośrednio związaną z wyświetlaczem), to jeszcze zupełnie niepotrzebnie przekazywana jest jako parametr wartość zmiennej globalnej, do której przecież cały czas mamy dostęp! Zmieńmy więc nieco tę funkcję:

void showSched()
{
    const char *c=textLine(sched,schedPos);
    if (!c) {
        // jesteśmy poza rozkładem, wracamy do początku
        schedPos=0;
        c=sched;
    }
    int i;
    for (i=0; i< SCHED_SIZE; i++) {
        if (parseScheduleLine(&SchedTrain[i], &c)) continue;
        // wyszliśmy poza rozkład, musimy kontynuować od początku
        c=sched;
        parseScheduleLine(&SchedTrain[i], &c);
    }
    for (i=0; i<SCHED_SIZE; i++) displayTrain(i);
    lastSched = millis();
}

Musimy dodatkowo zmienić tylko w funkcjach nextSched i initSched linijki:

    displaySched(sched);

na 

    showShed();

Możemy teraz na wszelki wypadek skompilować i wgrać tak poprawiony program.

No i teraz więcej roboty.

Załóżmy, że istnieje jakaś 16-bitowa zmienna, w której znajdzie się informacja o tym jak przebiegało czytanie plików, a każdy bit będzie miał odpowiednie znaczenie. Dodajmy więc do pliku rozklad.h przed kończącym #endif taki fragment kodu:

// bity komunikatów
enum {
    SC_INFO_NO_CARD=0,
    SC_INFO_NO_FILE,
    SC_INFO_BAD_FILE,
    SC_INFO_READ_ERROR,
    SC_INFO_READ_OK,
    SC_INFS_BAD_MOUNT,
    SC_INFS_NO_FILE,
    SC_INFS_READ_ERROR,
    SC_INFS_READ_OK,
    SC_INFS_WRITE_ERROR,
    SC_INFS_NEW_FILE,
    SC_INFO_USE_OLD,
    SC_INFO_USE_NEW,
    SC_INFO_USE_BUILTIN,
    SC_INFO_MAX
};

// maska bitów oznaczajęcych, że komunikat jest informacją a nie błędem
#define SC_INFO_NE ((1<<SC_INFO_NO_CARD) | (1<<SC_INFO_READ_OK) | \
(1<<SC_INFS_READ_OK) | (1<<SC_INFS_NEW_FILE) | \
(1<<SC_INFO_USE_OLD) | (1<<SC_INFO_USE_NEW))

// makro sprawdzające, czy komunikat o danym numerze jest błędem
#define SC_INFO_IS_ERROR(a) (!((1<<(a)) & SC_INFO_NE))

extern uint16_t sc_info;

Teraz musimy zmusić funkcję getSD do ustawienia odpowiednich bitów. Zabieramy się znowu za plik sd.cpp. Musimy przede wszystkim zdefiniować zmienną sc_info, wyzerować ją na początku i przy każdej operacji dodawać jakiś bit. Czyli końcowy fragment będzie wyglądać tak:

uint16_t sc_info;

const char *getSD()
{
    sc_info = 0;
    const char *txt = readSD();
    txt = readLFS(txt);
    // kontrolnie wypisujemy słowo info
    printf("INFO %04x\r\n", sc_info);
    return txt;
}

No i teraz wstawiamy sobie ustawianie odpowiedniego bitu w różne miejsca w kodzie. Zacznijmy od checkSched, kod tej funkcji zostanie "wzbogacony" o kilka linijek:

static bool checkSched(const char *txt)
{
    struct SchedTrain st;
    int n;
    for (n=0;parseScheduleLine(&st,&txt);n++) ;
    while (*txt && isspace(*txt)) txt++;
    if (*txt) {
        sc_info |= 1<<SC_INFO_BAD_FILE;
        printf("Śmieci w pliku rozklad1: %s\r\n", txt);
        return false;
    }
    if (n < 7) {
        sc_info |= 1<<SC_INFO_BAD_FILE;
        printf("Za mało pozycji w rozkładzie\r\n");
        return false;
    }
    sc_info |= 1<<SC_INFO_READ_OK;
    return true;
}

Nie będę może dalej pokazywał całych funkcji, a jedynie ich fragmenty gdzie zostały wstawione odpowiednie linie kodu.

static const char *readSD()
{
    File plik;
    if (!SD.begin(15)) {
        sc_info |= 1<<SC_INFO_NO_CARD;
        printf("Brak karty lub karta nieczytelna\r\n");
...
    plik = SD.open("/rozklad1.txt");
    if (!plik) {
        sc_info |= 1<<SC_INFO_NO_FILE;
        printf("Brak pliku rozklad1.txt\r\n");
...
static const char *selectVersion(const char *sch, const char *txt)
{
    // nie było karty i nie ma z czego wybierać?
    if (!sch) {
        if (txt) sc_info |= 1<<SC_INFO_USE_OLD;
        else sc_info |= 1<<SC_INFO_USE_BUILTIN;
        return txt;
    }
    
    if (txt && !strcmp(txt,sch)) {
        if (txt) sc_info |= 1<<SC_INFO_USE_OLD;
        printf("Pliki są identyczne\r\n");
...

    if (!plik) {
        sc_info |= 1<<SC_INFS_WRITE_ERROR;
        printf("Nie mogę otworzyć pliku do zapisu\r\n");
    }
    else {
        sc_info |= 1<<SC_INFS_NEW_FILE;
        plik.write((uint8_t *)sch, strlen(sch));
...
const char *readLFS(const char *sch)
{
    File plik;
    if (!LittleFS.begin()) {
        sc_info |= 1<<SC_INFS_BAD_MOUNT;
        printf("Nie mogę zamontować LittleFS\r\n");
...
    if (!plik) {
        sc_info |= 1<<SC_INFS_NO_FILE;
        printf("Brak pliku na LittleFS\r\n");
    }
...
        if (plik.read((uint8_t *)txt, size) != size) {
            sc_info |= 1<<SC_INFS_READ_ERROR;
            printf("Błąd czytania z LittleFS\r\n");
            free(txt);
            txt=NULL;
        } else {
            sc_info |= 1<<SC_INFS_READ_OK;

Można teraz skompilować kod i uruchomić - zobaczymy, że na monitorze pojawia się informacja o zmiennej sc_info.

Weźmy się teraz za plik display.cpp. Musimy dodać funkcję wyświetlania informacji:

static bool infoMode;
static uint32_t infoStart;

static const char * const infonames[]={
    "Brak karty SD",
    "Brak pliku na karcie",
    "B\222\204dny plik na karcie",
    "B\222\202d odczytu karty",
    "Plik na karcie OK",
    "B\222\202d montowania LFS",
    "Brak pliku na LFS",
    "B\222\202d odczytu LFS",
    "Plik na LFS OK",
    "B\222\202d zapisu LFS",
    "Skopiowano nowy plik",
    "U\214ywam starej wersji",
    "U\214ywam nowej wersji",
    "U\214ywam wersji wbudowanej"};

void displayInfo()
{
    int i,pos;
    tft.setTextSize(1,2);
    for (i=0, pos=20;i<SC_INFO_MAX;i++) if (sc_info & (1<<i)) {
        // centrujemy napis
        tft.setCursor(wscreen/2-3*strlen(infonames[i]),pos);
        //kolor zielony dla informacji, czerwony dla nłędu
        tft.setTextColor(SC_INFO_IS_ERROR(i) ? RGB565(255,0,0) : RGB565(0,255,0));
        tft.print(infonames[i]);
        pos += 20;
    }
    infoMode = true;
    infoStart = millis();
}

Ponieważ teraz na początku będą wyświetlane informacje, nie można już w funkcji initDisplay rysować tła rozkładu. Trzeba więc strorzyć nową funkcję:

const void initBackground()
{
    tft.fillScreen(SC_BGCOLOR);
#ifdef SC_HEADER_LINE
    tft.fillRect(0,0,wscreen,18,SC_HDRBGCOL);
    tft.setTextColor(SC_HDRFGCOL);
    tft.setTextSize(2);
    tft.setCursor(wscreen/2-strlen(SC_HEADER_LINE) * 6,1);
    tft.print(SC_HEADER_LINE);
    tft.setCursor(wscreen/2-strlen(SC_HEADER_LINE) * 6+1,1);
    tft.print(SC_HEADER_LINE);
#endif
    tft.setTextColor(SC_FGCOLOR);
}

a w samej funkcji initDisplay dokonac potrzebnych zmian:

void initDisplay()
{
    tft.initR(INITR_BLACKTAB);
    tft.setRotation(3);
    tft.cp437();
    wscreen = tft.width();
    hscreen = tft.height();
    tft.setTextWrap(0);
    tft.fillScreen(0);
// trochę obliczeń

    pos_name = 10;  // pozycja wyświetlania nazwy
    pos_hour = wscreen - 5 * 6; // pozycja wyświetlania godziny
    pos_tor = pos_hour - 10; // pozycja wyświetlania toru i peronu
    max_namelen = (pos_tor -14) / 6; // maksymalna długość nazwy

    wcanvas = max_namelen*6;
    hcanvas = 16;
    canvas = new GFXcanvas1(wcanvas, hcanvas);
    canvas->setTextColor(1);
    canvas->setTextSize(1,2);
    canvas->setTextWrap(0);
    canvas->cp437();
    infoMode = true;
    infoStart = millis();
}

W funkcji realizującej pętlę wyświetlania dodajemy dodatkowy kod odpowiedzialny za wyłączenie informacji po pewnym czasie:

void displayLoop()
{
    if (infoMode) {
        if (millis() - infoStart < 10000UL) return; // 10 sekund
        infoMode = false;
        initBackground();
        showSched();
        lastScroll = millis();
        return;
    }
        
    if (millis() - lastScroll < 60UL) return;
    int i;
    lastScroll=millis();
    for (i=0;i<SCHED_SIZE;i++) redisplayTrain(i);
}

Pozostają nam jeszcze dwie drobne zmiany.

W pliku rozklad.cpp w funkcji initSched nie będziemy wyświetlać od razu rozkładu, a informacje. Czyli:

void initSched()
{
    const char *newsched = getSD();
    if (newsched) sched = newsched;
    schedPos = 0;
    displayInfo();
}

Funkcje showSched i displayInfo muszą być teraz globalne, czyli w pliku rozklad.h dopisujemy jeszcze:

extern void showSched();
extern void displayInfo();

Można to sobie skompilować, wrzucić na ESP i cieszyć się działającym rozkładem jazdy. Kod jak zwykle w załączniku: rozklad4.zip

I to już wszystko. Rozkład jazdy w wersji standalone jest ukończony, wrócimy do niego jeszcze kiedy będziemy realizować radiowe połączenie między panelem a układami wykonawczymi, ale musimy wrócić do rozgrzebanych na razie semaforów... 

Od razu mówię: stworzenie pełnego programu wymaga oprócz napisania całkiem nowego kodu dla ESP8266 obsługującego semafor dopisania całej maszynerii związanej z transmisją radiową do kodu panela sterującego. Tak więc od razu informuję: będę tworzyć kod dla semafora na ESP8266, ale na ESP32 trzeba będzie napisać prosty kod demo. Trochę to potrwa, ale kolegów którzy uważają że to jakiś wybitnie wysoki poziom zapewniam, że wcale nie i zachęcam do dalszej lektury. Czyli jak zwykle: stay tuned!

[prezesedi]

Mistrzostwo z tym przewijaniem. Ta zmiana kolorów również dała fajny efekt. Dziś bez zakłóceń.

[ethanak]

Dobra, rozkład mamy na razie z głowy, czyli bierzemy się za semafory. Będzie trochę długo, ale to kwestia napisania zupełnie nowego programu

Zacznijmy od elektroniki semafora.

Ponieważ bez użycia dodatkowych układów jeden ESP8266 daje nam 7 pinów do wykorzystania, taki układ może obsłużyć:

• jeden semafor lub
• jeden semafor i jedną tarczę manewrową lub
• trzy tarcze manewrowe

Teoretycznie możemy połączyć diody bezpośrednio do wyjść ESP8266. Niestety - znów musimy pamiętać o maksymalnej wydolności GPIO - czyli 12 mA. Co prawda w paru miejscach można znaleść informację jakoby to było 20mA, ale ja wolę wierzyć oficjalnej dokumentacji Espressif. Dodatkowo biała dioda nie ma najmniejszego zamiaru świecić przy zasilaniu 3.3V...

Można tego uniknąć podłączając wzmacniacz buforowy ULN2003 między ESP i diodami. Ma on akurat 7 kanałów, czyli idealnie pasuje do naszych celów.

Zalety takiego rozwiązania to:

• brak niepotrzebnego obciążania GPIO ESP8266;
• większa odporność na zwarcia i przeciążenia (układ wytrzymuje 500 mA na kanał);
• możliwość zasilania wyższym napięciem (np. 16V, po prze;liczeniu rezystorów)
• w razie poważniejszej usterki zniszczeniu ulega układ kosztujący złotówkę (w chwili pisania tego posta).

Ten sam układ możemy zresztą zastosować przy sterowaniu semaforów bezpośrednio z głównego ESP32 i ukłądów PCF, ale o tym innym razem.

Zacznijmy więc od wyboru układu (z ULN2003 lub bez). Tutaj jest pierwszy haczyk:

W związku z niewielką ilością pinów musimy użyć pinu GPIO2 lub GPIO15. Niestety, te piny pełnią również inne funkcje niż GPIO i w czasue startu muszą być podciągnięte albo do Vcc (GPIO2) albo do GND (GPIO15). W związku z tym:

Nie możemy podłączyć diody bezpośrednio do GPIO15 (najprawdopodobniej będzie jedynka ma tym pinie co uniemożliwi mu bootowanie - jak ostatnio z NodeMCU i rozkładzie jazdy)

Nie powinniśmy podłączać wejścia ULN2003 to pinu GPIO2 - zanim ruszy program będzie niepotrzebnie świeciła jedna z diod.

Stąd połączenia są takie:

Lewa strona pokazuje połączenie bezpośrednie, prawa połączenie przez bufor. I tu uwaga: Oznaczenie Vz po prawej stronie oznacza napięcie zasilania, które może wynosić od 5 do nawet 24V (ULN2003 wytrzymuje do 50V, ale takich napięć w makiecie raczej nie będzie).

Natomiast w kodzie w pliku led.cpp znajduje się definicja:

#define SEMA_USE_ULN

oznaczająca, że mamy podłączenie przez ULN2003. Dla bezpośredniego połączenia należy po prostu zakomentować tę linijkę.

Do sprawdzenia połączenia diod możemy użyć krótkiego programu (w załączniku katalog "kolsemtest"):
 

#include <Arduino.h>

// zakomentuj, jeśli podłączasz diody bezpośrednio
// do ESP8266 - bardzo niewskazane!
#define SEMA_USE_ULN

#if defined(SEMA_USE_ULN)
#define LEDSIG(a)  (a)
#define ELED_PIN 15 // WEMOS D8
#else
#define LEDSIG(a) (!(a))
#define ELED_PIN 2 // wemos D4
#endif

// ELED_PIN to 15(D8) w przypadku ULN2003
// lub 2(D4) jeśli łączymy diody bezpośrednio

// wemos: D7 D6 D5 D0 D2 ? D1
static uint8_t pins[] = {
    13, 12, 14, 16, 4, ELED_PIN, 5};

static uint32_t ledTimer;
uint8_t ledNo;

void setup()
{
    Serial.begin(115200);
    delay(1000);
    int i;
    for (i=0;i<7;i++) {
        pinMode(pins[i],OUTPUT);
        digitalWrite(pins[i], LEDSIG(0));
    }
    ledTimer = millis();
    ledNo = 0;
}

void loop()
{
    int i;
    if (millis() - ledTimer > 1000UL) {
        ledTimer = millis();
        printf("Zapalona dioda nr %d na semaforze %d\r\n",
            (ledNo % 5) + 1, (ledNo / 5) + 1);
        for (i=0;i<7;i++) digitalWrite(pins[i], LEDSIG(i == ledNo));
        
        ledNo = (ledNo+1) % 7;
    }
}

Oczywiście nie mamy tu pliku led.cpp, ale definicja SEMA_USE_ULN jest w jedynym pliku programu.

Program zapala kolejne diody. Zakładająz że podłączony jest jeden semafor i jedna tarcza, sekwencja zaczyna się od górnej diody semafora (zielonej) kończąc na dolnej diodzie tarczy (białej).

Jeśli wszystko działa, możemy iść dalej. Będziemy na razie potrzebować drugiego układu (ESP8266 lub ESP32), który zasymuluje nam działanie panela - po prostu jednoczesna praca z dwoma programami na różne platformy nie jest tym, co przewidzieli autorzy Arduino IDE. Na szczęście program jest dość prosty, nie mam zamiaru go omawiać bo to po prostu chwilowa prowizorka i jego zastosowanie skończy się z chwila unończenia urządzenia "semafor". Jego jestnym zadaniem jest zakładając, że mamy podłączone semafor i tarczę zmiana ustawień na kolejne co 15 sekund.

Ale zanim zaczniemy, kilka informacji.

Połączenie esp-now (bo takiego będę dalej używać) przewiduje do 20 połączonych układów przy braku szyfrowania lub 7 przy szyfrowaniu. Ponieważ szyfrowanie jest w tym przypadku dość szybkie i nie wpływa praktycznie na połączenie - zastosuję więc wersję z szyfrowaniem. Wymaga to jednak, aby poszczególne jednostki znały klucz tej, z którą się komunikują. Ponieważ nie są to sterowniki bomb atomowych postanowiłem, że klucze będą identyczne dla wszystkich. Można to oczywiście zmienić w programie, ale na razie nie o to nam chodzi.

Drugą sprawą jest adres MAC. Ponieważ komunikacja działa właśnie na adresach MAC, należałoby znać te adresy dla wszystkich jednostek (co byłoby co najmniej uciążliwe). Na szczęście zarówno ESP32, jak i ESP8266 pozwalają na zmianę tego adresu na czas działania programu.

Co prawda można ten adres wygenerować sobie losowo, ale lepiej aby nie pokrywał się z żadnym z możliwych istniejących urządzeń. Na szczęście specyfikacja adresacji przewiduje pulę tzw. "adresów prywatnych": drugi bit w pierwszym oktecie adresu oznacza pulę prywatną (ustawiony) lub adres zastrzeżony (zero). Dodatkowo warto, aby najmłodszy bit w przypadku puli prywatnej był wyzerowany.

Postanowiłem więc, że w każdym programie będzie się znajdował plik cipher.h, zawierający zarówno klucz szyfrujący, jak i losowo wygenerowany szablon adresu MAC. Co prawda plik ten będę umieszczał dalej we wszystkich programach, ale w końcowej wersji warto użyć (tylko raz) dołączonego programu mkcipher.py, aby wygenerować własną pulę MAC i klucz szyfrujący i skopiować wygenerowany plik cipher.h we właściwe miejsca.

Dodatkowo ustaliłem, że wszystkie urządzenia będą miały pięć pierwszych oktetów identycznych, zaś ostatni oktet będzie oznaczać:

• 0x01 - panel sterujący
• 0x20 i kolejne - semafory
• 0x30 - rozkład jazdy

Przesyłane dane zawsze zaczynają się od bajtu identyfikującego polecenie (np. "podaj ustawienia", "ustaw semafory", "moje ustawienia"), po nim kolejne bajty są już zależne od tego polecenia.

A więc zaczynamy.

Potrzebny nam będzie dodatkowy ESP - może to być zarówno ESP32, jak i ESP8266. Można wykorzystać na razie ESP32 którego używaliśmy w dotychczasowej wersji panela sterującego. W załączniku znajduje się folder KolejSemTest - ten szkic należy wgrać na dodatkowego ESP.

Teraz semafor.

Przede wszystkim: struktura Semafor będzie nieco prostsza, bo nie musi zawierać wszystkich informacji a jedynie to, co jest potrzebne do ustalenia świecących w danej chwili diod. Tworzymy więc plik semafor.h, a w nim umieszczamy:

#ifndef SEMAFOR_H
#define SEMAFOR_H

class Semafor {
    public:
    Semafor(uint8_t offset, uint8_t red);
    uint16_t update();
    bool set(uint8_t cmd);
    uint8_t current() { return _current; };
    
    private:
    void _setMasks();
    uint8_t _current;   // altualna kombinacja
    uint8_t _offset;    // numer pierwszego bitu
    uint8_t _ledMask;   // obliczona maska LED
    uint8_t _blinkMask; // obliczona maska migania
    uint8_t _red;       // kombinacja "stop"
    uint32_t _last_set; // kiedy było ostatnie ustawienie
};

extern Semafor semafor[]; // tablica z semaforami
extern const int CNT_SEMA; // ile tych semaforów?

#endif

Teraz stwórzmy plik semafor.cpp z kodem:

#include <Arduino.h>
#include "semafor.h"

// podajemy offset w bitach do wyświetlania
// oraz kombinację odpowiadającą sygnałowi STOP

Semafor::Semafor(uint8_t offset, uint8_t red)
{
    _current=red;
    _red=red;
    _offset=offset;
    _last_set = 0;
    _setMasks();
}

// funkcja wywoływana okresowo, ustawia currentLed
// na podstawie _ledMask i _blinkMask i zwraca odpowiednio
// przesuniętą wartość

uint16_t Semafor::update()
{
    if (_current != _red && millis() - _last_set >= 60000) {
        _current = _red;
        _setMasks();
    }
    uint8_t currentLed = _ledMask;
    if (_blinkMask && (millis() & 512)) currentLed &= ~_blinkMask;
    return currentLed << _offset; 
}

// ustawia kombinację LED

bool Semafor::set(uint8_t cmd)
{
    _last_set = millis();
    if (cmd != _current) {
        _current=cmd;
        _setMasks();
        return true;
    }
    return false;
}

// funkcja wewnętrzna, ustawia _ledMask i _blinkMask
// na podstawie wartości _current

void Semafor::_setMasks()
{
    _ledMask = _current & 0x1f;
    _blinkMask = (_current & 0xe0) ?
        1 << (((_current >> 5) & 0x7)-1) :
        0;
}

Jak widać, całkiem tego niedużo. Teraz tablica z semaforami (zakładam pełny semafor i tarczę):

Semafor semafor[]={
    Semafor(0,1<<2),    //offset 0, czerwona dioda trzecia
    Semafor(5,1<<0)     //offset 5, czerwona dioda pierwsza
};

const int CNT_SEMA = sizeof(semafor) / sizeof(semafor[0]);

Zajmijmy się teraz świeceniem diod. W pliku led.cpp wpisujemy kod:

#include <Arduino.h>
#include "semafor.h"

// zakomentuj, jeśli podłączasz diody bezpośrednio
// do ESP8266 - bardzo niewskazane!

#define SEMA_USE_ULN

// zakomentuj jeśli nie chcesz oglądać na serialu
// jak migają ledy

//#define SHOW_SERIAL_LED


#if defined(SEMA_USE_ULN)
#define LEDSIG(a)  (a)
#define ELED_PIN 15 // WEMOS D8
#else
#define LEDSIG(a) (!(a))
#define ELED_PIN 2 // wemos D4
#endif

// ELED_PIN to 15(D8) w przypadku ULN2003
// lub 2(D4) jeśli łączymy diody bezpośrednio

// wemos: D7 D6 D5 D0 D2 ? D1
static uint8_t pins[] = {
    13, 12, 14, 16, 4, ELED_PIN, 5};


static uint16_t ledWord;
void initLed()
{
    int i;
    for (i=0;i<7;i++) {
        pinMode(pins[i], OUTPUT);
        digitalWrite(pins[i], LEDSIG(0));
    }
    ledWord = 0;
}

void updateLed(uint16_t word)
{
    if (word != ledWord) {
        ledWord = word;

#ifdef SHOW_SERIAL_LED
        // prowizorka ale ładnie wygląda
        char buf[32], *c;
        c=buf;
        for (int i=0;i<5;i++) *c++ = (ledWord & (1<<i)) ? '*' : '-';
        *c++=' ';
        for (int i=5;i<7;i++) *c++ = (ledWord & (1<<i)) ? '*' : '-';
        *c++=0;
        printf("SemaLed %04x %s\r\n",ledWord,buf);
        // koniec prowizorki
#endif
        int i;
        for (i=0;i<7;i++) {
            digitalWrite(pins[i], LEDSIG(ledWord & (1<<i)));
        }
    }
}

Jak widać mamy tu tylko dwie funkcje: initLed która ustawia odpowiednio piny i updateLed która zapala odpowiednie ledy.

Aby to połączyć i nie zajmować się więcej jakimiś prostymi problemami, w pliku semafor.cpp dopiszę funkcję realizującą update wszystkich semaforów i zapalającą odpowiednio ledy:

uint16_t updateSemaState()
{
    int i;
    uint16_t rc;
    for (i=0, rc=0; i< CNT_SEMA; i++) {
        rc |= semafor[i].update();
    }
    updateLed(rc);
    return rc;    
}

Do pliku semafor.h dopisujemy odpowiednie deklaracje funkcji:

extern uint16_t updateSemaState(); // update wszystkiego

// LED

extern void initLed();
extern void updateLed(uint16_t word);

Możemy się teraz zająć sprawą komunikacji. Stwórzmy sobie plik wifi.cpp:

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <espnow.h>
#include "semafor.h"

#include "cipher.h"

#define CHANNEL 5
#define MY_ID 0x20

static uint8_t macadr[6];   // adres MAC semafora
static uint8_t paneladr[6]; // adres MAC panela

static bool dataValid;          // czy dane są aktualne?
static uint32_t lastReceived;   // kiedy ostatnio odebrano ustawienia
static uint32_t lastAsk;        // kiedy ostatni raz poproszono o dane

Dwie pomocnicze funkcje będą wywoływane po wysłaniu danych do panela:

static void onDataSent(uint8_t *mac, uint8_t status)
{
    printf("Master %s\r\n", status ? "nie odebrał pakietu" : "odebrał pakiet");
}

oraz po odebraniu polecenia:

static void onDataReceive(uint8_t *mac,uint8_t *data,uint8_t len)
{
    // jeśli dostaliśmy aktualne dane
    // zapamiętujemy to
    if (runCommand(data, len)) {
        dataValid=true;
        lastReceived=millis();
    }
}

Zakładam tu istnienie funkcji runCommand, która w prawidłowy sposób zinterpretuje polecenie, wykona je i zwróci informację, czy polecenie zawierało ustawienia - ale o niej później.

Ponieważ reszta programu nie potrzebuje informacji o jakichś adresach, dopiszę sobie pewną funkcję pomocniczą, dostępną globalnie:

void sendToPanel(const uint8_t *data, uint8_t len)
{
    printf("Wysyłam dane\r\n");
    esp_now_send(paneladr, (u8 *)data, len);
}

Chciałbym tu zwrócić uwagę na pewien drobiazg: do funkcji esp_now_send podaję drugi parametr rzutowany na typ u8* (taka dziwna nomenklatura, oznaczająca wskaźnik na uint8_t). Niestety - z jakichś przyczyn parametr nie jest const, stąd takie dziwactwo.

Kolej na funkcję inicjalizującą:

void initWiFi()
{

    WiFi.mode(WIFI_STA);
    wifi_set_channel(CHANNEL);
    // tworzymy tablice zawierające adresy MAC
    // panela i naszego urządzenia
    memcpy(macadr,MACARRAY,5);
    memcpy(paneladr,MACARRAY,5);
    macadr[5]=0x20;
    paneladr[5]=0x01;

    // podmieniamy firmowy adres mac na wygenerowany
    
    wifi_set_macaddr(STATION_IF, &macadr[0]);
    esp_now_init();
    esp_now_set_self_role(ESP_NOW_ROLE_COMBO);
    esp_now_set_kok((u8 *)MYCIPHER,16);
    esp_now_add_peer((u8 *)paneladr,ESP_NOW_ROLE_COMBO, CHANNEL, (u8 *)&MYCIPHER[0], 16);
    esp_now_register_recv_cb(onDataReceive);
    esp_now_register_send_cb(onDataSent);
}

To wszystko?

No, niezupełnie. Semafor mamy uruchomiony, ale panel jeszcze o tym nie wie, a my nie wiemy co ma świecić. Dopiszmy więc funkcję odpowiedzialną za prośbę o podanie danych:

void askData()
{
    uint8_t cmd = ENOW_GIMMA_DATA;
    printf("Proszę o dane\r\n");
    sendToPanel(&cmd, 1);
    lastAsk = millis();
}

W pliku semafor.h dodajemy definicje poleceń:

#define ENOW_SEMA_SETALL 3
#define ENOW_GIMMA_DATA 0xDE
#define ENOW_MY_DATA 0xE0

a na koniec funkcji initWiFi dopisujemy:

    dataValid=false;
    askData();

Ponieważ program powinien okresowo przypominać o konieczności podania danych, dopiszmy funkcję która będzie wywoływana w głównej pętli i po jakimś czasie będzie to robić:

void wifiLoop()
{
    // jeśli dane są nieważne lub upłynęło za dużo czasu
    // od ostatniego ustawienia poproś o dane
    if (dataValid) {
        if (millis() - lastReceived >=10000) {
            dataValid=false;
            askData();
        }
        return;
    }
    if (millis() - lastAsk >=1000UL) askData();
}

Jak widać, ustaliłem czas ważności danych na 10 sekund, ale w docelowym programie można go wydłużyć.

Kolej na funkcję runCommand (tę, która wykonuje polecenia panela). Możemy stworzyć kolejny plik ecommand.cpp, a w nim:

#include <Arduino.h>
#include "semafor.h"

// odebranie polecenia ENOW_SEMA_SETALL powoduje ustawienie
// wszystkich semaforów zgodnie z otrzymanymi danymi
// Semafor zawsze odpowiada swoimi ustawieniami

bool runCommand(const uint8_t *data, uint8_t len)
{
    if (!len) return false;
    uint8_t command=*data++;
    uint8_t nrsem;
    bool rc=false;
    len--;
    printf("Odebrano %02X\r\n", command);
    if (command == ENOW_SEMA_SETALL) {
        for (nrsem = 0; nrsem < len && nrsem < CNT_SEMA; nrsem++) {
            semafor[nrsem].set(*data++);
        }
        rc=true;
    }
    uint8_t buf[8];
    buf[0] = ENOW_MY_DATA;
    for (nrsem=0; nrsem < CNT_SEMA; nrsem++) buf[1+nrsem] = semafor[nrsem].current();
    sendToPanel(buf, CNT_SEMA + 1);
    return rc;
}

Jak widać funkcja jest bardo prosta: jeśli otrzymała ustawienia ustawia semafory, a niezależnie od tego zawsze wysyła aktualny stan semaforów.

Nasuwa się pytanie: dlaczego nie wpisałem tej funkcji np. do wifi.cpp? Odpowiedź prosta: funkcje wifi nie wiedzą nic o tym jakim urządzeniem sterują, a ten sam plik będzie później wykorzystany w rozkładzie jazdy.

Pozostaje nam jedynie napisanie głównego pliku ino. Jak zwykle będzie bardzo prosty:

#include "semafor.h"

void setup()
{
    Serial.begin(115200);
    initLed();
    initWiFi();
    
}

void loop()
{
    updateSemaState();
    wifiLoop();
    delay(1);   // dajmy czas ESP na swoje sprawy
}

Teraz wystarczy dopisać wszystkie brakujące deklaracje funkcji do semafor.h:

// WiFi
extern void initWiFi();
extern void sendToPanel(const uint8_t *data, uint8_t len);
extern void wifiLoop();

// polecenie wykonywane po odebraniu pakietu
extern bool runCommand(const uint8_t *data, uint8_t len);

I to już wszystko. Kod programu jest w folderze kolsema1, a załącznik tu:semafor1.zip

Po uruchomieniu obu układów możemy przez chwilę cieszyć się ładnie zmieniającymi się kolorkami.

No cóż, przez chwilę oba układy leżą na tym samym biurku. Teraz warto przenieść jeden z układów na drugi koniec mieszkania i zaczynają się problemy.

Otóż protokół esp-now polega na tym, że nadajnik wysyła pakiet do odbiornika, a odbiornik odpowiada że dostał. Możemy zauważyć, że są trzy możliwości:

• odbiornik otrzymał pakiet, nadajnik otrzymał odpowiedź
• odbiornik otrzymał pakiet, wysłał odpowiedź ale nadajnik jej nie dostał
• nadajnik wysłał pakiet ale odbiornik jej nie dostał.

Zaglądając do dokumentacji esp-now można przeczytać, że w przypadku gdy nadajnik odpowiedzi nie otrzymał należy pakiet powtórzyć. Niecierpliwi mogą zajrzeć do kodu testowego nadajnika, ale na poważnie tym zajmiemy się później (czyli przerabianiem pliku wifi.cpp). Tak, że: stay tuned!