L’acquisizione di segnali analogici permette l’interfacciamento del Flyport Ethernet con svariate tipologie di sensori e trasduttori che forniscono una tensione analogica in funzione della grandezza fisica misurata.
Il modulo dispone di 4 ingressi analogici (p18, p20, p23, p25) con una risoluzione di 10bit (valori restituiti da 0 a 1023) ed una tensione di riferimento molto precisa fissata a 2.048V.
I pin analogici non supportano tensioni superiori a 3.3V quindi dobbiamo stare attenti al valore di tensione che sarà applicato sul pin analogico.

Dato che la tensione di riferimento è di 2.048V, il convertitore analogico digitale fornirà il valore intero zero(0) quando in ingresso sarà presente una tensione di 0V, fornirà invece il valore 1023 quando sul pin analogico sarà presente una tensione pari a 2.048V. Superata questa soglia, fino al valore consentito di 3.3V il convertitore restituirà sempre 1023.

La relazione tra valore di conversione e tensione è la seguente

tensione di riferimento / risoluzione => 2.048/1024 = 0.002V

quindi se il convertitore restituirà il valore di 560, potremmo facilmente constatare che sul pin analogico sarà presente la tensione di 1.12V

valore conversione * valore minimo di conversione => 560 * 0.002 = 1.12V

Ho realizzato il seguente circuito per provare le istruzioni che acquisiscono il segnale analogico presente sul pin p18.

il pin p24 è quello che fornisce la 3.3Vdc, il pin p22 è la massa ed il pi p18 è l’ingresso analogico 4 del modulo Flyport Ethernet.
Il potenziometro PT è da 5Kohm mentre la resistenza R è da 47Ohm e serve per evitare il cortocircuito nel caso in cui ci sia un malfunzionamento della meccanica del potenziometro che porta il collegamento della 3.3Vdc direttamente al gnd.

Le istruzioni per acquisire il segnale analogico sono molto semplici, i commenti nel codice illustrano questo procedimento:

[c]<br />#include "taskFlyport.h"<br /><br />void FlyportTask()<br />{<br /><%%KEEPWHITESPACE%%>  int Valore_ADC = 0;<br /><%%KEEPWHITESPACE%%>  char Dato_ADC[5];<br /><br /><%%KEEPWHITESPACE%%>  while(1)<br /><%%KEEPWHITESPACE%%>  {<br /><%%KEEPWHITESPACE%%>    //acquisisco ildato presente sul pin p18<br /><%%KEEPWHITESPACE%%>    Valore_ADC = ADCVal(4);<br /><%%KEEPWHITESPACE%%>    //converto il valore intero in un array di char<br /><%%KEEPWHITESPACE%%>    sprintf(Dato_ADC, "%d\n", Valore_ADC);<br /><%%KEEPWHITESPACE%%>    //invio il dato al serial monitor<br /><%%KEEPWHITESPACE%%>    UARTWrite(1, Dato_ADC);<br /><%%KEEPWHITESPACE%%>    //attesa di 1 secondo<br /><%%KEEPWHITESPACE%%>    vTaskDelay(100);<br /><%%KEEPWHITESPACE%%>  }<br />}<br />[/c]

L’unica raccomandazione nell’uso dei pin analogici è quella di non superare mai la tensione massima in ingressi di 3.3Vdc. Nel caso in cui la tensione da acquisire fosse maggiore si potrebbe adottare un semplice partitore di tensione.

The post Flyport Ethernet leggere dai pin analogici appeared first on Esperimenti con logiche programmabili.

Il moduli Flyport Ethernet, come Arduino e Netduino, hanno un piccolo software (bootloader) che permette di utilizzare una connessione seriale per caricare il firmware nella propria memoria. Il canale seriale viene anche usato per eseguire operazioni di debug, o comunque per scambiare dati col computer o altri dispositivi.
Inviare dati dal Flyport al computer, è una operazione che personalmente trovo fondamentale per poter capire se il programma sta girando nel modo che mi aspetto.

