ESP8266 loopt vast

Software vragen voor ESP chip familie
Berichten: 126
Geregistreerd: 21 Feb 2013, 16:04

Re: ESP8266 loopt vast

Berichtdoor René » 13 Feb 2017, 10:42

Dank je Nico,
Gisteren probeerde ik al Serial.println(lt->tm_mday);
Dat compileert maar geeft bagger als output
Code: Alles selecteren
192.168.1.54
Starting UDP
Local port: 265
sending NTP packet...
packet received, length=48
Seconds since Jan 1 1900 = 3695963482
Unix time = 1486974682

Exception (28):
epc1=0x40201c7b epc2=0x00000000 epc3=0x00000000 excvaddr=0x0000000c depc=0x00000000

ctx: cont
sp: 3ffef510 end: 3ffef6f0 offset: 01a0

>>>stack>>>
3ffef6b0:  3ffe85b8 3ffee5a8 3ffee6bc 40201c39 
3ffef6c0:  3ffe8700 3601a8c0 feefeffe 3ffee6c4 
3ffef6d0:  3fffdad0 00000000 3ffee6bc 40202f88 
3ffef6e0:  feefeffe feefeffe 3ffee6d0 40100718 
<<<stack<<<

 ets Jan  8 2013,rst cause:2, boot mode:(3,6)

load 0x4010f000, len 1384, room 16
tail 8
chksum 0x2d
csum 0x2d
v09f0c112
~ld
ÿ


Ik mag dat kennelijk niet doen maar heb geen idee waarom niet.

Advertisement

Gebruikers-avatar
Berichten: 4836
Geregistreerd: 13 Mei 2013, 20:57
Woonplaats: Heemskerk

Re: ESP8266 loopt vast

Berichtdoor nicoverduin » 13 Feb 2017, 10:49

Waarschijnlijk omdat het bytes zijn. Anders zet je ze gelijk over in de uur dag etc in die seconde routine. Zit je altijd goed
Docent HBO Software Engineering, Embedded ontwikkelaar & elektronicus
http://www.verelec.nl

Berichten: 126
Geregistreerd: 21 Feb 2013, 16:04

Re: ESP8266 loopt vast

Berichtdoor René » 13 Feb 2017, 11:14

het huilen staat mij nader dan het lachen:)
hier probeer ik dag te declaren en te vullen met een vertaald byte array element.
uint8_t dag = 0;
dag = atoi(lt->tm_mday);

Onzin vindt mijn compiler en daar heeft hij ongetwijfeld gelijk in. Nog ff en ik sloop die zonnepanelen wee van het dak af grr

Gebruikers-avatar
Berichten: 4836
Geregistreerd: 13 Mei 2013, 20:57
Woonplaats: Heemskerk

Re: ESP8266 loopt vast

Berichtdoor nicoverduin » 13 Feb 2017, 11:24

Als je nu eens begint om te kijken wat er in die struct staat en hoe de variabele binnen die struct staan. Zeker geen ascii. Dus atoi (ascii to int) gaat zeker niet werken.
Docent HBO Software Engineering, Embedded ontwikkelaar & elektronicus
http://www.verelec.nl

Berichten: 126
Geregistreerd: 21 Feb 2013, 16:04

Re: ESP8266 loopt vast

Berichtdoor René » 13 Feb 2017, 12:31

Ok ik moet weer glimlachen
dat atoi ascii to int betekent is heel logisch maar ik wist het effe niet

In de struct staan int's (volgens mij, klopt dat?)
Dus ik dacht ik maak een dag met
uint8_t dag = lt->tm_mday; // de int wordt dan omgezet in een uint8_t ( maar dat lijkt mij onzin omdat het allebei int's zijn toch?)
en die moet ik kunnen tonen met Serial.println(dag);

Nou dat is niet zo, resultaat is bagger

Gebruikers-avatar
Berichten: 4836
Geregistreerd: 13 Mei 2013, 20:57
Woonplaats: Heemskerk

Re: ESP8266 loopt vast

Berichtdoor nicoverduin » 13 Feb 2017, 12:45

