Decoder DCC a N relais con Arduino
Moderatori: adobel55, lorelay49, cararci, MrMassy86
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Decoder DCC a N relais con Arduino
In questo thread voglio descrivervi la gestione della stazione nascosta di cui mi sto occupando.
i 23 scambi sono gestiti da 4 decoder lenz ls150 pilotati ad itinerari da RocRail.
Per la gestione dell'alimentazione delle tratte isolate avrei potuto pilotare con 2 decoder ls150 11 relais per dare e togliere tensione, ma i costi sarebbero saliti troppo per cui ho voluto tentare la strada della autocostruzione riducendo pero'
al minimo l'uso del saldatore e puntando su una soluzione basata su Arduino.
Penso di aver testato tutto quello che c'e' sul Web a proposito di Arduino e DCC e alla fine ho scelto la soluzione che mi piaceva di piu'.
Per condividerla con voi in maniera semplificata vi mostrero' come costruire un decoder con 8 relais per alimentare o meno altrettanti sezionamenti.
Immagine:
126,37 KB
La scelta dei componenti e' caduta su un clone di Arduino che si trova in rete sotto i 10 Euro e su un modulo a 8 relais che si trova intorno ai 12/15 Euro.
L'unico circuito che occorre costruire e' quello che adatta il segnale DCC ai livelli richiesti da Arduino.
Nella foto seguente potete vedere i tre moduli e il loro collegamento
Immagine:
737,14 KB
All'indirizzo http://www.mynabay.com/arduino potrete trovare il circuito che ho impiegato, le librerie necessarie per il progetto e svariati esempi.
La costruzione dell'adattatore e' stata fatta in pochi minuti su una piastrina di Veroboard.
Nella foto seguente potete vedere il circuito, l'aspetto finale e come interrompere con il cutter alcune piste per realizzare il circuito.
Immagine:
390,49 KB
In un prossimo post vi mostrero' il programma di gestione .
Non so quanti di voi possano essere interessati alla realizzazione e soprattutto quanti di voi mastichino di Arduino per cui entrero in dettagli sempre piu' specifici solo su vostra sollecitazione per non annoiare gli altri.
A disposizione.
Antonello
-
- Socio GAS TT
- Messaggi: 6309
- Iscritto il: martedì 4 settembre 2012, 18:16
- Nome: Mauro
- Regione: Estero
- Città: Madrid (España)
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
-
- Messaggi: 1619
- Iscritto il: giovedì 20 dicembre 2012, 23:47
- Nome: Walter
- Regione: Lombardia
- Città: Casarile
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
io sono interessato al tuo progetto!!
Procedi pure con le spiegazioni.
Ciao Walter :geek:
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Per partire senza combattere con l'Inglese potete partire da qui http://it.wikipedia.org/wiki/Arduino_%28hardware%29.
Una volta compreso di che si tratta http://arduino.cc/
e' il punto d'ingresso al nuovo mondo.
Nella sezione Learning potrete capire a che serve la scheda e come si programma
attraverso vari esempi.
Nella sezione Download potrete trovare e scaricare tutto il SW necessario
per caricare i vostri programmi su Arduino e per testarli.
Il Forum e' la vera miniera di soluzioni per i campi piu' disparati e c'e' anche
una sezione in italiano http://forum.arduino.cc/index.php?board=34.0,
oggettivamente meno ricca.
Nel prossimo post passero' a trattare del SW che anima il Decoder
lo sketch come ora certamente saprete.
Antonello
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Lo sketch puo' essere scaricato da qui http://www.apud.it/public/DCC/dec8rel/D ... le_v02.ino. Si tratta di una versione molto semplificata dell'analogo programma presente su Minabay, ritagliata solo per le mie attuali necessita'.
Potete scaricare la libreria con gli esempi nella versione da me utilizzata da qui http://www.apud.it/public/DCC/dec8rel/d ... der.v4.zip
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
NB con alcuni clone di Arduino i driver presenti nel SW ufficiale non funzionano.
Quelli da me utilizzati possono essere scaricati da qui http://www.apud.it/public/DCC/dec8rel/CH341SER.ZIP
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
Antonello
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Codice: Seleziona tutto
#include <DCC_Decoder.h>
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Da compilare con versione aggiornata della libreria ( 0315 ) se si usano compilatori piu' recenti della 1.0.6
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Defines and structures
//
#define kDCC_INTERRUPT 0
typedef struct
{
int address; // Address to respond to
byte output; // State of output 1=on, 0=off
int outputPin; // Arduino output pin to drive
boolean isDigital; // true=digital, false=analog. If analog must also set analogValue field
boolean isFlasher; // true=flash output, false=no time, no flash.
byte analogValue; // Value to use with analog type.
int durationMilli; // Milliseconds to leave output on for. 0 means don't auto off
unsigned long onMilli; // Used internally for timing
unsigned long offMilli; //
} DCCAccessoryAddress;
//""""""""""""""""""""""""""" Definiamo le costanti del nostro Decoder """""""""""""""""""""""""""""""""""""""""""""""""""""""""""
//"
DCCAccessoryAddress gAddresses[8]; // inserire fra parentesi quadre il numero massimo di relè da collegare a questo Decoder
int baseaddress = 700; // indirizzo iniziale del Decoder
int mstot = 200; // tempo di chiusura dei contatti del relè in millisecondi; 0 vuol dire sempre chiuso fino a nuovo comando
int firstpin = 3; // primo pin di Arduino cui viene collegato il primo relè
//"
//""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Decoder Init
//
void ConfigureDecoder()
{
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
gAddresses[0].address = baseaddress + i;
gAddresses[0].output = 0;
gAddresses[0].outputPin = firstpin + i;
//gAddresses[0].isDigital = false;
//gAddresses[0].isFlasher = false;
//gAddresses[0].analogValue = 250;
gAddresses[0].durationMilli = mstot;
}
// Setup output pins
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
if( gAddresses[i].outputPin )
{
pinMode( gAddresses[i].outputPin, OUTPUT );
}
gAddresses[i].onMilli = 0;
gAddresses[i].offMilli = 0;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Basic accessory packet handler
//
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{
// Convert NMRA packet address format to human address
address -= 1;
address "= 4;
address += 1;
address += (data & 0x06) >> 1;
boolean enable = (data & 0x01) ? 1 : 0;
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
if( address == gAddresses[i].address )
{
Serial.print("Basic addr: ");
Serial.print(address,DEC);
Serial.print(" activate: ");
Serial.println(enable,DEC);
if( enable )
{
gAddresses[i].output = 1;
gAddresses[i].onMilli = millis();
gAddresses[i].offMilli = 0;
}else{
gAddresses[i].output = 0;
gAddresses[i].onMilli = 0;
gAddresses[i].offMilli = millis();
}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Setup
//
void setup()
{
Serial.begin(9600);
DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
ConfigureDecoder();
DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Main loop
//
void loop()
{
static int addr = 0;
////////////////////////////////////////////////////////////////
// Loop DCC library
DCC.loop();
////////////////////////////////////////////////////////////////
// Bump to next address to test
if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) )
{
addr = 0;
}
////////////////////////////////////////////////////////////////
// Turn off output?
if( gAddresses[addr].offMilli && gAddresses[addr].offMilli<millis() )
{
// Clear off time
gAddresses[addr].offMilli = 0;
// Disable output
digitalWrite( gAddresses[addr].outputPin, LOW);
return;
}
////////////////////////////////////////////////////////////////
// Turn on output?
if( gAddresses[addr].onMilli && gAddresses[addr].onMilli<=millis() )
{
// Clear off time
gAddresses[addr].onMilli = 0;
// Enable output
digitalWrite( gAddresses[addr].outputPin, HIGH);
// If still enabled and a flash type, set off time
if( gAddresses[addr].durationMilli )
{
gAddresses[addr].offMilli = millis() + gAddresses[addr].durationMilli;
}
return;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
""" Carichiamo la libreria di Minabay
#include <DCC_Decoder.h>
""" Definiamo le costanti del nostro Decoder
""" inserire fra parentesi quadre il numero massimo di relè da collegare a questo Decoder; sono 16 per una scheda Arduino Uno; oltre 50 per una Arduino Mega
DCCAccessoryAddress gAddresses(8); fra parentesi quadre: qui sul forum viene una faccina !!!
""" indirizzo iniziale del Decoder a scelta sara' l'indirizzo del relè N. 1
int baseaddress = 700;
""" tempo di chiusura dei contatti del relè in millisecondi quando viene ricevuto un comando; 0 vuol dire sempre chiuso fino a nuovo comando
""" io, ad esempio ho scelto 3000 ovvero il binario rimane in tensione per 3 secondi
int mstot = 3000;
""" primo pin di Arduino cui viene collegato il pin N. 1 della scheda relè
int firstpin = 3;
""" Nella sezione seguente viene ripetuto N volte il ciclo di inizializzazione
// Decoder Init
//
void ConfigureDecoder()
{
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
gAddresses[0].address = baseaddress + i;
gAddresses[0].output = 0;
gAddresses[0].outputPin = firstpin + i;
//gAddresses[0].isDigital = false;
//gAddresses[0].isFlasher = false;
//gAddresses[0].analogValue = 250;
gAddresses[0].durationMilli = mstot;
}
// Setup output pins
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
if( gAddresses.outputPin )
{
pinMode( gAddresses.outputPin, OUTPUT );
}
gAddresses.onMilli = 0;
gAddresses.offMilli = 0;
}
}
""" Nella sezione seguente viene catturato il flusso delle informazioni DCC e trasformato in un formato comprensibile da noi e da Arduino
//
// Basic accessory packet handler
//
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{
// Convert NMRA packet address format to human address
address -= 1;
address "= 4;
address += 1;
address += (data & 0x06) >> 1;
<font color="red">"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
con il Multimaus occorre aggiungere 4 all'indirizzo trovato per far coincidere
l'indirizzo digitato con quello calcolato: verificare nel proprio sistema
address +=4;
"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""</font id="red">
boolean enable = (data & 0x01) ? 1 : 0;
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
if( address == gAddresses.address )
{
Serial.print("Basic addr: ");
Serial.print(address,DEC);
Serial.print(" activate: ");
Serial.println(enable,DEC);
if( enable )
{
gAddresses.output = 1;
gAddresses.onMilli = millis();
gAddresses.offMilli = 0;
}else{
gAddresses.output = 0;
gAddresses.onMilli = 0;
gAddresses[i].offMilli = millis();
}
}
}
}
""" Il programma vero e proprio che fa scattare il relè al'indirizzo 700 + x con x compreso fra 0 e 7
//
// Setup
//
void setup()
{
Serial.begin(9600);
DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
ConfigureDecoder();
DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
}
//
// Main loop
//
void loop()
{
static int addr = 0;
////////////////////////////////////////////////////////////////
// Loop DCC library
DCC.loop();
////////////////////////////////////////////////////////////////
// Bump to next address to test
if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) )
{
addr = 0;
}
////////////////////////////////////////////////////////////////
// Turn off output?
if( gAddresses[addr].offMilli && gAddresses[addr].offMilli<millis() )
{
// Clear off time
gAddresses[addr].offMilli = 0;
// Disable output
digitalWrite( gAddresses[addr].outputPin, LOW);
return;
}
////////////////////////////////////////////////////////////////
// Turn on output?
if( gAddresses[addr].onMilli && gAddresses[addr].onMilli<=millis() )
{
// Clear off time
gAddresses[addr].onMilli = 0;
// Enable output
digitalWrite( gAddresses[addr].outputPin, HIGH);
// If still enabled and a flash type, set off time
if( gAddresses[addr].durationMilli )
{
gAddresses[addr].offMilli = millis() + gAddresses[addr].durationMilli;
}
return;
}
}
/
Le varie righe che contengono il comando Serial.Print e Serial.Println
servono per monitorare il funzionamento: possono essere commentate.
Giocando con le porte avanzate si potrebbero comandare 8 semafori in contemporane con gli 8 relè
A questo punto mi fermo in attesa delle inevitabili domande.
Antonello
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
L'alimentatore della scheda relè deve essere diverso da quello di Arduino perche' quest'ultimo non sopporta la corrente necessariaa pilotare l'altra scheda.
Potendo meglio alimentare Arduino a 5 Volt.
I binari vanno collegati alla scheda in questa maniera
.
Antonello
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Codice: Seleziona tutto
#include <DCC_Decoder.h>
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Da compilare con versione aggiornata della libreria ( 0315 ) se si usano compilatori piu' recenti della 1.0.6
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Defines and structures
//
#define kDCC_INTERRUPT 0
typedef struct
{
int address; // Address to respond to
byte output; // State of output 1=on, 0=off
int outputPin; // Arduino output pin to drive
boolean isDigital; // true=digital, false=analog. If analog must also set analogValue field
boolean isFlasher; // true=flash output, false=no time, no flash.
byte analogValue; // Value to use with analog type.
int durationMilli; // Milliseconds to leave output on for. 0 means don't auto off
unsigned long onMilli; // Used internally for timing
unsigned long offMilli; //
} DCCAccessoryAddress;
//""""""""""""""""""""""""""" Definiamo le costanti del nostro Decoder """""""""""""""""""""""""""""""""""""""""""""""""""""""""""
//"
DCCAccessoryAddress gAddresses[8]; // inserire fra parentesi quadre il numero massimo di relè da collegare a questo Decoder
int baseaddress = 700; // indirizzo iniziale del Decoder
int mstot = 200; // tempo di chiusura dei contatti del relè in millisecondi; 0 vuol dire sempre chiuso fino a nuovo comando
int firstpin = 3; // primo pin di Arduino cui viene collegato il primo relè
//"
//""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Decoder Init
//
void ConfigureDecoder()
{
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
gAddresses[i].address = baseaddress + i;
gAddresses[i].output = 0;
gAddresses[i].outputPin = firstpin + i;
gAddresses[i].durationMilli = mstot;
}
// Setup output pins
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
if( gAddresses[i].outputPin )
{
pinMode( gAddresses[i].outputPin, OUTPUT );
}
gAddresses[i].onMilli = 0;
gAddresses[i].offMilli = 0;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Basic accessory packet handler
//
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{
// Convert NMRA packet address format to human address
address -= 1;
address "= 4;
address += 1;
address += (data & 0x06) >> 1;
// """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
address +=4; // utilizzato con Multimaus per far coincidere indirizzo digitato con indirizzo del decoder. Verificare su altri sistemi
// """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
// """""""""""""""""""""""""""""""""""""""""""""""""""" Abilitare le righe seguenti per verificare il codice trasmesso """"""""""""""""""""""""""
//Serial.print("Basic addr: ");
//Serial.println(address,DEC);
//Serial.println("""""""""""");
//Serial.println("");
// """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
boolean enable = (data & 0x01) ? 1 : 0;
for(int i=0; i<(int)(sizeof(gAddresses)/sizeof(gAddresses[0])); i++)
{
if( address == gAddresses[i].address )
{
// """""""""""""""""""""""""""""""""""""""""""""" Commentare queste righe una volta terminati i test """"""""""""""""""""""""""""""""""""""""""""
Serial.print("Basic addr: ");
Serial.print(address,DEC);
Serial.print(" activate: ");
Serial.println(enable,DEC);
// """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
if( enable )
{
gAddresses[i].output = 1;
gAddresses[i].onMilli = millis();
gAddresses[i].offMilli = 0;
}else{
gAddresses[i].output = 0;
gAddresses[i].onMilli = 0;
gAddresses[i].offMilli = millis();
}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Setup
//
void setup()
{
Serial.begin(9600);
DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
ConfigureDecoder();
DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Main loop
//
void loop()
{
static int addr = 0;
////////////////////////////////////////////////////////////////
// Loop DCC library
DCC.loop();
////////////////////////////////////////////////////////////////
// Bump to next address to test
if( ++addr >= (int)(sizeof(gAddresses)/sizeof(gAddresses[0])) )
{
addr = 0;
}
////////////////////////////////////////////////////////////////
// Turn off output?
if( gAddresses[addr].offMilli && gAddresses[addr].offMilli<millis() )
{
// Clear off time
gAddresses[addr].offMilli = 0;
// Disable output
digitalWrite( gAddresses[addr].outputPin, LOW);
return;
}
////////////////////////////////////////////////////////////////
// Turn on output?
if( gAddresses[addr].onMilli && gAddresses[addr].onMilli<=millis() )
{
// Clear off time
gAddresses[addr].onMilli = 0;
// Enable output
digitalWrite( gAddresses[addr].outputPin, HIGH);
// If still enabled and a flash type, set off time
if( gAddresses[addr].durationMilli )
{
gAddresses[addr].offMilli = millis() + gAddresses[addr].durationMilli;
}
return;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Ogni relè collegato e' visto dal sistema come se fosse uno scambio con i due stati 0 ed 1
( esempio: corretto tracciato e deviata ).
Se quindi digito sul Multimaus 703 e il tastino di deviata il relè numero 3 scatta e da' tensione al binario corrispondente facendo partire il convoglio ivi in sosta.
Dopo tre secondi il relè numero 3 si diseciterà e il binario rimarrà di nuovo senza tensione bloccando il convoglio successivo.
Se avessi deciso di mettere a zero il tempo di eccitazione allora occorrerà premere il pulsante di corretto tracciato sul Multimaus sempre all'indirizzo 703.
Nel caso del nostro plastico sarà RocRail a mandare i segnali relativi ai vari relè nella sequenza prevista, automatizzando il traffico della stazione nascosta.
Antonello
-
- Messaggi: 1619
- Iscritto il: giovedì 20 dicembre 2012, 23:47
- Nome: Walter
- Regione: Lombardia
- Città: Casarile
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Spero mi dia una mano!!!
Ciao Walter :geek:
-
- Socio GAS TT
- Messaggi: 4974
- Iscritto il: venerdì 28 ottobre 2011, 0:59
- Nome: Edgardo
- Regione: Lombardia
- Città: Muggiò
- Età: 60
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Con Ubuntu invece non danno problemi. Per IOS non saprei...
Comunque grazie per la condivisione, qualsiasi progetto inerente ad Arduino è sempre molto apprezzato.
ciao
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
http://www.mynabay.com/dcc_monitor/
Antonello
-
- Socio GAS TT
- Messaggi: 4974
- Iscritto il: venerdì 28 ottobre 2011, 0:59
- Nome: Edgardo
- Regione: Lombardia
- Città: Muggiò
- Età: 60
- Stato: Non connesso
-
- Messaggi: 830
- Iscritto il: domenica 6 dicembre 2015, 8:30
- Nome: Marco
- Regione: Piemonte
- Città: Moncalieri
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Comunque molto interessante, Marco
-
- Messaggi: 655
- Iscritto il: martedì 6 novembre 2012, 6:58
- Nome: Antonello
- Regione: Abruzzo
- Città: Pescara
- Stato: Non connesso
Re: Decoder DCC a N relais con Arduino
Immagine:
331,35 KB
Antonello