Nixie Uhr Code

A/*
  Скетч к проекту "Часы на ГРИ"
  Страница проекта (схемы, описания): https://alexgyver.ru/nixieclock/
  Исходники на GitHub: https://github.com/AlexGyver/nixieclock/
  Нравится, как написан код? Поддержи автора! https://alexgyver.ru/support_alex/
  Автор: AlexGyver Technologies, 2018
  https://AlexGyver.ru/

  1.2 - Einstellung "Rückwärtsanzeigen" für Karte auf IN-12 hinzugefügt
  1.3 - Einstellung zum Ausschalten der Temperaturanzeige hinzugefügt
*/
/*
  SET
    - im Überwachungsmodus gehalten - ALARM einstellen
    - im Alarmeinstellungsmodus gehalten - UHR-Einstellung
    - Doppelklicken Sie im Alarmmodus - kehren Sie zur Uhr zurück
    - in den Uhreinstellungen beibehalten - mit einer neuen Uhrzeit zur Uhr zurückkehren
    - Klicken Sie während des Setups auf - ändern Sie die Stunden- / Minuteneinstellungen
  ALARM
    - Ein / Aus-Alarm
*/
// ************************** DIE EINSTELLUNGEN **************************

#define BRIGHT 100          // Tageslichthelligkeit, %
#define BRIGHT_N 100        // Nachthelligkeit, %
#define NIGHT_START 23      // Stunde des Übergangs zur Nachtbeleuchtung (BRIGHT_N)
#define NIGHT_END 7         // Stundenschaltung auf Tageslicht (BRIGHT)
#define FREQ 900            // Alarmfrequenz
#define REVERSE_TUBES 0     // 1 - "Spiegeln" Sie die Zeitanzeige (für IN-12-Karte), 0 - Nr

#define SHOW_TEMP_HUM 0     // 0 - Temperatur und vl. nicht anzeigen, 1 - anzeigen
#define CLOCK_TIME 10       // Zeit (en), zu der die Uhr angezeigt wird
#define TEMP_TIME 5         // Zeit (en), die Temperatur und Luftfeuchtigkeit anzeigt
#define ALM_TIMEOUT 30      // Alarm-Timeout

// *********************** FÜR ENTWICKLER ***********************

#define BURN_TIME 200       // Bypass-Zeit im Reinigungsmodus
#define REDRAW_TIME 3000    // einstellige Zykluszeit, ms
#define ON_TIME 2200        // auf Zeit einer Ziffer, ms

// пины
#define PIEZO 3
#define DHT_PIN 2
#define ALARM 11

#define DECODER0 A0
#define DECODER1 A1
#define DECODER2 A2
#define DECODER3 A3

#define KEY0 4    // Punkt
#define KEY1 10   // часы
#define KEY2 9    // часы
#define KEY3 5    // Minute
#define KEY4 6    // Minute
#define KEY5 7    // Sekunde
#define KEY6 8    // Sekunde
#include "DHT.h"
DHT dht(DHT_PIN, DHT22);

#include "GyverTimer.h"
GTimer_us redrawTimer(REDRAW_TIME);
GTimer_ms modeTimer((long)CLOCK_TIME * 1000);
GTimer_ms dotTimer(500);
GTimer_ms blinkTimer(800);
GTimer_ms almTimer((long)ALM_TIMEOUT * 1000);

#include "GyverButton.h"
GButton btnSet(3, LOW_PULL, NORM_OPEN);
GButton btnUp(3, LOW_PULL, NORM_OPEN);
GButton btnDwn(3, LOW_PULL, NORM_OPEN);

#include <Wire.h>
#include "RTClib.h"
RTC_DS3231 rtc;

#include "EEPROMex.h"

#if (REVERSE_TUBES == 0)
int opts[] = {KEY0, KEY1, KEY2, KEY3, KEY4, KEY5, KEY6};
#else
int opts[] = {KEY6, KEY5, KEY4, KEY3, KEY2, KEY1, KEY0};
#endif

