Eccoci nuovamente al mio classico speed test per misurare la frequenza massima ottenibile dalla commutazione continua di un singolo pin.

La scheda in esame è il nuovo Netduino Plus 2 basato sulla cpu STmicro STM32F4 operante a 168Mhz. Sicuramente l’incremento di frequenza ha permesso maggiori prestazioni ma il risultato è ben lontano dai 125KHz ottenuti dall’Arduino UNO, infatti la frequenza misurata è di 44.27 KHz, che paragonata alla prima versione della scheda (quella basata sulla cpu AT91SAM7 operante a 48MHz), è comunque un ottimo risultato che fa ben sperare in evoluzioni future e miglioramenti prestazionali nell’archittetura .Net micro framework.

Di seguito la tabella aggiornata degli speed test delle board che ho provato

Questo invece lo screen shot della schermata dell’oscilloscopio

The post Netduino Plus 2 Speed Test appeared first on Esperimenti con logiche programmabili.

L’associazione culturale DotNetCampania, costituita da un team di persone del territorio campano ed appassionate delle tecnologie Microsoft, ha organizzato a Napoli per il giorno 26 Gennaio 2013 la Microsoft Embedded Conference, una giornata completamente gratuita dedicata alle tecnologie embedded del mondo Microsoft.

Si partirà da una panoramica di tutte le soluzioni offerte da Microsoft per la realizzazione dei cosiddetti “Intelligent Systems”, attraverso il .Net Micro Framework ed i prodotti della famiglia Windows Embedded. Questi ultimi saranno analizzati nel dettaglio, partendo con Windows Embedded Compact 7 ed i relativi strumenti di sviluppo per la realizzazione di una BSP e dei drivers di un sistema OEM fino ad arrivare alla famiglia Windows Embedded Standard attraverso la quale è possibile definire un sistema operativo personalizzato, protetto, affidabile ed aggiornabile.

La mattina si concluderà con un’introduzione sul .Net Micro Framework, fratello minore della famiglia .Net, per lo sviluppo di applicazioni su sistemi caratterizzati da una disponibilità di risorse limitate ma pur sempre con le potenzialità del codice managed e soprattutto con il paradigma della programmazione ad oggetti.

Il pomeriggio inizierà con la presentazione della piattaforma .Net Gadgeteer che la Microsoft mette a disposizione per la realizzazione di dispositivi e prototipi anche in ambiente visuale attraverso Visual Studio. Si proseguirà con un’analisi della situazione attuale e futura sull’interconnessione dei dispositivi embedded nel mondo attraverso l’Internet Of Things e come sia possibile lo scambio di dati e di informazioni su scala mondiale tra di essi.

La giornata si concluderà con una interessantissima sessione dedicata allo sviluppo con Kinect, alla Natural User Interface e su come, attraverso ques’ultima, sia possibile interagire con dispositivi embedded che ci circondano.

Tutti i dettagli sulle sessioni e la logistica sono disponibili sul sito dell’evento raggiungibile all’indirizzo www.microsoftembeddedconference.it.

Un evento da non perdere per tutti gli appassionati e professionisti del mondo embedded!

The post Microsoft Embedded Conference appeared first on Esperimenti con logiche programmabili.

Circa 5 mesi fà ho realizzato un lettore badge basato sulla FEZ Cobra prodotta da GHI Electronics. Il prodotto è costituito da un display lcd, una tastiera numerica e un lettore rfid, ed è parte di un controllo accessi funzionante 24 ore su 24 7 giorni su 7.
Prima della sua messa in opera, ho seguito alcuni test “indoor” per verificarne la stabilità, e non ho avuto nessun tipo di problema sennonché il microprocessore della Cobra riscalda parecchio, nonostante il programma non esegua compiti gravosi.
Questo fatto mi ha preoccupato in quanto il lettore è posizionato in un passaggio carrabile ed è esposto ai raggi solari per quasi tutto il giorno, e visto che la scheda è racchiusa in un involucro a tenuta stagna e non avendo la possibilità di inserire un sistema di raffreddamento che mi permettesse di abbassare la temperatura interna, temevo ad un malfunzionamento del dispositivo.

