Gestire sensori analogici su Raspberry Pi2

      Nessun commento su Gestire sensori analogici su Raspberry Pi2
Tempo di lettura: 11 minuti
Introduzione.

Riprendiamo il nostro percorso sullo sviluppo e prototipazione con la board RaspberryPi2. Nel precedente articolo che trovate a questo link, il nostro obbiettivo era quello di comandare l’accensione di un Led. In questi ultimi giorni tra l’altro, e uscita la nuova release di Windows 10 IoT, ossia la 10.0.10586.0, che ha portato con se diverse novità che vedremo negli articoli successivi a questo. Il nostro scopo ora, e quello come da titolo, di gestire un sensore di tipo analogico. A differenza di uno digitale, il sensore analogico detto in maniera molto sintetica, si prenda come esempio uno di temperatura, fornisce un valore di tensione costante nel tempo, secondo il valore di temperatura che è rilevato dal sensore stesso. Altro esempio, un potenziometro, ossia una resistenza di tipo variabile, che secondo come agiamo su di essa mediante la sua manopola, varierà il suo valore in Ohm e di conseguenza varia anche il valore della tensione in uscita. Fino alla versione 10.0.10240.0 alla quale faremo riferimento, non vi e la possibilità di collegare sensori analogici sui pin della Gpio poiché mancano ingressi e uscite PWM (acronimo di power with modulation), per cui dobbiamo ricorrere ai cosiddetti ADC Converter (Analog to digital converter), ossia un circuito elettronico in grado di convertire un segnale analogico in valore di tipo binario espresso in byte.
Hardware necessario.

Dopo questa breve introduzione, passiamo allo step successivo. Per la realizzazione del nostro circuito, abbiamo bisogno del seguente materiale hardware:
  • Raspberry Pi2 con installata la versione 10.0.10240.0 dotata di cavo di alimentazione.
  • Cavo Hdmi così da connettere la Raspberry Pi2 a un monitor.
  • Monitor dotato di ingresso HDMI.
  • Cavo ethernet.
  • Breadboard, ovvero la base necessaria per il montaggio componenti e cablaggio elettrico.
  • Jumper maschio-maschio e maschio-femmina.
  • Sensore di temperatura analogica TMP36.
  • ADC converter MCP3008.
Un breve accenno sul circuito integrato MCP3008.   

Come da datasheet che trovate a questo link, si tratta di un convertitore analogico/digitale alimentato ad una tensione Max di 5 v DC, risoluzione 10 bit. Di seguito le caratteristiche principali.
  • 10-bit resolution
  • ± 1 LSB Max DNL
  • ± 1 LSB Max INL
  • 4 (MCP3004) or 8 (MCP3008) input channels
  • Analog inputs programmable as single-ended or pseudo-differential pairs
  • On-chip sample and hold
  • SPI serial interface (modes 0,0 and 1,1)
  • Single supply operation: 2.7V – 5.5V
  • 200 ksps max. sampling rate at VDD = 5V
  • 75 ksps max. sampling rate at VDD = 2.7V
  • Low power CMOS technology
  • 5 nA typical standby current, 2 µA max.
  • 500 µA max. active current at 5V
  • Industrial temp range: -40°C to +85°C • Available in PDIP, SOIC and TSSOP packages
Possiamo osservare che il tipo di comunicazione con la raspberry avviene mediante protocollo SPI. Di seguito la piedinatura.

Figura 1: La piedinatura dell’MCP3008.

Partendo dal pin 1 al pin 8, abbiamo I canali da CH0 A CH7, dove andremo a collegare l’uscita del/I sensori analogici. Ogni canale come vedremo, va configurato seguendo le indicazioni del costruttore come da datasheet allegato. I pin 16-15 vanno collegati al positivo, I pin 14-9 allo zero volt (o Ground della raspberry Pi2). I pin 13-12-11-10 sui pin del bus SPI0 o SPI1 della scheda Raspberry.
Circuito elettrico/elettronico. 

Qui di seguito il circuito finale del nostro progetto, realizzato con Fritzing, un ottimo software per la realizzazione di schemi elettrici/elettronici.

Figura 2: Il circuito elettronico.

