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.

Per chi lavora con vb.net vi allego il codice scritto da Alberto De Luca che gentilmente mi ha concesso per condividerlo con voi. Il listato seguente esegue il calcolo del checksum
del tag acquisito con il lettore RFID ID-12 come spiegato nell’articolo precedente.

Public Shared Function VerifyCheckSum(b As Byte()) As Boolean

Dim RetValue As Boolean
Dim tag As [Byte]() = New [Byte](9) {}
Dim Hex01 As [Byte], Hex02 As [Byte], Hex03 As [Byte],
Hex04 As [Byte], Hex05 As [Byte], crc As [Byte]

Array.Copy(b, 1, tag, 0, 10)

Dim ValoriAsc As New [String](UTF8Encoding.UTF8.GetChars(tag))

Hex01 = ConvHexToByte(ValoriAsc.Substring(0, 2))
Hex02 = ConvHexToByte(ValoriAsc.Substring(2, 2))
Hex03 = ConvHexToByte(ValoriAsc.Substring(4, 2))
Hex04 = ConvHexToByte(ValoriAsc.Substring(6, 2))
Hex05 = ConvHexToByte(ValoriAsc.Substring(8, 2))

crc = CByte(Hex01 Xor Hex02 Xor Hex03 Xor Hex04 Xor Hex05)

Debug.Print(crc.ToString())

RetValue = (b(0) = &H2 AndAlso b(13) = &HD AndAlso b(14) = &HA AndAlso b(15) = &H3)

Return RetValue

End Function

Private Shared Function ConvHexToByte(Value As String) As Byte

If Value.Length = 2 Then
Dim str1 As [String] = Value.Substring(0, 1)
Dim str2 As [String] = Value.Substring(1, 1)

If str1.ToUpper() = "A" Then
str1 = "10"
End If

If str1.ToUpper() = "B" Then
str1 = "11"
End If

If str1.ToUpper() = "C" Then
str1 = "12"
End If

If str1.ToUpper() = "D" Then
str1 = "13"
End If

If str1.ToUpper() = "E" Then
str1 = "14"
End If

If str1.ToUpper() = "F" Then
str1 = "15"
End If

If str2.ToUpper() = "A" Then
str2 = "10"
End If

If str2.ToUpper() = "B" Then
str2 = "11"
End If

If str2.ToUpper() = "C" Then
str2 = "12"
End If

If str2.ToUpper() = "D" Then
str2 = "13"
End If

If str2.ToUpper() = "E" Then
str2 = "14"
End If

If str2.ToUpper() = "F" Then
str2 = "15"
End If

Dim b1 As [Byte] = [Byte].Parse(str1)
Dim b2 As [Byte] = [Byte].Parse(str2)
Dim cv As [Byte] = CByte(b1 * 16 + b2)

Return cv

End If

Return 0

End Function

Potete visitare il blog di Alberto ed il suo progetto di Rivelatore presenze con RFID.

The post Calcolare il checksum del tag tramite lettore RFID ID-12 (versione vb.net) appeared first on Esperimenti con logiche programmabili.

Per velocizzare lo sviluppo ho scritto una semplicissima classe per rendere semplice l’utilizzo di un servomeccanismo. In allegato trovate il codice.

I metodi esposti sono

• PosizioneCentrale() -> sposta l’asse del servo meccanismo nella posizione centrale utilizzando un impulso di 1.5ms modificabile tramite la costante POS_CENTRALE
• PosizionePiuNovanta() -> sposta l’asse del servo meccanismo tutto a destra
• PosizioneMenoNovanta() -> sposta l’asse del servo meccanismo tutto a sinistra
• Posizione(Gradi) -> Sposta l’asse del servo meccanismo ad un valore in gradi compreso tra 0° e 180°
• Sweep(Cicli) -> Sposta continuamente, per il numero di cicli specificati, l’asse del servo meccanismo da 0° a 180° e viceversa

Scarica Servo.cs (3KB)

The post Semplice classe per utilizzare servomeccanismo appeared first on Esperimenti con logiche programmabili.

Il servo meccanismo è un dispositivo capace di eseguire dei movimenti meccanici in funzione del segnale applicato al suo ingresso. Viene utilizzato spesso per eseguire lavori continui, ovvero per controllare meccanismi che non possono essere azionati continuamente da personale umano.  In campo hobbystico viene impegnato per azionamenti a distanza tipici del radio modellismo.

Le caratteristiche comuni tra i servo sono principalmente, l’angolo di rotazione, la velocità di rotazione e la coppia motrice.
Il modello SG-5010 che ho acquistato viene prodotto dalla TowerPro e le sue caratteristiche tecniche sono elencate nella tabella seguente:

Il suo funzionamento è veramente elementare, tutto si riduce nell’utilizzo del segnale PWM variando il valore di duty cycle tra 1% e 50% .
Per convenienza possiamo alimentare il servo tramite il pin 5Vdc del Netduino, anche se per applicazioni operative consiglio vivamente di alimentare il servo con una tensione esterna, evitando in questo modo di sovraccaricare il Netduino rendendolo instabile.
Il TowerPro Sg-5010 dispone di tre fili con colori che possono essere ambigui infatti il filo marrone deve essere collegato a massa, il filo rosso deve essere collegato alla +5Vdc e il filo arancione va collegato ad un pin PWM del Netduino (Pin 5-6-9-10).

In via generale il segnale PWM tipico deve avere una frequenza di 50Hz (Periodo di 20mS), mentre l’impulso positivo del segnale deve avere una larghezza compresa tra 1ms e 2ms, infatti per portare l’asse del servo nella posizione centrale la larghezza dovrà essere di 1.5ms (zero gradi) per portare l’asse a +90° l’impulso deve essere largo 2ms mentre per portare l’asse a -90° l’impulso dovrà essere largo 1ms.

L’illustrazione seguente aiuta a capire meglio il funzionamento

Il codice che andremmo a scrivere dovrà generare un segnale pwm con una frequenza di 50Hz e con un impulso la cui larghezza dovrà variare da 1ms sino a 2ms, questo è possibile utilizzando la classe PWM e il metodo SetPulse(), per maggiori informazioni riguardo questa classe vi consiglio di leggere questo articolo

// Istanzio un oggetto pwm
// Setto il pin 9 come uscita pwm
PWM servo = new PWM(Pins.GPIO_PIN_D9);

while (true)
{
  //imposto una frequenza di circa 50Hz
  //con un impulso di 1.5ms
  //l'asse del servo viene posizionato a 0°
  servo.SetPulse(20000, 1500);
  //attendo 2 secondi
  Thread.Sleep(2000);

  //imposto la frequenza sempre a 50Hz
  //con un impulso di 1ms
  //l'asse del servo si posiziona a -90°
  servo.SetPulse(20000, 1000);
  Thread.Sleep(2000);

  //imposto la frequenza sempre a 50Hz
  //con un impulso di 2ms
  //l'asse del servo si posiziona a +90°
  servo.SetPulse(20000, 2000);
  Thread.Sleep(2000);
}

Il codice esegue continuamente, ogni due secondi, la rotazione dell’asse del servo. Sicuramente i valori di larghezza generati non portano alla rotazione completa dell’asse del servo, questo perché anche se si ha una certa standardizzazione ci possono essere delle differenze tra i vari modelli.

Quindi sarà necessaria una calibrazione per capire quali sono i valori limite che portano alla rotazione di 180° dell’asse. Eseguendo il codice precedente potremo vedere se l’asse compie una manovra di 180° se per esempio non raggiunge i limiti di -90° e +90° possiamo aumentare e diminuire della stessa quantità la larghezza degli impulsi relativa a questi limiti ad esempio portando il valore di 1000 (1ms) a 800 (0.8ms) e il valore di 2000 (2ms) a 2200 (2.2ms).

Tabella riepilogativa

Col servo in mio possesso ho dovuto cambiare i valori della larghezza dell’impulso in questo modo

In questo modo abbiamo capito quali sono i valori limite per il nostro servo, questo è fondamentale per impostare la larghezza dell’impulso per spostare l’asse anche nei valori intermedi.

The post Servo SG-5010 come controllarlo con Netduino tramite segnale PWM appeared first on Esperimenti con logiche programmabili.

Nell’articolo scritto qualche tempo, che mostrava come impiegare un Netduino ed un lettore rfid ID-12 della Innovations, ho descritto solamente la parte che acquisiva l’id del tag, senza analizzare come calcolare il crc indispensabile per avere la certezza che il dato letto fosse corretto.

Riprendo questo argomento su segnalazione di una gentilissima visitatrice Sabrina Cosolo, che ringrazio per avermi fatto notare un errore nell’illustrazione del calcolo del crc, infatti scrissi che i due byte del crc fossero ottenuti ponendo in OR i 10 byte dell’id del tag.
Questo non è vero in quanto bisogna mettere in XOR i valori esadecimali ottenuti dalla conversione in ASCII dei byte letti dal lettore.

Mi spiego meglio impiegando l’illustrazione seguente

i 10 byte rappresentano l’id del tag, mentre i due byte rappresentano il valore di crc. Il calcolo viene eseguito convertendo i singoli byte in valori ASCII, per ottenere 5 valori esadecimali prendendo 2 byte alla volta, come visibile in figura. Eseguendo un calcolo XOR di questi valori esadecimali otteniamo il calore del CRC.