La seriale utilizzata per caricare il firmware sul Flyport Ethernet è disponibile sul pin p13 (UART RX input) e sul pin p15 (UART TX output). Sono disponibili ulteriori 3 porte seriali impiegando i pin rimappabili. Per questo tutorial utilizzeremmo la porta seriale principale (pin p13 e p15), perché essendo collegata al miniUSB PROG permette, senza l’ausilio di circuiti aggiuntivi, di creare una connessione seriale col pc.

Alcune informazioni aggiuntive sulla comunicazione seriale potete trovarle in questo precedente articolo https://logicaprogrammabile.it/netduino-collegamento-seriale-rs232/.

La prima istruzione che dobbiamo scrivere riguarda l’inizializzazione della porta da usare e la velocità di comunicazione

[c]
//specifica il numero di porta e
//la velocità
UARTInit(1, 19200);
[/c]

Dopo la configurazione, per poter inviare e ricevere dati dobbiamo attivare la porta con la seguente istruzione:

[c]
//attivo la porta seriale 1
UARTOn(1);
[/c]

Inviamo una serie di caratteri singoli al pc, utilizzando un ciclo while() e l’istruzione UARTWriteCh()

[c]
#include "taskFlyport.h"

void FlyportTask()
{
UARTInit(1, 19200);
UARTOn(1);

while(1)
{
//invia il carattere A tramite
//la porta UART 1
UARTWriteCh(1, ‘A’);
//ritardo di 100ms
DelayMs(100);
}
}
[/c]

Compiliamo il sorgente e carichiamolo sul Flyport Ethernet. Dal tab View dell’Openpicus Flyport IDE, clicchiamo sul pulsante Serial Monitor.

Sul lato destro della finestra verrà visualizzato il pannello Serial Monitor. Selezioniamo la porta COM, dove è collegato il convertitore miniUSB PROG (nel mio caso la COM21), selezioniamo la velocità di comunicazione corretta, come quella specificata nell’istruzione UARTInit (nel mio caso 19200) e clicchiamo il pulsante Connect per avviare la ricezione dei caratteri inviati dal modulo Flyport Ethernet, per interrompere l’acquisizione utilizziamo il pulsante Close.

I dati provenienti dal modulo verranno printati sul Serial Monitor.
Abbiamo la possibilità di inviare una serie di caratteri (buffer) con una singola istruzione, utilizzando la funzione UARTWrite()

[c]
#include "taskFlyport.h"

void FlyportTask()
{
UARTInit(1, 19200);
UARTOn(1);

while(1)
{
//invia una serie di caratteri
//tramite la porta UART 1
UARTWrite(1, "Flyport Ethernet");
//ritardo di 100ms
DelayMs(100);
}
}
[/c]

Nel codice precedente sul serial monitor visualizzeremo la frase “Flyport Ethernet”.
Nel caso in cui volessimo spedire i dati in formato byte, dovremmo impiegare un buffer come descritto nel codice seguente:

[c]
#include "taskFlyport.h"

void FlyportTask()
{
UARTInit(1, 19200);
UARTOn(1);

char buffer[6];

//assegno dei valori in byte (0-254)
 buffer[0] = 1;
 buffer[1] = 65;
 buffer[2] = 45;
 buffer[3] = 2;
 buffer[4] = 15;
 buffer[5] = 14;

while(1)
{
//invia l’intero buffer
UARTWrite(1, buffer);
//ritardo di 100ms
DelayMs(100);
}
}
[/c]

Leggere i dati

La ricezione dei dati è affidata all’istruzione UARTRead().  La ricezione avviene tramite la creazione di una area di memoria (buffer) la cui dimensione deve essere decisa in base alla quantità di dati da ricevere.

Nel seguente esempio, utilizzo sempre il Serial Monitor per inviare un byte al modulo.

[c]
#include "taskFlyport.h"

void FlyportTask()
{
UARTInit(1, 19200);
UARTOn(1);

//creo un buffer da 1 byte per memorizzare
//i dati ricevuti dalla seriale
char buffer[1];
int numDataRX = 0;

while(1)
{
//leggo dalla seriale 1 byte e lo memorizzo
//sul buffer precedentemente creato
numDataRX = UARTRead(1, buffer, 1);

//se ho ricevuto dei dati invio
//una stringa di conferma al serial monitor
if(numDataRX > 0)
{
UARTWrite(1, "RX OK\n");
}

DelayMs(10);
}
}
[/c]