Per non confondersi nei collegamenti elettrici, vediamo di seguito come collegare la Gpio con l’intergrato MCP 3008. Osservando la figura 1, vediamo che tra I pin 1 e 16 abbiamo un segno di riconoscimento, ruotando di 90° il componente in senso antiorario, il pin 1 sarà quello in basso a sinistra, il pin 8 quello in basso a destra, il 9 in alto a destra e il 16 in alto a sinistra.
  • PIN 16 MCP3008 —-> 3,3V DC (CAVO ROSSO)
  • PIN 15 MCP3008 —-> 3,3V DC (CAVO ROSSO)
  • PIN 14 MCP3008 —-> GND (CAVO NERO)
  • PIN 13 MCP3008 —-> SPIO_SCLK (CAVO ROSSO)
  • PIN 12 MCP3008 —-> SPIO_MISO (CAVO GRIGIO)
  • PIN 11 MCP3008 —-> SPIO_MOSI (CAVO BLU)
  • PIN 10 MCP3008 —-> SPIO_CE0_N DC (CAVO VERDE)
  • PIN 9 MCP3008   —-> GND (CAVO NERO)
  • PIN 1 MCP3008   —-> PIN VOUT SENSORE TMP36 DC (CAVO GIALLO)
Questi sono I collegamenti del circuito integrato MCP3008 con la scheda Raspberry Pi2.
Sensore di temperatura TMP36.   

Figura 3: Piedinatura sensore TMP36.

Si tratta di un sensore di temperatura analogico, il quale fornisce un valore di tensione di 10mv per grado direttamente proporzionale al valore di temperatura che è rilevato. Ha un range di lettura che va da -40  a 125 °C. Vediamo ora come collegarlo. Guardando l’immagine precedente, notiamo che ha tre pin, il primo a sinistra(1) lo colleghiamo alla tensione di 3,3 v DC, il pin centrale(2) come da figura sull’ingresso CH0 del MPC3008, il pin di destra(3) su GND.
  • PIN SINISTRA TMP36   —-> 3,3V DC (CAVO ROSSO)
  • PIN CENTRALE TMP36 —-> SU PIN 1 MCP3008(CAVO GIALLO)
  • PIN DESTRA TMP36     —-> GND (CAVO NERO)
Creazione del progetto di prova con Visual Studio 2015.  

Terminata la parte hardware, dai materiali necessari ai componenti e loro caratteristiche, e giunto ora il momento di dedicarsi alla parte software. Useremo per la creazione del progetto Visual Studio 2015. Se ancora non e stato eseguito, oltre Visual Studio 2015 e sistema operativo Windows 10 (almeno la versione Professional), e necessario scaricare ed installare L’sdk per lo sviluppo su Windows 10 che trovare a questo link. A installazioni terminate, avviamo Visual Studio 2015, e creiamo mediante il comando File, nuovo progetto un’applicazione usando il template App vuota(Windows universale) come mostrato in figura e denominiamo il progetto con “AnalogTemperature”.

Figura 4: La schermata Nuovo progetto.
Confermiamo con tasto OK. A progetto creato, per sviluppare in ambito IoT, abbiamo bisogno delle librerie necessarie. In esplora soluzioni posizioniamo il cursore su “Riferimenti”, tasto destro selezioniamo “Aggiungi riferimento”, e nella successiva schermata alla sezione “Estensioni” selezioniamo Windows IoT Exstension for the UWP come visibile nella successiva immagine.
Figura 5: La schermata Gestione riferimenti.
A livello di Estensioni abbiamo tutto il necessario. Dobbiamo ora creare un paio di classi che ci serviranno per la gestione del sensore TMP36 e MCP 3008.
Creazione Classi MCP3008 e TMP36.   