Ora la difficoltà che ho riscontrato è quella di convertire un byte in un valore esadecimale, semplicissimo da fare con il .Net framework ma non altrettanto con la versione micro (non sono riuscito a trovare delle risorse che svolgessero questo compito!), quindi ho scritto un po di codice per arrangiarmi, mi rendo conto che non è il massimo ma diciamo che per questo esempio funziona!!

Ho commentato il codice per spiegare meglio il funzionamento.

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

using System.IO.Ports;
using System.Text;

namespace Netduino_ID12Reader
{
public class Program
{
    public static Byte ConvHexToByte(String Value)
    {
      if (Value.Length == 2)
      {
        String str1 = Value.Substring(0, 1);
        String str2 = Value.Substring(1, 1);

        if (str1.ToUpper() == "A")
          str1 = "10";

        if (str1.ToUpper() == "B")
          str1 = "11";

        if (str1.ToUpper() == "C")
          str1 = "12";

        if (str1.ToUpper() == "D")
          str1 = "13";

        if (str1.ToUpper() == "E")
          str1 = "14";

        if (str1.ToUpper() == "F")
          str1 = "15";

        //###########################
        if (str2.ToUpper() == "A")
          str2 = "10";

        if (str2.ToUpper() == "B")
          str2 = "11";

        if (str2.ToUpper() == "C")
          str2 = "12";

        if (str2.ToUpper() == "D")
          str2 = "13";

        if (str2.ToUpper() == "E")
          str2 = "14";

        if (str2.ToUpper() == "F")
          str2 = "15";

        //converto i singoli caratteri in valori byte
        Byte b1 = Byte.Parse(str1);
        Byte b2 = Byte.Parse(str2);
        //onverto i duebyte in un valore hex
        Byte cv = (Byte)(b1 * 16 + b2);

        //Debug.Print(cv.ToString());

        return cv;

      }

      return 0;
    }

    public static void Main()
    {
      SerialPort sp = new SerialPort("COM1", 9600, Parity.None, 8);
      OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);
      UTF8Encoding asen = new UTF8Encoding();

      //apro la oprta seriale per acquisire i dati dal lettore id-12
      sp.Open();

      while (true)
      {
        Thread.Sleep(200);
        led.Write(false);

        //controllo ciclicamente che arrivino tutti i
        //byte dal lettore
        if (sp.BytesToRead == 16)
        {
          Byte[] b = new Byte[sp.BytesToRead];
          Byte[] tag = new Byte[10];

          Byte Hex01, Hex02, Hex03, Hex04, Hex05, crc;

          //leggo tutti i byte provenienti dal lettore
          sp.Read(b, 0, b.Length);

          //copio i 10 byte dell'ID del tag in un array dedicato
          Array.Copy(b, 1, tag, 0, 10);

          //converto i byte in una stringa ASCII
          String ValoriAsc = new String(UTF8Encoding.UTF8.GetChars(tag));

          //ottengo i valori esadecimali dalla coppia di byte Ascii
          Hex01 = ConvHexToByte(ValoriAsc.Substring(0, 2));
          Hex02 = ConvHexToByte(ValoriAsc.Substring(2, 2));
          Hex03 = ConvHexToByte(ValoriAsc.Substring(4, 2));
          Hex04 = ConvHexToByte(ValoriAsc.Substring(6, 2));
          Hex05 = ConvHexToByte(ValoriAsc.Substring(8, 2));

          //calcolo il crc mettendo in xor i valori hex
          crc = (byte)(Hex01 ^ Hex02 ^ Hex03 ^ Hex04 ^ Hex05);

          //printo il valore di crc
          Debug.Print(crc.ToString());

          if (b[0] == 0x02 && b[13] == 0xD && b[14] == 0xA && b[15] == 0x03)
            led.Write(true);

        }

      }

    }
}
}

Il calcolo del crc può risultare utile nel caso di applicazioni dove la certezza di aver letto bene l’id del tag è fondamentale, come, per esempio in applicazioni come alcune delle applicazioni illustrate nella pagina di wikipedia dedicata al sistema RFID.

Per considerazioni e spiegazioni aggiuntive vi invito a scrivermi nei commenti o tramite mail

al prossimo articolo…

The post Come calcolare il crc del tag con Netduino e lettore RFID ID-12 appeared first on Esperimenti con logiche programmabili.

Pachube è uno dei tanti servizi online che offrono un’applicazione web aggiornabile tramite dispositivi elettronici come Netduino, Arduino, smartphone, PC o altri sistemi capaci di interagire con Internet.
Banalmente possiamo definirlo un “datalogger on line” capace di registrare dati provenienti dai dispositivi e di creare grafici che ne mostrano l’andamento nel tempo.
Pachube certamente è un buon servizio che dimostra lo sviluppo di applicazioni dell’Internet delle cose.