Werkt gewoon hoor....
cpp code
/*


Udp NTP Client

Get the time from a Network Time Protocol (NTP) time server
Demonstrates use of UDP sendPacket and ReceivePacket
For more on NTP time servers and the messages needed to communicate with them,
see http://en.wikipedia.org/wiki/Network_Time_Protocol

created 4 Sep 2010
by Michael Margolis
modified 9 Apr 2012
by Tom Igoe
updated for the ESP8266 12 Apr 2015
by Ivan Grokhotkov

This code is in the public domain.

*/

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>

const int UPDATE_FREQ = 1000; // elke halve seconde updaten

uint32_t epoch; // seconden teller in UNIX tijd
struct tm *lt; // struct om UNIX tijd op te breken in losse onderdelen
time_t t = (time_t) epoch; // Unix tijd in seconden
char * c_time_string; // pointer naar geformatteerde char array van datum en tijd
uint32_t timer = 0; // onze klok timer


char ssid[] = "xxxxxxxxxx"; // your network SSID (name)
char pass[] = "xxxxxxxxx"; // your network password
unsigned int localPort = 265; // local port to listen for UDP packets

//
// NTP stuff
//
IPAddress timeServerIP;
const char* ntpServerName = "nl.pool.ntp.org";
const int NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message
byte packetBuffer[NTP_PACKET_SIZE+1]; //buffer to hold incoming and outgoing packets
// A UDP instance to let us send and receive packets over UDP
WiFiUDP udp;
/**
* @name setup()
*/
void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
//
// connectie met lokaal wifi netwerk
//
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, pass);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
//
// ophalen NTP tijd voor de eerste keer
//
if (waitForNTPTime()) {
Serial.println("No time received after 10 retries");
}

timer = millis(); // start onze seconden teller
}
/**
* @name loop()
*/
void loop() {

uint32_t ditMoment = millis(); // uitgaan van een vast moment
//
// kijk of de klok bijgewerkt moet worden
//
if ((ditMoment - timer) > UPDATE_FREQ) {
//
// een seconde verlopen
//
epoch += 1; // verhoog de seconden
t = (time_t)epoch; // maak een time_t element van
c_time_string = ctime(&t); // maak er een string van
Serial.print(c_time_string); // en print deze
lt = localtime(&t); // zet onze unix tijd in een char array
uint8_t sec = lt->tm_sec;
Serial.println(sec);
timer = ditMoment; // start onze timer opnieuw
}
}
/**
* @name sentNTPpacket
* @param address IP Address of server
* Sends a request to the NTP server
*/
// send an NTP request to the time server at the given address
unsigned long sendNTPpacket(IPAddress& address) {
Serial.println("sending NTP packet...");
// set all bytes in the buffer to 0
memset(packetBuffer, 0, NTP_PACKET_SIZE);
// Initialize values needed to form NTP request
// (see URL above for details on the packets)
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;

// all NTP fields have been given values, now
// you can send a packet requesting a timestamp:
udp.beginPacket(address, 123); //NTP requests are to port 123
udp.write(packetBuffer, NTP_PACKET_SIZE);
udp.endPacket();
return 0;
}
/**
* @ name wait for a time back from the NPT server
* @return 1= OK 0=Error (after 10 times)
*/
uint8_t waitForNTPTime() {
uint8_t returnCode = 1; // de return code of dit wel/niet succesvol was

Serial.println("Starting UDP");
udp.begin(localPort);
Serial.print("Local port: ");
Serial.println(udp.localPort());
//get a random server from the pool
WiFi.hostByName(ntpServerName, timeServerIP);

for (uint8_t i = 0; i < 10; i++) {

sendNTPpacket(timeServerIP); // send an NTP packet to a time server
// wait to see if a reply is available
delay(1000);

int cb = udp.parsePacket();
if (!cb) {
Serial.println("no packet yet");
} else {
Serial.print("packet received, length=");
Serial.println(cb);
// We've received a packet, read the data from it
udp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer

//the timestamp starts at byte 40 of the received packet and is four bytes,
// or two words, long. First, esxtract the two words:

unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
// combine the four bytes (two words) into a long integer
// this is NTP time (seconds since Jan 1 1900):
unsigned long secsSince1900 = highWord << 16 | lowWord;
Serial.print("Seconds since Jan 1 1900 = ");
Serial.println(secsSince1900);

// now convert NTP time into everyday time:
Serial.print("Unix time = ");
// Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
const unsigned long seventyYears = 2208988800UL;
// subtract seventy years:
epoch = secsSince1900 - seventyYears;

// print Unix time:
Serial.println(epoch);
//
// breek onze tijd op in de verschillende componenten
//
t = (time_t) epoch;
returnCode = 0;
break;
}
}
return returnCode;
}