In esplora soluzioni, posizioniamo il cursore sul nome del progetto, tasto destro del mouse e scegliamo il comando “Inserisci” e subito dopo “Classe” e diamo il nome MCP3008 come il circuito integrato. Con la stessa procedura, creiamo una classe chiamata TMP36. All’interno della classe MCP3008 inseriamo il codice seguente.
using System;
using Windows.Devices.Enumeration;
using Windows.Devices.Spi;
using Windows.UI.Popups;
namespace AnalogTemperature
{
    public class MCP3008
    {
        SpiDevice _DEVICE;
        TMP36 _TMP36 = new TMP36();
        string _CHOICECHANNEL;
        const double _MAXVALUE = 1023.0;
        const int _MINVALUE = 0;
        const int _RESOLUTIONBITS = 10;
        const int _SHIFTBYTE = 8;
        byte[] _CH0 = new byte[] { 1, 0x80, 0 };
        byte[] _CH1 = new byte[] { 1, 0x90, 0 };
        byte[] _CH2 = new byte[] { 1, 0xA0, 0 };
        byte[] _CH3 = new byte[] { 1, 0xB0, 0 };
        byte[] _CH4 = new byte[] { 1, 0xC0, 0 };
        byte[] _CH5 = new byte[] { 1, 0xD0, 0 };
        byte[] _CH6 = new byte[] { 1, 0xE0, 0 };
        byte[] _CH7 = new byte[] { 1, 0xF0, 0 };
        byte[] _DATARECEIVED = new byte[] { 0, 0, 0 };
        /// <param name=”serialcomunication“>Define type comunication</param>
        /// <param name=”channel“>Define number channel of MCP3008</param>
        ///<param name=”spicomunication“>Define spicomunication channel</param>
        /// <param name=”mode“>Define spi mode</param>
        public async void InitializeMCP3008(SerialComunication serialcomunication,Channel channel,SpiComunication spicomunication, SpiMode mode)
        {
            varspiconnectionsettings = new SpiConnectionSettings((int)spicomunication);
            spiconnectionsettings.ClockFrequency = _TMP36.CLOCK_SIGNAL;
            spiconnectionsettings.Mode = mode;
            string spiDevice = SpiDevice.GetDeviceSelector(spicomunication.ToString());
            var deviceInformation = await DeviceInformation.FindAllAsync(spiDevice);
            if(deviceInformation != null&& deviceInformation.Count > 0)
            {
                _DEVICE = await SpiDevice.FromIdAsync(deviceInformation[0].Id, spiconnectionsettings);
                _CHOICECHANNEL = channel.ToString();
            }
            else
            {
                var dialog = new MessageDialog(“Device not found”);
                await dialog.ShowAsync();
                return;
            }
        }
        public double ReturnResult()
        {
            switch (_CHOICECHANNEL)
            {
                case “CH0”:
                    _DEVICE.TransferFullDuplex(_CH0, _DATARECEIVED);
                    break;
                case “CH1”:
                    _DEVICE.TransferFullDuplex(_CH1, _DATARECEIVED);
                    break;
                case “CH2”:
                    _DEVICE.TransferFullDuplex(_CH2, _DATARECEIVED);
                    break;
                case “CH3”:
                    _DEVICE.TransferFullDuplex(_CH3, _DATARECEIVED);
                    break;
                case “CH4”:
                    _DEVICE.TransferFullDuplex(_CH4, _DATARECEIVED);
                    break;
                case “CH5”:
                    _DEVICE.TransferFullDuplex(_CH5, _DATARECEIVED);
                    break;
                case “CH6”:
                    _DEVICE.TransferFullDuplex(_CH6, _DATARECEIVED);
                    break;
                case “CH7”:
                    _DEVICE.TransferFullDuplex(_CH7, _DATARECEIVED);
                    break;
            }
            var result = ((_DATARECEIVED[1] & 0x03) << _SHIFTBYTE) + _DATARECEIVED[2];
            var mvolt = result * (_TMP36.VOLTAGE / _MAXVALUE);
            var tempCelsius = mvolt / _RESOLUTIONBITS;
            return tempCelsius;
        }
    }
    public enum SerialComunication
    {
        SINGLE_ENDED,
        DIFFERENTIAL
    }
    public enum Channel
    {
        CH0, CH1, CH2, CH3, CH4, CH5, CH6, CH7
    }
    public enum SpiComunication
    {
        SPI0,
        SPI1
    }
}
Analizziamo il codice precedente. Sono state definite delle variabili a livello di classe. La prima non e altro che la classe base per verificare e gestire device collegati alla/e porte SPI della Gpio.
        SpiDevice_DEVICE;
Qui definiamo un nuovo oggetto di tipo TMP36 che vedremo dopo.
        TMP36 _TMP36 = new TMP36();