Anche io ho voluto realizzare la mia applicazione per semplice curiosità e per condividere la mia esperienza.

Iniziamo registrandoci al servizio Pachube. Al momento in cui scrivo sono disponibili tre tipi di piani tariffari, tra cui uno gratuito. La differenza sostanziale tra essi, è il numero di dati che possiamo caricare sul sito e il tempo di memorizzazione degli stessi.
Per una piccola applicazione fortunatamente è sufficiente creare un account gratuito. La registrazione richiede solo pochi dati come il Nome Utente e una casella e-mail valida. Una volta compilati tutti i campi clicchiamo sul pulsante Sign Up, verrà spedita automaticamente una mail contenente il link di attivazione del vostro account. Successivamente l’attivazione Pachube fornisce una API Key che viene utilizzata per autorizzare le nostre applicazioni.

Il passo seguente è quello di creare un feed per memorizzare i dati inviati da un dispositivo remoto.
Clicchiamo sul link Create a Feed dal menu My Account. Le informazioni da inserire sono diverse, molto intuitive, che identificano una precisa locazione geografica e il tipo di dispositivo utilizzato.
Prima di salvare dobbiamo aggiungere almeno un datastream, fondamentale per memorizzare e rappresentare i dati provenienti dal nostro dispositivo.
Clicchiamo su Add a datastream per crearne uno. Il campo ID serve ad identificare il datastream all’interno del Feed, può essere un valore numerico o testuale, Tags specifica alcune parole chiave descrittive per il datastream, Units rappresenta l’unita di misura per i dati del datastream e Symbol rappresenta la dicitura dell’unità di misura.

I valori realmente necessari per la creazione di un feed sono il suo nome e l’ID del datastream, gli altri campi possono essere lasciati in bianco ma è comunque consigliabile compilarli per dare tutte le informazioni per interpretare i dati e capirne la provenienza.

Salviamo il Feed cliccando sul pulsante Save.

In questo esempio reale ho creato un Feed che monitorizza il carico della cpu del mio pc, potete osservare i dati recandovi a questo indirizzo http://pachube.com/feeds/28933

Pachube aggiorna la finestra mostrando le impostazioni del Feed appena creato. In questa finestra troviamo tre link, JSON, XML e CSV, sotto la voce Feed Format. Questi tre formati sono quelli accettati da Pachube per interagire da remoto con il Feed. Quello che preferisco è il formato XML, cliccando sul link viene caricata una nuova finestra che mostra la struttura del file XML. Nella barra degli indirizzi viene mostrato il percorso del file XML.

La documentazione presente sul sito è molto chiara. In questa sezione troviamo il codice XML necessario per aggiornare il Feed (possiamo anche apprendere come leggere, creare e cancellare i Feed da remoto).
Ho modificato il codice XML della guida in base alle impostazioni del Feed e del datastream che ho precedentemente creato:

<?xml version="1.0" encoding="UTF-8"?>
<eeml xmlns="http://www.eeml.org/xsd/0.5.1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
version="0.5.1" xsi:schemaLocation="http://www.eeml.org/xsd/0.5.1
http://www.eeml.org/xsd/0.5.1/0.5.1.xsd">
<environment>

<title>Cpu_Usage</title>

<status>live</status>

<description>Monitoraggio Carico CPU</description>

<tag>Carico Cpu</tag>
<tag>Monitor</tag>

<data id="CpuLoad">
<current_value>10</current_value>
<max_value>100</max_value>
<min_value>0</min_value>
</data>

</environment>
</eeml>
<pre>

Prima di creare un applicazione basata su un dispositivo hardware ne ho sviluppato una in C# che permette di testare tutta la procedura per interagire con il Feed.

Il codice si basa sulla classe WebClient e permette con alcune righe di codice di eseguire l’aggiornamento

String UpdateData1 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
"<eeml xmlns=\"http://www.eeml.org/xsd/0.5.1\" " +
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " +
"version=\"0.5.1\" " +
"xsi:schemaLocation=\"http://www.eeml.org/xsd/0.5.1 " +
"http://www.eeml.org/xsd/0.5.1/0.5.1.xsd\"><environment>" +
"<status>live</status><data id=\"CpuLoad\"><current_value>";

String UpdateData2 = "</current_value></data></environment></eeml>";

try
{
String Value = "";
WebClient pachube = new WebClient();

//WebProxy mio_proxy = new WebProxy("Inserire nome proxy", 8080);
//pachube.Proxy = mio_proxy;

pachube.Headers.Add("X-PachubeApiKey", "Inserisci la tua API Key");

//questo codice recupera la percentuale di carico della CPU (testato su win XP)
ManagementObjectSearcher searcher = new ManagementObjectSearcher("root\\CIMV2",
 "SELECT * FROM Win32_Processor");

foreach (ManagementObject queryObj in searcher.Get())
{
Value = queryObj["LoadPercentage"].ToString();
}

Byte[] Data = Encoding.UTF8.GetBytes(UpdateData1 + Value + UpdateData2);

pachube.UploadData("Inserisci indirizzo file XML", "PUT", Data);

Console.WriteLine("Aggiornamento eseguito con successo");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}

