Pin digitali

La scheda Netduino prende spunto dal progetto Arduino, infatti, la forma della scheda e la disposizione dei connettori è identica a quella di Arduino UNO. I pin digitali sono 14 e possono essere configurati via software come ingressi o uscite (InputPort OutputPort). La possibilità di decidere programmaticamente la funzione di ognuno di questi pin permette una elevata flessibilità nell’adattare Netduino al mondo esterno.

La tensione di lavoro dei pin è di 3.3Vdc ma è possibile lavorare anche con tensioni in ingresso di 5Vdc (TTL). Per quanto riguarda la corrente prelevabile abbiamo valori massimi di 8 mA; i pin 2, 3, e 7 riescono a fornire 16mA massimi.

I pin sono collegati direttamente al chip Atmel, occorre fare molta attenzione ai collegamenti esterni, un corto circuito o una tensione di sovraccarico potrebbero danneggiare irreparabilmente il microcontrollore.

Configurazione pin in uscita

Vediamo come configurare un pin digitale in uscita, utilizzando la classe OutputPort (Microsoft.SPOT.Hardware.OutputPort). I parametri da passare al costruttore sono l’identificativo del pin che vogliamo usare come uscita e il suo stato iniziale (Livello logico alto pari a3.3Vdc oppure livello logico basso pari a 0Vdc).
Ecco un esempio che mostra come configurare il pin0 del Netduino come uscita

//Pin 0 in uscita, inizializzato a livello logico basso
OutputPort pin0 = new OutputPort(Cpu.Pin.GPIO_Pin0, false);

Se stiamo realizzando un circuito di esempio consiglio di inizializzare la porta in uscita a false (livello logico basso) per evitare di collegare per errore il pin a massa (corto circuito) con conseguente possibile rottura della porta del chip Atmel.
La classe Pins enumera tutte le porte del Netduino disponibili per la configurazione come uscite o ingressi.

L’operazione fondamentale disponibile per il pin è il cambio di livello utilizzando il metodo Write() dell’oggetto appena istanziato.
Il codice seguente mostra come utilizzare il metodo Write()

//Mette a livello alto (3.3Vdc) il pin D0
pin0.Write(true);
//Mette a livello basso (0Vdc) il pin D0
pin0.Write(false);
[/csharp]

Sebbene il pin0 sia configurato come uscita, possiamo leggere, tramite il metodo Read(), il livello logico impostato con il metodo Write():

[csharp]
//creo una variabile bool per memorizzare lo stato della porta
Boolean Livello = false;
//Mette a livello alto (3.3Vdc) il pin D0
pin0.Write(true);
//leggo lo stato del livello
Livello = pin0.Read();
//restituisce true
Debug.Print(Livello.ToString());
//Mette a livello basso (0Vdc) il pin D0
pin0.Write(false);
//leggo lo stato del livello
Livello = pin0.Read();
//restituisce false
Debug.Print(Livello.ToString());

La proprietà InitialState restituisce lo stato del livello al momento della creazione dell’oggetto

//creo una variabile bool per memorizzare lo stato della porta
Boolean Livello = false;
//Pin 0 in uscita, inizializzato a livello logico basso
OutputPort pin0 = new OutputPort(Cpu.Pin.GPIO_Pin0, false);
//Mette a livello alto (3.3Vdc) il pin D0
pin0.Write(true);
//leggo lo stato del livello al momento della creazione
//dell'oggetto pin0
Livello = pin0.InitialState;
//restituisce false
Debug.Print(Livello.ToString());

La proprietà ID fornisce il nome del piedino del microcontrollore Atmel (come definito nel datasheet)

//Creo un oggetto Pin
Cpu.Pin nomePin;
//Pin 0 in uscita, inizializzato a livello logico basso
OutputPort pin0 = new OutputPort(Cpu.Pin.GPIO_Pin0, false);
//Ottengo il nome del pin riferito al microcontrollore Atmel
nomePin = pin0.Id;
Debug.Print(nomePin.ToString());

Configurazione pin in ingresso

Per accettare segnali in ingresso dobbiamo decidere quali pin utilizzare e configurarli con la classe InputPort (Microsoft.SPOT.Hardware.InputPort). In questo caso i parametri da passare al costruttore sono 3, il primo definisce l’identificativo del pin da utilizzare come ingresso, il secondo permette di attivare il filtro antirimbalzo (glitch filter) e il terzo permette di attivare l’eventuale resistenza di pull-up interna al microcontrollore.
Il codice seguente utilizza il pin3 del Netduino come ingresso.

//Definisco il pin 3 come ingresso, abilito l'antirimbalzo e la reistenza di pullup
InputPort pin3 = new InputPort(Cpu.Pin.GPIO_Pin3, true, Port.ResistorMode.PullUp);

