Ferret Robotics

Polifemo / monocular

2011-05-03T22:31:00.002+02:00

Dopo un periodo di lunga assenza, oggi vorrei descrivere un progetto che ho realizzato nei ritagli di tempo (che sono veramente pochi ultimamente). Siccome il progetto è stato riadattato per un esame universitario, quella che segue è una relazione molto "accademica".

Lo scopo del progetto è stato elaborare e costruire hardware e software per muovere automaticamente una webcam, in modo che essa segua lo spostamento di un oggetto.

Il funzionamento è il seguente: il computer riceve un fotogramma dalla webcam ed elabora l'immagine per risalire all'eventuale posizione dell'oggetto da inseguire. Data la posizione nel fotogramma, elabora gli opportuni comandi di movimento e li invia ad una scheda di controllo, che ha il compito di controllare la posizione del motore su cui è montata la webcam.

I servomotori sono una tipologia di attuatori alimentati in corrente continua. In questo progetto si utilizza un servomotore per far ruotare la webcam che si trova montata su di esso.

Un servomotore presenta un connettore a tre fili: due per l'alimentazione e uno per il trasporto dei segnali di controllo. Questi ultimi sono segnali impulsivi periodici che trasmettono informazioni variando la durata dei propri impulsi. Prendono il nome di ''segnali PWM'', dove PWM è l'acronimo di Pulse-Width Modulation (Modulazione a Durata di Impulso).

Il servomotore associa alla durata degli impulsi la propria escursione motoria: l'elettronica di controllo riceve il segnale e, confrontando la posizione ad esso associata con quella attualmente assunta dal servo, pilota il movimento del motore.

La scheda di collegamento tra il computer e il servomotore che regola la posizione della webcam è basata su un microcontrollore programmabile della serie PIC 16F628-A.

La funzione principale di questa scheda è fornire, in modo continuativo, il segnale periodico necessario al servomotore per mantenere la sua posizione. Infatti, per il corretto funzionamento del servomotore, è necessario inviare un treno di impulsi e non un singolo segnale, che provocherebbe, invece, solo uno spostamento parziale del motore.

Complicare l'hardware inserendo questa scheda è stata una scelta progettuale che ha portato ad una semplificazione in fase di scrittura del codice di elaborazione delle immagini: in questo modo, il computer deve occuparsi solo di elaborare un fotogramma e inviare i comandi di movimento al servomotore, senza preoccuparsi di inviare anche il segnale periodico per mantenere la posizione raggiunta.

Il firmware, ossia il software memorizzato all'interno del microcontrollore, offre essenzialmente un'interfaccia con il servomotore.

Per la stesura del codice è stato utilizzato MikroC, un IDE prodotto dalla mikroElektronika che fornisce un compilatore in linguaggio C.

Il firmware può essere suddiviso in tre blocchi: ''inizializzazione'', ''generazione degli impulsi e del ritardo'' e ''interrupt''. Di seguito si trova il codice e la spiegazione delle singole fasi.

char buffer[3];
int posizione;
int cursore_buffer;
char car_letto;

void interrupt(){
        if(Uart1_data_ready()){
                car_letto=Uart1_Read();

                if(car_letto!=0x0D && car_letto!=0x0A){
                        buffer[cursore_buffer]=car_letto;
                        cursore_buffer++;
                }
                if(cursore_buffer==2){
                        buffer[2]='\0';
                        cursore_buffer=0;
                        posizione=atoi(buffer);
               }
        }
}

void main(){
                int i;
                TRISA=0;
                TRISB=0x00001000;
                PORTB=0;

                CMCON=0x07;

                INTCON.GIE=1;
                PIE1.RCIE=1;
                INTCON.PEIE=1;

                UART1_Init(9600);

                cursore_buffer=0;
                posizione=22;

                while(1){
                    RB3_bit=1;
                    for (i=0;i<posizione;i++) Delay_us(10);
                    RB3_bit=0;
                    Delay_ms(20);
                }
}

La fase di inizializzazione si occupa di configurare l'hardware del PIC e le variabili di sistema.

La fase di generazione degli impulsi e del ritardo è la fase principale del programma e consiste in un ciclo infinito. Ogni iterazione genera un impulso seguito da una pausa di circa 20 ms, in modo da produrre una frequenza di invio degli impulsi di circa 50Hz.

La fase di elaborazione dei comandi seriali è associata all'arrivo di un interrupt generato dal modulo USART del PIC a seguito della ricezione di dati dalla porta seriale. I comandi supportati dalla scheda sono tutti costituiti da un numero prefissato di caratteri. Nello specifico, la scheda si aspetta di ricevere due interi seguiti dal carattere \t .

Il computer richiede alla webcam un singolo fotogramma, e in base alle elaborazioni su tale immagine ricava la nuova posizione che dovrà assumere il servomotore. Questo processo è totalmente indipendente dalla scheda di controllo, che serve solamente per inviare comandi al servomotore.

Nelle seguenti sezioni sarà analizzato il codice che permette alla webcam di ruotare, inseguendo un fissato pattern di pixel. Il codice utilizzato si basa sulle librerie OpenCV, che forniscono numerose funzioni già implementate.

Inseguire un punto luminoso blu

In questo caso, l'obiettivo è inseguire un LED blu: l'algoritmo cercherà di muovere la webcam in modo da posizionare il punto luminoso al centro del fotogramma, e quindi davanti alla webcam.

Dato che si deve riconoscere un semplice LED blu, per rendere più efficiente l'elaborazione si estrarrà dai fotogrammi solo il canale blu. Il pattern da inseguire sarà, quindi, il punto a intensità maggiore all'interno dell'immagine.

Ovviamente, non ci si può aspettare che l'unico oggetto ad avere dei pixel sul terzo canale sia proprio il LED da seguire, ma sicuramente tale oggetto avrà una forte componente cromatica blu.

Questo introduce uno dei principali problemi riscontrati: se il LED si trova su uno sfondo molto luminoso verrà "confuso" con lo sfondo. La soluzione implementata prevede quindi la sottrazione del background, attraverso un metodo della libreria OpenCV: la funzione cvAbsDiff , che viene utilizzata nel codice per calcolare la differenza, in termini di pixel, tra il fotogramma appena ricevuto dalla webcam e il background.

Viene poi estratto il punto di massima intensità, che corrisponde al punto più blu all'interno del fotogramma. Se questa intensità è sufficientemente elevata, viene richiamata la routine che si occupa della rotazione della webcam.

Inseguire un fissato pattern di pixel

L'obiettivo rimane sempre inseguire un oggetto, ma in questo caso l'approccio è diverso: per stabilire la posizione dell'oggetto, bisogna prima procedere al campionamento dello stesso in un template che verrà poi utilizzato in fase di ricerca.

Si fa quindi ricorso al template matching, che consiste nel far scorrere un template sull'immagine da analizzare, per poi stimare la similarità tra template e sotto-immagine corrente.

Rispetto al metodo illustrato in precedenza, quindi, cambia il metodo utilizzato per stimare la posizione dell'oggetto da inseguire, ma l'algoritmo è praticamente uguale, anche se in questo caso non c'è bisogno di ricorrere alla sottrazione del background.

La funzione della libreria OpenCV, usata per effettuare il template matching, è la \verb cvMatchTemplate .

