Project_Dzialka_v0.4

// --------------------------------------------------------------------------------------------------------------------------------- //
//
// Projekt   :   Działka Project 1 - Zegar NANO :-) coś z tym badziewiem w szufladzie trzeba zrobić...
// Autor     :   Tomasz Majcher
//
//
// --------------------------------------------------------------------------------------------------------------------------------- //
//
//  wersja 0.4    :   2x expander
//  wersja 0.3    :   led & key
//  wersja 0.2    :   wyświetlacz TM1637
//  wersja 0.1    :   zegar RTC
//
// --------------------------------------------------------------------------------------------------------------------------------- //


#include <virtuabotixRTC.h>             // biblioteka zegar RTC
#include <TM1637Display.h>              // wyświetlacz TM1637
#include "wiring_shift_mod.h"           // wiring
#include "PCF8574.h"                    // expander'y


#define SerialSpeed 9600                // serial prędkość
#define SERIAL      true                // serial wyświetl tak (true) / nie (false)
#define RTC_SET     false               // aktualizacja manualna zegara RTC

// ----------------- expander'y ------------------------------- //

#define exp1_adres    0x20
#define exp2_adres    0x27

// ----------------- wyswietlacz TM1637 ----------------------- //

#define CLK 2
#define DIO 3

// ----------------- panel LED & KEY -------------------------- //

#define str_pin   4
#define clk_pin   5
#define dat_pin   6
#define CLOCK_TYPE CLOCK_INVERT
#define CLOCK_DELAY_US 1
uint8_t przycisk = 0;

const uint8_t LED_adres[] = { 0xC1, 0xC3, 0xC5, 0xC7, 0xC9, 0xCB, 0xCD, 0xCF};                   // adresy LED moduły LED & KEY

const uint8_t DIGIT_adres[] = { 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE};                 // adresy DIGIT moduły LED & KEY

                                /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
const uint8_t digits[] =      { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };    // cyfry bez kropki

                                /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
const uint8_t digits_dots[] = { 0xBF, 0x86, 0xdb, 0xcf, 0xe6, 0xed, 0xfd, 0x87, 0xff, 0xef };    // cyfry z kropką

// ----------------- PRZEKAZNIKI -------------------------- //

bool R_Status [8];        // stan logiczny przekaźników

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- O B I E K T Y --------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //


virtuabotixRTC myRTC(A0, A1, A2);                         // obiekt myRTC
TM1637Display display = TM1637Display(CLK, DIO);          // obiekt DISPLAY
PCF8574 expander1(exp1_adres);                                  // expander 1
PCF8574 expander2(exp2_adres);                                  // expander 2

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- Zmienne globalne ------------------------------------------------------------------------------------------------------------ //
// --------------------------------------------------------------------------------------------------------------------------------- //

struct RTC
{
    uint8_t   godzina = 0;
    uint8_t   minuta  = 0;
    uint8_t   sekunda = 0;
    uint8_t   dzien_tygodnia = 0;
    uint8_t   dzien = 0;
    uint8_t   miesiac = 0;
    uint16_t  rok = 0;
}
zegar;


unsigned long aktualnyCzas = 0;

unsigned long zapamietanyCzas1 = 0;    // dla millis
unsigned long roznicaCzasu1 = 0;       // dla millis

unsigned long zapamietanyCzas2 = 0;    // dla millis
unsigned long roznicaCzasu2 = 0;       // dla millis

bool F_sec = false;                    // sekundnik wyświetlacza TM1637 (:)

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- Aktualizuj Czas do Strukrury zegar ------------------------------------------------------------------------------------------ //
// --------------------------------------------------------------------------------------------------------------------------------- //

void AktualizujCzas()
{
    myRTC.updateTime();                               // pobierz czas z zegara

    zegar.godzina         =   myRTC.hours;            // pobierz i zapisz godzinę
    zegar.minuta          =   myRTC.minutes;          // pobierz i zapisz minutę
    zegar.sekunda         =   myRTC.seconds;          // pobierz i zapisz sekundę
    zegar.dzien           =   myRTC.dayofmonth;       // pobierz i zapisz dzień miesiąca
    zegar.dzien_tygodnia  =   myRTC.dayofweek;        // pobierz i zapisz dzień tygodnia
    zegar.miesiac         =   myRTC.month;            // pobierz i zapisz miesiąc
    zegar.rok             =   myRTC.year;             // pobierz i zapisz rok
}
// --------------------------------------------------------------------------------------------------------------------------------- //
// --- Aktualizuj Czas do Strukrury zegar ------------------------------------------------------------------------------------------ //
// --------------------------------------------------------------------------------------------------------------------------------- //