Il metodo Read() permette di leggere il livello logico presente sul pin di ingresso. Read() restituisce un valore booleano in funzione del livello logico.

Boolean Livello = false;
//Pin3 in ingresso
InputPort pin3 = new InputPort(Cpu.Pin.GPIO_Pin0, true, Port.ResistorMode.PullUp);
//leggo dal pin3
Livello = pin3.Read();

Le proprietà esposte dall’oggetto sono ID, GlitchFilter e Resistor

Boolean Livello = false;
Boolean StatoFiltro= false;
Port.ResistorMode Resistenza;
//Variabile per contenere il nome del pin
Cpu.Pin nomePin;

//nome del pin come indicato nel datasheet del microcontrollore
nomePin = pin3.Id;
Debug.Print(nomePin.ToString());
//stato del filtro antirimbalso
StatoFiltro = pin3.GlitchFilter;
Debug.Print("StatoFiltro " + StatoFiltro.ToString());
//tipo di resistenza selezionato
Resistenza = pin3.Resistor;
Debug.Print("Resistenza " + Resistenza.ToString());

GlitchFilter

Il filtro antirimbalzo permette di eliminare gli impulsi spurii che si formano nei contatti metallici di un pulsante. All’atto della chiusura del pulsante il contatto non avviene immediatamente ma esiste un piccolo tempo di assestamento che da luogo a degli impulsi spurii che possono essere interpretati erroneamente dal Netduino. Attivando il filtro, introduciamo un certo ritardo prima di leggere lo stato dell’ingresso, in questo modo possiamo avere una lettura sicura poichè il contatto meccanico si è ormai stabilizzato.
La figura mostra gli impulsi spurii generati dall’interruttore:

ResistorMode

Questa proprietà è molto importante perché permette di eseguire delle letture sicure del livello logico in ingresso quando, il circuito esterno, non imposta un riferimento di tensione sul pin. Le resistenze di pull up permettono di forzare un livello logico alto stabile sul pin d’ingresso. Nel caso del microcontrollore SAM7X possiamo utilizzare solo le resistenze di PullUp, dato che non sono presenti quelle di pull down (Impostando Port.ResistorMode.PullDown otteniamo un eccezione).

Abbiamo visto che per leggere dai pin dobbiamo richiamare il metodo Read(), quindi se vogliamo tenere sempre sotto controllo lo stato dell’ingresso è necessario eseguire ciclicamente il metodo Read();  sarebbe comodo un sistema che monitorizzi l’ingresso in modo da rilevare i cambiamenti di stato. Fortunatamente il Netduino ed il .Net micro framework mettono a disposizione la classe InterruptPort che svolge proprio questa funzionalità.

Configurazione pin in ingresso con InterruptPort

La classe InterruptPort permette di utilizzare un pin come ingresso e di eseguire un metodo ogni qualvolta che si verifica un cambiamento di stato su tale pin. Vediamo come configurare un pin in ingresso con la classe InterruptPort

InterruptPort pin0 = new InterruptPort(Cpu.Pin.GPIO_Pin0, false,
Port.ResistorMode.PullUp,
 Port.InterruptMode.InterruptEdgeBoth);

Il costruttore è molto simile alla classe InputPort ma in questo caso abbiamo un parametro aggiuntivo che definisce in che modo deve essere generato l’interrupt per quel pin. Le possibili opzioni sono:

Le opzioni sono diverse e riescono a soddisfare tutte le variazioni di segnale che possono interessare il pin in ingresso.
La parte importante è la possibilità di generare un evento ogni volta che si verifica un’interrupt. Il codice di esempio mostra come farlo

public static void Main()
{
//Definisco il pin0 come InterruptPort
//L'interrupt viene generato sul fronte di salita
InterruptPort pin0 = new InterruptPort(Cpu.Pin.GPIO_Pin0, false,
Port.ResistorMode.PullUp,
Port.InterruptMode.InterruptEdgeHigh);
//Creo un evento quando si scatena un interrupt
//Ogni volta che viene generato un evento viene eseguito il metodo EventoPinIngresso
pin0.OnInterrupt += new NativeEventHandler(EventoPinIngresso);

while(true)
{
//eseguo qualcosa
Thread.Sleep(100);
}
}

public static void EventoPinIngresso(uint data1, uint data2, DateTime time)
{
//eseguo qualcosa quando viene generato un interrupt
Debug.Print(data1.ToString());
Debug.Print(data2.ToString());
Debug.Print(time.ToString());
}

