Schema e pcb

Poco tempo fa ho pensato di  realizzare un semplice alimentatore stabilizzato a +5 Volt, che possa essere montato sulla BreadBoard, per una questione di comodità facilitando le operazioni di montaggio sulla basetta sperimentale.
Questo alimentatore funziona nel seguente modo: riceve in ingresso una tensione compresa nel range 8-20V e fornisce in uscita una tensione stabilizzata di  5Volt. La tensione in ingresso alla scheda può essere fornita tramite l’utilizzo di un connettore jack DC. La corrente massima che può erogare l’integrato 7805 è pari a 1,5 ampere, ma disponendo  di un piccolo dissipatore (come nella foto) sarà meglio non prelevare più di 500mA, altrimenti, l’integrato si surriscalderà fino a saltare. Inoltre sulla scheda è stato inserito uno switch per poter accendere o spegnere in maniera rapida il circuito che si sta alimentando senza la necessità di scollegare il cavo di alimentazione.
Il condensatore C1 ha la funzione di livellare la tensione presenta all’ingresso del circuito mentre C2, C3 servono ad eliminare eventuali disturbi presenti in uscita.Il diodo D1 ha lo scopo di salvaguardare il circuito in caso di errato inserimento della tensione di alimentazione. L’accensione del led segnala la presenza della tensione d’uscita. Come riportato nelle caratteristiche dell’intergrato l’alimentazione del circuito dovrà essere compresa tra i 8 e i 20 V continui, nel caso si notasse un surriscaldamento dell’integrato è possibile montare su di esso un’apposita aletta di raffreddamento.

 Caratteristiche

- Tensione in input: 8-20V (Power Jack);
- Tensione in output:  5V;
-  Corrente (max) in output: 500mA;
- Switch per accensione/spegnimento (ON/OFF);
- Power Status Led;

Schema e pcb

Questo è lo schema del circuito:

Questo è lo schema pratico di montaggio dell’alimentatore, e più in basso abbiamo il pcb per la realizzazione.

Poco tempo fa mi era venuta l’ossessione del tracciamento visivo di oggetti dopo aver visto vari video su youtube. Con l’intento di realizzare qualcosa di simile, mi sono armato di pazienza e di amore verso Google. Ho scovato tutorial qua e la e soprattutto l’ambiente ideale per sviluppare applicazioni con le librerie OpenCV.

Così ho scaricato l’SDK delle OpenCV, installato eclipse galileo e il compilatore C++ chiamato MinGW per applicazioni Windows.
Dopo vari tentativi ed insuccessi, sono riuscito a tracciare il movimento di una pallina gialla (color detection).
Per il riconoscimento vengono usati appositi filtri che eliminano dai frame provenienti dalla webcam (io ho usato una webcam virtuale free di nome ManyCam) eventuali disturbi e rumori visivi. In sostanza, per eliminare ciò che non serve per il riconoscimento di uno specifico colore, si usa la tecnica del threshold, ovvero della “soglia”. Se un particolare pixel appartiene ed è contenuto dentro ad una certa soglia (come un comparatore a finestra), allora quel pixel verrà colorato di bianco, viceversa di nero. Si avrà così un’immagine che sarà bianca solo nei punti in cui si trova in quel momento la nostra pallina. Questa tecnica è chiamata anche “binarizzazione immagine” per via dei soli due bit (bianco e nero) usati per l’immagine.

Esempio di applicazione del filtro di THRESHOLD

Ovviamente, di seguito il video che mostra il sistema:

I sorgenti verranno inseriti quando perfezionerò il tutto ed a lavoro ultimato.

Un utilissimo strumento, quando si effettuano molte modifiche al firmware (come in fase di test) o semplicemente per comodità, è il bootloader.

Il bootloader è essenzialmente un codice all’interno del microcontrollore che permette di caricare nuovo codice “utente” o di “applicazione” senza staccare e/o collegare un programmatore esterno alla scheda, come normalmente avviene nella fase di programmazione di un microcontrollore.

