Arduino Nano Przekazniki + Parser

// ---------------------------------------------------------------------------------------------- //
// Relay Controller v0.1 beta for NANO         by PowerTGS440                                     //
// Kontroler Przekaźników v0.1 beta dla NANO   by PowerTGS440                                     //
//                                                                                                //
// e-mail     : powerTGS440@gmail.com                                                             //
// autor      : Tomasz Majcher                                                                    //
// własność   : TransLine Polska                                                                  //
// licencja   : tylko do użytku własnego                                                          //
// ---------------------------------------------------------------------------------------------- //
//
//
// --- F U N C T I O N   D E C L A R A T I O N S ------------------------------------------------ //
                                                                                                  //
void Przekaznik_Start ( void );                                                                   //
void Przekaznik_Raport( int p);                                                                   //
void Przekaznik_Przelacz( int p, bool stan);                                                      //
void ESP_SerialRead ( void );                                                                     //
void ESP_ParseData ( void );                                                                      //
void ESP_ParseSwitch ( void );                                                                    //
void ESP_ShowParsedData ( void );                                                                 //
                                                                                                  //
// --- D E F I N E    M A K R O ----------------------------------------------------------------- //
                                                                                                  //
#define Terminal      1                 // Serial Terminal                                        //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
#if Terminal                                                                                      //
                                                                                                  //
    #define SerialSpeed   19200            // Prędkość transmisji Serial (bezp. prędk. dla NANO   //
    #define Debug         1                // Debug ON/OFF                                        //
    #define ESPDebug      1                // ESP Serial Debug                                    //
                                                                                                  //
#endif                                                                                            //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- Klasa Przekaznik ------------------------------------------------------------------------- //   <- Klasa Przekaznik
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
class Przekaznik                                                                                  //
{                                                                                                 //
    protected:                                                                                    //
                                                                                                  //
        uint8_t pin;                                                                              //
        bool state;                                                                               //
        bool normallyOpen;                                                                        //
                                                                                                  //
    public:                                                                                       //
                                                                                                  //
        Przekaznik()                                                                              //
        {                                                                                         //
            #if Terminal                                                                          //
                Serial.print(F("KONSTRUKTOR domyślny klasy Przekaźnik."));                        //
            #endif                                                                                //
        }                                                                                         //
                                                                                                  //
        Przekaznik(uint8_t p, bool isNormallyOpen)                                                //
        {                                                                                         //
            pin = p;                                                                              //
            normallyOpen = isNormallyOpen;                                                        //
                                                                                                  //
            #if Terminal                                                                          //
                Serial.print(F("KONSTRUKTOR klasy Przekaźnik."));                                 //
                Serial.print(F("Utworzono obiekt. Aktywowano przekaźnik nr : "));                 //
                Serial.println(p);                                                                //
            #endif                                                                                //
        }                                                                                         //
                                                                                                  //
        void begin()                                                                              //
        {                                                                                         //
            pinMode(pin, OUTPUT);                                                                 //
            turnOff();                                                                            //
        }                                                                                         //
                                                                                                  //
        bool getState()                                                                           //
        {                                                                                         //
            if (normallyOpen) return !state;                                                      //
            else return state;                                                                    //
        }                                                                                         //
                                                                                                  //
        void turnOn()                                                                             //
        {                                                                                         //
            if (normallyOpen)                                                                     //
            {                                                                                     //
                if (state == !true) return;                                                       //
                state = !true;                                                                    //
            }                                                                                     //
            else                                                                                  //
            {                                                                                     //
                if (state == true) return;                                                        //
                state = true;                                                                     //
            }                                                                                     //
                                                                                                  //
            digitalWrite(pin, state);                                                             //
                                                                                                  //
            #if Terminal                                                                          //
                Serial.print(F("Włączono Przekaźnik nr : "));                                     //
                Serial.println(pin);                                                              //
            #endif                                                                                //
        }                                                                                         //
                                                                                                  //
        void turnOff()                                                                            //
        {                                                                                         //
            if (normallyOpen)                                                                     //
            {                                                                                     //
                if (state == !false) return;                                                      //
                state = !false;                                                                   //
            }                                                                                     //
            else                                                                                  //
            {                                                                                     //
                if (state == false) return;                                                       //
                state = false;                                                                    //
            }                                                                                     //
                                                                                                  //
            digitalWrite(pin, state);                                                             //
                                                                                                  //
            #if Terminal                                                                          //
                Serial.print(F("Wyłączono Przekaźnik nr : "));                                    //
                Serial.println(pin);                                                              //
            #endif                                                                                //
        }                                                                                         //
};                                                                                                //
// ---------------------------------------------------------------------------------------------- //
// --- R E L A Y   O B J E C T   D E C L A R A T I O N   &   D E F I N E ------------------------ //
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
#define Przekaznik0   0                                           // to jest FAKE, nie ma go :)   //
#define Przekaznik1   1                                           // pin 1 dla Przekaźnik 1       //
#define Przekaznik2   2                                           // pin 2 dla Przekaźnik 2       //
#define Przekaznik3   3                                           // pin 3 dla Przekaźnik 3       //
#define Przekaznik4   4                                           // pin 4 dla Przekaźnik 4       //
#define Przekaznik5   5                                           // pin 5 dla Przekaźnik 5       //
#define Przekaznik6   6                                           // pin 6 dla Przekaźnik 6       //
#define Przekaznik7   7                                           // pin 7 dla Przekaźnik 7       //
#define Przekaznik8   8                                           // pin 8 dla Przekaźnik 8       //
                                                                                                  //
