Buongiorno a tutti, qualcuno sa dirmi il perchè i dati NON vengono memorizzati staccando la corrente?
Pila (ricaricabile) nuova, utilizzo solo il collegamento I2C (PIN SQW e 32K non collegati).
Saluti
Enrico
Buongiorno a tutti, qualcuno sa dirmi il perchè i dati NON vengono memorizzati staccando la corrente?
Pila (ricaricabile) nuova, utilizzo solo il collegamento I2C (PIN SQW e 32K non collegati).
Saluti
Enrico
Senza vedere il codice difficile risponderti ...
E comunque ... cosa è RW-084? Mettete SEMPRE il link ai prodotti che citate e che avete acquistato!
Guglielmo
Cioè un normalissimo modulo basato su DS3231
Metti il codice perché quei moduli, se non sono guasti, non danno alcun problema.
Guglielmo
Cosa intendi per pila ricaricabile?
Immagino intenda una LIR2032 che è quella che va montata su quei moduli SE non si esclude il diodo o la resistenza di ricarica (... ne abbiamo parlato QUI).
Guglielmo
Ovvio.
"Acc...!!!", speravo proprio ci fosse un modo per ripristinarlo! Ora mi tocca aspettare di ricevere i nuovi!
Per completezza d'informazione posto anche il programma (che non dovrebbe avere errori).
/*
prova scomposizione numero da seriale
aggiunto RTC, Data e temperatura
funziona - caricata
*/
#include <RTClib.h>
#include <LedControl.h>
#include <Wire.h>
const byte CLK = 10;
const byte CS = 9;
const byte DIN = 8;
const byte ELEMENTS = 1;
LedControl lc = LedControl(DIN, CLK, CS, ELEMENTS);
RTC_DS3231 myRTC;
long v_sec;
long v_min;
long v_hr;
long v_day;
long v_mon;
long v_year;
long v_temp;
byte digits[13] = {
B01111110, // 0
B00110000, // 1
B01101101, // 2
B01111001, // 3
B00110011, // 4
B01011011, // 5
B00011111, // 6
B01110000, // 7
B01111111, // 8
B01110011, // 9
B00000001, // "-"
B01001110, // "C"
B00000000 // " "
};
void setup() {
lc.shutdown(0, false);
lc.setIntensity(0, 3); //luminosità da 0 a 15
lc.clearDisplay(0);
Serial.begin(9600);
myRTC.begin();
myRTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
}
int el = 0;
int u_s, d_s, u_m, d_m, u_h, d_h, f, u_d, d_d, u_mo, d_mo, u_y, d_y, u_t, d_t, t, vuoto;
void loop() {
ora();
delay(5);
if ((u_s == 5) && (d_s == 5)) {
Data();
delay(2000);
}
if ((u_s == 5) && (d_s == 2)) {
Temperatura();
delay(1000);
}
}
void setDigit(int el, int pos, int n) {
byte dig = digits[n];
for (int cl = 0; cl < 8; cl++) {
if ((dig & (B10000000 >> cl)) >= 1) {
lc.setLed(el, pos, cl, true);
} else {
lc.setLed(el, pos, cl, false);
}
}
}
void ora() {
DateTime now = myRTC.now();
v_hr = now.hour();
v_min = now.minute();
v_sec = now.second();
u_s = v_sec % 10;
d_s = v_sec / 10;
u_m = v_min % 10;
d_m = v_min / 10;
u_h = v_hr % 10;
d_h = v_hr / 10;
f = 10;
lc.clearDisplay(0);
setDigit(el, 0, u_s);
setDigit(el, 1, d_s);
setDigit(el, 2, f);
setDigit(el, 3, u_m);
setDigit(el, 4, d_m);
setDigit(el, 5, f);
setDigit(el, 6, u_h);
setDigit(el, 7, d_h);
}
void Data() {
DateTime now = myRTC.now();
v_year = now.year();
v_mon = now.month();
v_day = now.day();
u_d = v_day % 10;
d_d = v_day / 10;
u_mo = v_mon % 10;
d_mo = v_mon / 10;
u_y = v_year % 10;
d_y = (v_year / 10) % 10;
f = 10;
lc.clearDisplay(0);
setDigit(el, 0, u_y);
setDigit(el, 1, d_y);
setDigit(el, 2, f);
setDigit(el, 3, u_mo);
setDigit(el, 4, d_mo);
setDigit(el, 5, f);
setDigit(el, 6, u_d);
setDigit(el, 7, d_d);
}
void Temperatura() {
v_temp = myRTC.getTemperature();
u_t = v_temp % 10;
d_t = v_temp / 10;
t = 11;
vuoto = 12;
lc.clearDisplay(0);
setDigit(el, 0, t);
setDigit(el, 1, vuoto);
setDigit(el, 2, u_t);
setDigit(el, 3, d_t);
setDigit(el, 4, vuoto);
setDigit(el, 5, vuoto);
setDigit(el, 6, vuoto);
setDigit(el, 7, vuoto);
}
Saluti
Enrico
Quindi deduco che siano stati esclusi o i diodi oppure le resistenze?
No, probabilmente si sono guastati e non sono in grado di sostituirli.
Ciao
Enrico
Il tuo problema non è il modulo RTC, il problema è in questa riga:
... tu sai cosa fa? O l'hai copiata senza chiederti perché fosse li?
Guglielmo
Se non vado errato mi aggiorna lo RTC ogni volta che carico il programma.
Era mia intenzione nidificarla in un IF se dovesse esaurirsi l'alimentazione.
Saluti
Enrico
Non esattamenete ...
... quella riga prende la data/ora della "compilazione" (è l'unica data/ora che il compilatore può avere, quella del PC dove compili nel momento in cui compili) e la imposta sul RTC ogni volta che Arduino parte per cui ... qualsiasi cosa tu faccia, comunque tu rimetta l'ora, ogni volta che scolleghi Arduino e lo ricolleghi, riparte esattamente dalla stessa data/ora ... quella in cui hai "compilato" il programma.
Ovvio quindi che non ti tiene l'ora ...
... ogni volta riparte dalla stessa vecchia ora di compilazione
Guglielmo
Certo, quando intendevo che non "tiene" l'ora è quando stacco la corrente dal sistema e, dopo almeno 10 sec., la riattacco senza ricompilare.
Ricompilando il programma mi aggiorna (come dicevi) i dati di data/ora.
Quindi ... è proprio rotto!
Saluti
Enrico
Ho riletto ancora il tuo ultimo .... quindi lo RTC NON aggiorna di volta in volta l'ora salvata in fase di compilazione, quindi nidificandolo in un IF come mi proponevo a programma finito risolvo il problema?
Enrico
NO, eseguire i seguenti passaggi:
In questo modo il codice memorizzato nell'arduino non contiene l'ordine di aggiornamento e l'RTC e conserverà l'ora corretta.
Perfetto, grazie.
Enrico
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.