Il problema della realizzazione su breadboard e che non puoi pensare di usare il circuito come definitivo, specialmente se sui contatti dei relé passa qualche carico importante, per non parlare dei costi assurdi che vai a sostenere. Puoi continuare a non usare programmi per disegnare schemi elettrici e PCB (ma dovresti) però i definitivi li dovresti passare su millefori, in fondo la tecnica è molto dimile a quella della bread, ma puoi operare in spazi molto più ristretti, ovvio che devi usare il saldatore.

Si, hai fatto bene a ricordarlo, mi è capitato di vedere bread usate come circuiti definitivi, fortunatamente non è il mio caso, infatti se vedi a inizio topic, il circuitino di prova, l'ho montato su millefori per stare tranquilo quando ho provato i vari tipi di carico, ciò non toglie che ho voglia di imparare, e saper disegnare le pcb mi intriga...

Grazie Riccardo

Intanto COMPLIMENTI per il bellissimo assemblaggio, davvero un'opera d'arte

  Ehm, grazie, in realtà però, quando due anni fa ho iniziato a fare casini con arduino, le mie bread somigliavano tanto a piatti di spaghetti super ingarbugliati con conseguenti errori di collegamento e difficoltà nel risalire a quelli fatti, così mi sono autoimposto la disiplina e l'ordine che vedi e tutto ha cominciato ad andare meglio, in più non so ancora usare i programmi per disegnare i circuiti e passare ai pcb, così come faccio è un pò come se la pcb l'ho gia disegnata  ad ogni modo volevo solo condividere e facilitare eventuali risposte...

il relé dovrebbe garantire di per se l'isolamento galvanico, visto che non c'è alcun "rapporto" tra l'avvolgimento di pilotaggio ed i contatti meccanici, gestiti mediante elettromagnete, però nessuno ti vieta di mettere optoisolatore e darlington in serie.

Anche io ero convinto che fosse così come scrivi, eppure sia su questo forum che su altri ho letto pareri discordanti sull'isolamento galvanico offerto dai relè, non mi sogno nemmeno lontanamente di mettere in dubbio la tua competenza, ma a furia di leggere si, no, ni, so ora un po' di dubbi li ho 

Ti ringrazio.

Riccardo

Grazie Michele,
ora so perché i triac fanno così, ma vorrei comunque continuare a cercare un'alternativa all'uso dei relé, perché per me è importante l'isolamento galvanico, molti dei carichi che voglio accendere o spengere, sono o immersi o comunque a contatto con l'acqua...
A questo punto, potrei usare un i/o expandre (pcf8574), con cui comandare 8 fotoaccoppiatori (4n25), che a loro volta comandano un'array darlyngton (uln2803) per far funzionare i relé e continuare ad avere un contatto meccanico che mi permette di chiudere più o meno qualsiasi circuito (compatibilmente con le caratteristiche del relé)...

Secondo voi può funzionare?

Per farvi capire provo a scendere più nel dettaglio del progetto di controller di base per acquari che cerco di sviluppare insieme all'amico mechrekt sul forum (nell'immagine allegata la mia bread):

Come vedete, uso display 20x4 via I2C con pcf8574, un RTC DS1307, un'altro pcf8574 per i tasti (inc, dec, su, giù e ok), ed uno shif register 74hc595 (volevo imperare ad usarlo) per pilotare i darlyngton e quindi i relé a 12v e quì viene il punto:

Con i relé attualmente piloto:
Gli alimentatori di due linee di strip led sepearate alle quali applico poi effetto fadind separatamente con due mosfet irf540, quì ho già quello che volevo nel senso che posso usare sia strip led a 12 che a 24 vdc, senza modificare il circuito (gli IRF non fanno una piega).
Comando i riscaldatori per il mantenimento della temperatura dell'acqua, sulla bread ci sono infatti due DS18B20 che misurano in due punti diversi la temperatura dell'acqua e faccio la media.
Vorrei comandare due elettrovalvole per il cambio automatico dell'acqua una per lo scarico ed una per il carico ed è qui che ho problemi, perché esistono elettrovalvole per tutti i voltaggi (12/24/230 vac e vdc)...
Io vorrei che chi decidesse di usare il progetto sia libero di attaccarci quello che vuole ed attualmente ci riesco solo con i relé, la domanda quindi è ancora una volta:
Esistono alternative???
Con le mie scarsissime conoscenze di elettronica, cercando di interpretare (illusoria speranza  ) i datashhet sia degli irf che dei bjt, mi pare che questo non sia possibile, mi aiutate a capire meglio?