Levert deze output op:

cpp code
Connecting to verelec_1
........
WiFi connected
IP address:
192.168.178.17
Starting UDP
Local port: 265
sending NTP packet...
packet received, length=48
Seconds since Jan 1 1900 = 3695971443
Unix time = 1486982643
Mon Feb 13 10:44:04 2017
4
Mon Feb 13 10:44:05 2017
5
Mon Feb 13 10:44:06 2017
6
Mon Feb 13 10:44:07 2017
7
Mon Feb 13 10:44:08 2017
8
Mon Feb 13 10:44:09 2017
9
Mon Feb 13 10:44:10 2017
10


En anders zet je maar jouw variant van de sketch hier ff neer... Ik vermoed wat de oorzaak is.... Je krijgt een pointer terug naar een adres van de heap. Zodra je een andere functie hebt uitgevoerd is die heap vrijwel zeker vernaggelt. Je moet dus eerst alle variabelen veilig stellen zoals ik al eerder zei door gelijk uur, minuten enz te vullen in die seconde routine.
Docent HBO Software Engineering, Embedded ontwikkelaar & elektronicus
http://www.verelec.nl

Berichten: 126
Geregistreerd: 21 Feb 2013, 16:04

Re: ESP8266 loopt vast

Berichtdoor René » 13 Feb 2017, 12:54

op die manier bij mij ook. ik had de statements:
cpp code
void loop() {

uint32_t ditMoment = millis(); // uitgaan van een vast moment
//
// kijk of de klok bijgewerkt moet worden
//
if ((ditMoment - timer) > UPDATE_FREQ) {
//
// een seconde verlopen
//
epoch += 1; // verhoog de seconden
t = (time_t)epoch; // maak een time_t element van
c_time_string = ctime(&t); // maak er een string van
Serial.print(c_time_string); // en print deze
lt = localtime(&t); // zet onze unix tijd in een char array

timer = ditMoment; // start onze timer opnieuw
}

uint8_t sec = lt->tm_sec;
Serial.println(sec);

}


buiten de if loop geplaatst en dan krijg ik de bagger en dan is het toch weer toveren voor mij ipv begrijpen waarom dat gebeurt

Berichten: 126
Geregistreerd: 21 Feb 2013, 16:04

Re: ESP8266 loopt vast

Berichtdoor René » 13 Feb 2017, 13:17

opgelost door if loop "uit te kleden" tot
Code: Alles selecteren
void loop() {
 
    uint32_t ditMoment = millis();                  // uitgaan van een vast moment
    //
    // kijk of de klok bijgewerkt moet worden
    //
    if ((ditMoment - timer) > UPDATE_FREQ) {
        //
        // een seconde verlopen
        //
        epoch += 1;   
        t = (time_t)epoch;                                // verhoog de seconden
         c_time_string = ctime(&t);                  // maak er een string van
        timer = ditMoment;                          // start onze timer opnieuw
    }
                       
        Serial.print(c_time_string);                // en print deze
        lt = localtime(&t);                         // maak een time_t element van

uint8_t sec = lt->tm_sec;
        Serial.println(sec);

}


en de rest er buiten te plaatsen. Nu wordt de tijd alleen opgehaald als die 1 sec is verlopen??

Gebruikers-avatar
Berichten: 4836
Geregistreerd: 13 Mei 2013, 20:57
Woonplaats: Heemskerk

Re: ESP8266 loopt vast

Berichtdoor nicoverduin » 13 Feb 2017, 14:28

Ik heb ff de oude sketch met de NTP uitgerust....
Er zaten nog wel wat adders met maandnummer en jaarnummer. Maar lijkt te werken:
cpp code
#include <Arduino.h>
/*
* programma meet de SO pulsen van een kwh meter die de levering van zonnepanelen meet
* programma stuurt data via HTTP GET requests naar PVoutput.org service.
* programma draait op een esp8266 v1.5.0
* via een website (google.com) wordt de tijd opgehaald
*/
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <time.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>

