Arduino w modelarstwie kolejowym

[ethanak]

@prezesedi - o to chodziło. Postaram się jakiś demo kod spłodzić (o ile znajdę klawiaturę bo jeszcze nie szukałem).

[prezesedi]

Przepraszam, musiałem się przesiąść z telefonu na komputer. Dokładnie wygląda to tak:

A1 - (S1)czerwona
A2 - (S2)zielona
A3 - (S3)zielona miga
A4 - (S4)pomarańczowa górna miga
A5 - (S5)pomarańczowa górna
A6 - (S10)zielona świeci, pomarańczowa dolna świeci
A7 - (S11)zielona miga, pomarańczowa dolna świeci
A8 - (S12)pomarańczowa górna  miga, pomarańczowa dolna świeci
A9 - (S13)pomarańczowa górna świeci, pomarańczowa dolna świeci
A0 - (Sz)czerwona świeci, biała miga

analogicznie dla semafora nr 2 - kody B0-B9 - wyświetlające dokładnie takie same kombinacje

 

przy tarczy:

A1 - (Ms1)niebieska lub (S1)czerwona
A2 - (Ms2)biała
A0 - (Sz)czerwona świeci, biała miga

Niebieskie dla tarczy manewrowej, czerwone dla tarczy zaporowej - w dalszej części nieistotne.

 

Wszystkie oznaczenia w nawiasach to oznaczenia sygnałów używanych w kolejnictwie.

[farmaceuta]

@ethanak mógłbyś mi powiedzieć co to jest? Nie chodzi mi o to co to ma robić tylko co to jest...to jest tablica, ale czego?? 

semafor[SEM_NUM(cmd)].set(SEM_CMD(cmd));

szczerze to nie spotkałem się jeszcze z takim zapisem...

[ethanak]

@farmaceuta zobaczysz jutro

[_LM_]

Ten słynny KISS a tak na prawdę zastąpienie węża switch case tablicą. 

Edytowano Czerwiec 12, 2023 przez _LM_

[farmaceuta]

1 godzinę temu, ethanak napisał:

@farmaceuta zobaczysz jutro

Z chęcią zobaczę...to jakaś tablica funkcji, chociaż nie pasuje mi ten "set" po kropce... Poczekam... 

No chyba że to coś ma związek z programowanie obiektowym/klasami itp, to by było jasne już czemu tego nie kojarzę... 

Ps ..już chyba wiem..tablica obiektów 

Edytowano Czerwiec 12, 2023 przez farmaceuta

[ethanak]

34 minuty temu, farmaceuta napisał:

tablica klas

Nie ma czegoś takiego, natomiast istnieją tablice obiektów. 

Kurka wodna... program mam praktycznie gotowy, tylko muszę komentarze jakieś pododawać żeby można było coś z tego zrozumieć... ale to już na 100% nie dzisiaj!

Program dla dwóch semaforów i dwóch tarcz, zakłada jednego pcf-a podłączonego do Arduino i jakiś wyświetlacz. PCF i wyświetlacz emulowany przez Serial.

 

[ethanak]

No to zaczynamy.

Postanowiłem, że funkcja getCommand() (odczytująca polecenie z klawiatury) będzie zwracać 16-bitową liczbę:
Młodszy bajt: numer programu na semaforze
Starszy bajt: numer semafora (1 do 14)

Wprowadzanie odbywa się następująco:
Wciśnięcie klawisza 0..9 lub A..D powoduje zapamiętanie numeru semafora, wyświetlenie go na wyświetlaczu i przejście do stanu przyjęcia numeru programu. Teraz wciśnięcie klawisza 0..9 lub A..D spowoduje zapamiętanie i wyświetlenie numeru programu. Zatwierdza się go klawiszem *, natomiast wciśnięcie klawisza # lub pozostawienie klawiatury na 5 sekund powoduje powrót do stanu spoczynkowego.

A więc zaczynamy...

#include <Keypad.h>

#define KEY_HASH '#'
#define KEY_ASTERISK '*'

const byte ROWS = 4;
const byte COLS = 4;

/*
 * tu wprowadzam wartości liczbowe odpowiadające klawiszom
 * bo znaki mi nie są do niczego potrzebne
 */

char keys[ROWS][COLS] = {
    {1,2,3,11},
    {4,5,6,12},
    {7,8,9,13},
    {KEY_ASTERISK,10,KEY_HASH,14}
};

// to dla sklerotyków co lubią odwrotnie wpinać kabelki

#if 1
byte rowPins[ROWS] = {9,8,7,6};
byte colPins[COLS] = {5,4,3,2};
#else
byte rowPins[ROWS] = {5, 4, 3, 2};
byte colPins[COLS] = {9, 8, 7, 6};
#endif

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
    
uint8_t kbdStatus=0;
uint8_t kbdSema, kbdProg;
uint32_t lastKeyPressed=0;