Grazie Riccardo.

Solo per completezza ma anche per eventuali consigli e critiche:
Alimento arduino ed i relè con un alimentatore comune da 12vdc, poi però con un 7805 ho i 5v per gli IC ed il display, il buzzer invece lo uso per avere un feedback sonoro a secondo dei tasti che premo.

Perdonami, ma non capisco...
Se pilotassi con il moc il gate ad esempio di un irf540, potrei pilotare sia grossi carichi in 230vac ad esempio 500watt che piccoli carichi 12vdc?
Di elettronica, proprio non capisco nulla   , quindi prima di farmi o fare male a qualcuno, vorrei proprio essere sicuro, poi l'RC lo posso inserire comunque?

Grazie Riccardo.

Rieccomi  ,
scusate, ma come ho già scritto in passato, con l'elettronica proprio non vado daccordo,
ho assemblato il circuito che vedete in allegato, l'ho montato su una mille fori saltando il fusibile perché mi interessava fare solo delle prove ed eccomi quà a chiedere.
Ho fatto prove con la 230vac di casa e sembra che tutto vada bene, mando il comando e lui chiude il circuito collegato, azzero e lui apre.
Ho fatto delle prove con una tensione molto più piccola, nella fattispecie, ho preso l'alimentatore (funzionante) di un modem con uscita 9vac e anche quì nessun problema, perdo appena 1 volt, ma la cosa non mi preoccupa, ho solo fatto una prova.
Ho provato a chiudere anche un circuito 12vdc e quì ho visto che con il comando accendo, ma che se poi provo a riaprirlo, rimane chiuso, probabilmente è normale, non sono in grado di capirlo      , ma se lo fosse, esiste un metodo per fare in modo che questo circuito comandi anche carichi in corrente continua?

Grazie in anticipo.

Riccardo

Grazie a tutti, 
ora sono più tranquillo, per il momento devo solo fare delle prove.

Riccardo.

Ciao a tutti,
vorrei iniziare a "giocherellare" con uno stadio del circuito di potenza che è stato postato in questo topic:

http://arduino.cc/forum/index.php/topic,58108.15.html

così sono andato nell'unico negozio di roma che conosco con lo schema del circuito ed ho acquistato i componenti, ma ora ho alcuni dubbi sul condenssatore, infatti ho chiesto un condensatore 0,1µF per 400V X2  (come consigliato da uwefed) e me ne è stato dato uno che riporta queste sigle:

MPX275-X2  
104K40/110/56/B  
250V~

identico nella forma a quello che si vede su questo link:

http://www.sumeccapacitor.com/product.php?id=20

In elettronica sono veramente scarso/nullo e ho dei dubbi che sia esattamente quello che ho chiesto, ho cercato su internet, ma i dubbi rimangono, così vi chiedo se mi hanno dato il condensatore giusto o no.

Grazie Riccardo.

Ciao a tutti,
ho seguito il consiglio di Leo72,
e dalla sua libreria ho estrapolato la sua funzione "getTimestamp" per confrontarne/capirna il funzionamento, l'ho adattata all'esempio della libreria time che si chiama "TimeSerial" per fare delle prove:

Code:

/*
 * TimeSerial.pde
 * example code illustrating Time library set through serial port messages.
 *
 * Messages consist of the letter T followed by ten digit time (as seconds since Jan 1 1970)
 * you can send the text on the next line using Serial Monitor to set the clock to noon Jan 1 2010
 T1262347200 
 *
 * A Processing example sketch to automatically send the messages is inclided in the download
 */
 
#include <Time.h> 