Le prime variabili contengono il codice XML che permette di aggiornare il datastream. Ho diviso il listato XML in due parti in modo da inserire, via codice, il dato della variabile Value all’interno dei tag XML <current_value></current_value>.

Creiamo un’istanza di oggetto dalla classe WebClient, specifichiamo la nostra API key tramite il metodo Add della collection Headers.
Recuperiamo il valore della percentuale di carico della CPU ed assegnamolo alla variabile Value.
Creiamo la stringa XML completa e convertiamola in un array di Byte (necessario per l’invio tramite WebClient). In fine aggiorniamo il Feed tramite il metodo UploadData.
Nel metodo UploadData dobbiamo specificare, come primo parametro, il nome del file .xml relativo al Feed ( recuperabile dai link presenti sotto la voce Feed Formats).

Eseguendo questo codice in modo ciclico, ad esempio utilizzando un timer, Pachube realizzerà, con i dati inviati, un grafico sull’andamento del carico della CPU:

Questi dati vengono memorizzati, nel caso dell’account free per un mese.

I campi di applicazione di questo servizio sono numerosi, possiamo collegare al pc dei sensori ed inviare i dati ai Feed Pachube e condividerli con la comunità.
Il passo successivo che mi interessa realizzare è il porting di questa applicazione desktop su Netduino o Arduino.

The post Pachube, utilizzo con Netduino o Arduino (Introduzione) 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.

Eccoci giunti alla parte più interessante dell’impianto di microirrigazione proposto negli articoli precedenti. Per il primo prototipo ho deciso di utilizzare il Netduino per eseguire velocemente tutti i test  dell’impianto e per poter adattare il software alle mie esigenze di irrigazione.

Lo schema elettrico del circuito è il seguente

Il circuito sembra complesso ma molti componenti sono stati utilizzati negli articoli precedenti.
Questo circuito sfrutta maggiormente gli ingressi analogici del Netduino. Sul pin A0 è collegata la fotoresistenza mentre sul pin A1 è collegato il sensore di temperatura. Sia la fotoresistenza che il sensore di temperatura sono alimentati con la 3.3V.
Gli altri ingressi analogici vengono utilizzati per le tre sonde che verificano l’umidità del terreno. Ho visto alcuni schemi elettrici che, per misurare la conducibilità del terreno, utilizzando una tensione continua. Questo approccio è molto semplice ma può dare problemi di elettrolisi, e conseguente ossidazione delle sonde poste nel terreno, con conseguente imprecisione della misura.
Per evitare questo problema, possiamo utilizzarne una tensione alternata, in questo caso però dobbiamo successivamente trasformarla in una tensione continua per poterla inviare agli ingressi analogici del Netduino.

Vediamo nel dettaglio il funzionamento della centralina, alcuni argomenti sono stati già esposti e quindi vi rimando alla lettura tramite questi link:

Per il sensore di temperature potete leggere questo articolo.
Per il sensore di luminosità tramite fotoresistenza potete fare riferimento a questo articolo.

La parte nuova da descrivere riguarda il sensore di umidità. Come ho detto prima, preferisco alimentare le sonde con un segnale alternato; la soluzione migliore è quella di utilizzare la funzione PWM del Netduino disponibile sul pin5.
Il segnale PWM viene inviato a tre ingressi dell’integrato 74HC244 (Line Driver) per avere un po più di corrente e disaccoppiare il Netduino delle sonde. Il duty cycle del pwm è del 50% e la sua frequenza è di 10Khz, naturalmente questi parametri possono essere variati in base alle esigenze e alla tipologia del terreno.

Quindi, il segnale si propaga nel terreno relativamente alla quantità di acqua presente. L’altro polo della sonda riceve questo segnale e lo invia al raddrizzatore che provvederà a fornire una tensione continua proporzionale al livello di umidità del terreno.
Il raddrizzatore è composto semplicemente da un diodo e da un condensatore. I diodi contrassegnati con il nome DP servono a limitare eventuali extra-tensioni captate dalla sonda.
Il partitore resistivo composto dalle resistenze R (da 27Kohm) serve a limitare la tensione sui pin analogici, dato che, il valore massimo applicabile non deve essere superiore a 3.3Vdc.

La parte che pilota il solenoide è composta da due relè, questa scelta può sembrare confusa ma penso che sia quella più economica e per capirla, è necessario conoscere  il funzionamento di una elettrovalvola (vedi riquadro)

