Scheda rele I/O con connessione USB

Scheda I/O USB

La scheda relè proposta in questo articolo permette di comandare dei relè e di leggere lo stato di alcuni ingressi digitali in modo semplice e con costi contenuti (da 39 euro).

L’immagine ingrandita della scheda
La scheda i/o relè è utilizzabile in numerose applicazioni, ad esempio, nella domotica, automazione industriale, ecc… Tramite un applicativo software sarà possibile controllare l’impianto di climatizzazione, irrigazione del giardino, luci, elettrodomestici in generale.

Scheda Rele USB: descrizione scheda

La parte di alimentazione viene prelevata dal bus USB. Il bus USB è in grado di erogare sino a 500 mAmpere, che sono più che sufficienti per pilotare alcuni relè e/o un display. La tensione sul bus USB è stabilizzata, quindi non occorre che la scheda abbia uno stabilizzatore di tensione.
Il microcontrollore ha a bordo un driver per USB che rende il dispositivo interfacciabile in modo semplice con l’USB. Oltre a pilotare i relè, la scheda relè ha degli ingressi (sino a otto) optoisolati (In pratica la tensione di ingresso entra in un fotodiodo che attiva un fototransistor collegato ad una resistenza di pull-up. Se nel fotodiodo non circola corrente, la resistenza di pull-up fa sentire sul pin una tensione di 5V. Mentre se circola corrente, il transistor si chiude e porta il pin a massa).
E’ possibile collegare a questi ingressi alcuni pulsanti, degli interruttori, oppure è possibile collegare l’ingresso in modo da avere un feedback sulla effettiva accensione del relè. Ad esempio, collegando l’ingresso in parallelo al carico del relè, si realizza un controllo ad anello chiuso.

Pilotare la scheda è molto semplice, collegandola al bus USB la periferica viene riconosciuta come una seriale RS232 virtuale, non occorre quindi conoscere il complicato protocollo USB. Inoltre non necessita di alcun driver di installazione per il suo utilizzo.
La comunicazione fra la scheda e il pc avviene tramite un protocollo molto semplice ( Vedi protocollo di comunicazione). Inviando il carattere "6" sulla seriale virtuale la scheda attiverà il primo relè e risponderà "I" dando evidenza che il comando è stato ricevuto.

scheda relè opto

Descrizione componenti dell scheda relè usb

I componenti usati per la creazione della scheda elettronica sono :

  • Una basetta doppio strato con serigrafia
  • Un microcontrollore Microchip (18f2455 – Datasheet) dotato di 32 Kb di memoria flash , 256 byte di memoria Eeprom. e controller USB
  • Array di transistor per il pilotaggio di relè (ULN2003)
  • Optoisolatore per lettura degli ingressi(TPL4N25-4)
  • Connettore USB
  • Relè. Possono essere montati due tipi di relè, uno a bassa tensione(30Vcc,125vac) oppure in alta tensione (230Vac,2A).

Schemi della scheda relè

Schematic USB scheda relè
Fig. 1

 

Schematic USB Board (2)
Fig. 2

Realizzazione firmware scheda usb relè

Una volta ultimata la realizzazione della scheda, è necessario programmare il microcontrollore tramite un apposito programmatore. Il programmatore trasferisce il file binario contenente il firmware della scheda dal PC al Microcontrollore. Questa operazione è chiamata ICSP ( In Circuit Serial Programming ). Il firmware è sviluppato in ANSI C. Il microcontrollore utilizzato è il 18F2455 della Microchip.

Ecco il sorgente del microcontrollore:

void main(void)
{
/* A7  A6  A5  A4  A3  A2  A1  A0 */
/*    1     1     1     1    1     1     0     0 */
LATA &= 0x0; TRISA &= 0xFC; /* configurazione della porta A del uC */
/* B7 B6 B5 B4 B3 B2 B1 B0  */
/*    1   1    1    1   1    1   1    1  */
LATB &= 0x0; TRISB &= 0xFF; /* configurazione della porta B del uC */
/* C7 C6 C5 C4 C3 C2 C1 C0 */
/*   0    0    1    1   1    1   0    0 */
LATC &= 0x0; TRISC &= 0x3C; /* configurazione della porta C del uC */
InitializeSystem();
mLED_1_Off();
MSB_num_riavvii = LeggiEEPROM(0x20);
LSB_num_riavvii = LeggiEEPROM(0x21);
if ((MSB_num_riavvii == 0xFF)&(LSB_num_riavvii == 0xFF)){
/* eeprom vergine*/
MSB_num_riavvii = 0 ;
LSB_num_riavvii = 0 ;
ScriviEEPROM ( 0x20, 0);
ScriviEEPROM ( 0x21, 0);
}
else
{
if (LSB_num_riavvii == 0xFF){
MSB_num_riavvii = MSB_num_riavvii +1;
ScriviEEPROM ( 0x20, MSB_num_riavvii);
ScriviEEPROM ( 0x21, 0);
LSB_num_riavvii = 0;
}
else
{
LSB_num_riavvii = LSB_num_riavvii +1;
ScriviEEPROM ( 0x21, LSB_num_riavvii);
}
}
EnablePullups();     /* abilita i resistori di pull-up sulla PORTB */
while(1)
{
USBTasks();        /*  USB Tasks  */
ProcessIO();        /* See user\user.c & .h */
}
}
void ProcessIO(void)
{
if((usb_device_state < CONFIGURED_STATE)||(UCONbits.SUSPND==1)) return;
if(getsUSBUSART(input_buffer,1)){
...
if(input_buffer[0] == '6') /* 0x36 */ {
if(mUSBUSARTIsTxTrfReady()){
mRele_1_On();                /* accendo relè numero 1*/
putrsUSBUSART("I");    /* acknoledge */
}
}
...
}
}