enum {
    KBD_RELAX=0,
    KBD_SEMA,
    KBD_PROG
};

void displayKbdStatus()
{
    static const char *sema2c=" 1234567890ABCD ";
    // tu powinna być obsługa 7seg ale mi się nie chciało
    if (!kbdStatus) {
        Serial.println("--");
    }
    else if (kbdStatus == KBD_SEMA) {
        Serial.print("SEMA ");
        Serial.println(sema2c[kbdSema]);
    }
    else {
        Serial.print("PROG ");
        Serial.println(sema2c[kbdProg]);                       
    }
}

uint16_t getCommand()
{
    int g=keypad.getKey();
    
    if (!g) {
        if (kbdStatus && millis() - lastKeyPressed > 5000UL) {
            kbdStatus=KBD_RELAX;
            displayKbdStatus();
            
        }
        return 0;
    }
    lastKeyPressed = millis();
    if (!kbdStatus) {
        if (g == KEY_HASH || g == KEY_ASTERISK) return 0;
        kbdStatus = KBD_SEMA;
        kbdSema = g;
        displayKbdStatus();
        return 0;
    }

    if (g == KEY_HASH) {
        kbdStatus = KBD_RELAX;
        displayKbdStatus();
        return 0;
    }
        
    if (kbdStatus == KBD_SEMA) {
        if (g == KEY_ASTERISK) return 0;
        kbdStatus  = KBD_PROG;
        kbdProg = g;
        displayKbdStatus();
        return 0;
    }
    if (g == KEY_ASTERISK) {
        kbdStatus = KBD_RELAX;
        displayKbdStatus();
        return (kbdSema << 8) | kbdProg;
    }
    kbdProg = g;
    displayKbdStatus();
    return 0;
}

// i kawałek programu żeby to sprawdzić

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

void loop()
{
    uint16_t cmd;
    cmd=getCommand();
    if (cmd) {
        Serial.print("CMD ");
        Serial.println(cmd,HEX);
    }
}

Można teraz uruchomić ten program i zobaczyć co się będzie działo, gdy będziemy wciskać klawisze na klawiaturze.

Na razie część pierwsza, niestety muszę robić kilka rzeczy na raz a chciałem przynajmniej kawałek pokazać. Stay tuned!!!
 

[ethanak]

Idziemy dalej. Na razie krótkie wyjasnienie:

Ponieważ:

1. Nie posiadam PCF8575
2. A nawet gdyby, fo nie chce mi się podpinać 12 diod z rezystorami

postanowiłem napisać funkcję emulującą PCF-a. Normalnie powinna ona wyglądać mniej więcej tak:

void sendToPcf(uint16_t port)
{
    pcf.write16(port);
}

lub dla dwóch PCF-ów:

void sendToPcf(uint32_t port)
{
    pcf1.write16(port & 0xffff);
    pcf2.write16((port >> 16) & 0xffff);
}

Nam na razie wystarczy wyświetlenie stanu semaforów w monitorze Serial, czyli:

void sendToPcf(uint16_t port)
 {
    char buf[32],*c;
    int i;
    c=buf;
    for (i=0;i<5;i++) *c++= (port & (1<<i))?'*':'.';
    *c++=' ';
    for (i=5;i<10;i++) *c++= (port & (1<<i))?'*':'.';
    *c++=' ';
    for (i=10;i<12;i++) *c++= (port & (1<<i))?'*':'.';
    *c++=' ';
    for (i=12;i<14;i++) *c++= (port & (1<<i))?'*':'.';
    *c++=0;
    Serial.println(buf);
    
}

OK, biorę się do drugiej roboty - stay tuned!!!
 

[ethanak]

No cóż, pora to dokończyć.

Zajmijmy się na razie klasą Semafor, która realizuje przyjmowanie poleceń dla konkretnego semafora, zapalaniem/gaszeniem/miganiem ledami jako też automatycznym powrotem do stanu STOP po 60 sekundach.
Kod jest chyba wystarczająco udokumentowany...

#define SEM_RED 1
#define SEM_GRN 2
#define SEM_ORU 3
#define SEM_ORD 4
#define SEM_WHI 5

#define TAR_RED 1
#define TAR_WHI 2

// makra do inicjalizacji tabel
// pięć młodszych bitów to zapalane ledy, trzy starsze to numer
// migającej ledy (1 do 5)

#define COMBO(a,b,c,d,e,blink) \
    (((a)?1:0) | ((b)?2:0) | ((c)?4:0) | ((d)?8:0) | ((e)?16:0) | ((blink)<<5))

#define TARCZA(a,b,blink) COMBO(a,b,0,0,0,blink)

// neutral - pali się tylko czerwona

#define SEM_NEUTRAL 1

// tabele programów dla semaforów