void WyswietlCzas()
{
    int clock;
    byte bufor;

    bufor = zegar.godzina / 10;       // (HH / 10)    - podziel, wyznacz część całkowitą (dziesiątki) godziny
    clock = 1000 * bufor;             // (Hh * 1000)  - zapisz Hx:xx

    bufor = zegar.godzina % 10;       // (HH % 10)    - reszcza z dzielenia, wyznacz część całkowitą (jedności) godziny
    clock = clock + (bufor * 100);    // (hH * 100)   - zapisz xH:xx

    bufor = zegar.minuta / 10;        // (MM / 10)    - podziel, wyznacz część całkowitą (dziesiątki) minuty
    clock = clock + (bufor * 10);     // (Mm * 10)    - zapisz xx:Mx

    bufor = zegar.minuta % 10;        // (MM % 10)    - reszcza z dzielenia, wyznacz część całkowitą (jedności) minuty
    clock = clock + (bufor * 1);      // (mM * 1)     - zapisz xx:xM

    if (F_sec)                                                           // jeśli flaga jest prawdziwa (true)
    {
        display.showNumberDecEx(clock, 0b11100000, true, 4, 0);          // wyświetl dwukropek między godziną a minutą
        F_sec = false;                                                   // przestaw flagę na fałszywą (false)
    }
    else                                                                 // jeśli flaga jest fałszywa (false)
    {
        display.showNumberDecEx(clock, 0b00000000, true, 4, 0);          // nie wyświetlaj dwukropka między godziną a minutą
        F_sec = true;                                                    // przestaw flagę na prawdziwą (true)
    }
}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- S E T    R T C -------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void setRTC()
{
    myRTC.setDS1302Time(0, 36, 9, 1, 17, 5, 2021);
}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- E X P A N D E R   I N I T    1 ---------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void ExpanderInit_1()
{
    expander1.begin();

    if (!expander1.begin())
    {
        #if SERIAL
            Serial.print(F("\n[SETUP] [EXPANDER] Nie udało się inicjować ---> EXPANDER 1 : 0x"));
            Serial.print(exp1_adres, HEX);
        #endif
    }
    if (!expander1.isConnected())
    {
        #if SERIAL
            Serial.print(F("\n[SETUP] [EXPANDER] Nie podłączono ---> EXPANDER 1 : 0x"));
            Serial.print(exp1_adres, HEX);
        #endif
    }
    else
    {
        #if SERIAL
            Serial.print(F("\n[SETUP] [EXPANDER] Udane połączenie ---> EXPANDER 1 : 0x"));
            Serial.print(exp1_adres, HEX);
        #endif
    }
}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- E X P A N D E R   I N I T    2 ---------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void ExpanderInit_2()
{
    expander2.begin();

    if (!expander2.begin())
    {
        #if SERIAL
            Serial.print(F("\n[SETUP] [EXPANDER] Nie udało się inicjować ---> EXPANDER 2 : 0x"));
            Serial.print(exp2_adres, HEX);
        #endif
    }
    if (!expander2.isConnected())
    {
        #if SERIAL
            Serial.print(F("\n[SETUP] [EXPANDER] Nie podłączono ---> EXPANDER 2 : 0x"));
            Serial.print(exp2_adres, HEX);
        #endif
    }
    else
    {
        #if SERIAL
            Serial.print(F("\n[SETUP] [EXPANDER] Udane połączenie ---> EXPANDER 2 : 0x"));
            Serial.print(exp2_adres, HEX);
        #endif
    }
}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- S E T U P ------------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void setup()
{
    #if SERIAL
        Serial.begin(SerialSpeed);
        Serial.print(F("[SETUP] [SERIAL] Serial Speed : "));
        Serial.print(SerialSpeed);
    #endif

    pinMode(A0,OUTPUT);                   // RTC Clock -> pin CLK
    pinMode(A1,OUTPUT);                   // RTC Clock -> pin DAT
    pinMode(A2,OUTPUT);                   // RTC Clock -> pin RST

    display.clear();
    display.setBrightness(7);

    #if RTC_SET
        setRTC();
    #endif

    pinMode(str_pin, OUTPUT);              // digital 4 OUT dla strobe (LED & KEY)
    pinMode(clk_pin, OUTPUT);              // digital 3 OUT dla clock (LED & KEY)
    pinMode(dat_pin, OUTPUT);              // digital 2 OIT dla data (LED & KEY)

    sendCommand(0x8f);                     // activate LED & KEY
    reset();                               // reset LED & KEY
    flash_LEDKEY();
    flash_LEDKEY();
    flash_LEDKEY();

    for(byte i = 0; i < 8; i++)
    {
        RelayTurnOff(i);                   // diody i wyświetlacz dla przekaźników OFF
        R_Status[i] = false;               // status przekaźników FALSE ( OFF )
    }

    ExpanderInit_1();
    ExpanderInit_2();


}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- L O O P --------------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void loop()
{

    aktualnyCzas = millis();

    roznicaCzasu1 = aktualnyCzas - zapamietanyCzas1;
    roznicaCzasu2 = aktualnyCzas - zapamietanyCzas2;

    // --- warunek wykonywany co 1 minutę ------------------------------------------------------- //

    if (roznicaCzasu2 >= 60000UL)                                 // wykonuj co minutę
    {
        AktualizujCzas();                                         // zapisz z zegara do struktury
        zapamietanyCzas2 = aktualnyCzas;                          // resetuj warunek
    }

    // --- warunek wykonywany co 1 sekundę ------------------------------------------------------ //

    if (roznicaCzasu1 >= 1000UL)                                 // wykonuj co 1 sekundę
    {
        WyswietlCzas();                                           // wyświetl czas na TM1637
        zapamietanyCzas1 = aktualnyCzas;                          // resetuj warunek
    }

    // ------------------------------------------------------------------------------------------ //

    przycisk = readButtons();

    switch (przycisk)
    {
        case      1   :   RelaySwitch(0);   break;
        case      2   :   RelaySwitch(1);   break;
        case      4   :   RelaySwitch(2);   break;
        case      8   :   RelaySwitch(3);   break;
        case     16   :   RelaySwitch(4);   break;
        case     32   :   RelaySwitch(5);   break;
        case     64   :   RelaySwitch(6);   break;
        case    128   :   RelaySwitch(7);   break;
        default       : break;

    }

    // ------------------------------------------------------------------------------------------ //
}

