L’utilizzo dei pin digitali rientra tra le nozioni basilari da comprendere per poter iniziare ad interagire con  i dispositivi ed i componenti esterni che permettono al modulo Flyport Ethernet di far parte di un sistema complesso.
Il modulo Flyport Ethernet è composto da due connettori, J1 e J2; essi sono collegati direttamente ai pin del microcontrollore Pic24F ed al controller Ethernet ENC424J600.

Tramite questi connettori possiamo collegarlo al modulo NEST Proto o ad un nostro circuito host dedicato.
Nel mio caso utilizzerò il Nest Proto per motivi di semplicità e di uniformità dei tutorial.

Nel Nest Proto è presente un connettore femmina collegato direttamente al connettore J1 del Flyport Ethernet, che permette di utilizzare dei fili elettrici pint-to-pin per realizzare velocemente prototipi ed esperimenti. Tralasciamo, per ora, il connettore J2 che viene impiegato per la comunicazione ethernet (tramite una porta RJ45 da saldare sul NEST Proto), e per offrire altri 8 pin IO.

Il connettore J1 è composto da 26 pin, ad ognuno è associata una funzione specifica. La tabella seguente mostra la pin-function del connettore:

Configurare pin GPIO come uscita

I pin contrassegnati come GPIO possono funzionare sia come ingressi sia come uscite digitali. La colonna Remappable indica invece se al pin può essere associata una funzione speciale, ad esempio i pin p1 e p3 NON sono rimappabili e quindi possono essere configurati o come GPIO o come bus I2C. Un pin rimappabile può funzionare sia come GPIO ed è possibile associarli anche una funzionalità aggiuntiva come PWM, UART o SPI. Questa peculiarità permette di avere un sistema molto flessibile, configurabile per ogni esigenza progettuale.
La colonna, 5V Tollerant, indica se il pin può sopportare tensioni di 5 Volt (Logica TTL), ad esempio il pin p17 non è 5V tollerant e quindi dobbiamo stare molto attenti a non collegare tensioni superiori ai 3.3V, causa possibile danneggiamento del microcontrollore.

Utilizziamo il circuito in figura per scrivere un piccolo programma che utilizzerà le istruzioni per definire il pin p2 come uscita digitale:

al pin p2, ho collegato una resistenza da 330 ohm ed un diodo led. Da notare che i numeri dei pin sono disposti utilizzando la prima riga, del connettore J1, per i numeri dispari e la seconda riga per i numeri pari.

Il codice seguente accende e spegne il led ogni 500ms:

[c]
#include "taskFlyport.h"

void FlyportTask()
{
//il pin p2 viene configurato
//come uscita digitale
IOInit(p2, out);

//ciclo infinito
while(1)
{
//commuto il pin p2 a livello
//logico alto
IOPut(p2, on);
//creo un ritardo di 500ms
DelayMs(500);
//commuto il pin p2 a livello
//logico basso
IOPut(p2, off);
//creo un ritardo di 500ms
DelayMs(500);
}
}
[/c]

L’istruzione che permette di definire un pin come uscita o come ingresso è la IOInit(). I parametri da passare sono il numero del pin, espresso nella forma px (dove x è il numero del pin) ed il flag per specificare un uscita out o un ingresso in.
In questo caso il pin p2 viene usato come uscita (out). Per poter commutare il suo stato logico utilizziamo la funzione IOPut(). Questa funzione accetta due parametri, il primo è il numero del pin, definito nella IOInit, e il secondo specifica se metterlo a livello logico alto (on) o al livello basso(off).

Configurare pin GPIO come ingresso

Il pin p2 viene ora impiegato come ingresso digitale. Lo schema elettrico è il seguente:

la resistenza R1 serve per avere un livello logico basso sul pin p2 quando il pulsante è aperto. Sul pin p4 ho collegato un diodo led in modo da poterlo accendere quando premo sul pulsante.
Questo è il codice del firmware da caricare sul Flyport:

[c]
#include "taskFlyport.h"

void FlyportTask()
{
//il pin p2 viene configurato
//come Ingresso digitale
IOInit(p2, in);

//il pin p4 viene configurato
//come Uscita digitale
IOInit(p4, out);

//ciclo infinito
while(1)
{
//verifico lo stato del pin p2
//Alto o basso
if(IOGet(p2) == 1)
//sel il pin è a livello
//logico alto, accendo il led
IOPut(p4, on);
else
//altrimenti
//spegni il led
IOPut(p4, off);

DelayMs(20);
}
}
[/c]

Ho usato due istruzioni IOInit per definire il pin p2 come ingresso e il pin p4 come uscita. Nel blocco while, controllo, con l’istruzione IOGet, se il livello logico sul pin p2 è alto. In caso affermativo, utilizzo il pin p4, per accendere o spegnere il diodo led.

Nei prossimi tutorial vedremo come attivare la resistenza interna di pull-up e di pull-down per gli ingressi digitali del Flyport Ethernet.

The post Flyport Ethernet, conoscere i pin digitali appeared first on Esperimenti con logiche programmabili.

