Chaospott/seven-segment-clock
43
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Code format

Browse Source
This commit is contained in:
T
2025-09-04 16:55:08 +02:00
parent f148cd1119
commit f0c9056cdc
3 changed files with 454 additions and 486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
.pio/

429
src/fooclock.ino
View File

@@ -1,35 +1,32 @@
#include <TimeLib.h> #include <TimeLib.h>
#include <Ethernet.h> #include <Ethernet.h>
#include <EthernetUdp.h>
#include <SPI.h> #include <SPI.h>
#include <TimerOne.h> #include <TimerOne.h>
#define A 0 #define _A 0
#define B 1 #define _B 1
#define C 2 #define _C 2
#define D 3 #define _E 4
#define E 4 #define _G 6
#define F 5 #define _H 7
#define G 6 #define _I 8
#define H 7 #define _J 9
#define I 8 #define _K 10
#define J 9 #define _L 11
#define K 10 #define _M 12
#define L 11 #define _N 13
#define M 12 #define _O 14
#define N 13 #define _P 15
#define O 14 #define _Q 16
#define P 15 #define _R 17
#define Q 16 #define _S 18
#define R 17 #define _T 19
#define S 18 #define _U 20
#define T 19 #define _V 21
#define U 20 #define _W 22
#define V 21 #define _X 23
#define W 22 #define _Y 24
#define X 23 #define _Z 25
#define Y 24
#define Z 25
#define UP 1 #define UP 1
#define DOWN 2 #define DOWN 2
@@ -39,12 +36,11 @@
// ---------------------------------- Definition of Global Variables -------------------------- // // ---------------------------------- Definition of Global Variables -------------------------- //
byte mac[] = { byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
// NTP Servers: // NTP Servers:
IPAddress timeServer(132, 163, 4, 101); // time-a.timefreq.bldrdoc.gov IPAddress timeServer(132, 163, 96, 1); // time-a.timefreq.bldrdoc.gov
// IPAddress timeServer(132, 163, 4, 102); // time-b.timefreq.bldrdoc.gov // IPAddress timeServer(132, 163, 96, 2); // time-b.timefreq.bldrdoc.gov
// IPAddress timeServer(132, 163, 4, 103); // time-c.timefreq.bldrdoc.gov // IPAddress timeServer(132, 163, 96, 3); // time-c.timefreq.bldrdoc.gov
//const int timeZone = 1; // Central European Time //const int timeZone = 1; // Central European Time
@@ -62,9 +58,9 @@ bool second_changed = false;
bool init_done = false; bool init_done = false;
bool transition_active = false; bool transition_active = false;
bool swipe_active = false; bool swipe_active = false;
bool shrink_active = false; // Maybe we should move them to a single variable an set or unset bits inside the variable bool shrink_active = false; // Maybe we should move them to a single variable and set or unset bits inside the variable
int cur_update = 0; int cur_update = 0;
int shift_state = 0; unsigned int shift_state = 0;
int update_counter = 0; int update_counter = 0;
int spinner_pos = 0; int spinner_pos = 0;
int animation = 0; int animation = 0;
@@ -99,20 +95,19 @@ int dataPin = 5;
int duration = 10; int duration = 10;
int digits[10] = { int digits[10] = {
238, //0 0xEE 238, // 0 0xEE
34, //1 0x22 34, // 1 0x22
214, //2 0xD6 214, // 2 0xD6
118, //3 0x76 118, // 3 0x76
58, //4 0x3A 58, // 4 0x3A
124, //5 0x7C 124, // 5 0x7C
252, //6 0xFC 252, // 6 0xFC
38, //7 0x26 38, // 7 0x26
254, //8 0xFE 254, // 8 0xFE
126 //9 0x7E 126 // 9 0x7E
}; };
int letter [26] = { int letter[26] = {
191, // A 191, // A
248, // b 248, // b
204, // C 204, // C
@@ -141,24 +136,23 @@ int letter [26] = {
214, // Z 214, // Z
}; };
int frame [6] = { int frame[6] = {
0,letter[T],letter[R],letter[A],letter[T],letter[S] // Display "Start" (write from right to left into the array) 0, letter[_T], letter[_R], letter[_A], letter[_T], letter[_S] // Display "Start" (write from right to left into the array)
}; };
int today [7] = { int today[7] = {
184,220,200,200,240,0,0 // Display "Hello" 184, 220, 200, 200, 240, 0, 0 // Display "Hello"
}; };
// ----------------------------------- Setup Code ---------------------------------------------- // // ----------------------------------- Setup Code ---------------------------------------------- //
void setup() void setup() {
{ pinMode(OutputEnable, OUTPUT);
pinMode (OutputEnable, OUTPUT); pinMode(latchPin, OUTPUT);
pinMode (latchPin, OUTPUT); pinMode(clockPin, OUTPUT);
pinMode (clockPin, OUTPUT); pinMode(dataPin, OUTPUT);
pinMode (dataPin, OUTPUT);
analogWrite(OutputEnable,light_lvl_standard); analogWrite(OutputEnable,light_lvl_standard);
Timer1.initialize(1000); // initialize timer1, and set a 1 milli second period Timer1.initialize(1000); // initialize timer1, and set a 1 millisecond period
Timer1.attachInterrupt(updateDisplay); // attaches callback() as a timer overflow interrupt Timer1.attachInterrupt(updateDisplay); // attaches callback() as a timer overflow interrupt
Serial.begin(9600); Serial.begin(9600);
@@ -173,51 +167,48 @@ void setup()
} }
// -------------------------------------- Main Loop ------------------------------------------------- // // -------------------------------------- Main Loop ------------------------------------------------- //
void loop() void loop() {
{
time_t timestamp = now(); time_t timestamp = now();
//Sync blinking with second change // Sync blinking with second change
if(cur_time != timestamp && !second_changed){ if (cur_time != timestamp && !second_changed) {
update_counter = 0; update_counter = 0;
cur_time = timestamp; cur_time = timestamp;
second_changed = true; second_changed = true;
} }
int intervalpos = timestamp%70; int intervalpos = timestamp % 70;
if( intervalpos == 0){ if (intervalpos == 0) {
update_done = false; update_done = false;
} }
if (intervalpos < 10){ if (intervalpos < 10) {
switch (animation) switch (animation) {
{ case 0: transition(today);
case 0:transition(today);
break; break;
case 1:combine(today); case 1: combine(today);
break; break;
case 2:swipe(UP,today); case 2: swipe(UP, today);
break; break;
case 3:swipe(DOWN, today); case 3: swipe(DOWN, today);
break; break;
case 4:shrink(UP, today); case 4: shrink(UP, today);
break; break;
case 5:shrink(DOWN, today); case 5: shrink(DOWN, today);
break; break;
default:displayDate(timestamp); default: displayDate(timestamp);
break; break;
} }
//shrink(DOWN,today); // shrink(DOWN,today);
//transition(today); // transition(today);
//combine(today); // combine(today);
//swipe(UP,today); // swipe(UP,today);
//displayDate(timestamp); // displayDate(timestamp);
} } else if (intervalpos > 20 && intervalpos < 30) {
else if (intervalpos > 20 && intervalpos < 30){
displayBinaryTime(timestamp); displayBinaryTime(timestamp);
}else{ } else {
displayTime(timestamp); displayTime(timestamp);
} }
if(intervalpos == 50 && !update_done){ if (intervalpos == 50 && !update_done) {
update_done = true; update_done = true;
transition_active = false; transition_active = false;
swipe_active = false; swipe_active = false;
@@ -225,32 +216,28 @@ void loop()
shift_state = 0; shift_state = 0;
updateDate(timestamp); updateDate(timestamp);
animation = (int) (rand() % 6); animation = rand() % 6;
} }
// Blinkenfoo - comment to remove pulsating light // Blinkenfoo - comment to remove pulsating light
if(update_counter < (light_lvl_risen-light_lvl_standard) && timestamp%600 == 0 ){ if (update_counter < (light_lvl_risen - light_lvl_standard) && timestamp % 600 == 0) {
dim(UP,light_lvl_standard,light_lvl_risen); dim(UP,light_lvl_standard,light_lvl_risen);
} }
if(update_counter > (1000 - (light_lvl_risen - light_lvl_standard)) && timestamp%600 == 0 ){ if (update_counter > (1000 - (light_lvl_risen - light_lvl_standard)) && timestamp % 600 == 0) {
dim(DOWN,light_lvl_standard,light_lvl_risen); dim(DOWN,light_lvl_standard,light_lvl_risen);
} }
if(update_counter == 900){ if (update_counter == 900) {
second_changed = true; second_changed = true;
} }
} }
// ---------------------- Interrupt Handler (Timer1) ------------------- // // ---------------------- Interrupt Handler (Timer1) ------------------- //
void updateDisplay () void updateDisplay() {
{
// take the latchPin low so // take the latchPin low so
// the LEDs don't flicker while you're sending in bits: // the LEDs don't flicker while you're sending in bits:
digitalWrite(latchPin, LOW); digitalWrite(latchPin, LOW);
for(int digitCount=5; digitCount>=0; digitCount--) for (int digitCount = 5; digitCount >= 0; digitCount--) {
{
shiftOut(dataPin, clockPin, MSBFIRST, frame[digitCount]); shiftOut(dataPin, clockPin, MSBFIRST, frame[digitCount]);
} }
//take the latch pin high so the LEDs will light up again: //take the latch pin high so the LEDs will light up again:
@@ -258,135 +245,134 @@ void updateDisplay ()
update_counter++; update_counter++;
if(update_counter == 1000){ if (update_counter == 1000) {
update_counter = 0; update_counter = 0;
} }
if(!init_done){ if (!init_done) {
if(update_counter % 100 == 0){ if (update_counter % 100 == 0) {
spin(0); spin(0);
} }
} }
} }
// -------------------------------- Date Functions ---------------------- // // -------------------------------- Date Functions ---------------------- //
void updateDate(time_t t) void updateDate(time_t t) {
{ today[0] = digits[(day(t) / 10)];
today[0] = digits[(day(t) /10)]; today[1] = digits[(day(t) % 10)] + 1;
today[1] = digits[(day(t) %10)]+1;
today[2] = digits[(month(t) /10)]; today[2] = digits[(month(t) / 10)];
today[3] = digits[(month(t) %10)]+1; today[3] = digits[(month(t) % 10)] + 1;
today[4] = digits[((year(t)-2000) /10)]; today[4] = digits[((year(t) - 2000) / 10)];
today[5] = digits[((year(t)-2000) %10)]; today[5] = digits[((year(t) - 2000) % 10)];
} }
void displayDate(time_t t) void displayDate(time_t t) {
{ frame[5] = digits[(day(t) / 10)];
frame[5] = digits[(day(t) /10 )]; frame[4] = digits[(day(t) % 10)] + 1;
frame[4] = digits[(day(t) %10 )]+1;
frame[3] = digits[(month(t) /10 )]; frame[3] = digits[(month(t) / 10)];
frame[2] = digits[(month(t) %10 )]+1; frame[2] = digits[(month(t) % 10)] + 1;
frame[1] = digits[((year(t)-2000) /10 )]; frame[1] = digits[((year(t) - 2000) / 10)];
frame[0] = digits[((year(t)-2000) %10 )]; frame[0] = digits[((year(t) - 2000) % 10)];
} }
// ------------------------------- Time Functions -------------------- // // ------------------------------- Time Functions -------------------- //
void displayTime(time_t t) void displayTime(time_t t) {
{ frame[5] = digits[(hour(t) / 10)];
frame[5] = digits[(hour(t) /10)]; frame[4] = digits[(hour(t) % 10)];
frame[4] = digits[(hour(t) %10)];
frame[3] = digits[(minute(t) /10)]; frame[3] = digits[(minute(t) / 10)];
frame[2] = digits[(minute(t) %10)]; frame[2] = digits[(minute(t) % 10)];
frame[1] = digits[(second(t) /10)]; frame[1] = digits[(second(t) / 10)];
frame[0] = digits[(second(t) %10)]; frame[0] = digits[(second(t) % 10)];
} }
void displayBinaryTime(time_t t) void displayBinaryTime(time_t t) {
{
int digit; int digit;
for(int digitCount=5; digitCount>=0; digitCount--) for (int digitCount = 5; digitCount >= 0; digitCount--) {
{ // digit zusammenbauen und dann invertieren
//digit zusammenbauen und dann invertieren
digit = 0; digit = 0;
digit |= ((hour(t) & (1 << digitCount))>>digitCount)<<2; digit |= ((hour(t) & (1 << digitCount)) >> digitCount) << 2;
digit |= ((minute(t) & (1 << digitCount))>>digitCount)<<4; digit |= ((minute(t) & (1 << digitCount)) >> digitCount) << 4;
digit |= ((second(t) & (1 << digitCount))>>digitCount)<<6; digit |= ((second(t) & (1 << digitCount)) >> digitCount) << 6;
//bitWrite(digit,2,(bitRead(hour(t), digitCount)) ); // bitWrite(digit,2,(bitRead(hour(t), digitCount)) );
//bitWrite(digit,4,(bitRead(minute(t), digitCount)) ); // bitWrite(digit,4,(bitRead(minute(t), digitCount)) );
//bitWrite(digit,6,(bitRead(second(t), digitCount)) ); // bitWrite(digit,6,(bitRead(second(t), digitCount)) );
frame[digitCount]= digit; frame[digitCount] = digit;
} }
} }
// ----------------------------------- System Functions ----------------------------------- // // ----------------------------------- System Functions ----------------------------------- //
void dim(int direction, int lower_limit, int upper_limit){ void dim(int direction, int lower_limit, int upper_limit) {
int range = upper_limit - lower_limit; int range = upper_limit - lower_limit;
int shift_start = 1000 - range; int shift_start = 1000 - range;
int write_out = 0; int write_out = 0;
int local_counter = 0; int local_counter = 0;
if(update_counter > range){ if (update_counter > range) {
local_counter = update_counter - shift_start; local_counter = update_counter - shift_start;
} } else {
else{
local_counter = update_counter; local_counter = update_counter;
} }
if(direction == DOWN && local_counter % range <= range ){ if (direction == DOWN && local_counter % range <= range) {
write_out = 255 - (upper_limit - (local_counter) % range); write_out = 255 - (upper_limit - (local_counter) % range);
analogWrite(OutputEnable, write_out); analogWrite(OutputEnable, write_out);
Serial.println("Down ->"); Serial.println("Down ->");
Serial.println(write_out); Serial.println(write_out);
} else{ } else {
write_out = 255 - (lower_limit + (local_counter % range) ); write_out = 255 - (lower_limit + (local_counter % range));
analogWrite(OutputEnable, write_out); analogWrite(OutputEnable, write_out);
Serial.println("UP ->"); Serial.println("UP ->");
Serial.println(write_out); Serial.println(write_out);
} }
} }
void spin(int digit){ void spin(int digit) {
if(spinner_pos >= 6)spinner_pos = 0; if (spinner_pos >= 6)spinner_pos = 0;
switch (spinner_pos){ switch (spinner_pos) {
case 0: frame[digit] = 4; break; case 0: frame[digit] = 4;
case 1: frame[digit] = 2; break; break;
case 2: frame[digit] = 32; break; case 1: frame[digit] = 2;
case 3: frame[digit] = 64; break; break;
case 4: frame[digit] = 128; break; case 2: frame[digit] = 32;
case 5: frame[digit] = 8; break; break;
default: frame[digit] = 0; break; case 3: frame[digit] = 64;
break;
case 4: frame[digit] = 128;
break;
case 5: frame[digit] = 8;
break;
default: frame[digit] = 0;
break;
} }
spinner_pos ++; spinner_pos++;
}; };
void shrink(int direction, int* new_data){ void shrink(int direction, int *new_data) {
static int j = 0; static int j = 0;
static int height = 0; static int height = 0;
int bitmask = 0; int bitmask = 0;
if(shrink_active == false){ if (shrink_active == false) {
shrink_active = true; shrink_active = true;
j = 0; j = 0;
if(direction == UP){ if (direction == UP) {
height = 2; height = 2;
} } else {
else{
height = 0; height = 0;
} }
} }
switch (height) switch (height) {
{
case 0: bitmask = 0x44; case 0: bitmask = 0x44;
break; break;
case 1: bitmask = 0xAA; case 1: bitmask = 0xAA;
@@ -397,57 +383,53 @@ void shrink(int direction, int* new_data){
break; break;
} }
if(update_counter % 100 == 0 && j < 7){ if (update_counter % 100 == 0 && j < 7) {
if(j < 3){ if (j < 3) {
for(int digit= 0; digit < 6; digit++){ for (int digit = 0; digit < 6; digit++) {
frame[digit] &= ~bitmask; frame[digit] &= ~bitmask;
} }
if(direction == DOWN){ if (direction == DOWN) {
height++; height++;
} } else {
else{
height--; height--;
} }
Serial.print("Shrink.J = "); Serial.print("Shrink.J = ");
Serial.println(j); Serial.println(j);
} } else {
else{ for (int digit = 0; digit < 6; digit++) {
for(int digit= 0; digit < 6; digit++){ frame[5 - digit] |= new_data[digit] & bitmask;
frame[5-digit] |= new_data[digit] & bitmask;
} }
if(direction == DOWN){ if (direction == DOWN) {
height--; height--;
} } else {
else{
height++; height++;
} }
Serial.print("Shrink.J = "); Serial.print("Shrink.J = ");
Serial.println(j); Serial.println(j);
} }
j++; j++;
} }
} }
void swipe(int direction, int* new_data){ void swipe(int direction, int *new_data) {
static int j = 0; static int j = 0;
static int height = 0; static int height = 0;
int bitmask = 0; int bitmask = 0;
if(swipe_active == false){ if (swipe_active == false) {
swipe_active = true; swipe_active = true;
j = 0; j = 0;
if(direction == UP){ if (direction == UP) {
height = 4; height = 4;
}else{ } else {
height = 0; height = 0;
} }
} }
switch(height){ switch (height) {
case 0: bitmask = 0x04; case 0: bitmask = 0x04;
break; break;
case 1: bitmask = 0x0A; case 1: bitmask = 0x0A;
@@ -463,115 +445,103 @@ void swipe(int direction, int* new_data){
} }
if(update_counter % 60 == 0 && j < 11){ if (update_counter % 60 == 0 && j < 11) {
if(j < 5){ if (j < 5) {
for(int digit= 0; digit < 6; digit++){ for (int digit = 0; digit < 6; digit++) {
frame[digit] &= ~bitmask; frame[digit] &= ~bitmask;
} }
if(direction == DOWN){ if (direction == DOWN) {
height++; height++;
} } else {
else{
height--; height--;
} }
Serial.print("Swipe. J = "); Serial.print("Swipe. J = ");
Serial.println(j); Serial.println(j);
} } else {
else{ for (int digit = 0; digit < 6; digit++) {
for(int digit= 0; digit < 6; digit++){ frame[5 - digit] |= new_data[digit] & bitmask;
frame[5-digit] |= new_data[digit] & bitmask;
} }
if(direction == DOWN){ if (direction == DOWN) {
height--; height--;
} } else {
else{
height++; height++;
} }
Serial.print("Swipe. J = "); Serial.print("Swipe. J = ");
Serial.println(j); Serial.println(j);
} }
j++; j++;
} }
}; };
void combine(int* a){ void combine(int *a) {
static int i = 0; static int i = 0;
static int j = 0; static int j = 0;
int current [6]; int current[6];
if(transition_active == false){ if (transition_active == false) {
transition_active = true; transition_active = true;
memcpy(current,frame,6*sizeof(int)); memcpy(current, frame, 6 * sizeof(int));
j = 0; j = 0;
} }
if(update_counter % 33 == 0 && j < 18){ if (update_counter % 33 == 0 && j < 18) {
Serial.print("i : "); Serial.print("i : ");
Serial.print(i); Serial.print(i);
Serial.print(" j : "); Serial.print(" j : ");
Serial.println(j); Serial.println(j);
if(j % 3 == 0){ if (j % 3 == 0) {
frame [5-i] |= a[i]; frame[5 - i] |= a[i];
} } else if (j % 3 == 1) {
else if(j % 3 == 1){ frame[5 - i] &= ~current[i];
frame [5-i] &= ~current[i]; } else {
} frame[5 - i] = a[i];
else{
frame [5-i] = a[i];
i++; i++;
} }
if(i == 6){ i = 0;} if (i == 6) { i = 0; }
j++; j++;
} }
} }
void shift_right(int neu) {
void shift_right(int neu) for (int i = 0; i < 5; i++) {
{ frame[i] = frame[i + 1];
for ( int i= 0; i< 5; i++){
frame[i] = frame[i+1];
} }
frame[5] = neu; frame[5] = neu;
} }
void transition(int* a){ void transition(int *a) {
time_t t = now(); if (update_counter % 150 == 0 && cur_update != update_counter && shift_state < sizeof(today) / 2) {
if (update_counter % 150 == 0 && cur_update != update_counter && shift_state < sizeof(today)/2){ //assuming the Array contains only ints, //assuming the Array contains only ints,
//which have a sizeof 2 on this Arduino //which have a sizeof 2 on this Arduino
Serial.println(sizeof(a)); Serial.println(sizeof(a));
cur_update = update_counter; cur_update = update_counter;
shift_right(a[6-shift_state]); shift_right(a[6 - shift_state]);
shift_state ++; shift_state++;
} }
} }
/*-------- Alarm Clock code ---------*/ /*-------- Alarm Clock code ---------*/
const int AlarmClockPacketSize = 256; const int AlarmClockPacketSize = 256;
byte AlarmBuffer[AlarmClockPacketSize]; byte AlarmBuffer[AlarmClockPacketSize];
int listenForAlarm(){ int listenForAlarm() {
while (AlarmClock.parsePacket() > 0); while (AlarmClock.parsePacket() > 0);
Serial.println("Any Alarm imminent?"); Serial.println("Any Alarm imminent?");
uint32_t packageBegin = millis(); uint32_t packageBegin = millis();
while(millis() - packageBegin < 1500){ while (millis() - packageBegin < 1500) {
int size = AlarmClock.parsePacket(); int size = AlarmClock.parsePacket();
if(size >= AlarmClockPacketSize){ if (size >= AlarmClockPacketSize) {
Serial.println("Alarm seems to be imminent."); Serial.println("Alarm seems to be imminent.");
AlarmClock.read(AlarmBuffer, AlarmClockPacketSize); AlarmClock.read(AlarmBuffer, AlarmClockPacketSize);
alarm_goal = (unsigned long)AlarmBuffer; alarm_goal = (unsigned long) AlarmBuffer;
return 1; return 1;
} }
} }
@@ -584,9 +554,8 @@ int listenForAlarm(){
const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
time_t getNtpTime() time_t getNtpTime() {
{ while (Udp.parsePacket() > 0); // discard any previously received packets
while (Udp.parsePacket() > 0) ; // discard any previously received packets
//Serial.println("Transmit NTP Request"); //Serial.println("Transmit NTP Request");
sendNTPpacket(timeServer); sendNTPpacket(timeServer);
uint32_t beginWait = millis(); uint32_t beginWait = millis();
@@ -597,10 +566,10 @@ time_t getNtpTime()
Udp.read(packetBuffer, NTP_PACKET_SIZE); // read packet into the buffer Udp.read(packetBuffer, NTP_PACKET_SIZE); // read packet into the buffer
unsigned long secsSince1900; unsigned long secsSince1900;
// convert four bytes starting at location 40 to a long integer // convert four bytes starting at location 40 to a long integer
secsSince1900 = (unsigned long)packetBuffer[40] << 24; secsSince1900 = (unsigned long) packetBuffer[40] << 24;
secsSince1900 |= (unsigned long)packetBuffer[41] << 16; secsSince1900 |= (unsigned long) packetBuffer[41] << 16;
secsSince1900 |= (unsigned long)packetBuffer[42] << 8; secsSince1900 |= (unsigned long) packetBuffer[42] << 8;
secsSince1900 |= (unsigned long)packetBuffer[43]; secsSince1900 |= (unsigned long) packetBuffer[43];
return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR; return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
} }
} }
@@ -609,8 +578,7 @@ time_t getNtpTime()
} }
// send an NTP request to the time server at the given address // send an NTP request to the time server at the given address
void sendNTPpacket(IPAddress &address) void sendNTPpacket(IPAddress &address) {
{
// set all bytes in the buffer to 0 // set all bytes in the buffer to 0
memset(packetBuffer, 0, NTP_PACKET_SIZE); memset(packetBuffer, 0, NTP_PACKET_SIZE);
// Initialize values needed to form NTP request // Initialize values needed to form NTP request
@@ -630,4 +598,3 @@ void sendNTPpacket(IPAddress &address)
Udp.write(packetBuffer, NTP_PACKET_SIZE); Udp.write(packetBuffer, NTP_PACKET_SIZE);
Udp.endPacket(); Udp.endPacket();
} }