Sono necessarie diverse prove per prende confidenza con l’utilizzo della seriale. Saperla adoperare è fondamentale per poter sviluppare tutti i tipi di progetti perché può essere usata per operazione di debugging utili a verificare la corretta esecuzione del codice.

The post Flyport Ethernet comunicazione seriale UART appeared first on Esperimenti con logiche programmabili.

Anche per il modulo Flyporyt Ethernet ho realizzato lo speed test come quello per le schede Netduino, Arduino e GHI. Il test consiste nella commutazione continua di un singolo pin digitale, misurando con un oscilloscopio, la frequenza risultante.

Il circuito elettrico dei collegamenti è il seguente:

mentre questo è il risultato della misura:

Come si può osservare la frequenza e di ben 134.5KHz, un risultato che reputo molto soddisfacente, paragonato ai precedenti speed test.

La tabella seguente riepiloga i risultati misurati con le varie schede

Lo speed test è indicativo e non stabilisce certamente la scheda migliore. Ogni dispositivo possiede pro e contro a prescindere dal risultato dello speed test.

The post Flyport Ethernet Speed Test appeared first on Esperimenti con logiche programmabili.

L’utilizzo dei pin digitali rientra tra le nozioni basilari da comprendere per poter iniziare ad interagire con  i dispositivi ed i componenti esterni che permettono al modulo Flyport Ethernet di far parte di un sistema complesso.
Il modulo Flyport Ethernet è composto da due connettori, J1 e J2; essi sono collegati direttamente ai pin del microcontrollore Pic24F ed al controller Ethernet ENC424J600.

Tramite questi connettori possiamo collegarlo al modulo NEST Proto o ad un nostro circuito host dedicato.
Nel mio caso utilizzerò il Nest Proto per motivi di semplicità e di uniformità dei tutorial.

Nel Nest Proto è presente un connettore femmina collegato direttamente al connettore J1 del Flyport Ethernet, che permette di utilizzare dei fili elettrici pint-to-pin per realizzare velocemente prototipi ed esperimenti. Tralasciamo, per ora, il connettore J2 che viene impiegato per la comunicazione ethernet (tramite una porta RJ45 da saldare sul NEST Proto), e per offrire altri 8 pin IO.

Il connettore J1 è composto da 26 pin, ad ognuno è associata una funzione specifica. La tabella seguente mostra la pin-function del connettore:

Configurare pin GPIO come uscita

I pin contrassegnati come GPIO possono funzionare sia come ingressi sia come uscite digitali. La colonna Remappable indica invece se al pin può essere associata una funzione speciale, ad esempio i pin p1 e p3 NON sono rimappabili e quindi possono essere configurati o come GPIO o come bus I2C. Un pin rimappabile può funzionare sia come GPIO ed è possibile associarli anche una funzionalità aggiuntiva come PWM, UART o SPI. Questa peculiarità permette di avere un sistema molto flessibile, configurabile per ogni esigenza progettuale.
La colonna, 5V Tollerant, indica se il pin può sopportare tensioni di 5 Volt (Logica TTL), ad esempio il pin p17 non è 5V tollerant e quindi dobbiamo stare molto attenti a non collegare tensioni superiori ai 3.3V, causa possibile danneggiamento del microcontrollore.

Utilizziamo il circuito in figura per scrivere un piccolo programma che utilizzerà le istruzioni per definire il pin p2 come uscita digitale:

al pin p2, ho collegato una resistenza da 330 ohm ed un diodo led. Da notare che i numeri dei pin sono disposti utilizzando la prima riga, del connettore J1, per i numeri dispari e la seconda riga per i numeri pari.

Il codice seguente accende e spegne il led ogni 500ms:

[c]
#include "taskFlyport.h"

void FlyportTask()
{
//il pin p2 viene configurato
//come uscita digitale
IOInit(p2, out);

//ciclo infinito
while(1)
{
//commuto il pin p2 a livello
//logico alto
IOPut(p2, on);
//creo un ritardo di 500ms
DelayMs(500);
//commuto il pin p2 a livello
//logico basso
IOPut(p2, off);
//creo un ritardo di 500ms
DelayMs(500);
}
}
[/c]