// ************************** DEFINIEREN DER WERTE **************************

byte counter;
byte digitsDraw[7];
boolean dotFlag;
int8_t hrs = 10, mins = 10, secs;
int8_t alm_hrs = 10, alm_mins = 10;
boolean indState;
int8_t mode = 0;    // 0 Uhr, 1 Temperatur, 2 Weckerstellung, 3 Uhreinstellung, 4 Wecker
boolean changeFlag;
boolean blinkFlag;
int on_time = ON_TIME;
boolean alm_flag;

void setup() {
  Serial.begin(9600);
  almTimer.stop();
  btnSet.setTimeout(400);
  btnSet.setDebounce(90);
  dht.begin();
  rtc.begin();
  if (rtc.lostPower()) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  DateTime now = rtc.now();
  secs = now.second();
  mins = now.minute();
  hrs = now.hour();

  pinMode(DECODER0, OUTPUT);
  pinMode(DECODER1, OUTPUT);
  pinMode(DECODER2, OUTPUT);
  pinMode(DECODER3, OUTPUT);
  pinMode(KEY0, OUTPUT);
  pinMode(KEY1, OUTPUT);
  pinMode(KEY2, OUTPUT);
  pinMode(KEY3, OUTPUT);
  pinMode(KEY4, OUTPUT);
  pinMode(KEY5, OUTPUT);
  pinMode(KEY6, OUTPUT);

  pinMode(PIEZO, OUTPUT);
  pinMode(ALARM, INPUT_PULLUP);

  if (EEPROM.readByte(100) != 66) {   // Überprüfen Sie den ersten Start
    EEPROM.writeByte(100, 66);
    EEPROM.writeByte(0, 0);     // Wecker
    EEPROM.writeByte(1, 0);     // Alarm
  }
  alm_hrs = EEPROM.readByte(0);
  alm_mins = EEPROM.readByte(1);

  sendTime();
  changeBright();
}

void sendTime() {
  digitsDraw[1] = (byte)hrs / 10;
  digitsDraw[2] = (byte)hrs % 10;

  digitsDraw[3] = (byte)mins / 10;
  digitsDraw[4] = (byte)mins % 10;

  digitsDraw[5] = (byte)secs / 10;
  digitsDraw[6] = (byte)secs % 10;
}

// ************************** TAG/NACHT WECHSEL **************************

void changeBright() {
  // Helligkeit ab Tageszeit einstellen
  if ( (hrs >= NIGHT_START && hrs <= 23)
       || (hrs >= 0 && hrs <= NIGHT_END) ) on_time = (float)ON_TIME * BRIGHT_N / 100;
  else on_time = (float)ON_TIME * BRIGHT / 100;
}

// ************************** UHRZEIT ANZEIGEN **************************

void loop() {
  if (redrawTimer.isReady()) showDigits();
  if (dotTimer.isReady() && (mode == 0 || mode == 1)) calculateTime();
  buttonsTick();
  if (SHOW_TEMP_HUM && !alm_flag) modeTick();
}

// ************************** KNOPFBELEGUNG **************************

