7segmUhr

#include <ESP8266WiFi.h>                    //https://github.com/esp8266/Arduino
#include "WiFiManager.h"                    //https://github.com/tzapu/WiFiManager
#include <Timezone.h>                       //https://github.com/JChristensen/Timezone
#include <TimeLib.h>                        //https://github.com/PaulStoffregen/Time
#include <WiFiUdp.h>
#include <Wire.h>
#include <Servo.h>

int h, m, s, w, mo, ye, d;                  // variablen für die lokale Zeit

// NTP Serverpool für die Schweiz:
static const char ntpServerName[] = "ch.pool.ntp.org";    //Finde lokale Server unter http://www.pool.ntp.org/zone/ch
const int timeZone = 0;                     // 0 wenn mit <Timezone.h> gearbeitet wird sonst stimmt es nachher nicht
WiFiUDP Udp;
unsigned int localPort = 8888;              // lokaler Port zum Abhören von UDP-Paketen

time_t getNtpTime();
void digitalClockDisplay();
void printDigits(int digits);
void sendNTPpacket(IPAddress &address);

// - Timezone. - //
// Bearbeiten Sie diese Zeilen entsprechend Ihrer Zeitzone und Sommerzeit.
// TimeZone Einstellungen Details https://github.com/JChristensen/Timezone
TimeChangeRule CEST = {"CEST", Last, Sun, Mar, 2, 120};     //Central European Time (Frankfurt, Paris)
TimeChangeRule CET = {"CET ", Last, Sun, Oct, 3, 60};       //Central European Time (Frankfurt, Paris)
Timezone CE(CEST, CET);

Servo secondsOnes;
Servo secondsTens;
Servo minutesOnes;
Servo minutesTens;
Servo hoursOnes;
Servo hoursTens;

String inString = "";

void setup() {
  Serial.begin(115200);
  WiFiManager wifiManager;
  //wifiManager.resetSettings();          //mit diesem befehl kannst die gespeicherten werte löschen
  wifiManager.autoConnect("clock");
  Serial.println("verbunden!");
  Udp.begin(localPort);
  Serial.print("lokaler Port: ");
  Serial.println(Udp.localPort());
  Serial.println("Warten auf die Synchronisation");
  setSyncProvider(getNtpTime);
  setSyncInterval(86400);                    // Anzahl der Sekunden zwischen dem erneuten Synchronisieren ein. 86400 = 1 Tag

// secondsOnes.write(0);
 // secondsTens.write(0);
  minutesOnes.write(0);
  minutesTens.write(0);
  hoursOnes.write(0);
  hoursTens.write(0);

  //secondsOnes.attach(2);
 // secondsTens.attach(3);
  minutesOnes.attach(D2);
  minutesTens.attach(D3);
  hoursOnes.attach(D4);
  hoursTens.attach(D5);

  Wire.begin();
  delay(500);
  Serial.println("Seven Segment Clock Begin");
}

time_t prevDisplay = 0; // wenn die Digitaluhr angezeigt wurde

void loop()
{
  if (timeStatus() != timeNotSet) {             // wenn die Zeit über NTP gesetzt wurde
  lokaleZeit();
  digitalClockDisplay();
  delay(1000);

  //Split the secondss into Tens and Ones
  int curSecsTens = second()/10;
  int curSecsOnes = second()%10;
  //Convert it into angles
  int curSecsTensAngle = curSecsTens * 20;
  int curSecsOnesAngle = curSecsOnes * 20;
  //Write Seconds Motors
  secondsTens.write(curSecsTensAngle);
  secondsOnes.write(curSecsOnesAngle);

  //Split the Minutes into Tens and Ones
  int curMinsTens = minute()/10;
  int curMinsOnes = minute()%10;
  //Convert it into angles
  int curMinsTensAngle = curMinsTens * 20;
  int curMinsOnesAngle = curMinsOnes * 20;
  //Write Minutes Motors
  minutesTens.write(curMinsTensAngle);
  minutesOnes.write(curMinsOnesAngle);


  //Split the hours into Tens and Ones
  int curHoursTens = hour()/10;
  int curHoursOnes = hour()%10;
  //Convert it into angles
  int curHoursTensAngle = curHoursTens * 20;
  int curHoursOnesAngle = curHoursOnes * 20;
  //Write Hours Motors
  hoursTens.write(curHoursTensAngle);
  hoursOnes.write(curHoursOnesAngle);

  }
}