Tramite un software su PC, è possibile fare il download (scaricare) dell’HEX del nostro programma sul PIC, senza appunto staccarlo.

Ma come funziona il bootloader e cosa succede all’avvio del PIC?

Quando il PIC viene avviato, questo codice di BOOT controlla lo stato di un pin di ingresso, se questo pin è ad un certo stato logico (con un pulsante si porta a 0 logico il piedino) allora viene creata una connessione (UART oppure USB) con il PC e si entra appunto in fase di boot. Se il pulsante di boot non è stato premuto, il PIC passa nella locazione di memoria del codice della nostra applicazione, come su un normale dispositivo programmato comunemente.

Un esempio grafico della mappatura della memoria di un PIC con bootloader:

Se il bootloader viene avviato, il PIC processerà le istruzioni all’interno di quel blocco, altrimenti passerà al blocco “User Code”, ovvero il codice della nostra applicazione sviluppata.

Da notare, che in presenza di bootloader, bisogna “rimappare” le porzioni di memoria riservata al nostro firmware in fase di sviluppo. Come vedete infatti, gli interrupt vector (con freccia tratteggiata) rimandano alla locazione di memoria rimappata dal programmatore in fase di sviluppo. Ad esempio, se si scatena un’interrupt su piedino esterno, il PIC salterà alla locazione “Interrupt Vector xx”, dove in questa locazione ci sarà un salto alla locazione “User Interrupt Vector xx”.

Bene, ora conosco cos’è questo bootloader! Ma come lo ottengo?

Esistono versioni “originali” creata dalla stessa Microchip e proprio da quest’ultima, preleveremo il nostro bootloader USB.

Per prima cosa, bisogna realizzare lo schema di implementazione del bootloader:

E programma il PIC (con il connettore ICSP) oppure con programmazione esterna staccando il PIC, con questo file .hex (i sorgenti sono qui).

Programmato il PIC, alimenta la scheda (nello schema si usa l’alimentazione del bus USB, quindi basta attaccare il cavo al PC) e per entrare nel programma di boot, tieni premuto il pulsante S2 e contemporaneamentre premi il pulsante S1, quindi rilascia S1, e poco dopo rilascia S2.

Se tutto è montato correttamente, la prima volta di utilizzo, il tuo computer rileverà una nuova interfaccia usb. E’ il nostro bootloader!

Se non lo hai già fatto, scarica il framework USB della Microchip da qui.

Installa il pacchetto selezionando, in fase di installazione, gli esempi della Microchip. Al termine dell’installazione troverai i firmware ed i progetti sviluppati in MPLAB che potrai modificare a tuo piacere.

Attenzione! Se nel tuo progetto fai utilizzo del bootloader, bisogna rimappare l’area di memoria riservata a vettori, locazioni di configurazione, memoria programma etc..

Per fare questo bisogna passare al linker del compilatore, un file modificato che puoi trovare qui (per il PIC18F4550).

Ora puoi utilizzare il bootloader per caricare i tuoi firmware velocemente e in modo pulito, hai bisogno solo della scheda con il PIC e due pulsanti!

AGGIORNARE IL FIRMWARE

Per aggiornare il firmware tramite bootloader quindi, si ha bisogno di un software che comunichi e carichi il nostro firmware (il nostro bel file .hex) sul PIC. La Microchip ha sviluppato un tool apposito, il “PICDEM FS  USB Demo Tool”, realizzato per comunicare con la scheda “PICDEM” fabbricata dalla stessa Microchip. Infatti il circuito raffigurato sopra è proprio la copia della scheda PICDEM originale.

Puoi scaricare il tool direttamente da ElettroEasy, andando qui.

Apriamo quindi il file “PDFSUSB.exe” contenuto nell’archivio ed all’avvio si presenterà così:

Quest’ottimo tool ci permette non solo di scrivere ma anche leggere la memoria programma del nostro PIC, inoltre effettua un check dei FUSES compatibili con la scheda PICDEM. Quindi se nel vostro progetto cambierete alcuni FUSES impostati di default sul progetto del PICDEM originale della Microchip, il software lo segnalerà con un avviso e se si verificherà un’errore critico, non permetterà la riscrittura della memoria.