Principalmente esistono due tipi di elettrovalvola, quella monostabile e quella bistabile. L’elettrovalvola monostabile è alimentata con una tensione alternata mentre quella bistabile con una continua.

Quelle monostabili possiedono un posizione stabile che è quella di chiusura della valvola, per aprirla dobbiamo alimentarla costantemente, se l’alimentazione viene a mancare la valvola ritorna nella sua posizione stabile. Il vantaggio è che se dovesse mancare l’alimentazione al circuito, mentre l’irrigazione è in atto, la valvola si chiude e quindi non ci sono problemi di allagamento.
Lo svantaggio è un maggior consumo elettrico poiché le valvole devono essere alimentate per tutto il tempo dell’irrigazione.

Quelle bistabili possiedono due stati stabili, uno per la valvola chiusa e uno per la valvola aperta. Alimentando il solenoide la valvola si apre e rimane aperta anche togliendo l’alimentazione. Per chiuderla dobbiamo alimentare il solenoide invertendo le polarità, anche in questo caso togliendo l’alimentazione la valvola rimane chiusa.
Il vantaggio principale e un consumo minimo in termini elettrici, dato che per aprire e chiudere la valvola basta alimentarla per qualche secondo, questo permette di creare automatismi a batteria .
Lo svantaggio è che se succede qualche problema al circuito o all’alimentazione, mentre la valvola è aperta, questa rimarrà in questo stato creando problemi di allagamento.

Nel mio caso, per la realizzazione del circuito, ho utilizzato una piccola basetta mille-fori dove ho alloggiato tutti i componenti del circuito. Per scopi prototipali, potete montare il circuito, anche su una breadboard.

La costruzione delle sonde richiede del comune filo elettrico e due elementi metallici da inserire nel terreno.

Una volta assemblato il circuito e le sonde, possiamo passare allo sviluppo del software. Avendo a disposizione vari input possiamo gestire il nostro impianto di microirrigazione adattando diversi algoritmi.

Per una irrigazione efficace dovremmo attivare l’elettrovalvola nel tardo pomeriggio, quando il sole inizia a tramontare. L’irrigazione deve avvenire se le sonde indicano una scarsa umidità del terreno. Il sensore di temperature serve per eseguire, ad esempio, una irrigazione aggiuntiva o prolungata, quando le giornate sono più calde.

Comunque sia, l’algoritmo può variare a seconda delle proprie esigenze, dal tipo di coltura e dalla posizione geografica dell’orto. Quello che mi interessa ora non è creare un algoritmo perfetto ma spiegare come utilizzare la centralina. Ognuno potrà poi, creare e personalizzare il proprio algoritmo.

La prima cosa da fare è assicurarsi che tutti i sensori del circuito funzionino a dovere. Il codice seguente acquisisce i segnali dagli ingressi analogici.

Nota: gli ingressi analogici potrebbero non rispettare la sequenza dello schema elettrico in quanto il prototipo è stato realizzato precedentemente allo schema elettrico

PWM pwmSondeUmidita = new PWM(Pins.GPIO_PIN_D5); //uscita pwm su pin5

AnalogInput SondaTerreno1 = new AnalogInput(Pins.GPIO_PIN_A0);
AnalogInput SondaTerreno2 = new AnalogInput(Pins.GPIO_PIN_A1);
AnalogInput SondaTerreno3 = new AnalogInput(Pins.GPIO_PIN_A2);
AnalogInput FotoSensor = new AnalogInput(Pins.GPIO_PIN_A3);
AnalogInput TempSensor = new AnalogInput(Pins.GPIO_PIN_A4);

//10Khz 50% duty cycle
pwmSondeUmidita.SetPulse(100, 50);

while (true)
{
Debug.Print("SondaTerreno1= " + SondaTerreno1.Read().ToString());
Debug.Print("SondaTerreno2= " + SondaTerreno2.Read().ToString());
Debug.Print("SondaTerreno3= " + SondaTerreno3.Read().ToString());
Debug.Print("SensoreLuce= " + FotoSensor.Read().ToString());
Debug.Print("SensoreTemperatura= " + TempSensor.Read().ToString());

Debug.Print("\n");

//attendo 1 secondo
Thread.Sleep(1000);
}

Le sonde S1, S2 ed S3 devono essere distanziate di qualche decina di centimetri cosi che il segnale di una sonda non interferisca con l’altra. Per verificarle ho immerso le sonde in 3 bicchieri di acqua diversi.
Nella finestra debug otterremo qualcosa di simile

Le sonde per il rilevamento dell’umidità hanno un valore di circa 650-700 quando sono in corto circuito, quando invece non conducono il valore tenderà a 0.
Il sensore di luminosità ha un valore elevato in presenza di forte luce mentre tenderà a 0 in presenza di poca luce.
Il sensore di temperatura ha un valore proporzionale alla temperatura misurata, per ottenere il valore in gradi centigradi vi rimando all’articolo dedicato al sensore.