uint16_t semaTable[16]={
    0,
    COMBO(1,0,0,0,0,0),
    COMBO(0,1,0,0,0,0),
    COMBO(0,1,0,0,0,SEM_GRN),
    COMBO(0,0,1,0,0,SEM_ORU),
    COMBO(0,0,1,0,0,0),
    COMBO(0,1,0,1,0,0),
    COMBO(0,1,0,1,0,SEM_GRN),
    COMBO(0,0,1,1,0,SEM_ORU),
    COMBO(0,0,1,1,0,0),
    COMBO(1,0,0,0,1,SEM_WHI)
};

// to samo dla tarcz

uint16_t tarczaTable[16]={
    0,
    TARCZA(1,0,0),
    TARCZA(0,1,0),
    0,0,0,0,0,0,0,
    TARCZA(1,1,TAR_WHI)
};

// główna klasa Semafor

class Semafor {
    public:
    Semafor(const uint16_t *typ);
    void set(uint8_t command);
    void update();
    uint8_t get();
    
    private:
    const uint16_t *_typ;
    uint8_t ledMask;
    uint8_t blinkMask;
    uint8_t currentLed;
    bool started;
    uint32_t startTime;
};

// inicjalizacja obiektu, jako "typ" podstawiamy
// jedną z tabel programów

Semafor::Semafor(const uint16_t *typ)
{
    _typ=typ;
    started=false;
    blinkMask=0;
    ledMask=SEM_NEUTRAL;
}

// ustawienie semafora

void Semafor::set(uint8_t command)
{
    uint8_t cmd=_typ[command];
    if (!cmd) return;
    ledMask=cmd & 0x1f;
    int blink = (cmd >>5) & 7;
    blinkMask = blink ? 1<<(blink-1) : 0;
    if (ledMask == SEM_NEUTRAL) started=false;
    else {
        started = true;
        startTime = millis();
    }
}

// pobranie aktualnie świecących LED

uint8_t Semafor::get()
{
    return currentLed;
}

// wywoływane w pętli

void Semafor::update()
{
    if (started && millis() - startTime > 60000UL) {
        started=false;
        ledMask=SEM_NEUTRAL;
        blinkMask=0;
    }
    currentLed = ledMask;
    if (blinkMask && (millis() & 512)) currentLed &= ~blinkMask;
}

// teraz tablica obiektów klasy Semafor: dwa semafory i dwie tarcze

Semafor semafor[4]={
    Semafor(semaTable),
    Semafor(semaTable),
    Semafor(tarczaTable),
    Semafor(tarczaTable)
};

Jak widać semafor nie reaguje na błędne polecenie (wygaś wszystkie ledy).

Z semaforami związana jest funkcja updateLed:

void updateLed()
 {
    static uint16_t oldport=0;
    uint16_t port=
        semafor[0].get() |
        (semafor[1].get() << 5) |
        (semafor[2].get() << 10) |
        (semafor[3].get() << 12);
    if (port != oldport) {
        oldport=port;
        sendToPcf(port);
    }
}

Funkcja wywoływana będzie na samym końcu loop, aby przesłać do PCF-a informacje o świecących diodach.

Teoretycznie mamy już wszystkie klocki do złożenia preogramu, ale...

No właśnie: semafory mamy cztery, a możliwości wyboru aż 14. Musimy w jakiś sposób kontrolować, czy na pewno numerek pograny z getCommand() jest numerem istniejącego semafora. Dodatkowo byłony miło mieć możliwość ustalenia, pod którym klawiszem znajduje się konkretny semafor. Stwórzmy więc mapę semaforów:

int8_t semaforMap[16]={
    0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,0
};

Jak widać, obsadzone są tylko pozycje 11 do 14 (czyli klawisze A-D).

No to cóż... pozostało tylko dopisać funkcje setup() o loop():

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

// makra do wyciągnięcia numeru semafora

#define SEM_NUM(c) (((c)>>8)-1)
#define SEM_CMD(c) ((c) & 0xff)


void loop()
{
    uint16_t cmd=getCommand();
    if (cmd) { // mamy coś do zrobienia
        int adr=semaforMap[SEM_NUM(cmd)];
        if (adr >= 0) { // czyli jakiś semafor tam jest
            semafor[adr].set(SEM_CMD(cmd));
        }
    }

    // niezależnie od tego czy coś robiliśmy czy nie

    for (int i=0; i<4; i++) semafor[i].update();

    // no i realizujemy to co nam w semaforach wyszło

    updateLed();
}

W załączniku oba programy (ten tylko z klawiaturą i ten pełny).prezesedi1.zip

Oczywiście można zauważyć, że da się wprowadzić nieprawidłowy numer semafora lub programu - co najwyżej nie będzie w tym przypadku żadnej reakcji. Nie chciałem jednak za bardzo komplikować programu, zajmiemy się tym następnym razem (ale to już nie dziś).