Continuiamo l’articolo precedente inserendo nello sketch il codice che permette di campionare segnali analogici per poterli inviarli tramite protocollo http.
Utilizzando la funzione analogRead() acquisiamo il valore della tensione presente sul pin analogico, che verrà utilizzato per essere inserito nella pagina html da inviare al client. Con alcuni tag html aggiuntivi abbiamo la possibilità di avere un refresh automatico della pagina che ad intervalli regolari interrogherà il server Arduino, ottenendo automaticamente nuovi campionamenti del segnale analogico.
Il circuito seguente:

In questo esempio la tensione presente sul pin è fissa, ma nulla vieta l’inserimento di un potenziometro o meglio di un sensore analogico come la sonda di temperatura mcp9700a.

Il codice dello sketch rimane essenzialmente invariato tranne per l’inserimento di una variabile per contenere i valori provenienti dalla funzione analogRead() e di qualche riga html aggiuntiva per formattare la pagina:

if (Data_RX == '\n')
{
//campiono il valore di tensione analogia
//in ingresso sul pin0 ella borad Arduino UNO
analogIn0 = analogRead(0);
//Invio la risposta al client
//invio lo status code
pc_client.println("HTTP/1.1 200 OK");
//imposto il data type
pc_client.println("Content-Type: text/html");
pc_client.println();
//invio codice html
pc_client.print("");
pc_client.print("");
//questo codice html permette di eseguireil refresh automatico
//della pagina html
pc_client.print("");
pc_client.print("");
pc_client.print("

Valore analogico letto dal pin 0");
//inserisco nella pagina html il valore acquisito dal pin analogico
pc_client.print(analogIn0);
pc_client.print("

");
//aspetto 1 ms affinche la risposta giunga al browser del client
delay(1);
//esco dal ciclo while una volta completato l'invio della risposta
break;
}

Non serve altro, è veramente semplice inviare via http i dati acquisiti dall’Arduino.
Possiamo certamente utilizzare anche gli altri ingressi analogici o come nel prossimo esempio leggere lo stato di alcuni pin digitali.
Per impiegare i pin digitali dobbiamo, nel blocco setup(),  specificare quali intendiamo utilizzare come ingressi. Per una semplice prova io ho usato il pin6 e il pin7:

void setup()
{
//inizializza lo shield con il mac e l'ip
Ethernet.begin(mac, ip);
//inizializza l'oggetto server
ArduinoServer.begin();
//definisco i pin6 e pin7 come ingressi
pinMode(6, INPUT);
pinMode(7, INPUT);
}

La funzione digitalRead() acquisisce il valore dello stato dei pin in esame e lo memorizza in una variabile precedentemente dichiarata. Questo valore viene successivamente inviato al client tramite la pagina html

if (Data_RX == '\n')
{
//leggo lo stato dei pin digitali 6 e 7
valPin6 = digitalRead(6);
valPin7 = digitalRead(7);

//campiono il valore di tensione analogia
//in ingresso sul pin0 ella borad Arduino UNO
analogIn0 = analogRead(0);

//Invio la risposta al client
//invio lo status code
pc_client.println("HTTP/1.1 200 OK");
//imposto il data type
pc_client.println("Content-Type: text/html");
pc_client.println();
//invio codice html
pc_client.print("");
pc_client.print("");
//questo codice html permette di eseguireil refresh automatico
//della pagina html
pc_client.print("");
pc_client.print("");
pc_client.print("

Valore analogico letto dal pin 0");
//inserisco nella pagina html il valore acquisito dal pin analogico
pc_client.print(analogIn0);
pc_client.print("

");

//inserisco nella pagina htm lo stato dei pin in ingresso
if(valPin6 == HIGH)
//se il valore è alto
pc_client.print("Stato pin6 = HIGH");
else
//se il valore è basso
pc_client.print("Stato pin6 = LOW");

pc_client.println("
");

if(valPin7 == HIGH)
//se il valore è alto
pc_client.print("Stato pin7 = HIGH");
else
//se il valore è basso
pc_client.print("Stato pin7 = LOW");

pc_client.print("");

//aspetto 1 ms affinche la risposta giunga al browser del client
delay(1);
//esco dal ciclo while una volta completato l'invio della risposta
break;
}

Anche questo codice risulta semplice e i commenti che lo accompagnano descrivono bene le varie istruzioni. Dopo aver caricato lo sketch sull’Arduino ho messo il pin6 alla +5Vdc e il pin 7 a massa ottenendo il risultato seguente:

Naturalmente i pin 10-11-12-13, sono utilizzati per la comunicazioni SPI con l’ethernet shield e quindi, non possono essere impiegati per altri scopi senza interferire nella comunicazione stessa.

Vi rimando al prossimo articolo dove vedremo come utilizzare il browser per inviare comandi alla board Arduino, nel frattempo potete sperimentare con le nozioni acquisite per aumentare le vostre capacità nell’uso della athernet shield.

A presto!

The post Leggere dagli ingressi analogici da remoto con Arduino appeared first on Esperimenti con logiche programmabili.