void buttonsTick() {
  int analog = analogRead(7);

  btnSet.tick(analog <= 1023 && analog > 1000);
  btnUp.tick(analog <= 820 && analog > 690);
  btnDwn.tick(analog <= 280 && analog > 120);

  if (mode == 2 || mode == 3) {
    if (btnUp.isClick()) {
      if (mode == 2) {
        if (!changeFlag) {
          alm_mins++;
          if (alm_mins > 59) {
            alm_mins = 0;
            alm_hrs++;
          }
          if (alm_hrs > 23) alm_hrs = 0;
        } else {
          alm_hrs++;
          if (alm_hrs > 23) alm_hrs = 0;
        }
      } else {
        if (!changeFlag) {
          mins++;
          if (mins > 59) {
            mins = 0;
            hrs++;
          }
          if (hrs > 23) hrs = 0;
        } else {
          hrs++;
          if (hrs > 23) hrs = 0;
        }
      }
    }

    if (btnDwn.isClick()) {
      if (mode == 2) {
        if (!changeFlag) {
          alm_mins--;
          if (alm_mins < 0) {
            alm_mins = 59;
            alm_hrs--;
          }
          if (alm_hrs < 0) alm_hrs = 23;
        } else {
          alm_hrs--;
          if (alm_hrs < 0) alm_hrs = 23;
        }
      } else {
        if (!changeFlag) {
          mins--;
          if (mins < 0) {
            mins = 59;
            hrs--;
          }
          if (hrs < 0) hrs = 23;
        } else {
          hrs--;
          if (hrs < 0) hrs = 23;
        }
      }
    }

    if (blinkTimer.isReady()) {
      if (blinkFlag) blinkTimer.setInterval(800);
      else blinkTimer.setInterval(200);
      blinkFlag = !blinkFlag;
    }

    if (mode == 2) {
      digitsDraw[1] = alm_hrs / 10;
      digitsDraw[2] = alm_hrs % 10;
      digitsDraw[3] = alm_mins / 10;
      digitsDraw[4] = alm_mins % 10;
    } else {
      digitsDraw[1] = hrs / 10;
      digitsDraw[2] = hrs % 10;
      digitsDraw[3] = mins / 10;
      digitsDraw[4] = mins % 10;
    }

    digitsDraw[5] = 0;  // Sekunde
    digitsDraw[6] = 0;  // Sekunde

    if (blinkFlag) {      // glühen
      if (changeFlag) {
        digitsDraw[1] = 10;
        digitsDraw[2] = 10;
      } else {
        digitsDraw[3] = 10;
        digitsDraw[4] = 10;
      }
    }
  }

  if (mode == 1 && btnSet.isClick()) {
    mode = 0;
    modeTimer.setInterval((long)CLOCK_TIME * 1000);
  }

  if (mode == 0 && btnSet.isHolded()) {
    mode = 2;
  }

  if (mode == 2 && btnSet.isHolded()) {
    mode = 3;
  }

  if (mode == 2 && btnSet.isDouble()) {
    sendTime();

    EEPROM.updateByte(0, alm_hrs);
    EEPROM.updateByte(1, alm_mins);
    mode = 0;
    modeTimer.setInterval((long)CLOCK_TIME * 1000);
  }

  if (mode == 3 && btnSet.isHolded()) {
    sendTime();
    mode = 0;
    secs = 0;
    EEPROM.updateByte(0, alm_hrs);
    EEPROM.updateByte(1, alm_mins);
    rtc.adjust(DateTime(2014, 1, 21, hrs, mins, 0));

    changeBright();
    modeTimer.setInterval((long)CLOCK_TIME * 1000);
  }

  if ((mode == 2 || mode == 3) && btnSet.isClick()) {
    changeFlag = !changeFlag;
  }

}

// ************************** TEMPERATUR UND LUFTFEUCHTIGKEIT MESSEN **************************

void modeTick() {
  if (modeTimer.isReady()) {
    if (mode == 0) {
      for (byte i = 1; i < 7; i++) digitsDraw[i] = 10;
      mode = 1;
      dotFlag = false;
      byte temp = dht.readTemperature();
      byte hum = dht.readHumidity();
      digitsDraw[1] = temp / 10;
      digitsDraw[2] = temp % 10;
      digitsDraw[3] = 10;
      digitsDraw[4] = 10;
      digitsDraw[5] = hum / 10;
      digitsDraw[6] = hum % 10;
      modeTimer.setInterval((long)TEMP_TIME * 1000);
    } else if (mode == 1) {
      for (byte i = 1; i < 7; i++) digitsDraw[i] = 10;
      mode = 0;
      modeTimer.setInterval((long)CLOCK_TIME * 1000);
    }
  }
}

// ************************** UHRZEIT ERRECHNEN UND SYNCHRONISIEREN **************************