Bene, colleghiamo la nostra scheda all’ingresso USB. Se tutto è andato per il verso giusto, il PC rileverà un nuovo dispositivo USB e in pochi istanti sarà pronto per essere utilizzato.

Andiamo a selezionare il nostro dispositivo alla voce “Select PICDEM FS USB Board” e selezioniamo l’unica (dipende da quante schede avete collegato) voce “PICDEM FS USB 0 (Boot)”.

Ora si sbloccheranno anche le varie funzioni del programma, interagendo pienamente con il PIC.

Per aggiornare il firmware, facciamo click sul pulsante “Load HEX file” e selezioniamo il nostro firmware (che ricordo deve essere compilato utilizzando il template in MPLAB del PICDEM che puoi trovare qui). A questo punto, se non abbiamo incontrato errori, facciamo click sul pulsante “Program Device“, aspettiamo alcuni istanti ed il nostro firmware è stato caricato sul nostro PIC in maniera pulita, veloce e se vogliamo, in maniera “professionale”.

Se si sono verificati errori nella fase di caricamento del firmware, consiglio di riguardare il sorgente e adattarlo alla Board originale della Microchip. In particolare è meglio non toccare le configurazioni dei FUSES.

Per poter eseguire il programma appena caricato, basta fare un reset del PIC, tramite il pulsante posto sul pin MCLR oppure utilizzando il pulsante “Execute” presente sul tool.

Come già detto, oltre a programmare è possibile anche leggere, salvare la memoria programma, cancellare la memoria e anche provare alcune funzioni Demo della board, ma che in questo caso non sono state implementate dal nostro circuito.

Bene, penso sia tutto per quanto riguarda questa breve e semplice infarinatura del Bootloader per il PIC 18F4550.

Scoprilo con la relazione in PDF scritta da me!

Per leggere la relazione, clicca qui -> Relazione EasyPIC5 (di Simone Giugliani)

In questa terza lezione di Arduino voglio presentarvi un semplice semaforo didattico,  che eseguirà tramite dei LED la sequenza da verde, giallo lampeggiante, rosso. Questo progetto potrebbe essere utilizzato su un modello ferroviario.

Esercizio 3 componenti utilizzati :

Per la realizzazione di questo semaforo occorrono:

-  la bread-board;
- 3 LED possibilmente di tre colori diversi (rosso,giallo,verde);
- 3 resistenze da 220 ohm 1/4 watt;
- cavi per bread-board.

 Come si nota dal programma ho utilizzato l’ istruzione for che in questo caso permette di far lampeggiare 10  volte il led giallo. E’ possibile determina l’esecuzione di una porzione di programma ripetuta per un certo numero di volte, modificando semplicemente il valore della condizione, in questo caso è 10.

L’istruzione for serve per ripetere un blocco di istruzioni racchiuso tra parentesi graffe. Si distingue in questo modo da altre forme di ciclo, come il ciclo while, che determina la ripetizione di una porzione di un programma fino al verificarsi di una determinata condizione. La scelta fra questi due tipi di ciclo è legata a considerazioni di leggibilità e chiarezza del codice; in linea di principio, infatti, qualunque algoritmo che impieghi un ciclo  for può essere trascritto in una forma che usa solo il ciclo while, e viceversa.

Ci sono tre parti per il  ciclo di intestazione:

for ( l'inizializzazione , condizione , incremento )

{ qui si fa qualcosa;

}

Programma :

int redPin = 10;//led connesso al pin digitale 10
int yellowPin = 9;//led connesso al pin digitale 9
int greenPin = 8;//led connesso al pin digitale 8
void setup() { //ripeti una sola volta quando il programma inizia
pinMode(redPin, OUTPUT);//imposta il pin come uscita
pinMode(yellowPin, OUTPUT);//imposta il pin come uscita
pinMode(greenPin, OUTPUT);//imposta il pin come uscita
}
void loop() {  //esegui più volte
digitalWrite(redPin, LOW);// imposta il pin digitale a livello basso
digitalWrite(greenPin, HIGH);// imposta il pin digitale a livello alto
digitalWrite(yellowPin,LOW);//imposta il pin digitale a livello basso
delay(10000);//attende 10 secondi
digitalWrite(greenPin,LOW);//imposta il pin digitale a livello basso
for(int x = 0; x < 10; x++) { //ripeti 10 volte
 digitalWrite(yellowPin,HIGH);//imposta il pin digitale a livello alto
 delay(500);//attende 500ms
 digitalWrite(yellowPin,LOW);//imposta il pin digitale a livello basso
 }
digitalWrite(yellowPin, LOW); // imposta il pin digitale a livello basso
digitalWrite(greenPin, LOW); // imposta il pin digitale a livello basso
digitalWrite(redPin, HIGH); //imposta il pin digitale a livello alto
delay(10000); // attendi 10 secondi
}

Schema :

Lo schema non richiede particolari spiegazioni, vi ricordo di rispettare la polarità dei 3 led, il pin più lungo è l’anodo (+), mentre il pin più corto è il catodo (-). Come si nota dallo schema bisogna  inserire come sempre sull ‘anodo del LED una resistenza da 220 ohm circa,ed infine collegarla al pin digitale corrispondente.

a cura di: Conicella Valerio

I Programmable Integrated Circuit si divino in “famiglie” ovvero gruppi di PIC riuniti per funzioni, porte di I/O, numeri di pin, tipo di memoria, quantità di memoria etc..Si parte da PIC con poche funzioni e numeri di pin come i PIC 12C5xx fino ad arrivare a PIC più grandi che contengono numerose funzioni e numeri di pin.
I PIC possono essere usati in migliaia di applicazioni, sia complicate che semplici..Le applicazioni più comuni riguardano il timing, l’automazione ed il controllo di apparecchiature varie. In questo articolo vedremo come far lampeggiare un led.

Prima di tutto abbiamo bisogno dello schema, ed è il seguente:

Come si vede sul semplice schema abbiamo usato pochi componenti. 2 condensatori da 22pF (C1, C2), 1 quarzo da 4 mhZ, 1 resistenza da 220 ohm (R2) e un’altra da 4,7k ohm (R1) e il led. La configurazione dei condensatori e del quarzo serve per dare si una giusta frequenza al PIC (la frequenza serve per scandire i processi del PIC) ma anche uno sbilanciamento iniziale dato dai condensatori. La tensione di alimentazione per qualsiasi PIC è di 5V…
ATTENZIONE: Non superare la tensione di alimentazione per evitare il malfunzionamento oppure la rottura dell’integrato stesso. Di solito per stabilizzare la tensione si usa un regolatore di tensione (es. 7805) molto semplice da costruire che vedremo presto nelle pagine di questo sito.
Per far funzionare il PIC serve anche il codice eseguibile (in formato HEX ovvero esadecimale) da inserire nel PIC. Al giorno d’oggi, molti ambienti di sviluppo e linguaggi di programmazione ci vengono incontro per creare codice per il nostro gioiellino. Un linguaggio di programmazione molto diffuso ma che a prima vista e a primo approcio si presenta difficile e incomprensibile è l’ASSEMBLER un linguaggio macchina di basso livello, e se vogliamo dire anche un pò sorpassato. Noi non tratteremo dell’assembler ma parleremo del linguaggio di programmazione C rivolto per i PIC.
Il C si presenta più flessibile e comprensibile per un principiante, ma anche per un professionista. Ma quale codice dobbiamo inserire nel PIC??….è presto detto:
Il nostro primo programma farà lampeggiare il nostro led situato sul piedino 6 ovvero RB0, la prima porta della serie di I/O B. Quindi ecco il codice (sviluppato in MikroC):

void main(){
TRISB = 0;
while(1){
PORTB = 0b00000001;
Delay_ms(250);
PORTB = 0b00000000;
Delay_ms(250);
}}

Esaminiamo il codice..
void main() è l’inizio del programma. Ogni programma sull’ambiente di sviluppo MikroC inizia con questa riga ( void main() specifica una funzione. In questo caso la principale)
TRISB = 0; configura le porte di I/O della serie B come uscite (Output). Mettendo 1 le porte sono di entrata (Input)
while (1) crea un ciclo all’infinito grazie al while che processa le istruzioni solamente quando la sua condizione è vera. In questo caso, con 1, è sempre vera.
PORTB = 0b00000001; Manda l’uscita RB0 (pin 6) del PIC a livello alto (+5V) quindi per far accendere il LED.

Delay_ms(250); Genera un ritardo software. Il PIC in parole povere si addormenta per poi risvegliarsi dopo il tempo passatogli come parametro. Ovviamente è possibile cambiare il tempo che in questa caso è espresso in millisecondi. 250 ms corrispondo ad 1/4 di secondo..
E infine le parentesi di chiusura.
Avendo un ciclo all’infinito il led si spegnerà e si accenderà ogni 250 ms fino allo spegnimento del circuito.

IL PROGRAMMATORE
Molti si staranno chiedendo, “ma come è possibile inserire un file “astratto” in un circuito integrato?!?”. E bene, ci viene in contro il programmatore.
Il programmatore è un dispositivo hardware che interfaccia il PC con il nostro PIC. Il classico e più semplice programmatore è il ludipipo.
Questo è lo schema:

In questo caso il programmatore è di tipo seriale, non molto affidabile. Se pensate di voler fare sul serio con i PIC vi consiglio di comprare il pickit2 che è originale Microchip, è USB è programma tranquillamente quasi tutti i PIC.

Come vedete è molto semplice. La lista dei componenti è la seguente:

R1,R2 = 2,2K
R3=22K
R4=5,6K
D2=1N4148
D1=5V6 (zener)
C1=10uF
Connettore DB9 femmina

Il programmatore però deve comunicare con il PC tramite un altro software inerenti i PIC. Esso è sempre un programmatore ma è un software che programma il PIC.

Il più noto è IC-Prog. Potete scaricare IC-Prog da qui.

IC-Prog si presenta così:

Se avete Windows XP o superiori aprite la cartella appena estratta. Non vi resta che aprire il file ICProg.bat e configurare il software in questo modo:

Aprite IC-Prog e andare su Settaggi -> Opzioni e sul Tabs Misc. Spuntare la voce Abilita il driver NT/2000/XP. A questo punto potete programmare il vostro PIC

In Windows 98 non c’è bisogno del driver poichè permette la comunicazione diretta con le periferche. Con le nuove versioni bisogna aggirare il Sistema Operativo.

Per questo articolo ho preparato il file hex che và caricato sul PIC con IC-Prog. Lo potete scaricare qui.

Caricate in IC-Prog (File -> Open File) e mettete come oscillatore XT perchè usiamo un quarzo di media frequenza e spuntate la voce PWRT e togliete la spunta su WDT.

A questo punto potete premere F5 e rispondere Si alla domanda e attendere la fine della programmazione. Se tutto è a suo posto, non dovrebbe accadere nessun errore.

Questo è tutto.
Ad una prossima puntata..

a cura di: Simone Giugliani

Introduzione:

Siamo già alla seconda lezione di Arduino, e voglio proporvi come realizzare un semplice interruttore crepuscolare che  come si evince dal nome, una volta montato ed eventualmente programmato,  entra in azione automaticamente  con l’arrivo del buio (crepuscolo) e si spegne con l’arrivo dell’alba. Per esempio, con esso è possibile controllare le luci del giardino di casa in modo totalmente automatico. Noi riprodurremo un piccolo crepuscolare in grado di controllare un LED; quindi nel momento in cui si farà buio il led automaticamente si accenderà, mentre in condizioni di luce il led si spegnerà. Questo è possibile grazie ad un sensore chiamato fotoresistenza. La fotoresistenza è un componente elettronico la cui resistenza è inversamente proporzionale alla quantità di luce che lo colpisce. Si comporta come un tradizionale resistore , ma il suo valore in Ohm diminuisce mano a mano che aumenta l’intensità della luce che la colpisce. Ciò comporta che la corrente elettrica che transita attraverso tale componente è proporzionale all’intensità di una sorgente luminosa.

Esercizio 2:

Ora vi presento lo sketch del crepuscolare. Ho usato le istruzioni if, else se avete bisogno di sapere come si usano vi consiglio di visitare il sito ufficiale sulla pagina reference: http://arduino.cc/en/Reference/HomePage

Questo è il programma:

const int sensorValue = 600;  //imposta il valore del sensore
int ledPin = 5; // connettere il LED al pin digitale 5
void setup() { // esegui una sola volta quando il disegno inizia
pinMode(ledPin,OUTPUT); // imposta il piedino 5 come uscita
Serial.begin (9600);  // imposta comunicazione seriale 9600bps
}
void loop() {  //esegui più volte
int sensor = analogRead(A0); // imposta il sensore
if (sensor < sensorValue) {  // registra il valore max del sensore
digitalWrite(ledPin,LOW);  // imposta il piedino 5 a livello basso
Serial.println("giorno");  // stampa "giorno" sul monitor
delay(1000);  //attende 1 secondo
}
else {
digitalWrite(ledPin,HIGH);  // imposta il piedino 5 a livello alto
Serial.println("notte");  // stampa "notte" sul monitor
delay(1000);    // attende 1 secondo
}
}

a cura di : Conicella Valerio

Arduino è il nome di una piattaforma hardware per lo sviluppo di applicazioni basate sui microcontrollori ATMEL.  Arduino può essere utilizzato per lo sviluppo di oggetti interattivi, ma può anche interagire con software presenti sul computer. Questa che vedete qui  sotto è l’ultima versione di Arduino UNO che ha sostituito la precedente versione Arduino 2009.

Se volete saperne di più andate sul sito ufficiale: http://www.arduino.cc/

Attraverso questa serie di articoli vorrei lanciare i concetti base per poter utilizzare al meglio questa potente piattaforma facendo alcuni utili e divertenti programmi in C++. Questi post verranno pubblicati ad intervalli regolari sempre sul tasto tutorial.

Esercizio 1:

Vi presento il primo blink molto interessante. Riprodurre l’effetto Supercar con 8 led ( Supercar popolare serie televisiva girata tra gli anni1982/1986, con protagonista David Hasselhoff). La vostra missione, è quella di ricreare semplicemente con il vostro Arduino, usando 8 LED.

Avrete bisogno di:

• Il tuo Arduino  (computer, cavo,Arduino Uno);
• 8 diodi emettitori di luce ( LED). Qualsiasitipo purché richiedono  una corrente minore di 40mA;
• 8 resistenze da 220 ohm 0,25 W . Per  ridurre la corrente che scorre nel LED;
• bread board;
• cavi per bread board;

Sketch (programma):

int del=100;

void setup()    //eseguire una sola volta quando il disegno inizia
{
pinMode(2, OUTPUT);  //imposta il pin digitale come OUTPUT
pinMode(3, OUTPUT);  //imposta il pin digitale come OUTPUT
pinMode(4, OUTPUT);  //imposta il pin digitale come OUTPUT
pinMode(5, OUTPUT);  //imposta il pin digitale come OUTPUT
pinMode(6, OUTPUT);  //imposta il pin digitale come OUTPUT
pinMode(7, OUTPUT);  //imposta il pin digitale come OUTPUT
pinMode(8, OUTPUT);  //imposta il pin digitale come OUTPUT
pinMode(9, OUTPUT);  //imposta il pin digitale come OUTPUT
}
void loop()   {
digitalWrite(2, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(2, LOW);    // imposta LED a livello basso
digitalWrite(3, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(3, LOW);    // imposta LED a livello basso
digitalWrite(4, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(4, LOW);    // imposta LED a livello basso
digitalWrite(5, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(5, LOW);    // imposta LED a livello basso
digitalWrite(6, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(6, LOW);    // imposta LED a livello basso
digitalWrite(7, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(7, LOW);    // imposta LED a livello basso
digitalWrite(8, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(8, LOW);    // imposta LED a livello basso
digitalWrite(9, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(9, LOW);    // imposta LED a livello basso
digitalWrite(8, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(8, LOW);    // imposta LED a livello basso
digitalWrite(7, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(7, LOW);    // imposta LED a livello basso
digitalWrite(6, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(6, LOW);    // imposta LED a livello basso
digitalWrite(5, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(5, LOW);    // imposta LED a livello basso
digitalWrite(4, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(4, LOW);    // imposta LED a livello basso
digitalWrite(3, HIGH);   // imposta il LED a livello alto
delay(del);              // attendi
digitalWrite(3, LOW);    // imposta LED a livello basso
}

Schema e cablaggio:

Questo è lo schema di montaggio del circuito,  molto facile, basta collegare ad ogni LED il suo corrispondente piedino digitale inserendo tra essi una resistenza di valore compresa tra 220-560 ohm. Per quanto riguarda l’alimentazione è possibile usare un alimentatore esterno con tensione compresa tra 7-12 V, oppure sfruttando la tensione presente sul cavo USB che proviene dal vostro PC.  In questo modo vedrete i led accendersi uno alla volta in sequenza da destra verso sinistra e viceversa.

a cura di: Conicella Valerio

Ieri mi è capitato di scrivere un pò di codice per un amico della community di Grix. Il suo problema era di comandare 3 uscite della porta paralla, per attivare tramite transistor, 3 relè.
Il software ovviamente è stato eseguito e prontamente inviamo all’amico ik3ssg.

Ne è derivata una nuova versione, completa di tutti e 8 i pin di output della LPT. Il software è stato chiamato “LPT Trigger”.

Il tutto è molto semplice..Il programma appena avviato setta come porta di uscita la 378 (la LPT di default sulla maggior parte dei computer). Ovviamente è possibile modificare la porta mettendo il numero che trovate sulle risorse di sistema. Potete trovare il numero di porta seguendo questa procedura:

Pannello di controllo  ->  Sistema  ->  andare su proprietà  ->  Tab hardware  -> Gestione periferiche  ->  Port COM e LPT  -> Selezionare la porta LPT  -> Tasto destro e proprietà  ->  Risorse  ->  leggere la riga “Intervallo I/O”

Impostata la porta non ci rimane che provare il programma. Se non avete voglia di farvi il circuito finale solo per provarlo, potete usare un tester su una scala non inferiore a 5V e mettere i contatti sui rispettivi pin. Il puntale negativo va sul piedino 18 oppure dal 18 al 25.
Il programma può operare in due modi: In configurazione pulsante, ovvero attivare il pin della porta per un lasso di tempo prestabilito (modificabile attraverso lo scroll orizzontale, da 1 a 100 millisecondi) oppure in modalità interruttore, spuntando la casella “Mantieni” della rispettiva uscita. Una volta attivata un’uscita, il pallino rosso si accenderà e diventerà verde, a significare della avvenuta attivazione del pin. In alto nella casella “Valore” potete vedere il valore decimale che la porta sta assumendo, cioè i pin che sono stati attivati. Se volete sapere quali porte sono attive avendo il numero decimale, basta la semplice calcolatrice di Windows e impostarla in modalità “Scientifica”. Immettere il valore decimale (assicuradosi che sia attivata la option “Dec” e poi cliccando sulla value “Bin”. Allo stesso modo potrete convertire il numero in Hex (esadecimale) e ottale..
Se per esempio dovete attivare i relè potete seguire questo semplice schema. Le uscite sono solo 3, ma basta aggiungere le porte che volete:

Bene, la breve spiegazione del software è giunta al termine..non mi resta che darvi l’eseguibile..
Potete trovare il programma QUI.

A presto,

Simone