L’istruzione che permette di definire un pin come uscita o come ingresso è la IOInit(). I parametri da passare sono il numero del pin, espresso nella forma px (dove x è il numero del pin) ed il flag per specificare un uscita out o un ingresso in.
In questo caso il pin p2 viene usato come uscita (out). Per poter commutare il suo stato logico utilizziamo la funzione IOPut(). Questa funzione accetta due parametri, il primo è il numero del pin, definito nella IOInit, e il secondo specifica se metterlo a livello logico alto (on) o al livello basso(off).

Configurare pin GPIO come ingresso

Il pin p2 viene ora impiegato come ingresso digitale. Lo schema elettrico è il seguente:

la resistenza R1 serve per avere un livello logico basso sul pin p2 quando il pulsante è aperto. Sul pin p4 ho collegato un diodo led in modo da poterlo accendere quando premo sul pulsante.
Questo è il codice del firmware da caricare sul Flyport:

[c]
#include "taskFlyport.h"

void FlyportTask()
{
//il pin p2 viene configurato
//come Ingresso digitale
IOInit(p2, in);

//il pin p4 viene configurato
//come Uscita digitale
IOInit(p4, out);

//ciclo infinito
while(1)
{
//verifico lo stato del pin p2
//Alto o basso
if(IOGet(p2) == 1)
//sel il pin è a livello
//logico alto, accendo il led
IOPut(p4, on);
else
//altrimenti
//spegni il led
IOPut(p4, off);

DelayMs(20);
}
}
[/c]

Ho usato due istruzioni IOInit per definire il pin p2 come ingresso e il pin p4 come uscita. Nel blocco while, controllo, con l’istruzione IOGet, se il livello logico sul pin p2 è alto. In caso affermativo, utilizzo il pin p4, per accendere o spegnere il diodo led.

Nei prossimi tutorial vedremo come attivare la resistenza interna di pull-up e di pull-down per gli ingressi digitali del Flyport Ethernet.

The post Flyport Ethernet, conoscere i pin digitali appeared first on Esperimenti con logiche programmabili.

Con i precedenti tutorial abbiamo visto tutti i passaggi per configurare l’ambiente di sviluppo e come caricare il nostro primo programma sul modulo Flyport ethernet senza però conoscere il modulo stesso. In questo articolo verrei analizzare le potenzialità di questo dispositivo, informazioni utili per poter sceglierlo nei nostri progetti.

Le sue dimensioni sono di 5 cm x 3.5 cm, caratteristica sempre apprezzata nelle installazioni dove le dimensioni contenute sono un fattore richiesto.

Il microprocessore che governa il modulo è il modello della serie PIC24F (PIC24FJ256) prodotto dalla Microchip, troviamo inoltre il controller ethernet ENC424j600, sempre prodotto da Microchip. Il processore opera a 16bit capace di eseguire, con i suoi 32MHz di clock, 16 milioni di istruzioni al secondo, possiede 256 KByte di Flash e 16KB di RAM. L’interfaccia di rete è una 10/100 Base-T.
Troviamo collegato sul pcb anche un quarzo da 32.768Mhz necessario al modulo RTCC (Real Time Clock and Calendar) implementato nel microprocessore PIC24F.

Le porte digitali sono 18, di cui 14 rimappabili (possibilità di configurarle come ingressi o come uscite), le porte analogiche sono 4 con una risoluzione di 10bit (valori da 0 a 1023). Inoltre possiamo configurare 4 porte UART, 9 canali PWM, una porta SPI e una porta I2C.

Il modulo ospita una memoria flash seriale da ben 16Mbit (SST25VF016Bb), utile per memorizzare le pagine html che poi verranno impiegate ad esempio dal webserver interno.

Il Flyport Ethernet può essere alimentato sia a 5Vdc sia a 3.3Vdc.

L’intervallo di temperature in cui il modulo può operare va da -20°C a +85°C. Questi valori sono veramente interessanti permettendo l’installazione in ambienti anche estremi.

Flyport framework