Eccovi un semplice esempio che può darvi un’idea di come utilizzare la centralina

Int32 LumDato = 0;
Int32 TempDato = 0;
Int32 UmSens1Dato = 0;
Int32 UmSens2Dato = 0;
Int32 UmSens3Dato = 0;

Boolean AttivaIrrigazione = false;
Int32 Ciclo = 0;

//Configurazione PWM
PWM pwmSondeUmidita = new PWM(Pins.GPIO_PIN_D5); //uscita pwm su pin5
//Configurazione attuatori (relè)
OutputPort AlimentazioneValvola = new OutputPort(Pins.GPIO_PIN_D7, false);
OutputPort PolarizzazioneValvola = new OutputPort(Pins.GPIO_PIN_D6, false);
//Configuraziobe Ingressi analogici
AnalogInput SondaTerreno1 = new AnalogInput(Pins.GPIO_PIN_A0);
AnalogInput SondaTerreno2 = new AnalogInput(Pins.GPIO_PIN_A1);
AnalogInput SondaTerreno3 = new AnalogInput(Pins.GPIO_PIN_A2);
AnalogInput FotoSensor = new AnalogInput(Pins.GPIO_PIN_A3);
AnalogInput TempSensor = new AnalogInput(Pins.GPIO_PIN_A4);

//10Khz 50% duty cycle
pwmSondeUmidita.SetPulse(100, 50);

while (true)
{
//leggo dal sensore fotosensibile
LumDato = FotoSensor.Read();
//leggo dal sensore 9700a
TempDato = TempSensor.Read();
//leggo dalle sonde
UmSens1Dato = SondaTerreno1.Read();
UmSens2Dato = SondaTerreno2.Read();
UmSens3Dato = SondaTerreno3.Read();

//attendi il tramonto
if (LumDato < 200 && AttivaIrrigazione == true)
{
//Questa variabile serve per attivare l'irrigazione
//una sola volta dopo che la luminosità scende sotto 200
AttivaIrrigazione = false;

//controllo l'umidità nelle tre sonde
 //Avvia l'irrigazione solo se necessaria (terreno secco)
 if (UmSens1Dato < 300 && UmSens2Dato < 300 && UmSens3Dato < 300)
{
//se la temperatura ha un valore elevato irriga
//per un tempo superiore
if (TempDato > 350)
{
//Irrigazione prolungata per alta temperatura

//attivo l'elettrovalvola per un secondo
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);

//l'elettrovalvola è attiva
//attendo 40 minuti prima di disattivarla
for (Ciclo = 0; Ciclo <= 2400; Ciclo++)
{
Thread.Sleep(100);
}

//Inverto le polarità del solenoide
//e poi l'alimento per 1 secondo
PolarizzazioneValvola.Write(true);
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);
PolarizzazioneValvola.Write(false);
}
else
 {
//Irrigazione Normale
//attivo l'elettrovalvola per un secondo
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);

//l'elettrovalvola è attiva
//attendo 15 minuti prima di disattivarla
for (Ciclo = 0; Ciclo <= 900; Ciclo++)
{
Thread.Sleep(1000);
}

//Inverto le polarità del solenoide
//e l'alimento per 1 secondo
PolarizzazioneValvola.Write(true);
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);
PolarizzazioneValvola.Write(false);
}
}
}
else if (LumDato > 200)
{
//Rispristina la variabile quando la luminosità
//risale sopra i 200
AttivaIrrigazione = true;
}

Thread.Sleep(500);
}

Appena alimentiamo il circuito, Netduino esegue il codice creando gli oggetti per l’acquisizione dagli ingressi analogici, per generare il segnale pwm e per comandare i due relè, successivamente esegue un ciclo infinito acquisendo i dati dai sensori ogni 500 millisecondi.

Durante il giorno, in presenza di una buona luminosità, il sistema rimane nella fase di acquisizione; appena la luminosità inizia a diminuire, presumibilmente per il calar del sole, il valore acquisito dal pin analogico A0, collegato alla fotoresistenza, diminuisce.
Quando questo valore scende sotto la soglia di 200 (variabile in funzione del vostro sistema),  Netduino entra nel primo blocco if, dato che, AttivaIrrigazione è uguale a True.
Se le tre sonde indicano una bassa umidità del terreno (dato inferiore a 300), Netduino entra nel secondo blocco if. A questo punto troviamo un’altra istruzione if che permette di eseguire il codice per attivare l’elettrovalvola a seconda della temperatura misurata dal sensore 9700a.
Quindi se la temperatura è elevata verrà eseguito il primo blocco if, altrimenti verrà eseguito il codice del blocco else.
Il codice di questi blocchi è identico, tranne per il ciclo for che, per una temperatura elevata, dura maggiormente.