A teraz czytać i pytać

 

[SOYER]

Offtopic, niewiele z tego kumam, przypominam się w takim razie z kolejnym cyklem o podstawach  programowania obiektowego na przykładach...

[prezesedi]

Dzień dobry,

6 godzin temu, ethanak napisał:

A teraz czytać i pytać

- co tu się podziało? @ethanak rozpędziłeś się z kodem tak, że nie wiem od czego zacząć. Zresztą nie tylko ja

- ile kursów Arduino/Forbot trzeba zaliczyć i ile milionów linijek kodu trzeba napisać, by móc stworzyć coś takiego?

- napisałeś kod do sterowania sygnalizacją kolejową, czy kryje się w nim coś grubszego ? Przepraszam, nie mogłem się powstrzymać - nie sądziłem (patrząc na poprzedni kod, którego używałem), że trzeba będzie aż tak go zmodyfikować. W sumie to już nie modyfikacja a napisanie wszystkiego od nowa.

 

[ethanak]

1 godzinę temu, prezesedi napisał:

nie wiem od czego zacząć.

Ale  co chcesz zaczynać? Ty masz to wrzucić do jakiegoś Arduino Uno (albo Nano, albo Pro Mini), podłączyć klawiaturę (na razie więcej nie trzeba) i sprawdzić, czy działa tak jak powinno.

1 godzinę temu, prezesedi napisał:

ile kursów Arduino/Forbot trzeba zaliczyć

A nie wiem - ja zaliczyłem jeden, ale raczej nie ma nic wspólnego z tego typu programami...

1 godzinę temu, prezesedi napisał:

ile milionów linijek kodu trzeba napisać, by móc stworzyć coś takiego?

Przecież to prosty i krótki program... dla porównania mój kod czytaka to 11500 linii. Tyle, że ten Twój pisałem przez jedno popołudnie, a czytak ma już chyba ze trzy lata i jeszcze nie jest skończony

1 godzinę temu, prezesedi napisał:

nie sądziłem (patrząc na poprzedni kod, którego używałem), że trzeba będzie aż tak go zmodyfikować.

Przecież napisałem wcześniej - tamten zlepek instrukcji trzeba zamieść pod dywan i nie zaglącać.

1 godzinę temu, prezesedi napisał:

W sumie to już nie modyfikacja a napisanie wszystkiego od nowa.

W sumie przerobienie drezyny na parowóz (że tak użyję kolejowego porównania) raczej nie polega na modyfikacji drezyny, prawda?

Ten kod jest pisany w tyen sposób, że umożliwia dowolną rozbudowę. Przykładowo - gdybyż chciał jednak użyć specjalizowanej klawiatury wystarczy zmienić tylko funkcję getCommand. Gdybyś chciał sterować czymś więcej niż semafory (np. zwrotnicami, wyświetlaczami rozkładów, oświetleniem czy co tam sobie wymarzysz) rozbudowujesz klasę Semafor (można wtedy zmienić nazwę na jakąś bardziej sensowną). Chcąc przejść na bezprzewodowe połączenie między modułami zmieniasz funkcję updateLed... i tak dalej. Nawet wrzucenie tego na ESP32 i sterowanie z telefony przez bluetooth nie wymagałoby żadnych zmian poza funcją przyjmującą polecenia.

Pisałeś wcześniej, że nie masz pojęcia o programowaniu, prawda? To teraz możesz mieć pojęcie - mianowicie takie, że przerabianie jakiegoś przypadkowego kodu i dorabianie jakichś pozornie prostych funkcji to w większości przypadków napisanie tego od zera.

A, żebyś pamiętał: to nie jest ostateczna wersja kodu. Chciałbym pokazać na przykładzie, jak można dopracowywać kod, który był pisany od początku z myślą o takiej możliwości. Tak jak pisałem poprzednio: stay tuned!

 

[prezesedi]

Na tę chwilę po podłączeniu mogę powiedzieć:

próba załadowania do klona UNO pliku ver.1 - powoduje błąd ładowania

próba załadowania do klona UNO pliku ver.2 - powiodła się. Na monitorze można zauważyć następujące sygnały:

[ethanak]

8 minut temu, prezesedi napisał:

powoduje błąd ładowania

ładowania czy kompilacji?

8 minut temu, prezesedi napisał:

Na monitorze można zauważyć następujące sygnały:

Jakie klawisze wciskałeś? Spróbuj np. A3*

Możesz mieć odwrotnie podłączoną klawiaturę - jeśli po wciśnięciu 2 pokaże się 4 odwróć klawiaturę albo zamień #if 1 na #if 0 tam, gdzie jest deklaracja pinów klawiatury.

 

Edytowano Czerwiec 13, 2023 przez ethanak