Ma...scusa, mi vuoi dire con chi ha comunicato il mio arduino quando mi ha inserito automaticamente l'ora e data esatta al primo lancio. Io non ho inserito manualmente proprio nulla. Ho lanciato lo sketch e ha fatto tutto da solo.
#ifndef ESP8266 while (!Serial); // wait for serial port to connect. Needed for native USB #endif
if (! rtc.begin()) { Serial.println("Couldn't find RTC"); Serial.flush(); abort(); }
if (! rtc.initialized() || rtc.lostPower()) { Serial.println("RTC is NOT initialized, let's set the time!"); // When time needs to be set on a new device, or after a power loss, the // following line sets the RTC to the date & time this sketch was compiled rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // This line sets the RTC with an explicit date & time, for example to set // January 21, 2014 at 3am you would call: // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0)); // // Note: allow 2 seconds after inserting battery or applying external power // without battery before calling adjust(). This gives the PCF8523's // crystal oscillator time to stabilize. If you call adjust() very quickly // after the RTC is powered, lostPower() may still return true. }
// When time needs to be re-set on a previously configured device, the // following line sets the RTC to the date & time this sketch was compiled // rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // This line sets the RTC with an explicit date & time, for example to set // January 21, 2014 at 3am you would call: // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
// When the RTC was stopped and stays connected to the battery, it has // to be restarted by clearing the STOP bit. Let's do this to ensure // the RTC is running. rtc.start();
// The PCF8523 can be calibrated for: // - Aging adjustment // - Temperature compensation // - Accuracy tuning // The offset mode to use, once every two hours or once every minute. // The offset Offset value from -64 to +63. See the Application Note for calculation of offset values. //
formatting link
// The deviation in parts per million can be calculated over a period of observation. Both the drift (which can be negative) // and the observation period must be in seconds. For accuracy the variation should be observed over about 1 week. // Note: any previous calibration should cancelled prior to any new observation period. // Example - RTC gaining 43 seconds in 1 week float drift = 43; // seconds plus or minus over oservation period - set to 0 to cancel previous calibration. float period_sec = (7 * 86400); // total obsevation period in seconds (86400 = seconds in 1 day: 7 days = (7 * 86400) seconds ) float deviation_ppm = (drift / period_sec * 1000000); // deviation in parts per million (?s) float drift_unit = 4.34; // use with offset mode PCF8523_TwoHours // float drift_unit = 4.069; //For corrections every min the drift_unit is 4.069 ppm (use with offset mode PCF8523_OneMinute) int offset = round(deviation_ppm / drift_unit); // rtc.calibrate(PCF8523_TwoHours, offset); // Un-comment to perform calibration once drift (seconds) and observation period (seconds) are correct // rtc.calibrate(PCF8523_TwoHours, 0); // Un-comment to cancel previous calibration
Serial.print("Offset is "); Serial.println(offset); // Print to control offset
"Gab" ha scritto nel messaggio news: snipped-for-privacy@mid.individual.net...
ha
non comunica con nessuno, la data e l'ora sono scritti come costanti nel
codice.
rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); e' come se ci fosse scritto rtc.adjust( 03/04/2021,23:01:00 ); che sono 2 valori costanti, vengono impostati dal compilatore durante la
compilazione, ma durante l'esecuzione dello sketch non cambiano mai, sono appunto costanti.
L'ha appena detto, con nessuno. E` stata usata una variabile prodotta al momento della compilazione, fissa e immutabile nel codice, che viene usata per settare l'ora corrispondente a quel momento (e solo se l'RTC non e` stato gia` inizializzato). In sostanza e` un trucco valido solo durante una compilazione + caricamento su scheda, non il modo "normale" per regolare un RTC.
Ed e` un trucco che puo` causare anche dei problemi, perche` se stacchi e rimetti la batteria, e poi riaccendi Arduino, l'ora viene di nuovo impostata a quando il programma e` stato compilato.
Ogni settaggio "normale" passa tramite regolazioine a runtime, con acquisizione via seriale / pulsanti / rete.
Grazie al post di Fabio non sottovaluterei l'idea di usare un ricevitore GPS. Se la collocazione e` adatta a ricevere il segnale mi sembra ancora quella meno brigosa (nessun PC / WiFi / pulsanti o display da collegare, ma solo una stringa da leggere dalla seriale prodotta "spontaneamente" dal ricevitore).
E' il classico cane che si morde la coda, dato che questa informazione dovrebbe proprio dartela l'RTC. Hai due strade: prendere un RTC molto ma molto preciso e rimetterlo ogni tanto (esistono, ma non mi vengono in
il classico dito laddove non batte mai il sole) e con poche righe di codice chiedere l'ora al NIST o altro server di tua scelta. Ci sono moltissimi esempi in rete ma
tempi lunghi, hai una connessione di rete e serve massima precisione non ci sono alternative :D
Solo ora ho capito cosa intendevi nell'altro post... Il compilatore (non l'IDE) ti fornisce delle macro che ti
ovviamente utile se hai diverse versioni del programma e
il programma appena dopo compilato (cosa non scontata) il tuo RTC parte sincronizzato con l'ora del PC. Ma come
--
- Se scegli la pillola blu la tua vita
- E se scelgo quella rossa?
Il solito DS3231SN da due euro e cinquanta, due minuti di errore all'anno, ma va appunto regolato, a mano o in lavatrice.
Rilancio il ricevitore GPS ;)
Certo l'esempio usa le stringhe C++ (classe String) che su un povero Arduino portano a morte certa per frammentazione della RAM. Ma basta usare le stringhe C "classiche" (array di char).
Molto interessante anche indipendentemente dall'altro problema.
una gabbia di Faraday. La cosa mi ha stuzzicato e non escludo di prenderla a mano. Grazie Gab NOTA: Gli undici satelliti li ricevo con il GPS in macchina.
termostatato e con la DS3231, precisa quanto basta per usi normali
verso l'uso dell'ESP32 che ha l'RTC interno, facilmente sincronizzabile con un servet ntp qualsiasi (se hai una WiFi disponibile), per cui non ti servono schede aggiuntive per RTC e per WiFi, in quanto ha tutto quello che serve l'ESP32.
Provai una volta con successo ma con fatica ad impostare la dataora sulla schedina con DS3231, ma ci sono riuscii utilizzando una libreria che richiede l'impostazione dei parametri come "int" ed un server ntp
visto che la mia Pasqua e' molto noiosa, ti ho scritto come secondo me si risolve il problema.
inserisci questa riga in alto nel tuo sketch: #include
poi in fondo dopo il tuo codice inserisci questa funzione: void serialEvent ( void ) { static String input; while( Serial.available() ) { char c = Serial.read(); if( c!='\n' ) input += c; else { DateTime dt; char cmd = input[0]; input.remove( 0,1 ); switch( cmd ) { case 's': case 'S': dt = DateTime( input.c_str() ); rtc.adjust( dt ); rtc.calibrate( PCF8523_TwoHours,0 ); EEPROM.put( 0,dt ); EEPROM.put( sizeof( dt ),0 ); break; case 'c': case 'C': { float drift = input.toFloat(); dt = rtc.now()-TimeSpan( drift ); DateTime lastset; int lastoffset; EEPROM.get( 0,lastset ); EEPROM.get( sizeof( lastset ),lastoffset ); float period_sec = ( dt-lastset ).totalseconds(); // total obsevation period in seconds float deviation_ppm = ( 1000000*drift/period_sec ); // deviation in parts per million (?s) int offset = lastoffset+round( deviation_ppm/4.34 ); // use with offset mode PCF8523_TwoHours rtc.adjust( dt ); rtc.calibrate( PCF8523_TwoHours,offset ); EEPROM.put( 0,dt ); EEPROM.put( sizeof( dt ),offset ); Serial.println( "offset:"+String( offset ) ); } break; default: dt = _rtc_now(); break; } Serial.println( "ora attuale:"+dt.timestamp() ); input=String(); } } }
cosa fa e a cosa serve quel codice: la funzione "serialEvent()" viene chiamata dopo ogni carattere ricevuto da linea seriale. ogni carattere ricevuto viene messo in una stringa fino al carattere NewLine ('\n') il primo carattere ricevuto determina il comando S=imposta l'orario, deve essere seguito dall'orario scritto in questa forma AAAA-MM-GG OO:MM:SS per esempio S2021-04-04 15:40:00 viene impostato l'orario sul RTC e memorizzato in EEPROM, la calibrazione viene azerata. C=imposta l'offset di calibrazione, deve essere seguito dai secondi di
scartamento con eventuale segno per esempio C-23 viene impostato l'orario sul RTC come "ora_attuale-scartamento", eseguito il calcolo dell'offset per il registro del PCF8325, e memorizzato il tutto su EEPROM. ?=qualsiasi altro carattere o stringa vuota, stampa l'orario corrente
come la devi usare: carichi il tuo sketch attivi il monitor seriale e nella riga di stato in basso attivi "Scorrimento automatico", "visualizza orario","a capo (NL)" scrivi in alto il comando per impostare l'orario, mettendo almeno 1 minuto in piu' dell'orario corrente: S2021-04-04 15:45:00 aspetti che il PC raggiunga quell'orario e dai INVIO arduino ti rispondera' con qualcosa di simile:
15:34:19.940 -> ora attuale:2014-04-04T15:34:20 assicurati che i 2 orari siano molto simili (meno di 1 secondo), se non lo sono ripeti il comando Saaaa-mm-gg oo:mm:ss lascialo girare per qualche giorno poi lo ricolleghi al PC e sul monitor seriale dai INVIO senza scrivere niente, avrai in risposta l'orario attuale come visto prima:
15:35:31.949 -> ora attuale:2014-04-04T15:34:20 da cui determini lo scostamento in secondi, nella riga sopra sarebbe -72
secondi, cioe' il tuo RTC e' in ritardo di 72 secondi (e' solo un esempio) quindi dai il comando di calibrazione come: C-72 in risposta viene stampato il valore dell'offset calcolato, se il numero che vedi e' inferiore a -64 o maggiore a +63, hai sbagliato qualcosa e produrra' effetti indesiderati
lascialo girare qualche giorno e ripeti la calibrazione se necessario.
ElectronDepot website is not affiliated with any of the manufacturers or service providers discussed here.
All logos and trade names are the property of their respective owners.