All’interno del microprocessore troviamo, il bootloader, un sistema operativo real-time (freeRTOS), lo stack TCP/IP e l’Openpicus Framework.
Il bootloader è un piccolo software che risiede nella flash del microcontrollore PIC24F. Questo software permette di caricare il programma scritto con l’Openpicus IDE dentro la flash del microcontrollore, tramite la porta seriale UART. Inoltre permette di avviare il programma o di resettarlo. Questa scelta permette di usare solamente il convertitore usb seriale piuttosto che impiegare un programmatore esterno più complesso per tutte le fasi di programmazione e di debug.
Il sistema operativo real time è basato su FreeRTOS, realizzato per girare su diversi dispositivi embedded. L’Openpicus framework integra lo stack TCP/IP tramite questo sistema operativo e permette così di facilitare la gestione di TCP/IP. Nonostante questa semplificazione è comunque richiesta una minima esperienza nell’uso delle reti e della loro configurazione.

Il modulo, o per meglio dire il sistema Openpicus, si dimostra utile in moltissime applicazioni, da quelle puramente hobbistiche a quelle industriali. Credo che conoscerne il funzionamento e la sua programmazione si davvero utile per arricchire le nostre competenze e per avere dalla nostra un utile strumento da utilizzare anche in campo lavorativo.

E poi è made in Italy!

The post Caratteristiche tecniche del Flyport Ethernet appeared first on Esperimenti con logiche programmabili.

Dopo aver visto come installare il software necessario alla scrittura dei programmi e dopo aver installato i driver del programmatore miniUSB Prog, passiamo alla pratica creando un piccolo progetto che ci permetterà di far lampeggiare il led onboard del Flyport ethernet.

Avviamo l’OpenPicus Flyport IDE.
L’interfaccia grafica è ben organizzata, molto intuitiva e snella.

Creiamo il nostro progetto cliccando sull’icona New Project -> Ethernet ->Ethernet 2.3 Basic no webserver, come rappresentato nella figura seguente:

Nella finestra andremmo ad inserire il nome del progetto e la cartella dove verrà salvato, confermiamo cliccando sul pulsante Create>>:

La configurazione dell’IDE è immediata. L’interfaccia grafica viene suddivisa in tre blocchi principali, il pannello progetto mostra i file sorgente e le eventuali librerie che utilizzeremmo durante lo sviluppo, il pannello editor codice è la parte dove andremmo a scrivere le istruzioni che saranno poi compilate e caricate sul Flyport Ethernet, infine il pannello output mostra tutte le informazioni di compilazione e gli eventuali messaggi di errore.

Sul pannello Editor Codice viene caricato un template standard. Andremo a modificarlo per poter far lampeggiare il led onboard del nostro Flyport Ethernet scrivendo le seguenti istruzioni:

[c]
#include "taskFlyport.h"

void FlyportTask()
{
//blink onboard led D1
while(1)
{
//comuto l’uscita p21 alta
IOPut(p21,on);
//attendo 1/2 secondo
DelayMs(500);
//commuto l’uscita p21 bassa
IOPut(p21,off);
//attendo 1/2 secondo
DelayMs(500);
}
}
[/c]

L’azione successiva è quella di “trasformare”, tramite la compilazione, le nostre istruzioni in un linguaggio comprensibile per il microcontrollore.
Clicchiamo sul pulsante Compile Project -> Compile, per avviarla.

I vari passaggi sono rappresentati nel pannello Output. Dopo poco tempo la compilazione termina con successo:

Ci siamo quasi, ora che abbiamo il file compilato possiamo caricarlo sul modulo Flyport utilizzando il tool Download firmware:

se non l’abbiamo fatto colleghiamo il Flyport Ethernet e il programmatore miniUSB Prog sul modulo NEST Proto. Colleghiamo il cavo usb al PC e nella finestra Openpicus – Flyport Bootloader clicchiamo il pulsante Refresh ports per aggiornare la lista dei dispositivi COM collegati al PC.
Selezioniamo la porta COM dove è collegato il miniUSB Prog (nel mio caso la porta COM21, vedi precedente articolo) e avviamo il download del firmware cliccando sul relativo pulsante Download:

la barra di avanzamento e la finestra di log mostreranno le fasi di scrittura:

Un popup di conferma ci indicherà che l’operazione è avvenuta con successo clicchiamo sul pulsante OK per chiudere la finestra:

osserviamo il led D1 posto sul pcb del Flyport Ethernet che inizierà a lampeggiare con una cadenza di 1/2 secondo.

Questo tutorial conclude una serie di articoli che permettono, a chi ha poca esperienza, di poter iniziare a smanettare con i moduli Flyport. Abbiamo visto infatti come installare l’ambiente di sviluppo, come installare i driver del programmatore ed infine come eseguire la compilazione e la scrittura del firmware sul modulo Flyport ethernet.

The post Flyport Ethernet scrivere il primo programma appeared first on Esperimenti con logiche programmabili.

Nel precedente articolo abbiamo visto come installare l’ambiente di sviluppo che ci permetterà di scrivere i programmi per la piattaforma Openpicus. Ora passeremmo alla pratica utilizzando il Flyport Ethernet Makerkit. Questo starter kit comprende un modulo Flyport Ethernet, il miniUSB Prog ed il Proto Nest.

Il Proto Nest permette di ospitare il modulo Flyport e il modulo miniUSB Prog. Il modulo Flyport deve essere inserito nel giusto verso, vi consiglio di inserire prima il modulo miniUSB Prog (anche questo da inserire correttamente confrontando il simbolo > serigrafato nel PCB) poichè la sua posizione verticale va ad interferire con il connettore RJ45, rendendo difficoltoso il posizionamento del modulo Flyport.
L’immagine seguente mostra il corretto posizionamento:

Il modulo miniUSB Prog è un convertitore USB seriale basato sul chip FTDI FT232. Le istruzioni seguenti mostrano come installare il dispositivo su Windows 7.

La prima operazione da eseguire è il download dei driver dal sito FTDIchip. Personalmente ho scaricato la versione eseguibile:

Colleghiamo il miniUSB Prog al computer, dopo qualche istante Windows avvierà la procedura automatica di installazione dei driver:

annulliamo la procedura automatica cliccando sul link “Ignora download di driver da Windows Update“, confermiamo la nostra scelta cliccando il pulsante Si nella seguente finestra:

l’installazione viene annullata:

Nella finestra Gestione Dispositivi (Pannello di controllo -> Sistema e sicurezza) potremmo osservare la presenza del dispositivo USB Serial Port:

Avviamo l’installazione dei driver tramite il pacchetto CDM20828_Setup.exe:

Clicchiamo sul pulsante Extract della seguente finestra:

Il programma di installazione estrarrà i file necessari ed avvierà automaticamente la procedura guidata:

Clicchiamo sul pulsante Avanti nella prima finestra della procedura guidata:

i driver saranno copiati sul sistema, questa operazione può durare anche diversi minuti, non interrompiamo la procedura e lasciamo collegato il miniUSB Prog alla porta usb del PC:

dopo un po di pazienza l’installazione termina correttamente, clicchiamo sul pulsante Fine:

Verifichiamo la corretta installazione del convertitore USB seriale anche tramite il pannello Gestione Dispositivi:

Annottiamo il numero di porta seriale assegnato dal sistema, nel mio caso la COM21, questo ci permetterà di selezionare la giusta COM in fase di caricamento del firmware sul modulo Flyport.

The post Openpicus come programmare il Flyport Ethernet appeared first on Esperimenti con logiche programmabili.

Openpicus è un progetto tutto italiano nato nel 2010, basato sulla filosofia open hardware che permette di realizzare applicazioni dove la connettività è il fattore chiave. Attualmente esistono tre moduli programmabili, il Flyport Ethernet, il Flyport Wi-Fi e il Flyport Gprs. I moduli Flyport sono gestiti dal microcontrollore Microchip Pic 24FJ256(16 bit) operante a 32MHz.

Analizzeremmo meglio le caratteristiche dei moduli Flyport nei seguenti tutorial.
Vediamo nel dettaglio come installare l’ambiente di sviluppo che ci permetterà di scrivere i programmi, di compilarli e caricarli nel modulo Flyport.