void lokaleZeit()
{
  time_t tT = now();
  time_t tTlocal = CE.toLocal(tT);
  w = weekday(tTlocal);
  d = day(tTlocal);
  mo = month(tTlocal);
  ye = year(tTlocal);
  h = hour(tTlocal);
  m = minute(tTlocal);
  s = second(tTlocal);

}

void digitalClockDisplay()
{
  // digitale Uhrzeitanzeige
  Serial.print(h);
  printDigits(m);
  printDigits(s);
  Serial.print(" ");
  Serial.print(d);
  Serial.print(".");
  Serial.print(mo);
  Serial.print(".");
  Serial.println(ye);
}

void printDigits(int digits)
{
  // Utility für digitale Uhrenanzeige: druckt vor Doppelpunkt und führende 0
  Serial.print(":");
  if (digits < 10)
    Serial.print('0');
  Serial.print(digits);
}

/*-------- NTP code ----------*/

const int NTP_PACKET_SIZE = 48; // NTP-Zeit in den ersten 48 Bytes der Nachricht
byte packetBuffer[NTP_PACKET_SIZE]; //Puffer für eingehende und ausgehende Pakete

time_t getNtpTime()
{
  IPAddress ntpServerIP; // NTP server's ip Adresse

  while (Udp.parsePacket() > 0) ; // alle zuvor empfangenen Pakete verwerfen
  Serial.println("Transmit NTP Request");
  // einen zufälligen Server aus dem Pool holen
  WiFi.hostByName(ntpServerName, ntpServerIP);
  Serial.print(ntpServerName);
  Serial.print(": ");
  Serial.println(ntpServerIP);
  sendNTPpacket(ntpServerIP);
  uint32_t beginWait = millis();
  while (millis() - beginWait < 1500) {
    int size = Udp.parsePacket();
    if (size >= NTP_PACKET_SIZE) {
      Serial.println("Receive NTP Response");
      Udp.read(packetBuffer, NTP_PACKET_SIZE);  // Paket in den Puffer einlesen
      unsigned long secsSince1900;
      // vier Bytes ab Position 40 in eine lange Ganzzahl umwandeln
      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
      secsSince1900 |= (unsigned long)packetBuffer[43];
      return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
    }
  }
  Serial.println("keine NTP Antwort");
  return 0; // gibt 0 zurück, wenn die Zeit nicht ermittelt werden kann.
}

// send an NTP request to the time server at the given address
void sendNTPpacket(IPAddress &address)
{
  // alle Bytes im Puffer auf 0 setzen
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialisieren von Werten, die für die Bildung von NTP-Requests benötigt werden.
  // (siehe URL oben für Details zu den Paketen)
  packetBuffer[0] = 0b11100011;   // LI, Version, Mode
  packetBuffer[1] = 0;     // Stratum, or type of clock
  packetBuffer[2] = 6;     // Polling Interval
  packetBuffer[3] = 0xEC;  // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12] = 49;
  packetBuffer[13] = 0x4E;
  packetBuffer[14] = 49;
  packetBuffer[15] = 52;
  // alle NTP-Felder wurden jetzt mit Werten versehen
  // Sie können ein Paket senden, das einen Zeitstempel anfordert.:
  Udp.beginPacket(address, 123); //NTP-Requests sollen auf Port 123 erfolgen
  Udp.write(packetBuffer, NTP_PACKET_SIZE);
  Udp.endPacket();
}