const int UPDATE_FREQ = 1000; // elke halve seconde updaten
const int GMT_CORRECTIE = 3600; // pas de tijd aan aan NL. = + 1 uur

unsigned int localPort = 265; // local port to listen for UDP packets
//
// internet specifieke zaken
//
const char* ssid = "xxxxxxxxx";
const char* password = "xxxxxxxxx";
const char* host = "pvoutput.org";
const char* SystemId = "XXXXXXXX";
const char* APIKey = "XXXXXXXXXXXXXXXXXXXX";

//
// NTP stuff
//
IPAddress timeServerIP;
const char* ntpServerName = "nl.pool.ntp.org";
const int NTP_PACKET_SIZE = 48; // NTP time stamp is in the first 48 bytes of the message
byte packetBuffer[NTP_PACKET_SIZE+1]; //buffer to hold incoming and outgoing packets

WiFiUDP udp; // udp object
//
// klok stuff
//
uint32_t epoch; // seconden teller in UNIX tijd
struct tm *lt; // struct om UNIX tijd op te breken in losse onderdelen
struct tm myTime;
time_t t; // Unix tijd in seconden
char * c_time_string; // pointer naar geformatteerde char array van datum en tijd
uint32_t timer = 0; // onze klok timer
uint8_t dag; // dagnummer
uint8_t maand; // maandnummer
uint16_t jaar; // jaartal
uint8_t uur; // uren
uint8_t minuut; // minuten
uint8_t seconde; // seconden

//
// programma constanten
//
const uint32_t SEND_TIME = 5000; // tijd tussen verzenden data TIJDELIJK op 30 seconden
const uint32_t NO_POWER_TIME = 1000 * 60 * 3; // tijdsduur geen pulsen meer ontvangen (normaliter 20 minuten)

//
// Stroom en puls variabelen
//
uint32_t pulseCount = 0; //Number of pulses, used to measure energy.
uint32_t pulseTime; // moment waarop de pulse wordt verwerkt
uint32_t lastTime; // vorige moment waarop de puls is verwerkt
volatile boolean pulse = false; // indicator dat er een puls is geweest
//power and energy
double power; // vermogen dat is geleverd
double opbrengst; // totale opbrengst // Number of pulses per wh - found or set on the meter.
uint32_t ppwh = 1; // 1000 pulses/kwh = 1 pulse per wh
uint32_t sent = 0; // tijd tussen verzenden data
//
// timers
//
uint32_t RTCTimer; // onze softwarematige RTC
uint32_t noPowerTimer; // timer die vaststeld hoelang er geen power is
uint32_t sendTimer; // timer die bepaalt wanneer er verzonden wordt

