Marsy Electronic

Link Articolo Originale: 

http://www.grix.it/viewer.php?page=10026

Breve presentazione della scheda chipkit uno 32 e realizzazione di un datalogger usb

Definirla la rivale di arduino è un pò riduttivo,  funziona a 80 Mhz di clock e la CPU alla velocità di 32MIPS, 128K di memoria flash e 16K di RAM.

Per maggiori dettagli vi rimando all'ottima recensione sul sito di settorezero.com 

Io l'ho comprata quì
il costo è anche più basso della concorrente scheda arduino senza contare le spese di spedizione.

Se avete letto la pagina vi sarete resi conto che stavolta siamo di fronte ad un vero "mostro" rispetto ad arduino, ma la cosa interessante è che l'ide di programmazione è lo stesso di arduino con una modifica per renderlo compatibile con il nuovo hardware.

Dopo avere fatto alcune prove caricando gli esempi presenti nell'ide per arduino, ho trovato un progetto molto interessante chiamato Networkviewer

Scommetto che anche a voi è scoccata la scintilla ;-) vedendo lo screenshot del programma.

In pratica questo programma consente di dialogare con la scheda e monitorare gli ingressi (nell'esempio gli ingressi analogici, ma credo sia possibile anche con i digitali, devo ancora provare) inoltre abbiamo vari plugin a disposizione come lo "scopeviewer" e il "logger" come si vede nel menù della foto seguente

 Lo scopeviewer è il grafico che visualizza l'andamento con un colore per ogni ingresso, mentre il logger consente di definire un file di testo dove verranno registrati i valori del o dei canali monitorati.

Bene ora che abbiamo visto una panoramica generale, iniziamo ad assemblare il dispositivo.

Ho voluto collegare anche un comunissimo display LCD 16x2 per leggere direttamente il valore degli ingressi anche in assenza del collegamento al pc.

ecco una foto della realizzazione .

Iniziamo:

1) collegate al canale analogico zero "A0" il centrale di un potenziometro da 10K (lineare ovviamente) e i lati al piedino siglato "3V3" e al pin "GND" (potenziometro a sinistra nella foto)
In questo modo possiamo variare a piacimento la tensione all'ingresso di "A0".

Se avete letto bene le caratteristiche non serve che vi ricordi che il pic32 funziona a 3,3Volt e quindi anche gli ingressi analogici accettano questo valore massimo (sempre comunque con risoluzione di 10bit)

2) collegare il display come da esempio che trovate sul sito di arduino e dal quale riporto quì di seguito l'immagine:

 Da quì si può vedere lo sforzo nella progettazione della scheda per renderla perfettamente compatibile pin to pin con arduino, possiamo usare tutti gli esempi già pronti e adattarli alle nostre esigenze.

Non abbiate paura di bruciare la scheda, i pin digitali possono accettare anche i 5 volt come ingresso perchè protetti da apposite sicurezze (tranquilli ci hanno pensato in fase di progettazione), inoltre come uscita i 3,3volt vengono comunque letti come livello alto.

3) carichiamo l'ide che trovate QUI  e poi le librerie e il programma originale  QUI quindi modifichiamo il programma che trovate nella cartella "example" come seguente e caricatelo tramite l'ide nella scheda:

#include <NETVArduino.h>
#include <NETV_define.h>

/**
 Copyright (C) 2009-2011 IntRoLab
 http://introlab.gel.usherbrooke.ca
 Dominic Letourneau, ing. M.Sc.A.
 Questo indirizzo email è protetto dagli spambots. È necessario abilitare JavaScript per vederlo.
 
 This file is part of OpenECoSys/NetworkViewer.
 OpenECoSys/NetworkViewer is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by the Free Software
 Foundation, either version 3 of the License, or (at your option) any later version.
 OpenECoSys/NetworkViewer is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 You should have received a copy of the GNU General Public License along with
 OpenECoSys/NetworkViewer. If not, see http://www.gnu.org/licenses/.
 */
 
#include <LiquidCrystal.h>  //libreria per gestione lcd
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //impostazione lcd
/**
  This is the memory we want to share on the network. 
  Every variable is read/write and can be changed with the NetworkViewer.
  For this demonstration, we will use those variables to store the state
  of the ADC conversion on the first 6 channels.
  
  The union means that the struct is mapped with the byte array
  NETV_SHARED_MEMORY_TABLE so that the address of 
  analog0 == NETV_SHARED_MEMORY_TABLE[0]
*/
typedef union 
{
  struct 
  {
    unsigned int analog0; //AD Conversion #0
    unsigned int analog1; //AD Conversion #1
    unsigned int analog2; //AD Conversion #2
    unsigned int analog3; //AD Conversion #3
    unsigned int analog4; //AD Conversion #4
    unsigned int analog5; //AD Conversion #5
  };
  
  //The same memory addressed with an array
  unsigned char NETV_SHARED_MEMORY_TABLE[];
  
} NETVSharedVariables;

//Let's declare the variables here. They will be global.
NETVSharedVariables variables;