Nell'immagine è riportato il risultato dell'applicazione della funzione ad un'immagine di esempio. La presenza dell'oggetto in un'area è più probabile quanto più l'intensità della zona si avvicina allo zero, ossia dove l'immagine risultato presenta punti scuri. E' poi possibile, utilizzando la funzione \verb cvMaxMinLoc , trovare la zona che presenta l'intensità minima all'interno del fotogramma, così da avere una buona approssimazione della posizione dell'oggetto che si sta cercando.

Gli oggetti di cui sono stati campionati i template sono due: un quadrato fatto in cartoncino rosso e lo stesso LED usato in precedenza.

La prima soluzione funziona molto bene in ambienti con poca luce, mentre il cartoncino viene rilevato all'interno delle immagini solo se la luce ambientale è sufficiente.

Dal link qui sotto potete scaricare il codice "lato computer" che è scritto velocemente ma rende l'idea di cosa deve fare. Ah si dovrebbe anche vedere un video.

https://rapidshare.com/files/460463115/ledblu.zip

Interfaccia mouse ottico e PIC

2011-03-20T12:09:00.001+01:00

se volete linkare, copiare, usare ecc ecc quello che c'è scritto in questo articolo potete farlo, ma citando l'autore.

non mi assumo responsabilità per danni a mouse, robot o alle vostre persone XD

e SI, sono io che ho pubblicato questo articolo anche su grix, quindi non l'ho copiato, è roba mia!

OK, COMINCIAMO! :)

Per un robot che sto costruendo avevo bisogno di un sensore di movimento preciso ed economico... cosa meglio di un mouse ottico? solo che il pic che stavo usando non ha controller usb...

Per cominciare, un po' di teoria del funzionamento di un mouse ottico.

Per trovare un mouse adatto ho passato le ultime settimane smontando mouse di amici e parenti, il risultato è che mi sono fatto un'idea di come funzionano le cose: ultimamente i mouse economici e "cinesi" utilizzano un integrato che si "appoggia" sul pc per funzionare, questi mouse NON vanno bene (ovviamente). Quello che uso nel seguito l'ho pagato 3€ su una bancarella dell'usato.

I mouse che ho provato e che mi hanno dato buoni risultati sono basati su integrati ADNS2051 e ADNS2610.

Immagino che altri chip usino lo stesso protocollo (o molto simile), ma io questi ho provato e questi vi riporto. Nel seguito dell'articolo, se non diversamente specificato, farò riferimento al ADNS2610 per le spiegazioni.

Un piccolo inciso: mi preme far notare che questi chip sono estremamente sensibili all'inversione di polarità, purtroppo ho bruciato un mouse collegandolo male, quindi bisogna fare estremo affidamento ai datasheet e controllare più volte i fili.

Tornando al discorso: gli integrati possono essere alimentati fino a 5v utilizzando i piedini VDD e GND, saldando direttamente dei fili sui piedini e permettendo una facile riconversione a mouse "normale" (il resto del mouse non viene toccato o modificato in nessun modo).