Analizziamo meglio il codice che pilota l’elettrovalvola

//Irrigazione Normale
//attivo l'elettrovalvola per un secondo
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);

//l'elettrovalvola è attiva
//attendo 15 minuti prima di disattivarla
for (Ciclo = 0; Ciclo <= 900; Ciclo++)
{
Thread.Sleep(1000);
}

//Inverto le polarità del solenoide
//e l'alimento per 1 secondo
PolarizzazioneValvola.Write(true);
AlimentazioneValvola.Write(true);
Thread.Sleep(1000);
AlimentazioneValvola.Write(false);
PolarizzazioneValvola.Write(false);

Le istruzioni comandano direttamente i due relè. In condizioni iniziali il relè2 permette di alimentare il solenoide per aprire l’elettrovalvola. Le prime istruzioni attivano il relè1, per alimentare per un secondo il solenoide.
Il ciclo for serve per creare un ritardo software di diversi minuti (tempo di irrigazione).
Una volta che il ciclo for termina, dobbiamo attivare il relè2 per invertire le polarità di alimentazione del solenoide. Una volta invertite viene attivato il relè1 per fornire nuovamente tensione al solenoide per circa 1 secondo il quale chiude la valvola, interrompendo l’irrigazione.
Le ultime istruzioni diseccitano il relè1 e il relè2.

Le illustrazioni seguenti mostrano come avviene la sequenza di azionamento dei relè.

Infine la variabile AttivaIrrigazioneviene utilizzata per irrigare una sola volta, altrimenti il ciclo di irrigazione dura finché le sonde S1, S2 ed S3 rilevano una elevata umidità del terreno.

Il codice è molto esemplificativo, serve per dare una linea guida su come utilizzare la centralina. Nulla vieta di utilizzare un algoritmo differente, o di utilizzare codice più efficiente.

Non ci resta che montare il circuito ed andarlo a sperimentare sul campo.

The post Netduino, centralina per impianto di microirrigazione appeared first on Esperimenti con logiche programmabili.

Dopo aver acquistato il materiale necessario alla realizzazione dell’impianto di microirrigazione sono passato alla pratica con l’aiuto dei mie familiari. Ho cercato di rispettare lo schema dell’impianto proposto nel precedente articolo. Per il momento l’impianto non ha ancora l’elettrovalvola perché prima vorrei capire quanta corrente assorbe e fare alcuni calcoli per dimensionare la batteria che dovrà garantire una sufficiente autonomia del sistema.

Per motivi logistici non ho potuto documentare la realizzazione dell’impianto tramite un video. Di seguito alcune foto che illustrano le fasi di realizzazione.

A monte dell’impianto, ho collegato il filtro, fondamentale per un corretto funzionamento dei gocciolatori.

Il filtro è facilmente accessibile, questo mi permette di eseguire delle manutenzioni regolari come la pulizia dell’elemento filtrante.
La fase successiva è quella di montare le ale gocciolanti al tubo di mandata principale. Nel mio caso il tubo di mandata è stato realizzato precedentemente per ovvi motivi pratici di assemblaggio delle staffe e foratura del tubo.

L’ala gocciolante è inserita nel portagomma del microrubinetto collegato alla presa a staffa del tubo di mandata.

L’impianto è composto da 12 tubi di ala gocciolante autocostruita da 16mm

questo un dettaglio del gocciolatore installato nel tubo di 16mm. In questo caso per motivi illustrativi il gocciolatore è rivolto verso l’alto ma in fase di irrigazione il gocciolatore deve essere posto in orizzontale.

In prossimità di ogni gocciolatore ho realizzato una piccola buca per creare la sede dove inserire la pianta

In ogni sede è stato praticato un foro, in direzione del gocciolatore, per inserire la piantina.

Ora inseriamo la piantina nel foro e ricopriamo le radici  con un po di terra

Non ci resta che aprire la valvola e collaudare il sistema. Potete osservare come le gocce bagnano una piccola zona del terreno, quella occupata dalle radici della pianta.

E’ consigliabile controllare ogni singolo gocciolatore per verificarne la corretta erogazione. Se qualche gocciolatore ha un flusso superiore agli altri potete intervenire stringendo la sua ghiera. Assicurarsi una omogenea erogazione, è importante per una irrigazione corretta delle piante.

La parte meno nobile del progetto è pronta (a parte l’installazione della elettrovalvola). Nel prossimo articolo presenterò il circuito della centralina formato da uno shield autocostruito e dal nostro amato Netduino.

The post Realizzazione impianto microirrigazione per orto appeared first on Esperimenti con logiche programmabili.