#define TIME_MSG_LEN  11   // time sync to PC is HEADER followed by unix time_t as ten ascii digits
#define TIME_HEADER  'T'   // Header tag for serial time sync message
#define TIME_REQUEST  7    // ASCII bell character requests a time sync message

//////////  VARIABILI DI LEO72

byte daysPerMonth[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
unsigned long time=0;
unsigned long tmstp;

void setup()  {
  Serial.begin(9600);
  setSyncProvider( requestSync);  //set function to call when sync required
  Serial.println("Waiting for sync message");
}

void loop(){   
  time = 0;
  if(Serial.available() )
  {
    processSyncMessage();
  }
  if(timeStatus()!= timeNotSet)   
  {
    digitalWrite(13,timeStatus() == timeSet); // on if synced, off if needs refresh 
    tmstp = now();
    Leo72();
    digitalClockDisplay(); 
  }
  //delay(1000);
}

void digitalClockDisplay(){
  // digital clock display of the time
  Serial.print(hour());
  printDigits(minute());
  printDigits(second());
  Serial.print(" ");
  Serial.print(day());
  Serial.print(" ");
  Serial.print(month());
  Serial.print(" ");
  Serial.print(year());
  Serial.print("    Timestamp = ");
  Serial.print(now());
  Serial.print("    LeoTimestamp = ");
  Serial.print(time);
  Serial.print("    LeoTimestamp-Timestamp = ");
  Serial.println(time - tmstp);
}

void printDigits(int digits){
  // utility function for digital clock display: prints preceding colon and leading 0
  Serial.print(":");
  if(digits < 10)
    Serial.print('0');
  Serial.print(digits);
}

void processSyncMessage() {
  // if time sync available from serial port, update time and return true
  while(Serial.available() >=  TIME_MSG_LEN ){  // time message consists of a header and ten ascii digits
    char c = Serial.read() ;
    Serial.print(c); 
    if( c == TIME_HEADER ) {       
      time_t pctime = 0;
      for(int i=0; i < TIME_MSG_LEN -1; i++){   
        c = Serial.read();         
        if( c >= '0' && c <= '9'){   
          pctime = (10 * pctime) + (c - '0') ; // convert digits to a number   
        }
      }   
      setTime(pctime);   // Sync Arduino clock to the time received on the serial port
    } 
  }
}

time_t requestSync()
{
  Serial.write(TIME_REQUEST); 
  return 0; // the time will be sent later in response to serial mesg
}


void Leo72()
{ time += (year()- 1970)*365.2422;
for (int i=0; i < month()-1; i++){
time += daysPerMonth[i]; //find day from month
}
time = ( time + day() ) * 24; //find hour from day
time = ( time + hour() ) * 60; //find minute from hours
time = ( time + minute() ) * 60; //find seconds from minute
time += second(); // add seconds
if (time>951847199) { time +=86400; } //year 2000 is a special leap year, so 1 day must be added if date is greater than 29/02/2000
        time -=86400UL; //because years start at day 0.0, not day 1.
      }

dal serial monitor, passando "T1347738804" che corrisponde come data 15/09/2012 ore 19:53:24 ecco la conferma:

Code:

Waiting for sync message
T19:53:24 15 9 2012    Timestamp = 1347738804    LeoTimestamp = 1347738804    LeoTimestamp-Timestamp = 0
19:53:25 15 9 2012    Timestamp = 1347738805    LeoTimestamp = 1347738805    LeoTimestamp-Timestamp = 0
19:53:26 15 9 2012    Timestamp = 1347738806    LeoTimestamp = 1347738806    LeoTimestamp-Timestamp = 0
19:53:27 15 9 2012    Timestamp = 1347738807    LeoTimestamp = 1347738807    LeoTimestamp-Timestamp = 0
19:53:28 15 9 2012    Timestamp = 1347738808    LeoTimestamp = 1347738808    LeoTimestamp-Timestamp = 0

Ora non mi rimane che scrivere la procedurina alla quale passare i valori che voglio per calcolare i timestamp futuri, che schiappa che sono due giorni per far girare sto sketchino...

Grazie a tutti, ma soprattutto a Leo72.

Riccardo.

Ciao,
io non sono un esperto, ma forse qui
http://arduino.cc/forum/index.php/topic,58108.15.html
trovi qualcosa di già dimensionato, ti basta usarne uno stadio.
 
Riccardo

Grazie Leo72,
ci guardo di sicuro, la tua libreria l'avevo già scaricata, perché come avrai capito mi interessa molto il controllo del tempo...
Spero prima o poi di svelare l'arcano...

Grazie.

Riccardo.

Lo UNIX Time è il numero di secondi trascorsi a partire dal 01/01/1970 e rappresenta un metodo rapido e semplice per calcolare il tempo nei calcolatori, grazie al fatto che si opera con numeri interi.

Il secondo link che hai fornito è sicuramente il più utile, in quanto l'ora che indica è riferita al GMT 0 (meridiano di Greenwich), da cui derivare tutti gli altri. Noi siamo in GMT +1 quindi lo UNIX Time "nostro" è quello indicato sul sito +2 ore espresse in secondi: una per il calcolo del fuso ed una per l'ora legale. Quindi X + (2 x 60 x 60).

L'altro sito fa la stessa cosa, ma considera un GMT -5 più l'eventuale ora legale (ecco il motivo dei diversi risultati).

Ettore Massimo Albani

Ciao,
scusami se nel post precedente ho dimenticato di ringraziarti, ero così preso dal risolvere il mio quesito che ho tralasciato le buone maniere.
Ti ringrazio ora scusa il ritardo.

Ad ogni modo il tuo post, ha risolto in parte il dubbio che avevo sul calcolo del timestamp, nel senso che una volta assunto che la differenza tra i risultati ottenuti via web dipendeva dal fuso orario ed eventualmente anche dall'ora legale, mi sono detto che la funzione now() aplicata all'orario catturato dal mio RTC (DS1307) non ne sarebbe stata influenzata e mi sono messo a scrivere le poche righe che ho postato,ottenedo appunto la differenza per eccesso che ho già scritto.

Oggi ho fatto un'altra prova ancora, ho attaccato un Mega 2560 che avevo da parte, ed ho applicato la mia formula anche all'esempio della libreria che riguarda la sincronizzazione attraverso la seriale "TimeSerial", il codice è quello che segue:

Code:

/*
 * TimeSerial.pde
 * example code illustrating Time library set through serial port messages.
 *
 * Messages consist of the letter T followed by ten digit time (as seconds since Jan 1 1970)
 * you can send the text on the next line using Serial Monitor to set the clock to noon Jan 1 2010
 T1262347200 
 *
 * A Processing example sketch to automatically send the messages is inclided in the download
 */
 
#include <Time.h> 

#define TIME_MSG_LEN  11   // time sync to PC is HEADER followed by unix time_t as ten ascii digits
#define TIME_HEADER  'T'   // Header tag for serial time sync message
#define TIME_REQUEST  7    // ASCII bell character requests a time sync message

unsigned long miotimestamp;
const unsigned long totmesiinsecondi [12]  = {0,2678400,5097600,7776000,10368000,13046400,15638400,18316800,20995200,23587200,26265600,28857600};
                   
const unsigned long annoinsec = 31536000;  // Un anno espresso in secondi
const unsigned long giornoinsec = 86400;   // Un giorno espresso in secondi
const int orainsec = 3600;                 // Un'ora spressa in secondi
const int announix = 1970;
int bisestile;


void setup()  {
  Serial.begin(9600);
  setSyncProvider( requestSync);  //set function to call when sync required
  Serial.println("Waiting for sync message");
}

void loop(){   
 
  if(Serial.available() )
  {
    processSyncMessage();
  }
  if(timeStatus()!= timeNotSet)   
  {
    digitalWrite(13,timeStatus() == timeSet); // on if synced, off if needs refresh 
    digitalClockDisplay(); 
    int indicetotmesi = month()-1;
    miotimestamp = ((year() - announix) * annoinsec) + ((int((year() - 1968) / 4)) * giornoinsec) + totmesiinsecondi[indicetotmesi] + (day() * giornoinsec) + (hour() * orainsec) + (minute() * 60) + second();
//                  (gli anni trascorsi da epoc    ) + (giorni aggiuntivi per gli anni bisestili) + (leggo nel vettorequanti sec.   + (giorni del mese in   + (ore att. in secondi)
//                                                                                                 sono passati dall' inizio anno    corso in secondi)
//                                                                                                 alla fine del mese precedente
//                                                                                                 tenedo conto della variabilità
//                                                                                                 dei mesi) 

   bisestile = (year() % 4); 
   
   if ((month() == 2) && (day() <= 29) && (bisestile = 0))
     {  miotimestamp = miotimestamp - giornoinsec; }
     // se l'anno rilevato è bisestile la formula sopra aggiunge un giorno anche se ancora non è passato il 29 febbraio quindi verifico le condizioni ed eventualmente sottraggo un giorno   
     
     
  }
  delay(1000);
}

void digitalClockDisplay(){
  // digital clock display of the time
  Serial.print(hour());
  printDigits(minute());
  printDigits(second());
  Serial.print(" ");
  Serial.print(day());
  Serial.print(" ");
  Serial.print(month());
  Serial.print(" ");
  Serial.print(year());
  Serial.print("    Timestamp = ");
  Serial.print(now());
  Serial.print("    MioTimestamp = ");
  Serial.print(miotimestamp);
  Serial.print("    Differenza = ");
  Serial.println(miotimestamp - now());
}

void printDigits(int digits){
  // utility function for digital clock display: prints preceding colon and leading 0
  Serial.print(":");
  if(digits < 10)
    Serial.print('0');
  Serial.print(digits);
}

void processSyncMessage() {
  // if time sync available from serial port, update time and return true
  while(Serial.available() >=  TIME_MSG_LEN ){  // time message consists of a header and ten ascii digits
    char c = Serial.read() ;
    Serial.print(c); 
    if( c == TIME_HEADER ) {       
      time_t pctime = 0;
      for(int i=0; i < TIME_MSG_LEN -1; i++){   
        c = Serial.read();         
        if( c >= '0' && c <= '9'){   
          pctime = (10 * pctime) + (c - '0') ; // convert digits to a number   
        }
      }   
      setTime(pctime);   // Sync Arduino clock to the time received on the serial port
    } 
  }
}

time_t requestSync()
{
  Serial.write(TIME_REQUEST); 
  return 0; // the time will be sent later in response to serial mesg
}

Anche in questo caso la differenza è stata di 20863 sec (1 in meno rispetto all'ora presa dall'RTC):

12:00:01 1 1 2010    Timestamp = 1262347201    MioTimestamp = 1262368064    Differenza = 20863

Me lo aspettavo in parte, ma ho voluto provare ugualmente...

Potrei anche fermarmi qui e semplicemente sottrarre l'eccedenza, ma mi rimarrebbe il tarlo di sapere cosa sbaglio...

Con sintesi estrema, devo eseguire in modo regolare x operazioni all'interno di un intervallo di tempo che può accavallarsi alla mezzanotte, quindi con i timestamp eseguo semplici confronti ed Arduino fa o legge qualcosa, diversemente dovrei raffontare orari che a mezzanotte si azzerano e via dicendo, non che non si faccia, ma con i timestamp il codice sarebbe decisamente più snello e risparmierei un bel po' di memoria.

Grazie a chiunque vorrà aiutarmi.

Ancora grazie a cyberhs.

Riccardo

Allora, allora,
ho preso l'esempio della libreria time.h denominato "TimeRTC" e l'ho modificato
per vedere se riesco a calcolare il timestamp, il codice è quello che segue:

Code:

/*
 * TimeRTC.pde
 * example code illustrating Time library with Real Time Clock.
 *
 */

#include <Time.h> 
#include <Wire.h> 
#include <DS1307RTC.h>  // a basic DS1307 library that returns time as a time_t

void setup()  {
  Serial.begin(9600);
  setSyncProvider(RTC.get);   // the function to get the time from the RTC
  if(timeStatus()!= timeSet)
     Serial.println("Unable to sync with the RTC");
  else
     Serial.println("RTC has set the system time");     
}

unsigned long miotimestamp;
const unsigned long totmesiinsecondi [12]  = {0,2678400,5097600,7776000,10368000,13046400,15638400,18316800,20995200,23587200,26265600,28857600};
                   
const unsigned long annoinsec = 31536000;  // Un anno espresso in secondi
const unsigned long giornoinsec = 86400;   // Un giorno espresso in secondi
const int orainsec = 3600;                 // Un'ora spressa in secondi
const int announix = 1970;
int bisestile;

void loop()
{
  int indicetotmesi = month()-1;
  miotimestamp = ((year() - announix) * annoinsec) + ((int((year() - 1968) / 4)) * giornoinsec) + totmesiinsecondi[indicetotmesi] + (day() * giornoinsec) + (hour() * orainsec) + (minute() * 60) + second();
//                (gli anni trascorsi da epoc    ) + (giorni aggiuntivi per gli anni bisestili) + (leggo nel vettorequanti sec.   + (giorni del mese in   + (ore att. in secondi)
//                                                                                                 sono passati dall' inizio anno    corso in secondi)
//                                                                                                 alla fine del mese precedente
//                                                                                                 tenedo conto della variabilità
//                                                                                                 dei mesi) 

   bisestile = (year() % 4); 
   
   if ((month() == 2) && (day() <= 29) && (bisestile = 0))
     {  miotimestamp = miotimestamp - giornoinsec; }
     // se l'anno rilevato è bisestile la formula sopra aggiunge un giorno anche se ancora non è passato il 29 febbraio quindi verifico le condizioni ed eventualmente sottraggo un giorno   
     
   digitalClockDisplay(); 
   delay(1000);
}

void digitalClockDisplay(){
  // digital clock display of the time
  Serial.print(hour());
  printDigits(minute());
  printDigits(second());
  Serial.print(" ");
  Serial.print(day());
  Serial.print(" ");
  Serial.print(month());
  Serial.print(" ");
  Serial.print(year());
  Serial.print("    Timestamp = ");
  Serial.print(now());
  Serial.print("    MioTimestamp = ");
  Serial.print(miotimestamp);
  Serial.print("    Differenza = ");
  Serial.println(miotimestamp - now());
 
}

void printDigits(int digits){
  // utility function for digital clock display: prints preceding colon and leading 0
  Serial.print(":");
  if(digits < 10)
    Serial.print('0');
  Serial.print(digits);
}

Nel serial monitor, il mio timestamp è costantemente magggiore rispetto a quello di now() di 20864 secondi  , ossia 5 ore 47 minuti e 44 secondi:

20:56:57 15 9 2012    Timestamp = 1347742617    MioTimestamp = 1347763481    Differenza = 20864

Da ore cerco di capire dove sta l'inghippo ma proprio non lo vedo  ,
Mi rendo conto che la domanda è impegnativa, ma qualcuno riesce a capire dove sbaglio...

Grazie Riccardo

Ciao a tutti,
ancora io che chiedo per la gestione del tempo:
ho bisogno di eseguire confronti tra il valore restituito da now() (i secondi trasforsi dal 1.1.1970 a now()) ed un timestamp futuro che quindi dovrei calcolarmi, solo che non riesco a capire come calcolarlo...
Da un bel po mi sbatto per capire come si calcola e creare una funzioncina, ma il valore che tiro fuori tenendo conto anche degli anni bisestili, non è mai affidabile, nel senso che ho cercato di raggiungere il risultato confrontandolo anche con quello restituito da due servizi on line:

http://www.timestampconvert.net/index.php?to=2ts&month=10&day=06&year=2013&hour=11&min=23&sec=15&ts=1347693604

http://www.unixtimestamp.com/index.php

che a loro volta restituiscono per la stessa data valori diversi, ottenedo a mia volta un terzo risultato  
Ho cercato invano anche su internet formule per il calcolo per poter a mia volta crearmi una funzioncina affidabile, ma non trovo nulla, quindi eccomi qui a chiedere aiuto...

Grazie in anticipo a tutti.

Riccardo

Grazie per i chiarimenti.

Riccardo

Scusate, scherzate o è veramente una "patacca"?
Da cosa si capisce?

Riccardo