La prima operazione è quella di scaricare il file di setup relativo all’IDE e al compilatore Microchip C30 seguendo questo link http://wiki.openpicus.com/index.php?title=Getting_Started.

Partiamo con l’installazione dell’IDE (attualmente giunto alla versione 2.3).

Eseguiamo il file FlyPort IDE-2.3-Setup.exe e accettiamo di eseguire l’installazione (Controllo account utente). Selezioniamo la lingua dell’ide che preferiamo, nel mio caso Italian:

Clicchiamo sul pulsante ok. Il prossimo popup ci avvisa che l’IDE sarà installato sul sistema, proseguiamo cliccando sul pulsante ‘Si’.

La prossima schermata mostra il Contratto di Licenza. Dopo averlo letto Accettiamo e clicchiamo sul pulsante Avanti:

Continuiamo l’installazione cliccando nuovamente sul pulsante Avanti:

La finestra seguente indica in quale percorso desideriamo installare l’IDE, nel mio caso ho lasciato il percorso di default sotto la cartella Programmi nell’unita C:, continuamo cliccando sul pulsante Avanti:

la schermata seguente riepiloga le scelte effettuate. Avviamo l’installazione dei file cliccando sul pulsante Avanti:

la barra di avanzamento indica lo stato della copia dei file:

dopo qualche istante l’installazione viene completata. Lasciamo i tre simboli di spunta selezionati e clicchiamo sul pulsante Fine:

A questo punto verrà avviato il FlyPort IDE. La finestra popup avvisa che non è stato trovato il compilatore GCC. Clicchiamo sul pulsante NO:

Il programma ci avviserà che non è stato possibile trovare il compilatore. Clicchiamo sul pulsante OK:

A questo punto il FlyPort IDE viene avviato ma non è possibile utilizzarlo. Chiudiamo il programma.

Per risolvere il problema avviamo l’installazione del compilatore Microchip C30 tramite il file MPLABC30Combo_v3_24Lite.exe:

dopo avver confermato, nella finestra account utente, l’intenzione di installare il programma, verrà avviata la finestra di benvenuto, clicchiamo sul pulsante Avanti:

accettiamo il contratto e clicchiamo sul pulsante Avanti:

il popup seguente ci permette di scegliere se l’installazione del programma deve avvenire per tutti gli utenti o solo per l’utente corrente, clicchiamo sul pulsante SI:

selezioniamo l’installazione Completa:

scegliamo la cartella di installazione. Se non avete particolari esigenze, consiglio di tenere il percorso prestabilito:

La finestra popup successiva vi indicherà che verrà aggiunta una voce alla sezione PATH Enviroment del sistema operativo, accettiamo cliccando sul pulsante Si:

la successiva finestra popup, vi chiederà se volete modificare il registro in modo che l’MPLAB IDE possa usare il compilatore GCC. Nel mio caso ho scelto cliccando il pulsante SI, se voi non avete installato l’MPlAB IDE potete anche cliccare sul pulsante NO:

La finestra successiva riepiloga le varie opzioni scelte, avviamo l’installazione cliccando sul pulsante Avanti:

una barra di avanzamento mostrerà lo stato dell’installazione:

dopo un po di attesa l’installazione si concluderà con una finestra di conferma. Clicchiamo sul pulsante Finish.

L’installazione dell’IDE  e del compilatore sono concluse.
Avviamo nuovamente il FlyPort IDE per assicurarci che il compilatore GCC sia stato riconosciuto.

se non ci sono problemi, le finestre popup di errore visualizzate precedentemente, non verranno visualizzate e l’ide sarà avviato senza nessun messaggio.
Clicchiamo sulla scheda View e poi sul pulsante Compiler Settings:

la finestra che verrà avviata mostra l’indirizzo di installazione del compilatore Microchip GCC come definito nella sezione PATH enviroment:

Nei prossimi tutorial vedremmo come installare il modulo FlyPort Ethernet  e come caricare il primo programma.

Per maggiori dettagli visitate il sito http://www.openpicus.com/
Altre info su http://wiki.openpicus.com/index.php/Main_Page

The post OpenPicus, prima installazione dell’ambiente di sviluppo appeared first on Esperimenti con logiche programmabili.