In questo modo ogni volta che il segnale in ingresso scatena un interrupt, Netduino esegue il codice contenuto in EventoPinIngresso.
La firma del metodo EventoPinIngresso deve contenere due valori uint e una DateTime. Il primo valore (data1) contiene il numero del pin del microcontrollore, il secondo contiene il livello logico sul pin e il terzo (time) contiene il tempo in cui è stato scatenato l’evento.
Da notare che la gestione dell’evento è asincrona e quindi il Netduino continua ad eseguire il codice del ciclo while ed esegue autonomamente il metodo EventoPinIngresso quando si verifica un interrupt.

Questa funzionalità permette di creare codice che reagisce autonomamente agli eventi esterni e fa in modo che il Netduino si adatti meglio alle esigenze progettuali moderne.

The post Netduino, linee GPIO configurarle con InputPort e OutputPort appeared first on Esperimenti con logiche programmabili.

Era il 1999 quando acquistai il libro Programmare Microsoft Visual Basic 6.0, di Francesco Balena, quello fu il mio ingresso nel mondo della programmazione. Ancora non sapevo cosa potessi fare, che programmi potessi sviluppare, quali problemi sarei riuscito a risolvere. Ero entusiasta di quel libro, tutto veniva spiegato accuratamente e con grande precisione e professionalità. Sognavo di realizzare software di ogni tipo, di aiutare amici e parenti con i miei programmi.

La cosa che più mi intrigava fu la possibilità che il software potesse interagire con il mondo esterno. Sfruttando la porta seriale oppure quella parallela, avevo l’intenzione di costruire piccoli dispositivi per acquisire segnali da sensori e pilotare attuatori. La cosa che però mi impedì di realizzare questi circuiti, fu l’ingombro fisico del pc. Non potevo creare un sistema di irrigazione automatizzato poiché era improbabile mettere un pc nei pressi di un giardino e farlo funzionare costantemente evitando malfunzionamenti. Senza pensare ai costi realizzazione di un sistema di questo tipo!

Passarono gli anni e la parte ‘hardware’ dei miei progetti fu sopraffatta da quella software… Nel mentre nacque il .Net Framework e incominciai a migrare, dopo tanto codice vb6, verso il  nuovo linguaggio C#.

Ogni tanto sentivo parlare su vari forum e blog del .Net micro framework e di alcuni (pochi) dispositivi che potevano essere programmati utilizzando Visual C#, ma ormai ero lanciato verso lo sviluppo desktop e web e la voglia di riprendere in mano il saldatore era quasi svanita.

Successivamente il mondo dello sviluppo software ha iniziato ad entrare nelle case, nelle auto, nei dispositivi portatili, nel controllo accessi ed in generale ha ridato linfa al mondo embedded che era una nicchia riservato all’industria e alle medio-grandi imprese.Alche io ho iniziato a domandarmi se i programmatori desktop e web potessero lavorare non solo con i pc ed i server ma anche con questi piccoli dispositivi che ormai potevano essere paragonati a dei pc in miniatura.
La risposta giunse quando scoprii l’esistenza di Arduino e di Netduino poi. L’idea di poter scrivere codice per queste piattaforme era sorprendentemente fantastica! Potevo riprendere a sperimentare con i dispositivi hardware è creare nuove applicazioni.

Ma la domanda principale che mi sono posto è, cosa posso fare con Arduino Netduino?

Sicuramente trovo che questi dispositivi siano davvero versatili e duttili, ma certamente penso che non possano essere impiegati ovunque. In base alla mia esperienza professionale credo che gli ambiti migliori dove utilizzare Arduino e Netduino sono:

• Domotica
• Agricoltura
• Controllo accessi
• Robotica amatoriale
• Dispositivi di allarme
• Stazioni meteo
• Sistemi di controllo, anche remoti (esclusi quelli real time)
• Dispositivi wireless
• Dispositivi con accesso LAN
• Utilizzo per scopi didattici e sperimentali

certamente esistono altri impieghi, ma questa lista nasce secondo le mie esperienze, secondo quello che io potrei realmente realizzare con questi dispositivi. Non mi sembra giusto scrivere una serie di applicazioni, solo per avere un elenco più lungo e importante, che poi non saprei giustificare!

Analizzo meglio queste voci per dare un’idea più precisa sui vari punti

Domotica:

Circuiti elettronici che riguardano l’ambito domestico come controllo del sistema di illuminazione, gestione dell’impianto di riscaldamento, rivelazione fumi e gas, azionamento sistemi di irrigazione del giardino.

Agricoltura:

Sistemi automatici di irrigazione, riscaldamento e refrigerazione serre.

Controllo Accessi:

Gestione lettori RFID per apertura ingressi, sistemi i accesso basati su tastiere o lettori di schede magnetiche. Possibilità di interfacciamento del sistema alla rete Lan.

Robotica Amatoriale:

Creazione automi basati sulla gestione di diversi sensori e attuatori. Creazione di piccoli robot autonomi che svolgono compiti predefiniti.

Dispositivi di Allarme:

Gestione di sensori di movimento e interruttori, attivazione sirene e segnalazione intrusione via rete gsm o internet.

Stazione Meteo:

Controllo di sensori di temperatura, pressione, umidità, anemometri e pluviometri e possibilità di registrare tutti i dati su memoria solida o invio tramite lan.

Sistemi di Controllo:

Controllo e gestione di sistemi numerici, acquisizione segnali, elaborazione e attuazione. Escluderei però sistemi real-time, e impieghi in ambito industriale.

Dispositivi Wireless:

Comunicazioni e controllo di dispositivi senza file utilizzando trasmettitori RF.

Dispositivi con Accesso Lan:

Creazione di sistemi con controllo remoto del dispositivo, piccoli server web, comunicazione con protocolli UDP e TCP/IP

Utilizzo per scopi didattici:

Realizzazione di semplici esperimenti per iniziare a imparare il funzionamento dei sistemi di controllo, dell’acquisizione segnali e loro elaborazione. Come sistema sperimentale per iniziare ad esplorare il mondo dell’elettronica.

La mia considerazione non vuole dare una  risposta definitiva alla domanda, ma penso che aiuti molti principianti, che ancora stanno valutando se acquistare questi dispositivi piuttosto che altri.
Il mio consiglio è, visto il basso costo delle schede e la disponibilità di ambienti di sviluppo gratuiti, di investire un po di denaro per poter provare a sperimentare e creare piccoli circuiti. La pratica fa subito capire la potenzialità di queste schede e ci fa entrare in un mondo sicuramente interessante che puo dare tante soddisfazioni.
Buona sperimentazione a tutti!

The post Cosa posso fare con Arduino Netduino? appeared first on Esperimenti con logiche programmabili.

Ora che abbiamo il nostro mini laboratorio per creare i prototipi e il software sul pc è installato correttamente possiamo avviare il primo progetto per verificare se tutto funziona e se il .net micro framework è correttamente attivo e funzionante sul Netduino.

Per prima cosa colleghiamo il Netduino al pc e verifichiamo che il led pwr sulla scheda sia acceso.
Ora avviamo Visual C# 2010 Express e creiamo un nuovo progetto:

la finestra Nuovo Progetto mostra tutti i tipi di soluzioni che possiamo generare con la nostra copia di Visual C# 2010 Express. Cliccando sulla voce Visual C# potremmo vedere la sottovoce Micro Framework, clicchiamo su di essa per visualizzare i vari tipi di progetto che possiamo creare. Se l’installazione dell’ sdk di Netduino è stata eseguita correttamente, in questo box ci sarà una voce dal nome Netduino Application

Selezioniamo la voce come mostrato in figura, diamo un nome alla nostra soluzione compilando la casella di testo Nome e clicchiamo sul pulsante OK per dar modo a Visual C# di impostare l’ambiente per lo sviluppo con Netduino e con il .Net micro framework.

Di tutte le voci elencate nella finestra Esplora Soluzione quella che ci interessa maggiormente è Program.cs che conterrà il codice della nostra applicazione. Avviamo l’editor cliccando due volte su questo file.

Il nostro codice può essere inserito nel blocco Main(), ma per il momento lasciamo tutto così com’è e proviamo subito a caricare il sorgente nel nostro Netduino.

Per prima cosa dobbiamo configurare Visual C# per comunicare con la scheda. Dalla finestra Esplora Soluzione clicchiamo due volte sulla voce Propierties per aprire la finestra delle proprietà della soluzione.

Selezioniamo la voce .Net Micro Framework; come si può vedere dalla figura nel box Deployment per default è selezionato l’emulatore. Per caricare il programma sul Netduino dobbiamo scegliere nella combobox Transport la voce USB. In questo modo Visual C# controllerà i dispositivi collegati alla porta usb e gli elencherà nella combobox Device. Selezioniamo la voce Netduino_Netduino disponibile nella lista dei device per poter comunicare con il Netduino.
Ora chiudiamo la finestra delle proprietà.

Tutto è pronto per programmare il  Netduino basta cliccare sull’icona Avvia Debug(F5) e Visual C# compilerà il sorgente e caricherà l’eseguibile sul dispositivo

Nella finestra Output di Visual Studio (Menu Visualizza -> Output) potremmo vedere tutti i passaggi della compilazione e del caricamento del sorgente sul Netduino.

Il .net micro framework contenuto nel Netduino inizierà a gestire ed eseguire il programma.

The post Netduino, .Net micro Framework e Visual C# appeared first on Esperimenti con logiche programmabili.