Il protocollo utilizzato per la comunicazione è di tipo seriale, bi-direzionale, half-duplex e basato su un clock condiviso tra mouse e PIC (generato da quest'ultimo). Quindi per il collegamento al PIC bastano due fili, da collegare ai pin SCK (il clock) e SDIO (la linea dati), per un totale di 4 fili da saldare sull'integrato (2 di alimentazione e 2 di comunicazione).

Il mouse che ho utilizzato dopo la modifica si presenta come in foto:

Il funzionamento - in teoria

Finora ho descritto i collegamenti, passiamo adesso alla vera e propria teoria.

Un mouse ottico è basato su quella che viene definita "tecnologia di navigazione ottica", ossia rileva lo spostamento attraverso l'acquisizione sequenziale di immagini (attraverso un modulo chiamato IAS Image Acquisition System) e il confronto matematico di questi (attuato da un DSP, Digital Signal Processor).

Nella prossima immagine è schematizzato il funzionamento dell'integrato, dove DSP e IAS sono integrati in quello che viene chiamato "IMAGE PROCESSOR"

Nell'esploso seguente si nota il chip/sensore con il led di illuminazione e la lente di collimazione sottostante.

Lo spostamento è memorizzato (in modo automatico, quindi) nei registri interni del chip, l'unica difficoltà è recuperare questo dato.

Il protocollo di comunicazione

Inizialmente utilizzavo un mouse basato su ADNS2051, leggermente più difficile da utilizzare perché richiede una prima fase di inizializzazione e un controllo di un registro di stato prima di ogni lettura dei dati di spostamento. Visto che non posso fare più esperimenti con questo mouse (causa rottura), parlerò solo del (MOLTO) più semplice ADNS2610, a chi è interessato posso comunque fornire il codice necessario al corretto funzionamento dei sensori come il ADNS2051 (comunque una volta capito il funzionamento del protocollo è facilissimo implementare altre routine).

La comunicazione seriale è utilizzata per leggere e scrivere parametri sui registri del mouse e per la lettura delle informazioni di spostamento (quello che interessa a noi).

A iniziare la comunicazione è sempre il microcontrollore:

La lettura dello spostamento consiste in 2 byte di dati scambiati: nel primo (il tempo nella figura va da sinistra a destra) il PIC invia 1 byte di informazioni, con 0 nel MSB per indicare la direzione dei dati, seguìto dall'indirizzo del registro che vuole leggere. Il chip sul mouse risponde con 1 byte di dati in complemento a 2, quindi il primo bit codifica il segno e i restanti lo spostamento rispetto all'ultima lettura.

NB: se 1bit va per il segno ci sono 7bit rimanenti, il massimo spostamento tra una lettura e l'altra è quindi 2^7=128 (in modulo ovviamente). Come detto in precedenza la comunicazione è sincronizzata con il clock, nello specifico si commuta la linea dati sul fronte discendente e si legge sul fronte ascendente (ma questo sarà molto più chiaro guardando il codice). Come specificato sul datasheet del ADNS2610, bisogna attendere almeno 100uS tra l'invio del primo byte e la ricezione delle informazioni, per permettere la preparazione dei dati (nell'immagine precedente è indicata con una "spaccatura" tra il ciclo 8 e 9).

A titolo di esempio, questi sono i registri presenti su ADNS2610:

Particolarmente interessante è il contenuto del registro 0x08, che permette di leggere i pixel "visti" dal sensore, attraverso 324 letture consecutive (che tornano l'intensità del pixel) con il seguente schema:

conto di approfondire l'argomento in futuro, magari in un prossimo articolo, se interessa.

Un po' di pratica - il circuito

Lo schema elettrico è molto semplice, è un semplice PIC 16F877 clockato a 4Mhz. Ho usato la porta E per il collegamento al mouse e la porta B per un LCD 16x2. Il tutto ovviamente a 5v.

realizzazione:

Un po' di pratica - il codice

Il codice che presento è sempre scritto in MikroC e lo trovate allegato, so che molti sono affezionati all'ASM ma questo rende la lettura molto più semplice e immediata. Nel seguito presento e commento un codice semplificato basato su quello che allego.

Questo che espongo è un po' l'"hello world" del mio progetto, ossia come ottenere le coordinate lette dal mouse. Da qui poi è facile modificare il codice.

Cominciamo con il main() che semplicemente legge i valori nei registri e li scrive su LCD ciclicamente (dopo aver inizializzato le porte e il display LCD). Ricordo che il registro contiene un valore in complemento a 2, quindi basta sommare sempre il valore di ritorno (positivo o negativo non importa, è solo uno spostamento dall'ultima lettura).

void main(){
        init_LCD_PIC();

        for(;;) {
          x += readRegister(DX);
          y += readRegister(DY);

          LCDWriteResult(x,y);
        }
}

Come avviene la lettura dei registri è presto detto (anzi scritto):

signed short readRegister(const unsigned short int address){
        signed short output = 0;

        DIRDATA = OUT;

        //scrivi l'indirizzo del registro da leggere
        for(i=7;i!=-1;i--){
            MOUSE_CLK = 0;
            MOUSE_DATA = 1 && ((address & (1<<i))>0);
            MOUSE_CLK = 1;
        }

        //preparati a leggere i dati inviati
        DIRDATA=IN;

        //aspetta che siano pronti
        Delay_us(100);

        for(i=8;i!=0;i--) {
           MOUSE_CLK = 0;
           MOUSE_CLK = 1;
           output |= MOUSE_DATA << i-1;
        }

        return output;
}

Spiegazione: DIRDATA codifica lo stato di ricezione o invio di dati sulla seriale. Il primo for invia il primo byte di dati al mouse, utilizzando il clock come sincronia. Qui l'unica cosa da capire è il booleano risultante da:

1 && ((address & (1<<i))>0)

Per semplicità divido l'espressione:

address & (1<<i) fa un semplice OR bitwise tra una maschera a singolo 1 e tutti 0 e la variabile "address".

Il problema sorge quando l'indirizzo del registro ha più di un bit a 1: è questo il caso, ad esempio, del registro 0x03 (00000011 in binario) torna "2" con una maschera come 00000010. Se si prova a scrivere "2" su MOUSE_DATA (che corrisponde ad UN SINGOLO bit sulla PORT del PIC) si ottiene... niente! e quindi l'AND binario tra 1 e il risultato dell'espressione precedente serve a tornare "1" quando l'or bitwise della maschera con l'indirizzo del registro è maggiore o uguale a 1. Facile no? XD

Il secondo for "compone" bit per bit il numero risultato, leggendo (sul fronte di salita del clock) i dati dal mouse.

Foto del risultato:

Conclusioni

Ho mostrato come sia possibile leggere le coordinate di spostamento del mouse, ma questa è solo una possibile applicazione...
è consentito qualsiasi uso non a scopo di lucro del codice, ma per favore citate l'autore (e possibilmente linkate questo sito)

Spero di non aver dimenticato niente... per qualsiasi commento o critica (possibilmente entrambi costruttivi...) sono a vostra disposizione.

FILE SORGENTE ZIPPATO

Interfacing an optical mouse (USB) with a PIC (which doesn't have USB CONTROLLER!)

2011-03-14T11:14:00.001+01:00

se preferite la versione in italiano la trovate nel post precedente :p

if you want to copy, share, use etc. etc. all or part of this article you CAN DO IT, BUT please cite me and share the link to this article.

I'm not taking any responsibility for any kind of damage to your mouse, your PIC or yourselves XD

and yes, I posted this article on grix.com too (written in Italian).

OK, LET'S GO! :)

I needed a cheap (and accurate) motion sensor... What could be better than an optical mouse for the job? BUT... my PIC doesn't have a usb controller (and I'm cheap, so I don't want to buy a new one :p ) so I had to do things my way... :)

Description

let's start with... “an optical mouse, how does it work????”

finding a useful mouse could be a bit hard: I've spent weeks trying to open up all the mice I could find (kindly offered by friends, parents etc. etc.), so I learnt what kind of chips you can get from a usb optical mouse:

the “made in china” mice contain chips that use the computer for motion processing... that kind of mouse doesn't work well with my code, but you can find a good mouse in second-hand shops or places like that.

The mice I've tried, with good results, are based on ADNS2051 and ADNS2610 chips.

I think that there are probably other mice using the same protocol (or quite similar), but I only tried with those two chips. For the purposes of this article, I shall illustrate how to use the ADNS2610 chip.

these chips are EXTREMELY sensitive to the polarity inversion: I broke a mouse just because I messed up with the polarity, so CHECK THE DATASHEET BEFORE YOU START! And check and re-check all the wires!

You can supply the chips with VDD – GND pins by soldering the wires directly on to the pins: in that way you can easily re-convert the sensor to a “common mouse” because this is the only modification that you have to make to the mouse itself.

The protocol used for the mouse-pc communication is a serial, bi-directional, half-duplex clock driven (the clock is generated by the PIC and shared both by the mouse and the PIC). Then, for the connection, you can use two wires: SCK pin (the clock) and SDIO pin (data line). So you have to solder just 4 wires in total: 2 for supply and 2 for communication.

This is a picture of the mouse that I used, after the mod:

how it works: theory of operation

After the connection phase, let's see how the mouse works.

An optical mouse is based on “Optical Navigation Technology”: it contains an Image Acquisition System (IAS) and a Digital Signal Processor (DSP).

A mouse reads any motion by acquiring sequential images by IAS module and mathematically confronting these images to determin the displacement (by DSP module).

In the next image you can see the logical architecture, where DSP and IAS are both integrated in the "IMAGE PROCESSOR".

The next diagram is of the inside of the mouse:

The displacement data is automatically stored in the registers of the chip... but how can we retrieve this data?

Communication protocol

The protocol used by ADNS2051 is harder to understand than the one used by ADNS2610 this is because it requires an initialization phase and a check on a state register before every reading.

The communication protocol is quite similar in every chip I've seen, so if you can understand the theory of operation you will be able to use any kind of mouse chip.

A serial communication is used for the read/write operations on the registers of the mouse chip and to read displacement informations (this is what we are interested in).

The communication is always initiated by the microcontroller.

A read operation, meaning data that is going from the ADNS-2610 to the microcontroller, is always initiated by the microcontroller and consists of two bytes. The first byte that contains the address is written by the microcontroller and has a “0” as its MSB to indicate data direction. The second byte contains the data and is driven by the mouse chip. This is a byte of data (two's complemented), in which the first bit is coding the sign and the other seven bits encode the displacement data since the last reading.

The maximum amount of displacement that a mouse can “feel” from reading to reading is formed by 7 bits (8 in total, but one of them is just for the sign) so 2^7=128.

The transfer is synchronized by SCK. SDIO is changed on falling edges of SCK and read on every rising edge of SCK. (look at the code below, it's simpler!). There are minimum timing requirements between read and write commands on the serial port: we have to ensure that the ADNS-2610 has at least 100 μs to prepare the requested data.

In the following image you can see the ADNS2610 registers:

The 0x08 register is quite interesting and useful since you can read the pixel seen by the mouse sensor by means 324 consecutive reading according to the following table. (the return value will represents the pixel intensity)

Practice – the circuit

The table basically shows a 16F877 PIC clocked at 4Mhz. I used the E-port for the mouse connection and the B-port for a 16x2 characters LCD (everything works fine at 5v).

the assembling phase:

Practice – the code

I wrote the code in MikroC language (you can find it attached at the end of this article).

This is the “hello world” of my project: in this way you can retrieve the coordinates and... do what you want to do with this data.

Let's start with the main(), which reads the value of the registers and writes it on the LCD (in a loop, after the port and LCD initialization).

The register contains a two's complement value, so you can simply add this value, which is only the displacement from the last reading phase, to the “global/final position”.

void main(){
        init_LCD_PIC();

        for(;;) {
          x += readRegister(DX);
          y += readRegister(DY);

          LCDWriteResult(x,y);
        }
}

This code reads from the register (THIS IS THE CORE OF THE PROJECT):

signed short readRegister(const register unsigned short int address){
        signed short output = 0;
        signed short i = 0;

        //direction WRITING
        DIRDATA = OUT;

        //write address of register to be read
        for(i=7;i!=-1;i--){
            MOUSE_CLK = 0;
            MOUSE_DATA = 1 && ((address & (1<<i))>0);
            MOUSE_CLK = 1;
        }

        //direction READING
        DIRDATA=IN;

        //wait for data
        Delay_us(100);

        //read the data
        for(i=8;i!=0;i--) {
           MOUSE_CLK = 0;
           MOUSE_CLK = 1;
           output |= MOUSE_DATA << i-1;
        }

        return output;
}

explanation: DIRDATA is the read/write serial state.

The first for loop sends the first byte of data to the mouse, using the clock for the synchronization.

The second one “composes” the result bit by bit, reading the data that come from the mouse.

Comments? Any questions? Use the “Comments” button :)
THANKS TO TIZIANA (TES T) FOR HELPING ME WITH EVERY ITALIAN-ENGLISH TRANSLATION!

ZIPPED SOURCE FILE

PWM seriale pic 16F628

2011-03-07T10:07:00.006+01:00

Per un progetto che vedrete prossimamente, avevo bisogno di generare un segnale PWM dalla seriale del pc... il problema principale è che mi serviva di continuare a generare lo stesso segnale anche dopo aver staccato il cavo di collegamento al pc. Bene, basta un pic, un max232 e una manciata di componenti a contorno.

questo è il circuito che ho realizzato:

I componenti sono pochi e la lista precisa è la seguente:

C1 1uF

C2 1uF

C3 1uF

C4 1uF

C5 22pF

C6 22pF

C7 22uF

C8 0,47uF

C9 100nF

IC1 PIC16F628A
IC2 MAX232

IC3 LM2940T
Q1 4.000Hz

Q5 IRF540

R4 100ohm

I più attenti noteranno che sul circuito che ho realizzato manca il MOSFET... si lo so, all'ultimo momento ho pensato che tanto non mi serviva di controllare l'accensione e lo spegnimento degli impulsi PWM, quindi non l'ho più messo.

Per chi non lo sapesse, il 2940 è un regolatore di tensione fisso a 5v LDO (Low Drop Out) che regge fino a 1Ampere circa. Lo uso spesso perché mi permette di alimentare i circuiti "come viene", senza dovermi preoccupare di fornire 5v stabili (di solito uso pacchi batterie da modellismo).

Per la realizzazione ho usato un semplice millefori, non mi andava di fare lo stampato e comunque non è che il circuito sia poi così difficile da assemblare

e questo è il codice MikroC necessario per far funzionare il tutto:

char buffer[4];
int posizione;
int cursore_buffer;
char car_letto;

void interrupt(){
        if(Uart1_data_ready()){
                car_letto=Uart1_Read();

                if(car_letto!=0x0D && car_letto!=0x0A){
                        buffer[cursore_buffer]=car_letto;
                        cursore_buffer++;
                }
                if(cursore_buffer==3){
                        buffer[3]='\0';
                        cursore_buffer=0;
                        posizione=atoi(buffer);
               }
        }
}

void main(){
                TRISA=0;
                TRISB=0x00001000;

                CMCON=0x07;

                INTCON.GIE=1;
                PIE1.RCIE=1;
                INTCON.PEIE=1;

                UART1_Init(9600);

                 PWM1_Start();
                 PWM1_Init(50000);

                cursore_buffer=0;
                posizione=0;
                PWM1_Set_Duty(posizione);

                while(1){
                     Delay_ms(20);
                     PWM1_Set_Duty(posizione);
                }

}

Vorrei solo far notare che l'interrupt dalla seriale è generato ogni volta che arrivano dei dati, ma è un canale orientato al byte, e quindi ogni volta che si chiama la read si legge un byte. Per questo è necessario concatenare l'input e solo dopo convertirlo in numero. NO, non esiste una read bloccante o se esiste (e io non l'ho vista) non la potevo usare dentro la procedura di interrupt, che già è troppo lunga così).

Ovviamente la sintassi per generare i PWM è la stessa seguita dall'struzione MikroC. Il PIC si aspetterà sulla seriale un numero di 3 cifre, quindi se volete passare "8" alla PWM1_Set_Duty dovrete in realtà scrivere "008".

In conclusione si tratta di un circuito semplice e fine a se stesso, in realtà stiamo controllando un segnale dalla porta del pc semplificando la programmazione di quest'ultimo, visto che non si dovranno generare i treni di impulsi. Ma non vorrei rivelare troppo sul progetto che sto portando avanti, maggiori dettagli nei prossimi articoli!

E questo è il risultato finale:

Duty cycle del 50% circa

termostato PIC-based con isteresi

2011-02-21T21:42:00.003+01:00

premessa: questo articolo è presente anche su grix.it.

Quello che vi mostro oggi è un semplice termostato/attuatore a isteresi basato su PIC 16F690 (questo avevo e questo ho usato) e il solito LM35. Il circuito è semplice, quindi l'attenzione vorrei porla sulla spiegazione del codice da caricare sul PIC, che sarà scritto in mikroC e abbondantemente commentato per permettere anche a chi non ne sa niente di capire di cosa si sta parlando.

Descrizione
Ho utilizzato un 16F690 perché, tra i PIC che avevo a disposizione, è l'unico con un ingresso analogico. In questo modo nonho dovuto utilizzare altri componenti per leggere la temperatura rilevata dal sensore. Il circuito risultante è pulito e semplice, in grado di resistere nel tempo senza dover subire manutenzione di nessun tipo (verrà posizionato in un posto poco accessibile).

Che vuol dire isteresi? Con l'isteresi si definisce una "finestra" di funzionamento, in cui un attuatore viene azionato senza il pericolo di avere instabilità attorno ad un valore. Mi spiego meglio: diciamo che vogliamo far accendere una lampadina se con un sensore si misurano 25 gradi. Che succede se la temperatura comincia ad oscillare tra 25,001 e 24,999 gradi? succede che la lampadina comincia a "sfrigolare" (termine altamente tecnico/elettronico che rende bene l'idea). La soluzione è creare un sistema che, superata una certa soglia S1 non si spegne fino al raggiungimento di una soglia S2, dove S2<S1. Tornando all'esempio precedente, la lampada non si spegne fino, ad esempio, al raggiungimento dei 23 gradi, cioè una soglia minore di 25.

Come funziona un LM35? Questo sensore è, secondo me, il più facile in assoluto da interfacciare con un pic (ma anche con un Arduino, in realtà). E' il solo alimentato tra 0 e +5 V e può misurare solo temperature positive. Sul datasheet, comunque, sono presenti vari metodi per ottenere anche la misurazione di temperature negative. Nel mio caso questo non era necessario, e ho utilizzato il sensore semplicemente interfacciandolo al pic, come visto in molti altri tutorial in rete.

L'idea di base del progetto che volevo realizzare è semplice: il sensore misura la temperatura ad intervalli regolari. Quando si preme un pulsante apposito, la temperatura corrente viene memorizzata. Il sistema cerca poi di mantenersi attorno al valore rilevato in precedenza, accendendo una pompa di ricircolo per il raffreddamento se si dovessero rilevare temperature superiori a quella memorizzata e spegnendola in caso di temperature inferiore.

Circuito

Come dicevo il circuito è molto semplice, ci sono dei 3 led che indicano lo stato del sistema: un led lampeggia quando si è impostata la temperatura di riferimento, altri due led indicano se l'attuatore è acceso o spento (come fosse una configurazione binaria: o è acceso un led oppure l'altro).

Con un pulsante (in pullup) è possibile impostare la temperatura che dovrà poi essere mantenuta.

Un comune relais a 6V è comandato da un transistor "general purpose", l'alimentazione (5V) è fornita da un alimentatore esterno, quindi nessun regolatore di tensione è presente a bordo del circuito.

In più, ho previsto un connettore per poter caricare il firmware all'interno del pic senza doverlo smontare (ICSP).

Codice

Qui di seguito il codice da utilizzare, diviso in base alla funzione svolta e commentato. Le porte del PIC sono impostate come sullo schema precedente.

La funzione di init del PIC ha solamente il compito di inizializzare i registri interni e di abilitare gli interrupt (servirà poi per capire quando è stato premuto il pulsante per impostare la temperatura da mantenere).

void init() {
       //abilita interrupt sulla porta RA4 + globali
       INTCON.GIE=1;
       INTCON.INTE=1;

       ANSEL=0b00000010;              // configura RA1 come ingresso analogico
       ANSELH=0;
       ADCON0=1;                         //abilita ADC
       CM1CON0=0;                        //disabilita tutti i comparatori
       CM2CON0=0;

       //PORTA input il resto output
       TRISA=0xFF;
       PORTA=0;

       TRISB=0;
       PORTB=0;

       TRISC=0;
       PORTC=0;
     }

Per poter accendere l'utilizzatore (che in questo caso, come già detto è una pompa di ricircolo) utilizzo la seguente funzione:

void accendiPompa(){

     //ACCENDI LA POMPA
     PORTC.F6=1;

     //STATO POMPA ACCESA
     PORTC.F4=0;
     PORTC.F5=1;

     while(adc_rd>temperaturaImpostata-1) {
           delay_ms(2000);
           adc_rd = ADC_read(1);
           adc_rd *= 5;
           adc_rd /= 10;

           if (flag)
              return;
     }

     //la temperatura si è abbassata
     //spegni la pompa e esci
     PORTC.F6=0;

     //STATO POMPA SPENTA
     PORTC.F4=1;
     PORTC.F5=0;

     return;
}

lmportante, qui e nel seguito, è notare la presenza della variabile "flag" che serve per poter entrare nella procedura di impostazione della temperatura a seguito della pressione del pulsante collegato al PIC.

Il tutto è richiamato da una procedura main:

void main() {
short int i;
int valore;

       //lettura della temperatura salvata in memoria (con protezione)
       ee_read(0,&temperaturaImpostata,sizeof(int));
       temperaturaImpostata=min(temperaturaImpostata,MAX_TEMP);

       flag=0; //interrupt non ancora avvenuto
       while(1)   {
                     //stato: POMPA SPENTA
                     PORTC.F4=1;
                     PORTC.F5=0;
                     PORTC.F6=0;

                     //leggi il valore dal sensore
                     adc_rd = ADC_read(1);
                     adc_rd *= 5;
                     adc_rd /= 10;

                     //decidi se accendere o no la pompa
                     if(adc_rd>=temperaturaImpostata+1){
                        contatore=0;
                        accendiPompa();
                     }

                     //se c'è stato un interrupt allora salva il nuovo valore
                     if (flag){
                                 flag=0;

                                 //valori MIN e MAX di sicurezza
                                 valore=min(adc_rd,MAX_TEMP);
                                 valore=max(adc_rd,MIN_TEMP);

                                 //salva valore in memoria
                                 ee_write(0,&valore,sizeof(int));

                                 //e nella variabile (evita accessi in EEPROM)
                                 temperaturaImpostata=valore;

                                 //lampeggia
                                 for(i=0;i<4;i++){
                                    PORTB.F6=1;
                                    delay_ms(125);
                                    PORTB.F6=0;
                                    delay_ms(125);
                                  }
                     }
          //letture ogni mezzo secondo CIRCA
          delay_ms(500);
          }
}

Sulle prime istruzioni per il salvataggio e il ripristino della temperatura tornerò tra poco. Intanto vorrei commentare quello che succede "a regime". La temperatura viene rilevata ogni mezzo secondo circa. La precisione non mi interessava molto, infatti uso l'oscillatore interno del PIC invece del quarzo esterno, sempre per avere un circuito il più semplice e meno soggetto ad usura. Bene, è arrivato il momento di discutere un problema che mi si è posto durante la progettazione: Il funzionamento del circuito, come ho detto, è semplice: si preme un pulsante e il sistema cerca di mantenere la temperatura attorno a quella rilevata in quel momento. Che succede quando si spegne il circuito? la temperatura memorizzata viene persa. Per questo motivo ho introdotto le seguenti due routine:

void ee_write(unsigned int ee_addr, int *p, int size){
     while (size-- != 0) {
         EEPROM_Write(ee_addr++, *p++);
         Delay_ms(20);                   /* 20ms is microC recommendation */
     }
}

void ee_read(unsigned int ee_addr, int *p, int size){
     while (size-- != 0) {
         *p++ = EEPROM_Read(ee_addr++);
     }
}

Queste hanno il compito di "spezzare" un int in byte e memorizzarlo in locazioni di memoria sequenziali (l'indirizzamento qui è sempre al byte). Ovviamente lo stesso vale anche per ripristinare il valore dalla memoria. Utilizzo una variabile globale per non dover accedere ogni volta in memoria (visto che comunque nei pic questo tipo di letture si possono fare solo un numero finito di volte, molto elevato ma sempre finito).

Chiudo spendendo due parole sulla routine di gestione dell'interrupt: questa viene richiamata in automatico da mikroc quando si genera un interrupt esterno, e non fa altro che settare una variabile globale che poi viene "catturata" durante l'esecuzione del programma (vedere funzione main).

void interrupt(void){
    flag=1;
    delay_ms(1000);        //evita problemi con la pressione del pulsante
    INTCON.INTF=0;
}

Realizzazione
Ecco il circuito stampato finito e assemblato (con la famosa tecnica dello stira e ammira). La pinzetta che si vede la stavo utilizzando per dialogare con il pic tramite seriale (per debug).

Alimentatore 5v per breadboard

2011-02-14T10:07:00.001+01:00

Spesso lavorando con le breadbord si sente la necessità di un alimentazione stabilizzata, si ricorre quindi ai soliti integrati 7805 ecc. con lo svantaggio di dover ogni volta assemblare il circuito di alimentazione, o lasciarlo sempre montato rubando spazio per il progetto che si sta realizzando.

Ho voluto utilizzare un integrato del tipo LM2940, poco diffuso ma secondo me valido: è un regolatore di tensione fisso di tipo LDO a 5v con 1A di corrente massima in uscita. La sigla LDO sta per "Low Drop Out", infatti questo regolatore ha solo 0,5v di drop out, il che permette di alimentare il circuito anche con poco più di 5v. Il funzionamento di un regolatore è relativamente semplice, bisogna solo inserire (come specificato sul datasheet www.wulfden.org/downloads/datasheets/LM2940.pdf) due condensatori che hanno il compito di fornire un "buffer" di corrente.

Solitamente le breadbord presentano l'alimentazione da entrambi i lati, in alcuni casi questa soluzione si rivela una comodità perché ci permette di avere due differenti voltaggi a cui collegare i componenti. Per non dover rinunciare a questo particolare ho inserito un jumper (sostituibile facilmente con un dip switch ad esempio) per selezionare l'alimentazione per la "seconda linea di alimentazione" della breadboard. Quindi, una linea sarà sempre a 5v mentre per l'altra si può scegliere tra:

nessuna alimentazione (togliendo del tutto il jumper)
5v
alimentazione diretta dal trasformatore (non stabilizzata)

Realizzazione

Per prima cosa, anche se il circuito è semplice, ho usato Eagle per disegnare lo schema e il pcb. Poi tramite PovRay ho renderizzato lo schema per avere un idea di come sarebbe venuto. Quindi ho realizzato il circuito su millefori (è un progetto un po' vecchio e ancora non avevo cominciato a farmi gli stampati da solo). Di seguito le immagini relative alla progettazione e alla realizzazione:

realizzazione - componenti necessari:

connettore da 2,5 (al trasformatore, io ne uso uno da 12v)
del filo sottile rigido per le saldature
la basetta millefori tagliata a misura della breadboard
led e relativa resistenza (220Ohm per funzionare a 5v)
jumper per selezionare l'alimentazione (vedere sezione precedente)
regolatore di tensione LM2940 con relativi condensatori e dissipatore di calore

realizzazione - lato saldature (qui non avevo ancora tagliato i connettori del regolatore di tensione)

realizzazione - collaudo finale

Demoboard modulare per pic

2011-02-07T10:07:00.002+01:00

Questa è la demoboard che ho usato nel progetto del mouse interfacciato con il PIC... volevo farvela veder eun po' più nel dettaglio :)

Una parte della demoboard rimane sempre costante (però non è detto, potrebbe cambiare anche questa), mentre lo zoccolo porta pic cambia in base al pic che si vuole usare.
Questa scelta ha inoltre l'enorme vantaggio (per chi come me ha cominciato da pochissimo con l'elettronica) di permettere un buon debug: se non funziona un modulo (o se questo si rompe) si butta e se ne costruisce un altro mantenendo intatto il resto della demoboard.

Per la realizzazione ho usato una scatola in plastica (ne potete avere 3 per 2€ nel "negozio svedese") opportunamente modificata mentre il circuito è realizzato su millefori...

Inizialmente la scatola si presenta così:

Nelle prossime sezioni descriverò i principali moduli, ma la demoboard è pensata per essere ampliata o modificata a piacere.

Ogni modulo ha un connettore per l'alimentazione che proviene dal "modulo di alimentazione" (5v stabilizzati).

Modulo base

Questo è lo zoccolo porta pic, permette di avere a disposizione le porte del pic su una stripline femmina a cui si possono connettere normali pin o infilare fili volanti.

Su questo modulo è saldato anche un porta quarzo (un socket a 8 pin).

C'è un pulsante di reset che collega MCLR a massa (normalmente invece questo pin è collegato al positivo con una resistenza di pullup), un led per segnalare l'alimentazione e il connettore per ICSP (per la programmazione del pic con programmatori Microchip). Di seguito lo schema e le foto della realizzazione per pic 16f628.

Si nota nello schema il diodo 1N4148 che permette di riprogrammare il pic anche con l'alimentazione della demoboard inserita (parlo di programmatori come ad esempio il picKit2) e un condensatore da 100nf per l'eliminazione di eventuali disturbi tra il polo positivo e la massa.

Modulo di alimentazione

Ho progettato e realizzato un regolatore di tensione fisso a 5v utilizzano un lm2940 e una manciata di condensatori aggiuntivi... Non ho fatto foto di questo modulo realizzato, ma si vede nelle foto finali.

Moduli aggiuntivi - led e pulsanti

Non mi dilungo tanto su questa parte, ho solo collegato 6 led ad altrettanti pin in modo da poterli collegare alle porte del pic all'occorrenza. I led sono collegati a massa con una resistenza da 220Ohm, quindi basta alzare la porta del pic per far accendere il led.

Ho poi creato un modulo su cui ho inserito dei pulsanti e bottoncini di recupero da un vecchio mouse, tutti con resistenze di pull up. C'è poi un trimmer il cui comune si può collegare ad una porta del pic e gli altri due connettori vanno a massa e al positivo (niente di nuovo insomma).

Ulteriori moduli

Nella mia realizzazione ho inoltre inserito un display LCD (qui il "modulo" comprende solo l'alimentazione e un potenziometro per regolare il contrasto) sulla parte frontale e un modulo RS232 (usando il solito MAX232) nella parte interna della scatola (dove trova posto anche l'alimentatore).

Questa è una vista a coperchio alzato.

Conclusioni

Questo è il risultato finale, si vede anche una piccola breadboard sulla parte superiore della scatola.

particolare con interruttore di accensione/spegnimento della breadboard:

spero che possa essere un'idea interessante per qualcuno che come me cercava "ispirazione"... in futuro penso di inserire almeno un modulo con display 7 segmenti, ma se avete suggerimenti sono qui.

Micro-alimentatore da banco (molto) economico

2011-01-31T10:07:00.004+01:00

do you want me to translate this article in English?ask me in the "comments" :)

Come realizzare un alimentatore regolabile con un tester cinese da pochi euro, un LM317 e qualche componente a contorno?

Utilizzando spesso breadboard e piccoli circuiti può nascere l'esigenza di avere un alimentatore regolabile di poca potenza e di non voler spendere soldi per un vero alimentatore da banco.

L'occorrente per la costruzione del mio micro-alimentatore è:

un tester qualsiasi, io ne ho usato uno pagato 6€ su una bancarella, ma ne ho visti anche a 2€!
LM317 + componenti a contorno: 4 condensatori, 2 diodi e un potenziometro (vedere sezione dedicata)
connettore da 2,5 per l'alimentazione e pulsanti di accensione/spegnimento

ho stimato che la spesa per tutto l'occorrente non supera i 10€ e per la realizzazione non serve più di una giornata....

All'apertura il tester si presenterà così:

Dopo aver aperto il tester consiglio, per prima cosa, di incollare il piccolo schermo LCD in modo che non si possa muovere: ritrovare il corretto posizionamento non è cosa semplice.

Idea del funzionamento

L'alimentazione è fornita da un'alimentatore a 12v esterno al tester, collegato con un connettore 2,5 da pannello (nella parte sinistra della prossima immagine). Con un pulsante (in alto a destra nella foto) si accende e si spegne l'alimentatore da banco e un led avvisa dello stato (on/off). Questo può permettere di conservare alcune funzionalità del tester (vedere sezioni successive). Per ottenere un alimentatore "tascabile" ma capace di erogare 1,5A c'è bisogno di un dissipatore di calore sul regolatore di tensione, ma all'interno del tester lo spazio è troppo poco. Ho quindi deciso di posizionare un dissipatore da cpu (un 486) nella parte frontale (ma esterna) del tester.

La prossima sequenza di immagini chiarirà il procedimento:

In basso si vede la posizione del regolatore: praticamente si troverà nell'alloggiamento della batteria, sotto ad essa (come se fosse un doppio fondo).

In questa immagine si vede anche il posizionamento del connettore di alimentazione e del pulsante di accensione.

Successivamente ho quindi forato la parte frontale del tester e creato i fori di fissaggio per il dissipatore.

Dopo il montaggio del dissipatore e del regolatore nella parte posteriore, il tester appare così:

Il regolatore non da fastidio alla batteria perchè di fatto si trova ad un livello più basso, mentre i piedini sono al livello della scocca. Bisogna inoltre prestare attenzione affinché il selettore del tester possa girare anche dopo aver montato il dissipatore.

Funzionamento del regolatore

Colgo l'occasione per spiegare velocemente il circuito con l'integrato LM317.

Premetto che questa è "la spiegazione che avrei sempre voluto avere io e non ho mai trovato", quindi è probabile che chi ne sa già di elettronica possa storcere la bocca, ma per chi come me è alle prime armi (spero) chiarirà qualche punto dell'uso dei regolatori.

partendo da sinistra:

C1: I regolatori di tensione in generale (e LM317 non fa eccezione) sono progettati per funzionare con delle buone sorgenti di tensione in ingresso. Siccome per il funzionamento io utilizzo un alimentatore 12v (pure questo da bancarella o poco più) poco affidabile, e con un lungo cavo tra trasformatore e connettore, questo può comportarsi da induttanza posta in serie all'ingresso. Per evitare problemi con il ripple rejection (il "residuo" di corrente alternata che rimane dopo il ponte raddrizzatore all'interno dell'alimentatore da 12v) si inserisce per prima cosa questo condensatore.

C4: questo condensatore deve essere posto vicino al piedino di ingresso del regolatore e serve ad evitare le auto-oscillazioni. Nelle foto del progetto finito si vede che l'ho proprio saldato al piedino.

D2: si tratta di un diodo di protezione per il regolatore. Quando il condensatore di uscita è grande si rischia, una volta spento l'alimentatore del circuito, che il condensatore si scarichi sull'uscita del LM317. Con questo diodo posto in antiparallelo, la corrente evita di passare nel regolatore "nel verso sbagliato".

C3: La funzione di questo condensatore è quella di fornire una tensione più stabile possibile al piedino di regolazione del regolatore.

D1: anche questo è un diodo di protezione. La sua funzione è semplicemente quella di scaricare il condensatore C3 in caso di cortocircuito.

R1 e R3: queste sono le resistenze che permettono si variare la tensione in uscita dal regolatore. Per il calcolo del valore vi rimando al datasheet. In questa sede basta sapere che con un potenziometro da 5k e una resistenza da 220Ohm si varia la tensione tra 1,3v e 12v circa (comunque molto dipende dalla tensione erogata dall'alimentatore che si utilizza). Come specificato sul datasheet ufficiale la resistenza va saldata il più vicino possibile al piedino dell'integrato.

C2: questo condensatore si comporta come un "serbatoio". Sul datasheet sembrerebbe di secondaria importanza, ma per esperienza personale è molto importante che ci sia (nella prima realizzazione di questo alimentatore lo avevo omesso, il risultato è stato un alimentatore stabile solo sopra ai 6v).

Montaggio

Questo è come si presenta il tester a montaggio ultimato:

La batteria da 9v originale (in basso a sinistra) è stata avvolta nel nastro isolante per evitare che possa cortocircuitare i piedini del regolatore (per sicurezza anche i piedini del regolatore andranno isolati).

Il connettore di alimentazione è stato sostituito da uno migliore "ad incastro".

Non avendo a disposizione un potenziometro da 5k ne ho usato momentaneamente uno da 10k ricavato da una vecchia ventola (serviva per la regolazione della velocità), e l'ho posizionato nella parte superiore del tester (nella foto si trova a destra).

Per utilizzare il tester come alimentatore da banco basta collegare i puntali e utilizzarli come fossero i poli di un qualsiasi alimentatore.

Conclusioni

La funzionalità del tester viene compromessa, si potrà utilizzare al massimo per misurare piccole tensioni, le altre misurazioni saranno falsate dalla presenza del carico costituito dal circuito del regolatore. Si può comunque inserire un interruttore che permetta di disabilitare il circuito, interrompendo quelli che nelle foto sono i fili di colore rosso e nero che dal regolatore vanno agli spinotti del tester.

Per qualsiasi proposta o commento sono qui :)

Il tester finito

TUTORIAL: how to control a BIpolar stepper motor

2011-01-26T11:42:00.001+01:00

ok from now on I'll write in english, I have to learn it.

In this tutorial I will show you how to control a stepper motor with FOUR control wires and a L293D IC. You can use everything you want in order to generate control signals. In this tutorial I used an Arduino board, but a PIC is also ok.

Why "FOUR" control wires? because everyone who writes a tutorial or something else about bipolar stepper motors wants to control them with only TWO wires and a lot of components (NPN transistors, resistors ecc ecc). But controlling a L293D with 4 wires is simpler!

ok, let's see the circuit:

How does the L293D work?

That's simple: you send a signal on the "inputX" and then the IC "opens" the port "outputX" for the current passing.
You can also enable or disable a particular input-output "phase" (pin 1 and 9), but in this tutorial they are always enabled.

This is the result:

and this is a (very) simple sketch of Arduino programming:

//declaration of PINS that connected the wire to motor
int nero = 13;
int marrone = 12;
int arancio = 11;
int giallo = 10;

//this is the time to wait in every single step
int delayTime = 100;

//set the pin for OUTPUT
void setup() {
pinMode(nero, OUTPUT);
pinMode(marrone, OUTPUT);
pinMode(giallo, OUTPUT);
pinMode(arancio, OUTPUT);
}

void loop() {
forward(13);
delay(500);
backward(13);
}

void forward(int steps){
for(int i=0;i<steps;i++){
// in every phase 2 wires is up and 2 is down
digitalWrite(nero, LOW);
digitalWrite(marrone, HIGH);
digitalWrite(arancio, HIGH);
digitalWrite(giallo, LOW);
delay(delayTime);

digitalWrite(nero, LOW);
digitalWrite(marrone, HIGH);
digitalWrite(arancio, LOW);
digitalWrite(giallo, HIGH);
delay(delayTime);

digitalWrite(nero, HIGH);
digitalWrite(marrone, LOW);
digitalWrite(arancio, LOW);
digitalWrite(giallo, HIGH);
delay(delayTime);

digitalWrite(nero, HIGH);
digitalWrite(marrone, LOW);
digitalWrite(arancio, HIGH);
digitalWrite(giallo, LOW);
delay(delayTime);}
}

void backward (int steps){
for(int i=0;i<steps;i++){
    digitalWrite(nero, HIGH);
digitalWrite(marrone, LOW);
    digitalWrite(arancio, HIGH);
    digitalWrite(giallo, LOW);
    delay(delayTime);

    digitalWrite(nero, HIGH);
    digitalWrite(marrone, LOW);
    digitalWrite(arancio, LOW);
    digitalWrite(giallo, HIGH);
    delay(delayTime);

   digitalWrite(nero, LOW);
   digitalWrite(marrone, HIGH);
   digitalWrite(arancio, LOW);
   digitalWrite(giallo, HIGH);
   delay(delayTime);

   digitalWrite(nero, LOW);
   digitalWrite(marrone, HIGH);
   digitalWrite(arancio, HIGH);
   digitalWrite(giallo, LOW);
   delay(delayTime);
}

}

PS
this page: http://www.arduino.cc/en/Tutorial/StepperBipolar is for UNIPOLAR stepper motor!

analisi comparativa WL0025 e Alfa Network 500mA

2011-01-26T11:39:00.000+01:00

finalmente ho finito una recenzione comparativa di due tra le migliori schede di rete wireless in commercio... il senso è presentarvi qualche shoot per mettervi in condizione di giudicare voi stessi, più che di spendere parole, comunque partiamo dalla descrizione veloce dei prodotti (googolando si trovano tantissime recensioni specifiche, volendo...)

Alfa Network AWUS036H

Basata sul chipset Realtek 8187L succhia 500mw alla massima potenza, non so se corrisponde a vero, ma sicuramente la batteria del portatile dura meno con la scheda attaccata.
viene riconosciuta out-of-the-box da debian (senza injection se non si patchano i driver) e BackTrack3 (in pieno), con i driver contenuti nel cd anche su windows, ma non era mia intenzione testarla sul sistema operativo di zio Bill, per dovere di cronaca ho inserito anche degli screen con i grafici di NetStrumbler che vanno tanto di moda, ma non ho fatto di più.
Carina la confezione in cui arriva, solo cd driver (inutile...) e scheda, senza manuali e roba inutile.

LogiLink WL0025

Monta un chip Ralink rt2570, è una scheda economica ed essenziale.
scaricando dai repository debian i driver la scheda funziona bene (sempre senza injection se non si patchano), BT3 la riconosce senza problemi.

piattaforma di testing:

portatile DELL 640m con BackTrack3 on USB

antenne:
- antenne originali delle due schede

- omnidirezionale da 5db

- elicoidale autoprodotta

basta chiacchiere, le prove sono fatte tutte indoor per due buoni motivi:
- in terrazzo fa freddo
- le reti all'esterno con la alfa diventano talmente tante da essere quasi ingestibili

premettendo che me ne frego di mascherare gli ESSID delle reti (già è tanto che ho levato qualche MAC) visto che non sono segreti e che se la gente ci mette nome e cognome... beh peggio per loro, una volta attaccate le schede CON ANTENNA ORIGINALE questo è quello che ci si presenta davanti:

WL0025:

ALFA:

come si può vedere la alfa rileva più reti ma con margini minori, questo comporta un segnale non sempre costante nelle connessioni (non è mia intenzione entrare nelle reti che rilevo, ma dalle prove che ho fatto sulla mia rete basta un segnale di "30" segnato da airodump per una connessione funzionante, con entrambe le schede.

prossimo passo, attacco l'antenna omnidirezionale da 5db e ripeto il test:
WL0025:

ALFA:

e di nuovo si evidenziano gli stessi risultati, la LogiLink rileva solo le reti con segnale maggiore, ma più stabili a dispetto della alfa che per conto suo ci da una panoramica notevole delle reti intorno a noi.

ultimo passo, antenna elicoidale (puntata verso l'esterno della camera):
WL0025:

ALFA:

è difficile riuscire a dare un giudizio globale, sono schede molto diverse che si tende a assimilare... mentre la LogiLink è perfetta per un uso casalingo (ottimo rapporto qualità/prezzo) la Alfa è dedicata agli smanettoni, ai wardriver (si ricorda che entrare nelle reti altrui senza permesso è un reato)
certo è difficile non commuoversi quando si fa injection con la Alfa che "sfrigola", ma è anche vero che ha un costo circa doppio della "tranquilla" WL0025.

chiudo con due grafici di NetStrumbler che non hanno molto valore, visto che non sono fatti sulla stessa rete, ma fanno una gran scena!

FAXE CANTENNA

2011-01-26T11:11:00.001+01:00

Come anticipato nel primo post, oggi si costruisce una direzionale con un barattolo di FAXE.
non è esattamente una antenna a costo zero come decantato da tanti siti, ma permette un buon guadagno con una spesa decente.

occorrente:
barattolo di FAXE da un litro (costo 2,71€ alla SMA)
connettore tipo N femmina da pannello (costo 5€ perche l'ho preso da ladri, mediamente costa 3€)
pigtail rp-sma --> N maschio (7€ circa sulla baia)
chiodo, fil di ferro (meglio rame) o qualsiasi conduttore di diametro 2mm e lunghezza 3,1cm

dremel con dischi per tagliare la lamiera, carta vetrata e trapano (punte per ferro da 1cm e 3mm)

per prima cosa buttate la "birra" contenuta nel barattolo. non provate a berla. secondo me i produttori della faxe hanno rinunciato a produrre birra per il consumo, fanno i barattoli per le cantenne in realtà, e ci buttano dentro quello che gli capita.

prendete il barattolo e con il dremel tagliate lungo la linea dorata superiore del barattolo (sembra fatta a posta per avere una guida per il taglio, questo avvalora la mia tesi sulla produzione di barattoli per antenne e non per la birra).

alla fine otterrete questo:

By mikymouse

più è preciso il taglio e meglio è. alla fine rifinite con la carta vetrata.

prendete il fil di ferro o quello che avete scelto come dipolo e saldatelo sul connettore.

adesso, montate una punta da 1 per metallo sul trapano e contate 5,2cm dal fondo della lattina. il punto è appena sopra le scritte, regolatevi con l'immagine sotto.
una volta fatto il buco principale, poggiateci sopra il connettore e fate i buchi per le viti di fissaggio del connettore (punta da 3).
consiglio: fate prima UN buco, poi ci mettete sopra il connettore (fissato con una vite) e fate un altro buco, se segnate i 4 punti e fate i buchi tutti insieme rischiate di non trovarli allineati con i fori del connettore.

ora montate il connettore.... alla fine ottenete questo:

beh praticamente abbiamo già finito. ora ci attaccate il pigtail e collegate l'antenna alla vostra scheda di rete. il tocco di classe è fissare un bullone per poter mettere l'antenna su un treppiede, una cosa del genere:

il guadagno che si ottiene lo avevo postato anche l'altra volta, ma per completezza lo rimetto.

prima

dopo

external antenna eeepc 900

2011-01-26T10:24:00.000+01:00

ed ecco a voi il primo post di questo blog.... una mod semplice semplice.... piazzare un connettore rp-sma per antenne esterne su un asus eeepc 900 (con qualche riferimento a come si smonta un eeepc, visto che in rete non avevo trovato consigli)

allora, per prima cosa vi serve:
un pigtail U.FL / IPX RP-SMA facilmente reperibile sulla baia (non tanto facilmente in Italia...) costo approssimativo 6-7€

pesantemente ispirato a:
wiki.portertech.org/doku.php

dove potrete trovare anche altre foto e approfondimenti.

per prima cosa vanno rimosse le viti dalla parte inferiore della scocca, poi sbloccata e rimossa la tastiera, svitate le altre viti (sotto la tastiera) e sbloccata la parte superiore della scocca.

una volta rimossa la parte superiore si ottiene questo: (i connettori con i cerchi rossi vanno tolti)

alzando la scheda madre... sulla destra si nota la scheda di rete con i due fili (bianco-nero) delle antenne che si trovano dietro al monitor.

a questo punto si può procedere bucando come si può vedere sotto....

inserendo il connettore dopo aver lavorato il buco e creato la feritoia per il pigtail

a questo punto il connettore del pigtail va collegato alla scheda wifi sostituendo il connettore "aux" presente. rimontando.... lavoro finito

conclusioni:

la modifica è adatta per antenne direzionali, molto meno per antenne fisse omnidirezionale come quella che ho montato per prova nell'ultima foto a causa della posizione del connettore: montando antenne più grosse si ha che il pc "poggia" sull'antenna e non sui piedini perchè questa sporge troppo. con piccole antenne come quella sopra o con cantenne il problema non si pone.

queste sono due schermate di airodump prima e dopo la connessione di una antenna direzionale (le foto della realizzazione le metterò nel prossimo post) ovviamente nello stesso punto della casa.