#define P_SIZE        9                                                                           //
                                                                                                  //
Przekaznik P [P_SIZE] = { {Przekaznik0, 1}, {Przekaznik1, 1}, {Przekaznik2, 1},                   //
                          {Przekaznik3, 1}, {Przekaznik4, 1}, {Przekaznik5, 1},                   //
                          {Przekaznik6, 1}, {Przekaznik7, 1}, {Przekaznik8, 1}                    //
                        };                                                                        //
                                                                                                  //
bool PrzekaznikStan [P_SIZE] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };                                     //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- P A R S E   F R O M   E S P   C O N S T   a n d   V A R I A B L E ------------------------ //
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
const byte numChars = 32;                                                                         //
char receivedChars[numChars];                                                                     //
bool newData = false;                                                                             //
char tempChars[numChars];                                                                         //
char messageFromEsp[numChars] = {0};                                                              //
int codeFromEsp1 = 0;                                                                             //
int codeFromEsp2 = 0;                                                                             //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// ------ S E T U P --- S E T U P --- S E T U P --- S E T U P --- S E T U P --- S E T U P ------- //
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void setup( void )                                                                                //   <- SETUP
{                                                                                                 //
                                                                                                  //
   Serial.begin(SerialSpeed);                             // ustaw prędkość SERIAL                //
   Przekaznik_Start();                                    // aktywuj przekaźniki                  //
                                                                                                  //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// ------ L O O P --- L O O P --- L O O P --- L O O P --- L O O P --- L O O P --- L O O P ------- //   <- LOOP
// ---------------------------------------------------------------------------------------------- //
// pętla główna programu dla NANO. Sprawdza czy napłynęła jakaś wiadomość z ESP (RX,TX)           //
                                                                                                  //
void loop ( void )                                                                                //
{                                                        // początek funkcji LOOP (pętli)         //
    ESP_SerialRead();                                    // sprawdź czy nadeszedł rozkaz z ESP    //
}                                                        // koniec funkcji LOOP (pętli)           //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- E S P   S E R I A L   R E A D ------------------------------------------------------------ //   <- ESP Serial Read
// ---------------------------------------------------------------------------------------------- //
// sprawdź czy nadeszła jakaś wiadomość z ESP                                                     //
                                                                                                  //
void ESP_SerialRead ( void )                                                                      //
{                                                                                                 //
    static boolean recvInProgress = false;                                                        //
    static byte ndx = 0;                                                                          //
    char startMarker = '<';                              // marker początku ->   "<"              //
    char endMarker = '>';                                // marker końca    ->   ">"              //
    char rc;                                                                                      //
                                                                                                  //
    while (Serial.available() > 0 && !newData)                                                    //
    {                                                                                             //
        rc = Serial.read();                                                                       //
                                                                                                  //
        if (recvInProgress == true)                                                               //
        {                                                                                         //
            if (rc != endMarker)                       // znak to jeszcze nie marer końca  ">"    //
            {                                                                                     //
                                                                                                  //
                receivedChars[ndx] = rc;                                                          //
                ndx++;                                                                            //
                                                                                                  //
                if (ndx >= numChars) ndx = numChars - 1;                                          //
                                                                                                  //
            }                                                                                     //
            else                                                                                  //
            {                                                                                     //
                                                                                                  //
                receivedChars[ndx] = '\0';              // znak końca                             //
                recvInProgress = false;                                                           //
                ndx = 0;                                                                          //
                newData = true;                                                                   //
                                                                                                  //
            }                                                                                     //
        }                                                                                         //
        else                                                                                      //
        if (rc == startMarker)                           // jeśli znak to startMarker ->   "<"    //
        {                                                                                         //
                                                                                                  //
            recvInProgress = true;                                                                //
                                                                                                  //
        }                                                                                         //
    }                                                                                             //
                                                                                                  //
    // --- jeśli nowe dane --------------------------------- //                                   //
    if (newData)                                             //                                   //
    {                                                        //                                   //
                                                             //                                   //
        strcpy(tempChars, receivedChars);                    //                                   //
        ESP_ParseData();                                     //                                   //
        ESP_ShowParsedData();                                //                                   //
        ESP_ParseSwitch();                                   //                                   //
        newData = false;                                     //                                   //
                                                             //                                   //
    }                                                        //                                   //
    // ----------------------------------------------------- //                                   //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- E S P   P A R S E   M E S S A G E -------------------------------------------------------- //   <- Parse data from ESP
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void ESP_ParseData ( void )                                                                       //
{                                                                                                 //
    char * strtokIndx;                                                                            //
                                                                                                  //
    strtokIndx = strtok(tempChars,",");                                                           //
    strcpy(messageFromEsp, strtokIndx);                                                           //
                                                                                                  //
    strtokIndx = strtok(NULL, ",");                                                               //
    codeFromEsp1 = atoi(strtokIndx);                                                              //
                                                                                                  //
    strtokIndx = strtok(NULL, ",");                                                               //
    codeFromEsp2 = atof(strtokIndx);                                                              //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- E S P   D E B U G   M E S S A G E -------------------------------------------------------- //   <- Show Parsed Data
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void ESP_ShowParsedData ( void )                                                                  //
{                                                                                                 //
    #if ESPDebug                                                                                  //
        Serial.print(F("Odebrano z ESP. Code: "));                                                //
        Serial.print(codeFromEsp1);                                                               //
        Serial.print(F(" Msg : "));                                                               //
        Serial.print(messageFromEsp);                                                             //
        Serial.print(F(" Data : "));                                                              //
        Serial.println(codeFromEsp2);                                                             //
    #endif                                                                                        //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- E S P   P A R S E   S W I T C H ---------------------------------------------------------- //   <- Parsed Data Switch
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void ESP_ParseSwitch ( void )                                                                     //
{                                                                                                 //
    switch ( codeFromEsp1 )                                    // przełącznik kodów z SERIAL      //
    {                                                                                             //
        case  301 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P1     //
        case  302 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P2     //
        case  303 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P3     //
        case  304 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P4     //
        case  305 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P5     //
        case  306 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P6     //
        case  307 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P7     //
        case  308 : Przekaznik_Przelacz ( codeFromEsp1 - 300, codeFromEsp2 ); break;    // P8     //
        case  309 : Przekaznik_Wlacz_Wszystkie();                             break;    // P! ON  //
        case  310 : Przekaznik_Wylacz_Wszystkie();                            break;    // P! OFF //
    }                                                                                             //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- R E L A Y   I N I T --- uruchamiane z SETUP ---------------------------------------------- //   <- Przekaznik (INIT)
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void Przekaznik_Start()                                                                           //
{                                                                                                 //
    for (byte i = 0; i <= P_SIZE; i++)                                                            //
    {                                                                                             //
        P[i].begin();                                                                             //
        PrzekaznikStan[i] = P[i].getState();                                                      //
    }                                                                                             //
}                                                                                                 //
// ---------------------------------------------------------------------------------------------- //
// --- R E L A Y   S W I T C H ------------------------------------------------------------------ //   <- Przekaznik (SWITCH)
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void Przekaznik_Przelacz( int p, bool stan)                                                       //
{                                                                                                 //
    switch ( stan )                                                                               //
    {                                                                                             //
        case  0 : P[p].turnOff(); PrzekaznikStan[p] = P[p].getState(); break;                     //
        case  1 : P[p].turnOn();  PrzekaznikStan[p] = P[p].getState(); break;                     //
    }                                                                                             //
                                                                                                  //
    #if Debug                                                                                     //
        Przekaznik_Raport(p);                                                                     //
    #endif                                                                                        //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- R E L A Y   S W I T C H ------------------------------------------------------------------ //   <- Przekaznik (SWITCH)
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void Przekaznik_Wlacz_Wszystkie()                                                                 //
{                                                                                                 //
    for(int i = 1; i < P_SIZE; i ++) Przekaznik_Przelacz( i, 1 );                                 //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- R E L A Y   S W I T C H ------------------------------------------------------------------ //   <- Przekaznik (SWITCH)
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void Przekaznik_Wylacz_Wszystkie()                                                                //
{                                                                                                 //
    for(int i = 1; i < P_SIZE; i ++) Przekaznik_Przelacz( i, 0 );                                 //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //
// --- R E L A Y   S W I T C H ------------------------------------------------------------------ //   <- Przekaznik (RAPORT)
// ---------------------------------------------------------------------------------------------- //
                                                                                                  //
void Przekaznik_Raport( int p)                                                                    //
{                                                                                                 //
    #if Terminal                                                                                  //
        Serial.print(F("Stan przekaźnika nr : "));                                                //
        Serial.print(p);                                                                          //
        if ( PrzekaznikStan[p] ) Serial.println(F(" ON "));                                       //
        else                                                                                      //
        if (!PrzekaznikStan[p] ) Serial.println(F(" OFF "));                                      //
    #endif                                                                                        //
}                                                                                                 //
                                                                                                  //
// ---------------------------------------------------------------------------------------------- //