void setup() { 

  lcd.begin(16, 2);
  //This will configure the NETVProtocolStack to work with our project.  
  netvArduino.setup(50, //Project ID, NetworkViewer will look at this ID for automatic loading of configuration (XML files)
              1, //Module ID (you can use anything from 0 to 254, 255 = broadcast address)      
              1, //The Code Version, this is useful if you want to track the version of the actual code
              115200, //The baud rate, recommanded = 115200
              variables.NETV_SHARED_MEMORY_TABLE, //The memory we would like to share with the NETVProtocolStack
              sizeof(NETVSharedVariables));  //The size of the memory mapped
}

void loop() 
{
  
      
        //This will process data on the serial port and read/write to the shared memory
    netvArduino.transceiver();

        //Update the state of the memory
    variables.analog0 = analogRead(A0);
    variables.analog1 = analogRead(A1); 
    variables.analog2 = analogRead(A2); 
    variables.analog3 = analogRead(A3); 
    variables.analog4 = analogRead(A4); 
    variables.analog5 = analogRead(A5); 
/**************************scrivi lcd**************************************/
  lcd.print("ANALOG A0=");<br />  lcd.print(variables.analog0); //scrivi su lcd valore canale A0<br />  lcd.setCursor(0, 1);  //sposto cursore su seconda riga<br />          delay(12); //se display lampeggia aumentare leggermente questo ritardo a 13-14<br />  lcd.clear();<br />}</span></p> <p style="color: #000000; font-family: Verdana, Geneva, sans-serif; font-size: medium;">Ho modificato il programma originale inserendo le librerie e i comandi per scrivere sul display, ho messo i commenti in italiano per distinquere meglio le parti aggiunte.

Come potete vedere nel file originale sono pronti per acquisizione 6 ingressi analogici "analogRead(A0.....5)" e infatti quando collegheremo il software li vedremo abilititati (io durante le prove ne ho disattivati 5 lasciando solo il primo canale per semplificare le cose)

4) fatto ciò passiamo al software scaricando la versione per il proprio sistema operativo da QUI , quindi installiamolo.

5) colleghiamo il chipKIT uno32 ad una  porta usb del pc e controlliamo qual'è (COM1-2......9 ecc)

6)passiamo al primo avvio del programma  da START--->programmi---> networkviewer.

All'avvio il programma fà vedere la finestra di impostazione della connessione, che deve essere configurata come quella seguente (a parte la porta COM che può variare a seconda di che usb collegate alla scheda)

selezionate il "serialemulator" quindi porta COM e velocità 115200 quindi fate add e dovreste trovarvi come nella precedente schermata, quindi cliccate su close e partirà il programma)

Se tutto è andato come doveva dopo qualche secondo di attesa vi troverete come nella seguente figura:

BRAVI!!!!!!!!!!! il più è fatto!!!!!!

L'icona in alto a destra dichiara che il software stà comunicando con la scheda, che lui pensa sia arduino (potere del camuffamento :-))

ora facciamo doppio click sull'icona verde "arduino" e apparirà la seguente figura:

Quì vedete i 6 canali che la scheda stà leggendo, potete disabilitarne qualcuno per alleggerire la comunicazione.

Ora basta cliccare sopra l'icona verde del canale che vogliamo monitorare e trascinarla nella finestra di sinistra dello "scopeViewer" e per magia apparirà il tracciato che varierà al variare dell'ingresso analogico.

Come avrete intuito potete abilitare gli altri canali e trascinarli nel grafico in maniera da avere più onde sullo stesso grafico (pensa il programma a cambiare il colore delle linee.....fantastico!!!!!!)

Ovviamente nel display lcd potrete leggere il valore del canale come segue:

Nella foto ho preparato la seconda linea del display per leggere il valore del canale A1 aggiungendo l'apposita linea nel programma della scheda (guardate alla fine del programma in C, sono già andato a capo con il cursore per inserire le altre 2 righe sopra la " Delay(12)"............lascio a voi il semplice esercizio di prova ;-))

E ora salviamo i valori in un file di testo.

Dal menù in alto scegliamo -------> plugin---->Logger e apparirà la finestra quì sotto:

Cliccando su file date un nome e una posizione dove creare un file con estensione TXT, quindi trascinate come nell'esercizio precedente il canale sulla finestra del logger e premete il pulsante START per iniziare la registrazione.

Premete STOP per terminare l'acquisizione, quindi se aprite il file creato vi troverete i valori (devo capire come incollonarli perchè quando lo apro con blocconote mi fà un pò di casino).

CONCLUSIONI:

Personalmente la trovo un'applicazione molto interessante che dimostra come utilizzare software libero (in questo caso di ottimo livello) e una scheda "opensource" per un'applicazione veramente utile.

Per imparare da zero la programmazione dei pic non credo che questa sia l'applicazione migliore, meglio partire dal "basso" come ad esempio la microGT-mini del grande ad.noctis, oppure montando un pic su una millefori.

Quello che voglio chiarire, è che questo articolo credo sia più utile a chi cerca qualcosa che funzioni subito, senza tanto mettere mano al saldatore, e senza "sbattersi" più di tanto nella programmazione in C/C++.

Ovviamente ci sono ampi spazi di sperimentazione e miglioramento, divertitevi!!!

daniele as daneel

Questo indirizzo email è protetto dagli spambots. È necessario abilitare JavaScript per vederlo.