///////////////////////////////////////////////////////////////////////////////////////////////
//  RelaySwitch
///////////////////////////////////////////////////////////////////////////////////////////////

void RelaySwitch(byte nr)
{
    if ( R_Status[nr])
    {
        RelayTurnOff(nr);
        R_Status[nr] = false;
    }
    else
    if (!R_Status[nr])
    {
        RelayTurnOn(nr);
        R_Status[nr] = true;
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////
//  LED & KEY funckje startu
///////////////////////////////////////////////////////////////////////////////////////////////

void sendCommand(uint8_t value)
{
    digitalWrite(str_pin, LOW);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, value);
    digitalWrite(str_pin, HIGH);
}


///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////

void reset()
{
    sendCommand(0x40);
    digitalWrite(str_pin, LOW);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0xc0);       // reset od adresu 0

    for (uint8_t i = 0; i < 16; i++)                                                 // petla 16x
    {
        shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x00);   // 8x LED + 8x DIGIT reset
    }
    digitalWrite(str_pin, HIGH);
}

///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////

void flash_LEDKEY()
{
    for (uint8_t i = 0; i < 16; i++)                                   // zapal diody 1-8 z przerwą 100ms
    {
        if (i < 8) setLed(1, i);                                       // zapal diodę na pozycji i jesli i<8
        else setLed(0, i - 8);                                         // zgas diodę na pozycji i jeśli i>8
        delay(100);
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////

void setLed(uint8_t flaga, uint8_t adres)
{
    pinMode(dat_pin, OUTPUT);
    sendCommand(0x44);
    digitalWrite(str_pin, LOW);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, LED_adres[adres]);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, flaga);
    digitalWrite(str_pin, HIGH);
}

///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////

uint8_t readButtons(void)
{
    uint8_t buttons = 0;
    digitalWrite(str_pin, LOW);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x42);

    pinMode(dat_pin, INPUT);

    for (uint8_t i = 0; i < 4; i++)
    {
        uint8_t v = shiftInMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US) << i;
        buttons |= v;
    }

    pinMode(dat_pin, OUTPUT);
    digitalWrite(str_pin, HIGH);
    delay(200);
    return buttons;
}

///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////

void RelayTurnOff(byte adres)
{
    digitalWrite(str_pin, LOW);                                                                 // pin strobe na OFF
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adres]);    // ustaw adres
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x5c);                  // ustaw 0 (0x3f)
    digitalWrite(str_pin, HIGH);
    setLed(0, adres);
    expander1.write(adres, LOW);                                                                // wyłącz przekaźnik na expander1
}

///////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////

void RelayTurnOn(byte adres)
{
    digitalWrite(str_pin, LOW);                                                                 // pin strobe na OFF
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adres]);    // ustaw adres
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x63);                  // ustaw 1 (0x3f)
    digitalWrite(str_pin, HIGH);
    setLed(1, adres);
    expander1.write(adres, HIGH);                                                               // włącz przekaźnik na expander1
}