void calculateTime() {
  dotFlag = !dotFlag;
  if (dotFlag) {
    secs++;

    if (secs > 59) {
      secs = 0;
      mins++;

      if (mins == 1 || mins == 30) {      // jede halbe Stunde
        burnIndicators();                 // sauber sauber!
        DateTime now = rtc.now();         // Synchronisation mit RTC
        secs = now.second();
        mins = now.minute();
        hrs = now.hour();
      }

      if (!alm_flag && alm_mins == mins && alm_hrs == hrs && !digitalRead(ALARM)) {
        mode = 0;
        alm_flag = true;
        almTimer.start();
        almTimer.reset();
      }
    }
    if (mins > 59) {
      mins = 0;
      hrs++;
      if (hrs > 23) hrs = 0;
      changeBright();
    }


    if (mode == 0) sendTime();

    if (alm_flag) {
      if (almTimer.isReady() || digitalRead(ALARM)) {
        alm_flag = false;
        almTimer.stop();
        mode = 0;
        noTone(PIEZO);
        modeTimer.setInterval((long)CLOCK_TIME * 1000);
      }
    }
  }

  // bei Alarm blinken
  if (alm_flag) {
    if (!dotFlag) {
      noTone(PIEZO);
      for (byte i = 1; i < 7; i++) digitsDraw[i] = 10;
    } else {
      tone(PIEZO, FREQ);
      sendTime();
    }
  }

}

void burnIndicators() {
  for (byte ind = 0; ind < 7; ind++) {
    digitalWrite(opts[ind], 1);
  }
  for (byte dig = 0; dig < 10; dig++) {
    setDigit(dig);
    delayMicroseconds(BURN_TIME);
  }
}

void showDigits() {
  if (indState) {
    indState = false;
    redrawTimer.setInterval(on_time);   // Ordnen Sie den Timer neu an, sodass viele Anzeigen leuchten
    counter++;                          // der Zähler läuft durch die Anzeigen (0 - 6)
    if (counter > 6) counter = 0;

    if (counter != 0) {                   // wenn dies nicht der Punkt ist
      setDigit(digitsDraw[counter]);      // Zeigen Sie die NUMMER in ihrer ANZEIGE an
      digitalWrite(opts[counter], 1);     // Schalten Sie die aktuelle Anzeige ein
    } else {                              // wenn es ein Punkt ist
      if (dotFlag)
        if (mode != 1) digitalWrite(opts[counter], 1);   // Schalten Sie den Punkt ein
        else
          digitalWrite(opts[counter], 0);   // Schalten Sie den Punkt aus
    }

  } else {
    indState = true;
    digitalWrite(opts[counter], 0);                 // Schalten Sie die aktuelle Anzeige aus
    //setDigit(10);
    redrawTimer.setInterval(REDRAW_TIME - on_time); // Ordnen Sie den Timer neu an, so dass viele Anzeigen ausgeschaltet sind
  }
}

// konfigurieren den Decoder gemäß der angezeigten DIGIT
void setDigit(byte digit) {
  switch (digit) {
    case 0: setDecoder(0, 0, 0, 0);
      break;
    case 1: setDecoder(1, 0, 0, 0);
      break;
    case 2: setDecoder(0, 0, 1, 0);
      break;
    case 3: setDecoder(1, 0, 1, 0);
      break;
    case 4: setDecoder(0, 0, 0, 1);
      break;
    case 5: setDecoder(1, 0, 0, 1);
      break;
    case 6: setDecoder(0, 0, 1, 1);
      break;
    case 7: setDecoder(1, 0, 1, 1);
      break;
    case 8: setDecoder(0, 1, 0, 0);
      break;
    case 9: setDecoder(1, 1, 0, 0);
      break;
    case 10: setDecoder(0, 1, 1, 1);    // Ziffer ausschalten!
      break;
  }
}

// Decoder-Setup-Funktion
void setDecoder(boolean dec0, boolean dec1, boolean dec2, boolean dec3) {
  digitalWrite(DECODER0, dec0);
  digitalWrite(DECODER1, dec1);
  digitalWrite(DECODER2, dec2);
  digitalWrite(DECODER3, dec3);
}