void setup() {
Serial.begin(115200);
Serial.println();
Serial.println();
//
// connectie met lokaal wifi netwerk
//
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
//
// ophalen NTP tijd voor de eerste keer
//
if (waitForNTPTime()) {
Serial.println("No time received after 10 retries");
}

timer = millis(); // start onze seconden teller
noPowerTimer = millis(); // start de no power timer
sendTimer = noPowerTimer; // start de zend timer

// KWH pulsen worden geteld via interrupt
attachInterrupt(2, onPulse, FALLING);
}
/**
* @name loop
* Wordt eindeloos aangeroepen
*/
void loop() {
uint32_t ditMoment = millis(); // nu
//
// een keer per dag even de tijd synchroniseren met de NTP server
//
if (uur == 0 && minuut == 0 && seconde == 30) {
if (waitForNTPTime()) {
Serial.println("No time received after 10 retries");
}
}
//
// kijk of de klok bijgewerkt moet worden
//
if ((ditMoment - timer) > UPDATE_FREQ) {
//
// een seconde verlopen
//
epoch += 1; // verhoog de seconden
t = (time_t)epoch; // maak een time_t element van
c_time_string = ctime(&t); // maak er een string van
lt = localtime(&t); // zet onze unix tijd in een char array

//
// bewaar onze parameters omdat we ze anders kwijt zijn vanwege heap
// tevens correctie van maand: Die lopen van 0-11
// en jaar omdat de standaard telling vanaf 1900 loopt.
//
dag = lt->tm_mday;
maand = lt->tm_mon + 1; // maanden lopen van 0-11
jaar = lt->tm_year + 1900; // startpunt van tellen was 1900
uur = lt->tm_hour;
minuut = lt->tm_min;
seconde = lt->tm_sec;
timer = ditMoment; // start onze timer opnieuw
}
//
// check of er een puls is binnengekomen
//
if (pulse) {
pulse = false; // deze puls is verwerkt
pulseCount++; // verhoog aantal pulsen voor totale opbrengst verwerking
lastTime = pulseTime; // bewaar vorige puls moment
pulseTime = ditMoment; // zet de huidige tijd vast
//
// Calculate power
//
power = (3600000.0 / double((pulseTime - lastTime))) / (double)ppwh;
//
//Find Wh elapsed
//
opbrengst = (1.0 * (double)pulseCount / (double)(ppwh));
//
// er komt nog steeds stroom binnen dus reset de nopower timer
//
noPowerTimer = ditMoment;
}

//
// kijk of we de limiet van geen stroom nog niet zijn overschreden
//
if (ditMoment - noPowerTimer < NO_POWER_TIME) {
//
// er is op zijn minst binnen de afgelopen 20 minuten NOG stroom geleverd
//
if ((ditMoment - sendTimer) > SEND_TIME) {
//
// We now create a URI for the request
//
char url [200]; // char array om url op te bouwen
char opbrengstStr[10]; // om een float in char array om te zetten
char powerStr[10]; // om een float in char array om te zetten

dtostrf(opbrengst, 7, 2, opbrengstStr); // zet de float om in een 7.2 cijfer
strcpy(opbrengstStr, trimLeadingSpaces(opbrengstStr)); // en haal de voorloop spaties weg

dtostrf(power, 7, 2, powerStr);
strcpy(powerStr, trimLeadingSpaces(powerStr));
//
// bouw de url op
//
sprintf(url, "/service/r2/addstatus.jsp?key=%s&sid=%s&d=%4d%02d%02d&t=%02d:%02d&v1=%s&v2=%s",
APIKey,
SystemId,
jaar,
maand,
dag,
uur,
minuut,
opbrengstStr,
powerStr);
Serial.println(url);
//
// De data verzenden naar onze host
//
//
// //Serial.print("connecting to ");
// //Serial.println(host);
// // Use WiFiClient class to create TCP connections
// WiFiClient client;
// const int httpPort = 80;
// if (!client.connect(host, httpPort)) {
// Serial.println("connection failed");
// return;
// }

// This will send the request to the server
/* client.print(String("GET ") + url + " HTTP/1.1\r\n" + //TIJDELIJK UITGEZET
"Host: " + host + "\r\n" +
"Connection: close\r\n\r\n");
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 5000) {
//Serial.println(">>> Client Timeout !");
client.stop();
return;
}
}
// Read all the lines of the reply from server and print them to Serial
while(client.available()) {
String line = client.readStringUntil('\r');
//Serial.print(line);
}
*///Serial.println();
//Serial.println("closing connection");
//
// reset de send timer
//
sendTimer = ditMoment;
//
// als er binnen 10 minuten geen pulsen zijn binnengekomen
// dan zetten we het vermogen op 0
//
if ((ditMoment - pulseTime) > 60000) {
power = 0.0; // als er 10 minuten geen pulsen zijn gekomen is power 0
}
}
} else {
//
// we hebben al meer dan 20 minuten geen power
//
if (uur == 22) {
//
// na 22:00 worden de totalen op 0 gezet
//
pulseCount = 0;
opbrengst = 0.0;
power = 0.0;
}
}
} // einde loop