Le variabili che seguono, sono tutte le caratteristiche del circuito intergrato MCP3008, partendo da _MAXVALUE, che sarà il valore massimo in una risoluzione 10 bit come da caratteristiche che trovate nel datasheet. _MINVALUE rappresenta il valore  minimo, _RESOLUTIONBITS e la risoluzione massima del MCP3008,  _SHIFTBYTE rappresenta lo spostamento di 8 bit che va eseguito una volta acquisiti i valori che ci vengono restituiti dal pin DOUT del MCP3008. Le variabili da _CH0 A _CH7, rappresentano gli otto canali disponibili in cui e possibile collegare un componente di tipo analogico, noi useremo in questo esempio il _CH0. La variabile _CHOICECHANNEL, servirà per memorizzare quale canale e stato utilizzato e passare il byte con la configurazione corretta, lo vedremo nel metodo ReturnResult(). Rimane ancora _DATARECEIVED,  il byte che contiene alla fine le informazioni in bit da elaborare e mostrare all’utente come temperatura rilevata.
        string _CHOICECHANNEL;
        const double _MAXVALUE = 1023.0;
        const int _MINVALUE = 0;
        const int _RESOLUTIONBITS = 10;
        const int _SHIFTBYTE = 8;
        byte[] _CH0 = new byte[] { 1, 0x80, 0 };
        byte[] _CH1 = new byte[] { 1, 0x90, 0 };
        byte[] _CH2 = new byte[] { 1, 0xA0, 0 };
        byte[] _CH3 = new byte[] { 1, 0xB0, 0 };
        byte[] _CH4 = new byte[] { 1, 0xC0, 0 };
        byte[] _CH5 = new byte[] { 1, 0xD0, 0 };
        byte[] _CH6 = new byte[] { 1, 0xE0, 0 };
        byte[] _CH7 = new byte[] { 1, 0xF0, 0 }
 byte[] _DATARECEIVED = new byte[] { 0, 0, 0 };
Il metodo InitializeMCP3008, richiede alcuni parametri, il primo e il tipo di gestione lettura dei dati dai canali su MCP3008, che possiamo impostare su “single-ended” o “differenzial” come richiesto nel datasheet, il canale sul quale colleghiamo il sensore  nel nostro caso TMP36 su CH0, quale porta SPI utilizziamo sulla Gpio, infine il modo di comunicazione sul bus SPI.
        /// <param name=”serialcomunication“>Define type comunication</param>
        /// <param name=”channel“>Define number channel of MCP3008</param>
        ///<param name=”spicomunication“>Define spicomunication channel</param>
        /// <param name=”mode“>Define spi mode</param>
        public async void InitializeMCP3008(SerialComunication serialcomunication,Channel channel,SpiComunication spicomunication, SpiMode mode)
        {
Viene definita un istanza della classe SpiConnectionSettings, passando come argomento un intero che definisce quale bus SPI viene utilizzato, per noi sarà 0.
            varspiconnectionsettings = new SpiConnectionSettings((int)spicomunication);
Impostiamo poi la frequenza di clock e la modalità. Notiamo per impostare la frequenza di clock facciamo uso di una proprietà della classe TMP36.
            spiconnectionsettings.ClockFrequency = _TMP36.CLOCK_SIGNAL;
            spiconnectionsettings.Mode = mode;
Successivamente, con la classe SpiDevice e il metodo GetDeviceSelector, otteniamo tutti i bus SPI presenti sulla scheda Raspberry Pi2.  
            string spiDevice = SpiDevice.GetDeviceSelector(spicomunication.ToString());
In questa sezione con la classe DeviceInformation, recuperiamo tutte le informazioni necessarie sul/i bus SPI. 
            vardeviceInformation = await DeviceInformation.FindAllAsync(spiDevice);
Se il parametro deviceInformation non e null, e maggiore di zero, possiamo definire quale bus SPI utilizzare,  aprire il canale di comunicazione che abbiamo impostato, per noi sarà come detto SPI0, passando al metodo FromIdAsync l’Id del bus e la configurazione.
            if(deviceInformation != null&& deviceInformation.Count > 0)
            {
                _DEVICE = await SpiDevice.FromIdAsync(deviceInformation[0].Id, spiconnectionsettings);
                _CHOICECHANNEL = channel.ToString();
            }
            Else
Se non sono stati rilevati bus SPI avvertiamo l’utente con una MessageDialog.
            {
                var dialog = new MessageDialog(“Device not found”);
                await dialog.ShowAsync();
                return;
            }
        }