Anche l’estate non è stata clemente, qui in Sardegna abbiamo raggiunto temperature di 38-40° all’ombra, di conseguenza la Cobra è stata sottoposta a temperature di lavoro quasi estreme e sinceramente mi aspettavo da un giorno all’altro la sua rottura.

Invece con mia grande sorpresa la FEZ Cobra sta ancora funzionando perfettamente dopo circa 3500 ore di lavoro continuo senza aver mai dato problemi di nessun tipo.

Certamente un solo pezzo non è sufficiente per fare una valutazione completa di questo prodotto ma viste le estreme condizioni a cui ho sottoposto la Cobra devo dire che ne sono rimasto davvero soddisfatto. Questo mi rende anche più fiducioso nel realizzare dei prodotti basati sul .Net micro framework vista la stabilità software che ho ottenuto in questo progetto.

The post FEZ Cobra esperienze e considerazioni appeared first on Esperimenti con logiche programmabili.

Dopo aver caricato il nuovo bootloader sul nostro Netduino non ci resta che caricare il firmware 4.2 per rendere la scheda operativa. Questa operazione deve essere eseguita utilizzando il tools MFdeploy contenuto nella cartella di installazione del .Net Micro framework 4.2 (che dovete installare precedentemente).
L’utility si trova, se avete fatto l’installazione standard, nella cartella C:\Program Files\Microsoft .NET Micro Framework\v4.2\Tools

Una volta avviato MFdeploy, tramite il blocco Device, dobbiamo selezionare il Netduino (precedentemente collegato alla porta USB del PC), utilizzando come canale di collegamento la voce USB. Automaticamente otterremmo nella casella di testo adiacente la voce Netduino_Netduino. Verifichiamo, utilizzando il pulsante Ping, che la comunicazione tra PC e Netduino sia attiva e funzionante.

Nel blocco Image File clicchiamo sul pulsante Browse… per selezionare sul nostro disco locale, il due file che compongono il firmware (ER_CONFIG, ER_FLASH) da scrivere sul Netduino.
Cliccando sul pulsante Deploy avvieremmo la scrittura, l’operazione richiede qualche minuto.

Al termine scolleghiamo il Netduino dalla porta USB e ricolleghiamolo dopo qualche istante.

Verifichiamo le informazioni del nuovo firmware tramite il menu Target->Device Capabilities, sempre tramite MFdeploy, per accertarci chel’operazione sia stata eseguita correttamente.

Le immagini seguenti mostrano tutte le fasi descritte precedentemente

The post Caricare nuovo firmware 4.2 sul Netduino appeared first on Esperimenti con logiche programmabili.

Con il rilascio della nuova versione del .Net micro framework 4.2 (QFE2) la Secret Labs ha rilasciato un nuovo bootloader e un nuovo firmware per le board Netduino, Netduino Plus e Netduino Mini. Viste le molte novità e migliorie della versione 4.2 consiglio vivamente l’upgrade delle board.

Le procedure principali sono le seguenti

1. Ricaricare il nuovo bootloader
2. Ricaricare il nuovo firmware

Prima di iniziare dobbiamo scaricare i seguenti software

• Firmware 4.2 del Netduino (Contenente anche il nuovo bootloader)
• Driver Netduino (Necessario per installare la scheda dop aver caricato il bootloader)
• .Net Micro Framework 4.2
• Atmel SAM-BA versione 2.12 o superiore (Contiene il software ed il driver del chip AT91SAM7X512-ex)

Installiamo il software SAM-BA che useremmo per caricare il bootloader. Di seguito alcuni screen shot dell’installazione

Scarichiamo il pacchetto zip contenente il firmware ed il bootloader. Teniamo da parte il file TinyBooterDecompressor.bin che caricheremo sul microcontrollore.