/**
* @name onPulse
* Wordt via een interrupt aangeroepen
*/
void onPulse() {

static uint32_t last_interrupt_time = 0; // moment van laatste interrupt
uint32_t interrupt_time = millis(); // haal de interne millis tijd op

if (interrupt_time - last_interrupt_time > 1500) { //declare the debounce/block out interval in setup
pulse = true;
}

last_interrupt_time = interrupt_time; // en bewaar dit moment voor de volgende puls
}
/**
* @name trimLeadingSpaces
* @param charString pointer to string containing chars
* @return new pointer to first non space
*/
char * trimLeadingSpaces(char * charString) {

char *ptr = charString;

for (uint16_t i = 0; i < strlen(charString); i++) {
//
// kijk of het een spatie is
if (*ptr == 0x20 ) {
ptr++;
} else {
//
// we zijn er dus klaar
//
break;
}
}
return ptr;
}
/**
* @name sentNTPpacket
* @param address IP Address of server
* Sends a request to the NTP server
*/
// send an NTP request to the time server at the given address
unsigned long sendNTPpacket(IPAddress& address) {
Serial.println("sending NTP packet...");
// set all bytes in the buffer to 0
memset(packetBuffer, 0, NTP_PACKET_SIZE);
// Initialize values needed to form NTP request
// (see URL above for details on the packets)
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;

// all NTP fields have been given values, now
// you can send a packet requesting a timestamp:
udp.beginPacket(address, 123); //NTP requests are to port 123
udp.write(packetBuffer, NTP_PACKET_SIZE);
udp.endPacket();
return 0;
}
/**
* @ name wait for a time back from the NPT server
* @return 1= OK 0=Error (after 10 times)
*/
uint8_t waitForNTPTime() {
uint8_t returnCode = 1; // de return code of dit wel/niet succesvol was

Serial.println("Starting UDP");
udp.begin(localPort);
Serial.print("Local port: ");
Serial.println(udp.localPort());
//get a random server from the pool
WiFi.hostByName(ntpServerName, timeServerIP);

for (uint8_t i = 0; i < 10; i++) {

sendNTPpacket(timeServerIP); // send an NTP packet to a time server
// wait to see if a reply is available
delay(1000);

int cb = udp.parsePacket();
if (!cb) {
Serial.println("no packet yet");
} else {
Serial.print("packet received, length=");
Serial.println(cb);
// We've received a packet, read the data from it
udp.read(packetBuffer, NTP_PACKET_SIZE); // read the packet into the buffer

//the timestamp starts at byte 40 of the received packet and is four bytes,
// or two words, long. First, esxtract the two words:

unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
// combine the four bytes (two words) into a long integer
// this is NTP time (seconds since Jan 1 1900):
unsigned long secsSince1900 = highWord << 16 | lowWord;
Serial.print("Seconds since Jan 1 1900 = ");
Serial.println(secsSince1900);

// now convert NTP time into everyday time:
Serial.print("Unix time = ");
// Unix time starts on Jan 1 1970. In seconds, that's 2208988800:
const unsigned long seventyYears = 2208988800UL;
// subtract seventy years:
epoch = secsSince1900 - seventyYears;
//
// GMT correctie
//
epoch = epoch + GMT_CORRECTIE;

// print Unix time:
Serial.println(epoch);
//
// breek onze tijd op in de verschillende componenten
//
t = (time_t) epoch;
returnCode = 0;
break;
}
}
return returnCode;
}


Output:
cpp code
Starting UDP
Local port: 265
sending NTP packet...
packet received, length=48
Seconds since Jan 1 1900 = 3695977568
Unix time = 1486992368
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:26&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
/service/r2/addstatus.jsp?key=XXXXXXXXXXXXXXXXXXXX&sid=XXXXXXXX&d=20170213&t=13:27&v1=0.00&v2=0.00
Docent HBO Software Engineering, Embedded ontwikkelaar & elektronicus
http://www.verelec.nl

Berichten: 126
Geregistreerd: 21 Feb 2013, 16:04

Re: ESP8266 loopt vast

Berichtdoor René » 13 Feb 2017, 15:31

Helemaal te gek Nico.
Draait bij mij nu effe met echte pulsen uit de meterkast maar zonder verzenden.
Wat ik mij afvraag mar even niet kan testen is het volgende.
Als er straks 0 t/m 9 minuten komen krijg ik dan een voorloop nul. Hetzelfde geldt voor uren en de maanden.

of is dat met die %02d geregeld?

Als ik één keer per dag de tijd synchroniseer is dat toch zat?
Vindt je dat de boel nog gereset moet worden aan het einde van de dag? ( of eerst maar eens testen hoe lang het blijft draaien zonder problemen?

VorigeVolgende

Terug naar ESP Software

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 1 gast