Etemenanki:
Non so perche', ma mi sa che il punto due e' quello preferibile ...
No ragazzi gli amici hanno già avuto modo di vedere e apprezzare le mie doti artistiche in tal senso :D...
Claudio_FF:
OR
i collegamenti vanno rimessi come in origine
Aspetta, mi sono accorto che il link ti riporta uno schema che ho già aggiornato da tempo...
in verità il progetto è stato aggiornato come da allegato. Non so perchè il link che condivido riporta alla vecchia versione.
pensi che col vecchio codice ora possa funzionare?
OK!
Sembra funzionare tutto, segmenti componenti e sketch dei vari test... Stasera proverò a fare un'ultima prova attaccando tutti i 4 display per vedere che funzioni tutto contemporaneamente...
Poi aggiungerò RTC e pulsanti.
volessi aggiungere anche il componente USB per programmare lo stand alone direttamente nel circuito, immagino che lo sketch finale dell'orologio NON cambi, giusto?
Eccoci! Euiva euiva ;D 
8)
con questo codice ho ricollegato il tutto (sulla breadboard) e tutto sembra funzionare.
#include <Wire.h>
#define CLOCK_PIN 2
#define LATCH_PIN 3
#define DATA_PIN 4
#define MIN_PULS 5
#define HOUR_PULS 6
//-----------------------------------------------------------------------------
// Variabili di lavoro globali (28 byte)
//-----------------------------------------------------------------------------
typedef struct {
uint32_t time;
byte stat;
} button_t;
button_t minPulsData = {millis(), 0}; // dati pulsante minuti
button_t hourPulsData = {millis(), 0}; // dati pulsante ora
uint32_t tempoPunti = millis(); // tempi di partenza
byte point = 1; // variabile per lampeggio punti
byte error = false; // true se errore lettura RTC
byte minuti = 0; // minuti correnti
byte ore = 0; // ore correnti
byte tabella[10] = {0xFC, 0x60, 0xDA, 0xF2, 0x66,
0xB6, 0xBE, 0xE0, 0xFE, 0xF6};
//-----------------------------------------------------------------------------
// Rileva click su tasti con debounch 60 ms e autorepeat dopo 1 s
//-----------------------------------------------------------------------------
bool click(byte pin, ::button_t* data){
uint32_t elapsed = millis() - data->time;
bool press = digitalRead(pin);
switch (data->stat)
{
case 0: // attesa pressione
if (press){ // se premuto
data->stat = 1; // passa ad antirimbalzo
data->time = millis();
}
return false;
case 1: // antirimbalzo pressione
if (!press){ // se non premuto
data->stat = 0; // ritorna ad attesa
return false;
}
if (elapsed > 60){ // primo click
data->stat = 2;
data->time = millis();
return true;
}
return false;
case 2: // attesa inizio autorepeat
if (!press){ // se non premuto
data->stat = 3;
data->time = millis();
return false;
}
if (elapsed > 1000){ // inizio autorepeat dopo 1 s
data->stat = 4;
data->time = millis();
return true; // primo autoclick
}
return false;
case 3: // antirimbalzo rilascio
if (press){ // se premuto
data->stat = 2;
data->time = millis();
return false;
}
if (elapsed > 60) // rilasciato
data->stat = 0; // torna ad attesa
return false;
case 4: // autorepeat
if (!press){ // se non premuto
data->stat = 5;
data->time = millis();
return false;
}
if (elapsed > 100){ // successivi click ogni 100 ms
data->time = millis();
return true;
}
return false;
case 5: // antirimbalzo rilascio
if (press){ // se premuto
data->stat = 4;
data->time = millis();
return false;
}
if (elapsed >= 60) // rilasciato
data->stat = 0; // torna ad attesa
return false;
}
}
//-----------------------------------------------------------------------------
byte binBCD(byte n){
return ((n / 10) << 4) | (n % 10);
}
//-----------------------------------------------------------------------------
void impostaRTC(){
Wire.beginTransmission(0x68); // <--- indirizzo RTC su bus i2c
Wire.write(0); // <--- punta al registro 0
Wire.write(0); // <--- azzera secondi RTC
Wire.write(binBCD(minuti)); // <--- imposta minuti RTC
Wire.write(binBCD(ore)); // <--- imposta ore RTC
Wire.endTransmission();
}
//-----------------------------------------------------------------------------
void avanzaOra(){
ore = (ore + 1) % 24;
}
//-----------------------------------------------------------------------------
void avanzaMinuto(){
if (++minuti == 60){
minuti = 0;
avanzaOra();
}
}
//-----------------------------------------------------------------------------
void blinkPunti(){
if (millis() - tempoPunti >= 500){
tempoPunti += 500;
point ^= 1;
}
}
//-----------------------------------------------------------------------------
byte BCDbin(byte n){
return ((n >> 4) * 10) + (n & 0x0F);
}
//-----------------------------------------------------------------------------
void leggiRTC(){
Wire.beginTransmission(0x68); // <--- indirizzo RTC su bus i2c
Wire.write(1); // <--- punta al registro 1
if (Wire.endTransmission()){ // <--- errore di connessione
error = true;
return;
}
Wire.requestFrom(0x68, 2); // <--- due registri da leggere
if (Wire.available() != 2){
error = true; // <--- errore di ricezione
return;
}
minuti = BCDbin(Wire.read());
ore = BCDbin(Wire.read());
error = false;
}
//-----------------------------------------------------------------------------
// Scrittura su display con blanking primo zero e lampeggio se errore
//-----------------------------------------------------------------------------
void visualizza(){
digitalWrite(LATCH_PIN, LOW);
if (error && !point){
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, 0);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, 0);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, 0);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, 0);
}else{
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, tabella[minuti%10]);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, tabella[minuti/10]);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, tabella[ore%10]|point);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, (ore/10) ? tabella[ore/10] : 0);
}
digitalWrite(LATCH_PIN, HIGH);
}
//-----------------------------------------------------------------------------
// Impostazione sistema
//-----------------------------------------------------------------------------
void setup(){
Wire.begin(); // inizializza bus i2c
pinMode(MIN_PULS, INPUT);
pinMode(HOUR_PULS, INPUT);
pinMode(LATCH_PIN, OUTPUT);
pinMode(CLOCK_PIN, OUTPUT);
pinMode(DATA_PIN, OUTPUT);
digitalWrite(CLOCK_PIN, LOW);
visualizza(); // prima scrittura su display
}
//-----------------------------------------------------------------------------
// Ciclo principale eseguito circa 800 volte al secondo
//-----------------------------------------------------------------------------
void loop(){
leggiRTC(); // lettura ora corrente da RTC
blinkPunti(); // lampeggio punti 1 Hz
if (click(MIN_PULS, &minPulsData)){ // se premuto puls.minuti
avanzaMinuto(); // regola minuti
impostaRTC();
}
if (click(HOUR_PULS, &hourPulsData)){ // se premuto puls.ore
avanzaOra(); // regola ora
impostaRTC();
}
visualizza(); // aggiorna display
}
Ore, minuti, pulsanti (minuti e ore); anche l'rtc tiene l'ora. L'arduino continua ad essere esterno... ma confido che seguendo i collegamenti indicati non avrò problemi.
L'unico piccolo neo è che i due punti centrali (due semplici LED), sono molto meno luminosi rispetto alle strip quindi si perdono un pochino (ma direi che, a questo punto, è un male necessario).
Ecco la foto.
Non mi rimane che aspettare la scheda comprata dalla cina e vedere se riesco anche a saldare il tutto.
Incrociamo le dita 
ghezzia:
...
L'unico piccolo neo è che i due punti centrali (due semplici LED), sono molto meno luminosi rispetto alle strip quindi si perdono un pochino ...
... che e' poi il motivo per cui nello schema che avevo modificato avevo messo 4 led per punto 
Comunque, nulla ti vieta, se ti e' avanzato un pezzettino di strip, di tagliare fuori due led della strip e fissarli dietro al pannello incollati a qualcosa, con i fili (e le opportune resistenze) verso il resto del circuito, per averli piu o meno luminosi come gli altri ... 
Oppure, volendo esagerare, di farti un paio di piccoli PCB monofaccia per saldarceli sopra ... roba tipo questa, ma casalinga ... pero' potrebbero anche bastare due ritagli di millefori, dato che i pin dello stesso lato vanno comunque saldati insieme ...
Etemenanki:
... che e' poi il motivo per cui nello schema che avevo modificato avevo messo 4 led per punto
Si in effetti avevo preso in considerazione questa ipotesi, però 4 led mi occupavano troppo spazio ;).
Comunque anche con 4 led credo che rimanga il problema che il colore è sostanzialmente diverso...
Etemenanki:
Comunque, nulla ti vieta, se ti e' avanzato un pezzettino di strip, di tagliare fuori due led della strip e fissarli dietro al pannello incollati a qualcosa, con i fili (e le opportune resistenze) verso il resto del circuito, per averli piu o meno luminosi come gli altri ...
Mi piace di più questa ipotesi, solo che le strip che ho (mi è avanzato qualche metro) se non sbaglio hanno il taglio ogni 3 led e non ogni led...
Inoltre sono collegati tra loro in parallelo (ogni led ha già una resistenza) come li "innesco" al circuito? GND verso l'ULN e + 12v direttamente all'ingresso? non cambia nulla anche se sono in parallelo, giusto?
P.S. ora che sto vedendo la luce del tunnel vorrei aggiungere mille cose a questo orologio... Sicuramente la possibilità che quando non c'è nessuno in casa si possano in qualche modo spegnere i led (energy saving )... Avete idee semplici da poter inserire a questo punto del progetto senza stravolgerlo?
Tu tagli fuori un LED e togli la gomma waterproof, grattando anche le piste per saldarci sopra i cavetti da portare dietro. Credo si riferisse a questo.
Ogni spezzone sono 3 LED in serie con una resistenza se non ricordo male. Leggi il valore della resistenza.
Sai che ogni LED rosso ha una caduta di tensione di 1.8 V immagino, quindi moltiplichi per 3, sottrai questo valore ai 12 volt entranti e dividi per la resistenza trovandoti la corrente passante limitata. I due LED dei punti li metti in serie, 12 V meno la caduta di tensione di soli due LED tutto quanto diviso la corrente che ti sei trovato prima e trovi la resistenza da applicare per avere più o meno la stessa luminosità.
A questo punto i due LED li tratti come fossero delle strip, per cui 12 V e massa separata.
Non ho sotto mano il tuo schema elettrico per dirti che modifiche devi fare.
Per altre idee, dipende da cosa vorresti fare tu e da quanti pin ti sono rimasti liberi.
Comunque se vuoi il modulo TTL / USB per caricare i firmware aggiornati non devi cambiare lo sketch. Però mi viene il dubbio che l'alimentazione USB e l'alimentazione data dall'LM7805 possano andare in conflitto e debbano essere divise, questo non lo so e dovrebbe risponderti qualcuno come Etem.
Si, esatto ... ogni pezzo che puoi tagliare sono tre led in serie, con la propria resistenza ... ed i tre chip all'interno di ogni led 5050 sono in parallelo fra loro ... quindi basta che li tagli (o dissaldi e risaldi su un PCB o millefori) uno ad uno, e poi calcoli la resistenza per fargli passare circa 50mA su una caduta di circa 1.8V, o meglio su una caduta di 3.6V, dato che nel tuo caso sarebbero due in serie (si potrebbe arrivare a 60mA ma e' sempre meglio rimanere leggermente sotto)
Dissaldarli e' abbastanza semplice, dato che lo stampato e' flesibile, basta piegarlo leggermente mentre scaldi (velocemente) i tre pin da un lato ...
ricki158:
Per altre idee, dipende da cosa vorresti fare tu e da quanti pin ti sono rimasti liberi.
Un'idea è quella di cui sopra: spegnere solo i led nel momento che non c'è nessuno a casa, oppure quando spegnamo le luci per evitare che di notte illumini effetto stadio tutta la cucina... Meno male non dorme nessuno in cucina :D.
ricki158:
Comunque se vuoi il modulo TTL / USB per caricare i firmware aggiornati non devi cambiare lo sketch. Però mi viene il dubbio che l'alimentazione USB e l'alimentazione data dall'LM7805 possano andare in conflitto e debbano essere divise, questo non lo so e dovrebbe risponderti qualcuno come Etem.
per questa eventualità non è sufficiente staccarlo dalla spina ogni volta che voglio collegarlo all'USB per programmarlo? (tra l'altro non credo lo farò mail )
Etemenanki:
Si, esatto ... ogni pezzo che puoi tagliare sono tre led in serie, con la propria resistenza ... ed i tre chip all'interno di ogni led 5050 sono in parallelo fra loro ... quindi basta che li tagli (o dissaldi e risaldi su un PCB o millefori) uno ad uno, e poi calcoli la resistenza per fargli passare circa 50mA su una caduta di circa 1.8V, o meglio su una caduta di 3.6V, dato che nel tuo caso sarebbero due in serie (si potrebbe arrivare a 60mA ma e' sempre meglio rimanere leggermente sotto)Dissaldarli e' abbastanza semplice, dato che lo stampato e' flesibile, basta piegarlo leggermente mentre scaldi (velocemente) i tre pin da un lato ...
quindi comunque mi stai dicendo di metterne due di led e non tre per ogni punto, corretto?
p.s. qualcuno di voi mi sa dire che "consumo energetico" potrebbe avere?
ghezzia:
...
quindi comunque mi stai dicendo di metterne due di led e non tre per ogni punto, corretto?
No, uno ... ogni led tipo 5050, come quelli delle strip, ha al suo interno tre chip, che nelle strip sono collegati in parallelo (in pratica, ogni pezzo che puoi tagliare, e' come se forssero tre gruppi di tre led in parallelo, collegati in serie fra loro) ... usando un solo led, e' come se ne usassi tre normali, con il vantaggio pero' di avere lo stesso tipo di led delle strip, quindi stesso colore e luminosita' ...
Se invece la cosa ti crea problemi, puoi usare pezzi da 3 led, ma dovresti scavare dietro al pannello due asole in modo da far affacciare ai fori solo uno dei led, ad esempio quello centrale, e rimanere nascosti dietro gli altri due ... o trasformare i punti in trattini, in modo che ci si affaccino due led per trattino, con due led in mezzo nascosti dal pannello, cosi potresti usare uno spezzone da sei ... sistemi ce ne sono piu di uno ... pero' avendo il pannello gia tagliato e rifinito, per evitare il rischio di rovinarlo, mi limiterei ad un led per foro ...
Per ridurre la luminosita' di notte, dovresti agire sul positivo in comune dei led (escludendo il PWM che preferivi evitare) ... potresti farlo usando un regolatore di tensione LDO, che regga abbastanza corrente per alimentare tutti i led, pilotato o da un segnale del micro, o piu semplicemente da una fotoresistenza o fototransistor, in modo da abbassare di un tot la tensione quando la luminosita' ambiente scende sotto un certo livello ... come alternativa, se volessi usare il PWM, potrebbe essere applicato ai pin OE degli shift, in modo da accenderli e spegnerli ad alta velocita', abbassando la luminosita' media ...
ghezzia:
per questa eventualità non è sufficiente staccarlo dalla spina ogni volta che voglio collegarlo all'USB per programmarlo?
Ni. Alimentando solo da USB si rischia di rovinare il regolatore.
Per evitare questo nel mio schema ho aggiunto i due diodi (vicino al regolatore).
Per collegare da entrambe le parti, e quindi avere anche i 12V verso le strip per test "dal vivo", nell'ultimo schema ho aggiunto apposta un jumper per sezionare i +5V provenienti da USB.
Tra l'altro io vedo in questo progetto qualcosa di ben più generale e di diverso utilizzo di un oroglogio, abbiamo 28 uscite darlington, un micro, un RTC, un collegamento FTDI, gli usi sono molteplici: scheda attuatori comandata da PC, sofisticato temporizzatore multiplo per 28 lucine presepe... ecc ecc
Etemenanki:
No, uno ... ogni led tipo 5050, come quelli delle strip, ha al suo interno tre chip, che nelle strip sono collegati in parallelo (in pratica, ogni pezzo che puoi tagliare, e' come se forssero tre gruppi di tre led in parallelo, collegati in serie fra loro) ... usando un solo led, e' come se ne usassi tre normali, con il vantaggio pero' di avere lo stesso tipo di led delle strip, quindi stesso colore e luminosita' ...
Si si, intendevo due uno per punto... è così che intendi tu, giusto? .... devo capire come gestire i "tagli" delle strip
Etemenanki:
... potresti farlo usando un regolatore di tensione LDO, che regga abbastanza corrente per alimentare tutti i led, pilotato da una fotoresistenza o fototransistor, in modo da abbassare di un tot la tensione quando la luminosita' ambiente scende sotto un certo livello ...
questa soluzione mi sembra simpatica... mi pare che non bisogna neanche intervenire sul codice giusto? io avevo già comprato questi pensi possano fare al caso mio? una foto resistenza ce l'ho, come dovrei inserire il tutto nello schema?
Claudio_FF:
Ni. Alimentando solo da USB si rischia di rovinare il regolatore.
Per evitare questo nel mio schema ho aggiunto i due diodi (vicino al regolatore).Per collegare da entrambe le parti, e quindi avere anche i 12V verso le strip per test "dal vivo", nell'ultimo schema ho aggiunto apposta un jumper per sezionare i +5V provenienti da USB.
grazie Claudio anche questo è un ottimo aiuto
Claudio_FF:
Tra l'altro io vedo in questo progetto qualcosa di ben più generale e di diverso utilizzo di un oroglogio, abbiamo 28 uscite darlington, un micro, un RTC, un collegamento FTDI, gli usi sono molteplici: scheda attuatori comandata da PC, sofisticato temporizzatore multiplo per 28 lucine presepe... ecc ecc
peccato non faccio il presepe
Claudio_FF:
Ni. Alimentando solo da USB si rischia di rovinare il regolatore.
Per evitare questo nel mio schema ho aggiunto i due diodi (vicino al regolatore).
Basta questo? Se invece ho sovratensioni per qualsiasi motivo sulla linea dei 5v sulla USB?
Parti comunque dal presupposto che potrebbe capitarti che ti dimentichi l'alimentazione collegata e vuoi cambiare il firmware, così prevedi lo scenario peggiore.
Claudio: veramente, se colleghi tutto hai 32 uscite darlington disponibili, non 28 ... e per giunta avanza ancora qualche pin da usare come ingresso, volendo farsi proprio del male
ghezzia: quello e' uno step-down, serve che la tensione di ingresso sia piu alta di quella di uscita, per funzionare correttamente ... nel tuo caso, dato che le strip vanno a 12V, potrebbe perfino bastare metterci 3 o 4 diodi in serie, e cortocircuitarli con un mosfet canale P ... quando e' aperto la luminosita' e' minore, e viceversa ... oppure servirebbe alimentare il tutto con poco piu di 12V, ed in quel caso potresti usare uno degli step-down come preregolatore per il 7805, abbassandolo a 9V (cosi scalderebbe di meno), ed un'altro sul positivo dei led, collegando la fotoresistenza al trimmer di regolazione (o meglio, sostituendo il trimmer con un partitore che incorpori anche una fotoresistenza, occhio alle saldature, e' roba SMD e si fa presto a rovinarla se non si fa attenzione), in modo che piu c'e' luce e piu la tensione aumenta, e viceversa ...
Etemenanki:
ghezzia: quello e' uno step-down, serve che la tensione di ingresso sia piu alta di quella di uscita, per funzionare correttamente ... nel tuo caso, dato che le strip vanno a 12V, potrebbe perfino bastare metterci 3 o 4 diodi in serie, e cortocircuitarli con un mosfet canale P ... quando e' aperto la luminosita' e' minore, e viceversa
mmmm mi sono perso
La seconda parte mi è invece più chiara, anche se non semplicissima da realizzare, solo che io ho il trasformatore che fa uscire 12v.... da quello che ho capito ne servirebbero di più giusto?
@Etem... diceva di fare una cosa così..
brunello: si, ma come diodi prenderei quelli da almeno 3A, cosi scaldano ancora di meno ... la serie 1N regge 1A massimo, ma gia a 500mA iniziano a scaldarsi un po ... oppure, si possono sempre mettere tre diodi in parallelo per ognuno di quelli nello schema, tanto costano pochi centesimi l'uno ... mentre per il numero di unita' in serie, va trovata sperimentalmente la quantita' che da la luminosita' desiderata ...
ghezzia: quegli step-down usano un MP1584 come integrato, ed il trimmer e' fra l'uscita ed il pin FB, mentre di solito fra FB e massa usano una resistenza fissa ... dato che la fotoresistenza diminuisce il valore con l'aumentare della luminosita', bisogna metterla (con un secondo trimmer in serie) in parallelo alla resistenza che va dal pin FB a massa ... in questo modo si puo regolare in modo che la tensione di uscita aumenti quando la luce aumenta (fino ad un certo punto ovviamente), ed al contrario si riduca al buio, diminuendo la luminosita' dei segmenti ... siccome i componenti li sono SMD, il sistema migliore e' saldare due fili lunghi 4 o 5 cm ai capi della resistenza in questione (senza toglierla dallo stampato ovviamente), e poi saldare la serie fotoresistenza/trimmer ai fili, in modo da non forzare sulle saldature del modulino ... pero' bisogna che abbiano almeno tre volt di differenza fra ingresso ed uscita per poter funzionare correttamente, quindi per tirarci fuori i 12V per il massimo di luminosita', servirebbe alimentarli con minimo 15 o 16 V ... ci sono alimentatori per portatili che danno 16V in uscita (quelli dei vecchi IBM/Lenovo, ad esempio), oppure gli universali che hanno il cambio tensione ... e su ebay ormai non costano piu molto ... esempio ... pero' con il 12V in ingresso, lo step-down piu di 9 in uscita non te ne darebbe ...
Il sistema con i diodi ed il mosfet e' piu "grossolano", avresti piu che altro una specie di commutazione invece che una regolazione proporzionale, ma basterebbero i 12V che hai, ed i componenti si possono far stare sul PCB ... o anche su un pezzo di millefori a parte ... rispetto allo schema di Brunello, si collega la fotoresistenza alla base del transistor tramite un trimmer, in modo da poter regolare la soglia di accensione in base alla luminosita' ambiente, piu un paio di condensatori come filtro ... ed usando un mosfet per alta corrente, non dovrebbe servire neppure un dissipatore ...