Eseguiamo la cancellazione del firmware e del bootloader del Netduino utilizzando un filo elettrico che, dal pin 3.3V andrà collegato al piccolo quadrato dorato vicino al pin0.
Alimentiamo per qualche istante il Netduino (tramite USB o alimentazione esterna) tenendo sempre collegato filo sul pad dorato. Togliamo alimentazione. Il nostro dispositivo è ora privo di firmware e di bootloader.

Ricollegando Il Netduino verrà avviata la ricerca Nuovo Hardware, annulliamo questa operazione per caricare manualmente i driver del microcontrolloare AT91SAM7X512-ek.

Le seguenti figure mostrano il processo di installazione della scheda

Una volta che il dispositivo è stato riconosciuto da Windows 7  possiamo caricare il nuovo bootloader.

Clicchiamo sull’icona SAM-BA v2.12. Nella prima schermata dobbiamo selezionare, alla voce Select the connection la porta COM dove è collegato il dispositivo, alla voce Select your board selezioniamo il chip AT91SAM7X512-ek. Clicchiamo sul pulsante connect.
Caricata la finestra principale del programma SAM-BA, bisogna, per prima, eseguire due script. Selezioniamo nel blocco Script la voce Boot from flash (GPNVM2), clicchiamo sul pulsante Execute, successivamente selezioniamo lo script Enable Flash Access, clicchiamo sempre su Execute.

Ora nel blocco Download/Upload file, selezioniamo dalla casella Send file Name il file TinyBooterDecompressor.bin precedentemente messo da parte sul nostro PC, clicchiamo sul pulsante Send File. Dopo qualche istante apparirà una finestra popup per richiedere il Lock Region, clicchiamo sul pulsante NO.

Se non si verificano errori il bootloader è stato scritto correttamente sul microcontrollore.

Le immagini seguenti mostrano il processo:

A questo punto scolleghiamo la scheda dalla porta usb per poi ricollegarla dopo qualche istante. Nuovamente verrà avviata l’installazione nuovo hardware relativa alla scheda Netduino. Seguiamo i passi rappresentati nelle seguenti figure per installare i driver della scheda Netduino:

Nel prossimo articolo vedremmo come caricare il nuovo firmware.

The post Aggiornare le schede Netduino alla versione 4.2 del .Net MF appeared first on Esperimenti con logiche programmabili.

Ho notato che negli ultimi anni molti sviluppatori software, provenienti da ambienti desktop, hanno iniziato ad interessarsi ai dispositivi programmabili, in particolare ad Arduino e Netduino. Di pari passo le case costruttrici hanno iniziato a produrre componenti di ogni sorta, semplificandone il loro impiego e garantendo un prezzo molto competitivo.

Questo interesse continuerà ad aumentare e credo che gli sviluppatori per dispositivi embedded eguaglieranno ben presto quelli desktop. Questo, in parte, è dovuto grazie all’impegno di aziende quali Microsoft e Google, che con il .Net micro framework e Android hanno contribuito a richiamare l’interesse per queste tecnologie.
Queste aziende stanno cercando, a mio avviso, di creare dispositivi semplici da programmare che possano collegarsi a smatphone e tablet e di conseguenza avere un accesso semplice ad internet. Lo scenario che si presenta è una richiesta sempre crescente di software e hardware capaci di colloquiare tra loro al fine di potere interagire con la grande rete.

Anche aver reso open, sia dal punto di vista hardware sia software, questi sistemi, ha dato la possibilità di far nascere cloni capaci di attirare sviluppatori e creare nuove community.

Dal punto di vista hobbystico, il gran numero di esempi e tutorial sui crescenti forum e blog, danno la possibilità di imparare autonomamente i principi della programmazione e della prototipazione hardware.

Parlando del mondo professionale credo che tutto ciò sia una buona opportunità di lavoro vista la possibilità di realizzare shield che risolvono problemi particolari o addirittura sviluppare un proprio sistema complesso.

Tu cosa ne pensi?