La funzione ProcessIO( ) rimane in attesa di un comando.
In questo esempio, si nota che quando si riceve via seriale il carattere "6" il relè 1 viene attivato, è quindi data conferma della ricezione del comando inviando il carattere "I". Ovviamente questa funzione deve essere implementata per ogni relè presente sulla scheda. Inoltre è possibile controllare il numero di riavvii della scheda. Nel sorgente del firmware è presente un contatore, questo viene incrementato ogni qualvolta che la scheda viene accesa. Il valore del contatore viene salvato in Eeprom.

Realizzazione Software.

Il software per interfacciarsi con la scheda è stato sviluppato in Visual Basic. Dalla ToolBox di sinistra basta importare il controllo SerialPort.
Di questo controllo useremo solo 3 funzioni, Open, Write, Read

Come primo step occorre aprire la porta seriale.
Per aprire la porta seriale usiamo la funzione SerialPort.Open

A questa funzione si deve passare un parametro che rappresenta il numero della porta seriale virtuale.
Tipicamente la scheda viene vista come COM4.
Una volta che la porta seriale è stata aperta,possiamo inviare i comandi tramite la funzione SerialPort.Write

Ad esempio, inviando il char "6" si attiva il relè 1.
SerialPort.Write("6") ‘ Attiva il relè 1

Per leggere la risposta della scheda, che conferma la ricezione e l’esecuzione del comando si usa la funzione Read. Quindi ,questa funzione non fa altro che leggere una stringa dalla porta seriale virtuale.

scheda rele visual basic

Appendice: Protocollo di comunicazione.

Ecco il protocollo della scheda relè:

Invio 0 = 0x30 = 48 => Accende led 1 e risponde "A"

Invio 2 = 0x32 = 50 => Spegne led 1 e risponde "C"
Invio 5 = 0x35 = 53 => se pulsante premuto risponde "G" altrimenti "H"
Invio 6 = 0x36 = 54 => Accende Relè 1 e risponde "I"
Invio 7 = 0x37 = 55 => Spegne Relè 1 e risponde "L"
Invio 8 = 0x38 = 56 => Accende Relè 2 e risponde "M"
Invio 9 = 0x39 = 57 => Spegne Relè 2 e risponde "N"
Invio a = 0x61 = 97 => Accende Relay 3 e risponde "O"
Invio b = 0x62 = 98 => Spegne Relay 3 e risponde "P"
Invio c = 0x63 = 99 => Accende Relay 4 e risponde "Q"
Invio d = 0x64 = 100 => Spegne Relay 4 e risponde "R"
Invio e = 0x65 = 101 => se input 1 è alto risponde "S" altrimenti "T"
Invio f = 0x66 = 102 => se input 2 è alto risponde "U" altrimenti "V"
Invio g = 0x67 = 103 => se input 3 è alto risponde "W" altrimenti "Y"
Invio h = 0x68 = 104 => se input 4 è alto risponde "J" altrimenti "K"
Invio i = 0x69 = 105 => se input 5 è alto risponde "Z" altrimenti "a"
Invio l = 0x6C = 108 => se input 6 è alto risponde "b" altrimenti "c"
Invio m = 0x6D = 109 => se input 7 è alto risponde "d" altrimenti "e"
Invio n = 0x6E = 110 => se input 8 è alto risponde "f" altrimenti "g"
Invio o = 0x6F = 111 => Accende Relè 5 e risponde "H"
Invio p = 0x70 = 112 => Spegne Relè 5 e risponde "B"
Invio q = 0x71 = 113 => Accende Relè 6 e risponde "D"
Invio r = 0x72 = 114 => Spegne Relè 6 e risponde "E"
Invio s = 0x73 = 115 => Accende Relè 7 e risponde "F"
Invio t = 0x74 = 116 => Spegne Relè 7 e risponde "G"
Invio u = 0x75 = 117 => Accende Relè 8 e risponde "X"
Invio v = 0x76 = 118 => Spegne Relè 8 e risponde "m"

E’ possibile anche leggere il numero di volte che la scheda è stata accesa

Invio w = 0x77 = 119 => Legge il numero di riavvii: Parte alta.
Invio z = 0x7A = 122 => Legge il numero di riavvii: Parte bassa.
STAMPA

7 Comments

  1. cremona_luigi 27 maggio 2010
  2. Emanuele 1 ottobre 2008
  3. daihoa 1 ottobre 2008
  4. cybergatto 8 ottobre 2008
  5. lucas 9 ottobre 2008
  6. cybergatto 9 ottobre 2008
  7. bulbapeppe 25 maggio 2009

Leave a Reply