In questo metodo, secondo il canale che abbiamo deciso di usare, sarà chiamato sempre il metodo TransferFullDuplex, che si occuperà di inviare le impostazioni di ciascun canale sul bus SPI selezionato, e come secondo parametro il byte dove vi saranno memorizzati i dati convertiti da segnale analogico a digitale che dobbiamo poi elaborare in maniera opportuna. Infine avremo il risultato che sarà poi il nostro valore di temperatura finale.
        public double ReturnResult()
        {
            switch (_CHOICECHANNEL)
            {
                case “CH0”:
                    _DEVICE.TransferFullDuplex(_CH0, _DATARECEIVED);
                    break;
                case “CH1”:
                    _DEVICE.TransferFullDuplex(_CH1, _DATARECEIVED);
                    break;
                case “CH2”:
                    _DEVICE.TransferFullDuplex(_CH2, _DATARECEIVED);
                    break;
                case “CH3”:
                    _DEVICE.TransferFullDuplex(_CH3, _DATARECEIVED);
                    break;
                case “CH4”:
                    _DEVICE.TransferFullDuplex(_CH4, _DATARECEIVED);
                    break;
                case “CH5”:
                    _DEVICE.TransferFullDuplex(_CH5, _DATARECEIVED);
                    break;
                case “CH6”:
                    _DEVICE.TransferFullDuplex(_CH6, _DATARECEIVED);
                    break;
                case “CH7”:
                    _DEVICE.TransferFullDuplex(_CH7, _DATARECEIVED);
                    break;
            }
            var result = ((_DATARECEIVED[1] & 0x03) << _SHIFTBYTE) + _DATARECEIVED[2];
            var mvolt = result * (_TMP36.VOLTAGE / _MAXVALUE);
            var tempCelsius = mvolt / _RESOLUTIONBITS;
            return tempCelsius;
        }
    }
_DATARECEIVED, e un array di byte, a noi servono i primi due bit di sinistra del secondo elemento, mentre il primo, ossia _DATARECEIVED[0] lo ignoriamo perché non vi sarà alcun valore. Andiamo poi a sommare  _DATARECEIVED[1] con_DATARECEIVED[2]. I calcoli successivi, non fanno altro che ricavare il valore di temperatura, da notare _TMP36.VOLTAGE, che vedremo dopo. Ho inserito inoltre tre enumerazioni che serviranno nel momento in cui nella MainPage definiamo il codice per implementare il metodo InitializeMCP3008, sono il tipo di comunicazione, il canale utilizzato e su quale bus SPI intendiamo inviare e ricevere dati.
    public enum SerialComunication
    {
        SINGLE_ENDED,
        DIFFERENTIAL
    }
    public enum Channel
    {
        CH0, CH1, CH2, CH3, CH4, CH5, CH6, CH7
    }
    public enum SpiComunication
    {
        SPI0,
        SPI1
    }
 Questo e il necessario per la classe MCP3008. Passiamo ora alla classe TMP36, dopo averla creata, inseriamo il codice che segue.  
namespace AnalogTemperature
{
    public class TMP36
    {
        const int _CLOCKSIGNAL = 1650000;
        const double _VOLTAGE = 2000;
        public int CLOCK_SIGNAL
        {
            get
            {
                return _CLOCKSIGNAL;
            }
        }
        public double VOLTAGE
        {
            get
            {
                return _VOLTAGE;
            }
        }
    }
}
Semplicemente, sono definiti dei parametri che sono la frequenza di clock, e la tensione massima che può il sensore erogare a massimo regime, il  TMP36 a 125° c, eroga una tensione di circa 2 vdc.
Creazione dell’interfaccia grafica e codice nella classe MainPage.   
Definite alche le classi necessarie, vediamo come implementare il tutto nella Classe MainPage. In esplora soluzioni, doppio click con il mouse su MainPage.xaml, entrati nell’editor di codice definiamo la nostra interfaccia grafica, inserendo il seguente codice XAML.
<Page
    x:Class=”AnalogTemperature.MainPage”
    xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
    xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
    xmlns:local=”using:AnalogTemperature”
    xmlns:d=”http://schemas.microsoft.com/expression/blend/2008″
    xmlns:mc=”http://schemas.openxmlformats.org/markup-compatibility/2006″
    mc:Ignorable=”d”>
    <GridBackground=”{ThemeResourceApplicationPageBackgroundThemeBrush}”>
        <Grid.RowDefinitions>
            <RowDefinition Height=”Auto”/>
            <RowDefinition Height=”Auto”/>           
        </Grid.RowDefinitions>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width=”Auto”/>
            <ColumnDefinition Width=”Auto”/>
            <ColumnDefinition Width=”Auto”/>           
        </Grid.ColumnDefinitions>
       
       
            <TextBlock Grid.Row=”0″Grid.ColumnSpan=”3″ x:Name=”txtHeader”FontSize=”50″ Text=”TMP 36 AND MCP 3008 SAMPLE”/>
            <TextBlock Grid.Column=”0″Grid.Row=”1″ x:Name=”txtReadingTemp”FontSize=”30″ Margin=”15,0,0,0″ Text=”Temperature value is:”/>
            <TextBlock Grid.Column=”1″Grid.Row=”1″ x:Name=”txtReading”FontSize=”30″ Margin=”15,0,0,0″/>
            <TextBlock Grid.Column=”2″Grid.Row=”1″ x:Name=”txtCelsius”FontSize=”30″ Margin=”15,0,0,0″ Text=”°C”/>                  
    </Grid>