The post Riflessioni personali sullo sviluppo embedded appeared first on Esperimenti con logiche programmabili.

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.

Mi è sempre piaciuta l’idea di un orto/giardino automatizzato, magari con Netduino, capace di sfruttare l’irrigazione in modo coscienzioso e senza sprechi d’acqua.
Penso sia uno di quei progetti molto ricercati per la sua evidente utilità pratica, e anche perché la coltivazione e la cura di piante è un istinto innato che ci avvicina alla natura e ci fa sentire bene!

Abito in un piccolo paese dove ogni famiglia possiede un piccolo orto per la coltivazione di verdure e frutti. La tecnica di irrigazione principale è quella a solco (scorrimento), decisamente svantaggiosa e poco efficace per l’eccessivo spreco d’acqua.
Fortunatamente oggi ci sono molte tecnologie efficienti che permettono l’impiego di sistemi programmabili per la gestione delle attività di irrigazione.

Anche io ho voluto sviluppare il mio sistema a microcontrollore per gestire le fasi di irrigazione di un piccolo orto.
Per la realizzazione di questo sistema bisogna avere un minimo di esperienza nella coltivazione di piante ed essere consapevoli che ci dovremmo sporcare le mani!!

La tecnica di irrigazione migliore per questo progetto si basa sulla microirrigazione a goccia. E’ necessario quindi procurarci tutto il materiale per l’impianto. Le mie informazioni progettuali sono da considerare di carattere generale, dato che il sistema è influenzato da vari parametri come, la tipologia del terreno (inclinazione, consistenza, composizione, esposizione agli agenti atmosferici) il tipo e la quantità di piantine da coltivare.La figura seguente rappresenta un tipico impianto a goccia automatizzato:

La cisterna contiene l’acqua necessaria ad irrigare le piante, le sue dimensioni variano a seconda della dimensione dell’orto, un valore sufficiente per una autonomia di 2-3 settimane potrebbe essere di 1000 litri.
Subito dopo troviamo il filtro, questo elemento è essenziale per un impianto di microirrigazione in quanto blocca le impurità dell’acqua che col tempo potrebbero otturare i gocciolatori.
L’elettrovalvola è un rubinetto elettronico che permette, tramite la centralina elettronica, di gestire tutte le fasi d’irrigazione. La centralina riceve input dai sensori di umidità, temperatura e luminosità, in questo modo possiamo sviluppare algoritmi che gestiscono l’irrigazione in funzione dei parametri ambientali.

Il tubo di mandata principale permette di alimentare i vari rami dell’impianto, ogni ramo (ala gocciolante) è sezionabile tramite un minirubinetto, questo permette di effettuare operazioni di manutenzione anche durante l’irrigazione.
L’ala gocciolante è composta da un tubo, solitamente da 16mm, dove sono collocati i gocciolatori. Ogni gocciolatore irriga una singola pianta.

La realizzazione dell’impianto dipende dalla dimensione del terreno a disposizione e dal numero e tipo di piante da coltivare. Secondo la mia esperienza vi posso dire che per il fabbisogno di una famiglia di 5-6 persone potete coltivare i seguenti prodotti

• 20 piante Pomodoro
• 10 piante Melanzane
• 10 piante Peperoni
• 20 piante Fagiolini
• 10 piante Cetrioli
• 5 piante Zucchine
• 20 piante Lattuga

naturalmente ognuno può aumentare o diminuire queste quantità a seconda delle preferenze e dei gusti personali.
Per quanto riguarda la distanza tra gocciolatori possiamo dimensionare in questo modo

• 40-50 cm per Pomodori, Melanzane, Peperoni, Fagiolini e Cetrioli
• 60-70 cm per le Zucchine
• 15-20 cm per le Lattughe

Mentre la distanza tra un ala gocciolante e la successiva può variare da 40-50 cm a  80-100cm a seconda dello spazio a disposizione, e della comodità che vogliamo avere per passare tra i filari.

Dopo l’assemblaggio dell’impianto è necessario verificare che tutti i gocciolatori funzionino a dovere e che non ci siano perdite d’acqua dai raccordi di connessione.

La parte che ora bisogna studiare, riguarda la centralina elettronica. Certamente sul mercato esistono vari modelli con prezzi anche di poche decine di euro, che potrebbero farci abbandonare l’idea dell’autocostruzione, ma il nostro scopo è quello di sperimentare e imparare nuovi concetti per poi applicarli in altri ambiti o per accrescere il nostro bagaglio culturale.

Apro una piccola parentesi sull’elettrovalvola: a parte le varie dimensioni e capacità idriche, esistono modelli a 24Vac e a 9Vcc. Volendo creare un impianto autonomo è meglio utilizzare il modello a 9Vcc in modo da eliminare qualsiasi trasformatore. Il costo delle elettrovalvole in continua è purtroppo superiore a quelle in ca (circa 30€).

Il circuito elettronico deve acquisire come input i dati dai sensori e pilotare l’elettrovalvola per un tempo che può essere fisso o variabile a seconda del software che andremmo a sviluppare.
Come microcontrollore possiamo optare per diverse soluzioni come Netduino piuttosto che Arduino o Picmicro. Certamente un fattore importante è il costo, che si aggira intono ai 30€ per Netduino/Arduino mentre per i Picmicro siamo intorno ai 3-8€.
In una prima fase possiamo usare Netduino per creare un prototipo, per poi eseguire un porting del progetto su Picmicro in modo da abbattere i costi di realizzazione della centralina.

I sensori del mio prototipo sono tre, un sensore di temperatura analogico tipo MCP9700a, un sensore di luminosità basato su fotoresistenza e un sensore di umidità realizzato con due puntali da inserire nel terreno.
Il Netduino acquisisce tramite gli ingressi analogici questi segnali e in base al suo software gestisce un piccolo relè che va a pilotare l’elettrovalvola.
Nella figura seguente è rappresentato lo schema a blocchi:

Credo che le informazioni di questo articolo siano sufficienti per iniziare a costruire il proprio orto automatizzato. Certamente le nozioni per la realizzazione dell’impianto di microirrigazione sono da approfondire ma con un po di manualità si può apprendere da soli come impostare e realizzare il proprio sistema idrico.
Per quanto riguarda la parte della realizzazione della centralina elettronica vi rimando al prossimo articolo.

The post Netduino e irrigazione automatica fai da te (Teoria) appeared first on Esperimenti con logiche programmabili.

Ho acquistato la scheda FEZ Panda II della GHI Electronics, sinceramente non ho ancora provato ad usarla ma le sue caratteristiche tecniche mi hanno incuriosito. Anche la FEZ Panda è basata sul .Net micro framework, come il Netduino, e nonostante le sue dimensioni siano leggermente superiori rispetto al Netduino le funzionalità della Panda II sono notevolmente superiori. L’immagine riepiloga le funzioni principali della scheda:

Il cuore della scheda è il processore è un NXP LPC2387 a 32bit, con una frequenza di ben 72Mhz. Oltre ai classici connettori Arduino compatibili, ne troviamo un’altro che dispone di ulteriori 32 pin digitali configurabili come ingressi o uscite, inoltre sono presenti 3 porte UART una SPI e una CAN.
La scheda presenta anche uno slot micro SD per come supporto di memorizzazione una scheda SD. La porta usb che viene normalmente utilizzata per il debug delle applicazioni può essere programmata come porta seriale in modo da creare programmi che permettono di scambiare dati tramite la porta USB.
Da notare la presenza di un quarzo aggiuntivo che permette di creare un RTC (real Time clock) e di tenerlo attivo tramite una batteria esterna.

La tabella seguente riepiloga le altre caratteristiche della scheda

Nei prossimi post cercherò di realizzare qualche esperimento con questa scheda.
Se qualcuno di voi ha avuto esperienza con questa scheda fatemi sapere cosa ne pensate.

The post FEZ Panda 2 GHI Electronics caratteristiche tecniche 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.