ESP8266 loopt vast

[René Profiel Privébericht]

work arround:???
1 keer per 5 minuten verzenden , 12 keer per uur 237 keer voordat het misgaat is bijna 20 uur. Zolang schijnt de zon niet achter elkaar in nederland. Je zou de boel om 22 uur kunnen resetten. dan gaat hij pas weer aan de slag als er pulsen komen ( om 6 uur in de zomer?)

Zou moeten kunnen maar het is natuurlijk een workaround:(

[René Profiel Privébericht]

Website limiet misschien ook aan tijdsduur gebonden?
Ik heb de loop nu draaien met sentTijd 10 sec. Elke 10 minuten moet ik dan een puls geven en dan loopt hij weer verder. Ik zit nu op 280! loops. Misschien zitten we naar een niet bestaand probleem te kijken? Want straks staat sentTijd weer op 10 minuten?
Nu eerst weer effen wat anders. Ik laat hem gewoon aanstaan tot ik terug ben

[René Profiel Privébericht]

oops kreeg na 298 een auto reset helaas

[nicoverduin Profiel PrivéberichtWebsite]

Hij klapt nderdaad uit met een exception en dump. Ben net een dump analyzer aan eclipse aan het toevoegen. Het lijkt er steeds meer op dat het niet aan jouw code ligt

[nicoverduin Profiel PrivéberichtWebsite]

Ik had ff een test programmatje gemaakt met deze code:
cpp code

#include "Arduino.h"
#include "ESP8266WiFi.h"

const char* ssid 		= "xxxxxxxxx";
const char* password 	= "xxxxxxxxx";

uint32_t teller = 0;
uint32_t myTeller = 0;

WiFiClient client;



void setup()
{
	Serial.begin(115200);
	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());
}

// The loop function is called in an endless loop
void loop()
{
	Serial.print("teller : ");
	Serial.print(myTeller);
	myTeller++;
	Serial.print(" ");
	Serial.println(getTime());
	delay(1000);
}
char * getTime()    							// functie om tijd op te halen van website
{

	char 		*startPositie;					// start positie van datum veld in regel
	uint8_t 	charArrayIndex = 0;				// index binnen array
	char 		charArray[200];                 // ff ruim genomen buffer voor ontvangen regels
	charArray[0] = '\0';						// de regel leegmaken

	if (WiFi.status() != WL_CONNECTED) {
		//
		// reconnect
		//
		Serial.println("Reconnect");
		WiFi.begin(ssid, password);
		while (WiFi.status() != WL_CONNECTED) {
			delay(500);
			Serial.print(".");
		}
	}

	while (!client.connect("www.google.nl", 80)) {
		Serial.println("connection failed, retrying...");
	}

	client.print("HEAD / HTTP/1.1\r\n\r\n");	// dit zorgt ervoor dat de server de tijd teruggeeft

	uint16_t teller = 0;
	while (!client.available()) {
		teller++;
		if (teller > 15) {
			//
			// timeout
			//
			Serial.println("timeout");
			break;
		}
		yield();// om de stress op de server te verlichten
	}

	//
	// Als er data is te verwerken
	//
	while (client.available()) {
		charArray[charArrayIndex] = client.read();    	// lees teken in de tabel

		if (charArray[charArrayIndex] == '\r') { 		// blijven lezen tot er een return komt
			charArray[charArrayIndex] = '\0'; 			// en sluit te tekst af met een '\0'. De return halen we gelijk weg
			//
			// kijk of dit de datumregel is
			//
			startPositie = strstr(charArray, "\nDate: ");
			//
			// is dit is onze regel?
			//
			if (startPositie != NULL) {
				//
				// yep dus skip 7 posities en we hebben het startpunt
				//
				startPositie = startPositie + 7; //was 7
				client.stop();
				return startPositie;
			} else {
				charArray[0] = '\0';
				charArrayIndex = 0;
			}
		} else {
			charArrayIndex++;
		}
	}
	Serial.println("De tijd server stuurt niets terug");
	client.stop();
	charArray[0] = '\0';
	startPositie = &charArray[0]; // lege tabel dus geen datum
	return startPositie;
}

Die loopt inmiddels al tot 466

Maar ik zit te overwegen om een geheel andere aanpak te nemen:
a) bij het opstarten van de ESP haal je de tijd op vanuit een NTP server.
b) met software de tijd bijhouden
c) daarna gewoon elke dag een reset() uitvoeren
Loop je eigenlijk ook nog redelijk gelijk en hoef je maar 1x per dag die NTP te benaderen.

[René Profiel Privébericht]

Met mijn kleinkind in de schouwburg zat ik ook al te denken "waarom haal ik eigenlijk zo vaak de tijd op?"
Je opmerking over het berekenen van de power zette mij ook nog aan het denken. Eigenlijk zou ik de maximale power willen zien van dat tijdsblokje van 5 minuten sentTime. Nu zie ik de power van de laatste puls acties in de tijdblokje. Tijdens een dag met regelmatig wolkjes voor de zon zag ik dat effect al langs komen soms was er een piek van 1500 W op de omvormer terwijl ik een veel lagere waarde op PV output zag omdat er alweer een wolk voor de zon zat tijdens de laatste pulsen in het sentTime venster..
Ik heb ook al eens naar een tijdserver gekeken maar las toe op internet dat die af en toe wel erg lang op zich laten wachten als je een tijd op vraagt.
Ik ben wel blij dat je er de lol van in blijft zien Nico:)

[nicoverduin Profiel PrivéberichtWebsite]

Eerste proef versie loopt al...

[nicoverduin Profiel PrivéberichtWebsite]

De eerste experimentele versie
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[] = "xxxxxxxxx";  	//  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

		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 on ze tijd op in de verschillende componenten
			//
			t = (time_t) epoch;
			returnCode = 0;
			break;
		}
	}
	return returnCode;
}

[René Profiel Privébericht]

ok Nico jij wint!
Eerst een s even je testprogramma gedraaid. Ik ben bij tellerstand 800 zoveel en zie heel veel time outs (5 tot 20) en daarna een tijd langs komen.
Bij je laatste code voorstel voor een NTP server sla je wat mij betreft niet alleen een paar hoofdstukken maar zelf een paar boeken over.
Als de code straks stabiel draait heb ik nog wel een paar vragen over de voorgaande codes

[René Profiel Privébericht]

geeft nu 16 minuten lang elke seconde een update van de tijd dat is ca 1000 keer. Die had ik nog niet gezien.

Voor wat de code betreft: ik kan het niet goed uitstaan dat zo'n klein esp8266 pruts ding dat allemaal snapt en ik nog voor geen meter