</Page>
Di per se e molto semplice, ma sufficiente per visualizzare il valore di temperatura restituito dal metodo ReturnResult() della classe MCP3008 che rappresenta il nostro obbiettivo. Con tasto F7, entriamo nell’editor di codice C#, inserendo la parte sottostante.
using System;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.Devices.Spi;
// Il modello di elemento per la pagina vuota è documentato all’indirizzo http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x410
namespace AnalogTemperature
{
    /// <summary>
    /// Pagina vuota che può essere utilizzata autonomamente oppure esplorata all’interno di un frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        DispatcherTimer _timer = new DispatcherTimer();
        MCP3008 _mcp3008 = new MCP3008();
        public MainPage()
        {
            InitializeComponent();
            _mcp3008.InitializeMCP3008(SerialComunication.SINGLE_ENDED, Channel.CH0, SpiComunication.SPI0,SpiMode.Mode0);
            _timer.Interval = new TimeSpan(0, 0, 5);
            _timer.Start();
            _timer.Tick += _timer_Tick;
        }
        private void _timer_Tick(object sender, object e)
        {
            txtReading.Text = Math.Round(_mcp3008.ReturnResult()).ToString();
        }
    }
}
Analizzando il precedente codice C#, inizializziamo un Timer.
        DispatcherTimer_timer = new DispatcherTimer();
Definiamo un oggetto di tipo MCP3008.
        MCP3008 _mcp3008 = new MCP3008();
Ne implementiamo il metodo InitializeMCP3008,passando i parametri necessari.
            _mcp3008.InitializeMCP3008(SerialComunication.SINGLE_ENDED, Channel.CH0, SpiComunication.SPI0,SpiMode.Mode0);
Impostiamo la proprietà Interval del timer con un valore di tipo TimeSpan di 5 secondi,  lo avviamo con il metodo Start() ,e gestiamo infine il suo evento Tick.
             _timer.Interval = new TimeSpan(0, 0, 5);
            _timer.Start();
            _timer.Tick += _timer_Tick;
All’interno dell’evento Tick, andiamo a valorizzare la proprietà Text del controllo TextBox txtReading, mostrando il valore di temperatura richiamando il metodo ReturnResult(), ma prima arrotondiamo il valore con la classe statica Math e il metodo Round() per togliere i decimali di troppo.
        private void _timer_Tick(object sender, object e)
        {
            txtReading.Text = Math.Round(_mcp3008.ReturnResult()).ToString();
        }
Test dell’applicazione.
Terminata la parte di codice, prima di eseguire il test dell’applicazione, ci sono un paio di cose da vedere. La prima essendo che stiamo sviluppando su Raspberry Pi2, e quella di impostare la compilazione in modalità ARM, lo si può eseguire dal menù a tendina come presente in figura.
Figura 6: Il menù principale di Visual Studio 2015.
In riferimento all’immagine precedente, noterete che è attivata l’esecuzione come “Computer remoto”. Questo perché vogliamo eseguire l’applicazione sulla scheda Raspberry Pi2. Selezionate questa modalità, e alla schermata seguente andiamo a selezionate il device e l’indirizzo IP della Raspberry Pi2 deselezionando l’autenticazione, in alternativa è possibile modificare queste impostazioni, selezionando il progetto, tasto destro del mouse, selezioniamo il comando “Proprietà” e subito dopo “Debug”, saremo condotti nella seguente schermata.
Figura 7: La sezione debug nelle proprietà del progetto.
Terminata quest’attività, possiamo eseguire il Debug dell’applicazione. Tasto F5, e se tutto è stato eseguito in maniera corretta, ecco cosa visualizzeremo a monitor.
Figura 8: L’applicazione di esempio in esecuzione sulla Raspberry Pi2 e Windows 10 IoT.
Conclusione.

In quest’articolo, e stata fatta un’introduzione su cosa sono i sensori Analogici, cosa e un convertitore ADC, perché la scheda RaspberryPi2 necessita di questo componente per fare uso dei sensori e strumenti con segnale analogico. Nei prossimi articoli, vedremo di approfondire questi argomenti, utilizzando altri componenti e vedere come adattare diverse tipologie di sensori e strumenti analogici sul convertitore ADC e Raspberry.

(Visited 82 times, 1 visits today)
Ad

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *