Quantcast
Channel: Esperimenti con logiche programmabili
Viewing all 122 articles
Browse latest View live

Lampada di cortesia a batteria con ATtiny85

$
0
0

Usare un ATtiny85 per controllare una lampada led a batteria

Mi piace realizzare progetti che impiegano dispositivi esistenti che, magari messi da parte per lungo tempo, si rivelano ottimi per costruire nuovi dispositivi.
La lampada led a batteria è un oggetto molto comune che si compra a basso costo nelle bancarelle delle fiere di elettronica. Date le sue dimensioni ridotte è possibile utilizzarla per illuminare tutte quelle piccole aree dove non abbiamo previsto una fonte di illuminazione fissa e dove non abbiamo la possibilità di portare dei cavi elettrici se non tramite opere murarie.

Usare un attiny85 per pilotare lampada led

Usare un attiny85 per pilotare lampada led

Non potendo tenere accesa la lampada per ore, causa scaricamento repentino della batteria, ho realizzato un piccolo circuito che tramite un sensore PIR e un relè permetta l’accensione della lampada solo al passaggio di una persona (o comunque qualsiasi cosa che si muove![tranne mosche e zanzare!]). Adoperando anche una fotoresistenza riesco a gestire l’accensione solo nelle ore notturne.
Tutto il sistemino è gestito da un parsimonioso ATtiny85.

Lo schema del circuito è il seguente:

Luce cortesia lampada led attiny85

Schema elettrico

Le batterie della lampada (che forniscono nel mio caso circa 7Vdc) hanno anche il compito di alimentare il circuito. Il regolatore di tensione 7805 stabilizza e fornisce alimentazione al circuito. L’ATtiny85 acquisisce il segnale analogico proveniente dalla fotoresistenza e il segnale digitale proveniente dal sensore PIR. Tramite il transistor comando un micro relè che cortocircuita l’interruttore meccanico posto sulla lampada, provocandone l’accensione.

Il codice che governa l’ATtiny85 è il seguente:


void setup()
{
  //uscita per comandare il rele
  pinMode(0, OUTPUT);
  //ingresso per sensore pir
  pinMode(4, INPUT);
}

void loop()
{
  //leggo il valore analogico proveniente dalla fotoresistenza
  int FotoR = analogRead(3);
  //leggo lo stato del segnale pir
  byte inp = digitalRead(4);

  //se il sensore pi rileva un movimento...
  if (inp == HIGH)
  {
    //controlla se la luce ambiente è insufficiente
    if (FotoR <= 150)
    {
      //attiva il relè pe accendere la lampada led
      digitalWrite(0, HIGH);
      //tieni la lampada accesa per 30 secondi
      Ritardo();
    }
  }
  else
    //altrimenti tieni il relè disattivato
    digitalWrite(0, LOW);
}

void Ritardo()
{
  //ritardo di 30 secondi

  for(byte Ciclo = 0; Ciclo <= 30; Ciclo++)
  {
    delay(1000);
  }
}

Per programmare l’ATtiny85 potete usare un Arduino UNO come spiegato in questo tutorial. Per chi possiede un programmatore dedicato come quello descritto nel precedente articolo potete usare lo schema seguente per caricare lo sketch nel microcontrollore.

Programmatore usbAsp per attiny85

Programmate l’ATtiny85 con L’USBasp

Attenzione il connettore da utilizzare dellUSBasp è il J5

La lampada del led è costata circa 15€ mentre per i componenti del circuito o speso circa 10-12€.

Per usare il circuito all’esterno consiglio di utilizzare un buon contenitore, per evitare che umidità o pioggia possano causare rotture o cortocircuiti.


Arduino gestire display a matrice 20×4

$
0
0

Come impiegare la libreria LiquidCrystal per scrivere su un display a matrice 20×4

Utilizzare un display risulta utile per una miriade di applicazioni dove è necessario una maggiore interazione con l’utente. Effettuare i collegamenti tra display e Arduino ed utilizzare la libreria LiquidCrystal per gestire il display è una operazione tutto sommato semplice ma nonostante molti utenti alle prime armi trovano alcune difficoltà.

I display a matrice di punti, utilizzano un protocollo comune basato sul chip HD44780 prodotto dalla Hitachi. Sono formati da diverse colonne e righe ed i valori tipici vengono espresso nella forma ColonnexRighe, nel nostro caso il display è un 20×4, quindi composto da 20 colonne per ognuna delle 4 righe (altri tipi possono essere 16×1, 16×2, 128×64, ecc…).

Display a matrice 20 colonne x 4 righe 20x4

L’interfaccia per poter inviare i comandi ed i dati è di tipo parallelo, composta da 16 pin. Nella tabella seguente viene illustrata la pin function:

Numero Pin Descrizione
1 GND collegamento a massa dell’alimentazione del display
2 VCC Alimentazione del display tipicamente 5Vdc
3 Vo Gestisce la luminosita dei pixel del display
4 RS Specifica se vogliamo caricare un dato(Livello Alto) o un comando (Livello basso)
5 R/W Specifica se vogliamo scrivere o leggere dal display
6 E Necessario per far leggere al display il comando o il dato presente sulle linee DB
7 Data bit 0
8 Data bit 1
9 Data bit 2
10 Data bit 3
11 Data bit 4
12 Data bit 5
13 Data bit 6
14 Data bit 7
15 Vcc Alimentazione per la retroilluminazione del display
16 Gnd Massa per la retroilluminazione del display

I pin Data servono per inviare un byte al chip del display. Il valore inviato può essere interpretato sia come un comando (ad esempio per spostare il cursore, per posizionarsi su una riga specifica, per pulire il display) sia un valore ASCII da scrivere sulla matrice. La scelta tra comando e carattere ASCII viene gestita dal livello logico posto sul pin RS.
Il pin E abilita l’esecuzione del comando o la scrittura sulla matrice.

Il circuito seguente è quello che ho realizzato per il tutorial:

Gestione Arduino display 20x4

Nello schema potete notare che i Data Pin non sono collegati completamente ma vengono utilizzati solo i bit più significativi (bit 4, 5, 6, 7). Questa peculiarità è possibile poichè il display supporta la modalità a 4-bit, che essendo implementata anche dalla libreria LiquidCrystal, fa in modo di usare solo 4 file piuttosto che 8.

Il pin6 di Arduino è collegato al pin4 del display per gestire la funzione di RS (Comando/Dato) mentre il pin7 è collegato al pin6 del display E, per far processare al chip del display il Comando o il Dato.

Una volta effettuati i collegamenti, possiamo iniziare con un piccolo sketch di esempio:

//inserisco la libreria per
//gestire i display a matrice di punti
#include <LiquidCrystal.h>

//creo un oggetto specificando i pin RS il pin E e
//i 4-bit di dati (bit 4, 5, 6, 7)
//collegati rispettivamente ai pin 6, 7, 4, 3, 2
//di arduino come da schema
LiquidCrystal Display20x4(6, 7, 5, 4, 3, 2);

void setup()
{
  //il metodo begin permette di impostare il numero di
  //colonne e di righe che compongono il display
  //nel mio caso il modello è un 20x4
  Display20x4.begin(20, 4);

  //pulisci il display e posiziona il cursore sulla prima
  //riga e sulla prima colonna
  Display20x4.clear();

  //visualizza il cursore sul display
  //per verificare la posizione iniziale
  Display20x4.cursor();

  //attendi 2 secondi
  delay(2000);

  //disattivo il cursore
  Display20x4.noCursor();

}

void loop()
{
  //sposta il cursore alla prima riga e prima colonna
  //questa operazione è necessaria se vogliamo
  //scrivere il testo sempre nella stessa posizione
  //omettendo questa istruzione il testo verrà scritto continuamente
  //sul display andando a coprire tutte le righe
  Display20x4.home();
  //scrivi nella prima riga un testo
  Display20x4.print("Logicaprogrammabile");

  //ritardo
  delay(500);
}

La scrittura deve essere composta da una istruzione che gestisce la posizione del cursore e una successiva che effettua la scrittura del testo sul display.

Per scrivere su ogni riga dobbiamo quindi comporre le istruzioni in questo modo:

void loop()
{
  //posiziono il cursore all'inizio della prima riga
  Display20x4.setCursor(0,0);
  //scrivi nella prima riga un testo
  Display20x4.print("ABCDEFGHILMNOPQRSTUV");

  Display20x4.setCursor(0,1);
  //scrivi nella seconda riga un testo
  Display20x4.print("ABCDEFGHILMNOPQRSTUV");

  Display20x4.setCursor(0,2);
  //scrivi nella terza riga un testo
  Display20x4.print("ABCDEFGHILMNOPQRSTUV");

  Display20x4.setCursor(0,3);
  //scrivi nella quarta riga un testo
  Display20x4.print("ABCDEFGHILMNOPQRSTUV");

  //ritardo
  delay(500);
}

Se il testo che printiamo sul display supera i 20 caratteri avremmo una situazione di riscrittura del testo sulla stessa riga, in pratica se abbiamo un testo di 25 caratteri, verranno prima printati 20 caratteri e i rimanenti 5, saranno riscritti nella stessa riga occupando le prime 5 colonne,compromettendo il testo scritto precedentemente.

Se ad esempio scrivessi questo teso (25 caratteri)

ABCDEFGHILMNOPQRSTUV12345

otterrei sul display questa visualizzazione (20 caratteri)

12345FGHILMNOPQRSTUV

L’uso del display risulta quindi molto semplice, la libreria è composta da altri metodi che permettono di effettuare altre operazioni. Nel link seguente potete trovare ulteriori informazioni a riguardo.

Riferimento libreria LyquidCrystal su Arduino.cc

Microsoft Embedded Conference

$
0
0

mec_thumb

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

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

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

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

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

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

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

Come programmare l’Arduino Mini 05

$
0
0

Utilizzare un convertitore Usb Seriale per programmare l’Arduino Mini

La famiglia di schede Arduino è composta da vari formati. A seconda del tipo di progetto che stiamo realizzando potremo scegliere un dispositivo che ci permetta di ottimizzare gli spazi. Una scheda che reputo molto utile è l’Arduino Mini, giunto alla quinta revisione, poiché le sue dimensioni sono davvero contenute (3 cm x 1.8 cm) ed il suo costo è attualmente di 15€ (sullo store ufficiale).

Arduino Mini 05

Essendo cosi compatto per poterlo programmare abbiamo bisogno di un convertitore usb seriale esterno, infatti non è disponibile sulla scheda un convertitore integrato.
Per questo tutorial ho utilizzato il convertitore ufficiale Arduino USB2Serial Light ed un convertitore DFrobot basato sul chip FTDI FT232RL.

Questo lo schema usando l’USB2Serial:

Arduino Mini USB serial

Il circuito è molto banale ma bisogna assicurarsi di inserire il condensatore C da 100nF per poter resettare il Mini e caricare il nuovo sketch.
Da notare anche che il TX del convertitore è collegato all’RX del Mini mentre l’RX del convertitore è collegato all’TX del Mini.

Lo schema elettrico utilizzando il convertitore della DFrobot è identico, tranne che nella serigrafia del convertitore non è presente la dicitura reset ma DTR:

FTDI FT232 RL converter USB to SerialLa compilazione dello sketch e del caricamento sul Mini è identica ad un Arduino UNO, bisogna selezionare dall’IDE la board corretta (Arduino MINI /w ATmega328) e la porta COM dove è collegato il convertitore.

Netduino Plus 2 Speed Test

$
0
0

Velocità di commutazione del nuovo Netduino Plus 2

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

Netduino Plus 2

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

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

Tipo Scheda Frequenza di commutazione
Arduino UNO 125 KHz
Arduino LEONARDO 106 KHz
FEZ Panda II 12.7 KHz
Netduino Plus 2 43.8 KHz
Netduino 8.4 KHz

Questo invece lo screen shot della schermata dell’oscilloscopio

Netduino Plus 2 Test toggle pin

Per progettare dispositivi elettronici devo essere laureato?

$
0
0

Perché credo che tutti possano costruire il proprio progetto

Alcuni utenti mi scrivono in privato chiedendomi se, anche non avendo esperienze nel campo dell’elettronica o dell’informatica, possano comunque realizzare piccoli progetti o comunque iniziare ad avere esperienze utilizzando Arduino.

Progettare con Arduino
Chi non ha mai sognato di diventare il MacGyver di casa propria? Probabilmente questa serie tv ha segnato il mio percorso di studi e mi ha fatto appassionare a tutto ciò che si possa costruire con le proprie mani, utilizzando quel che capita. Quando ero alle superiori Arduino non esisteva e i miei progetti si basavano sull’elettronica analogica, bisognava sapere bene come i componenti elettronici interagivano tra loro per far si che il circuito funzionasse e non prendesse fuoco.

Oggi il 99.9% dell’elettronica è digitale e in effetti, sapere come lavora un circuito digitale potrebbe essere trascurato, è sufficiente sapere il comportamento generale del componente. Quello che interessa capire è la logica di funzionamento di un circuito, senza pensare troppo a cosa accade dietro le quinte.
Credo che questo sia un consiglio importante per tutti quelli che vogliono iniziare a progettare qualcosa, non ci si deve spaventare di fronte alla complessità dei dispositivi o alla poca esperienza, bisogna fare affidamento alle proprie capacità di ragionamento.

Si inizia a piccoli passi seguendo guide basilari ben documentate. I primi esercizi devono essere molto semplici, senza troppi componenti, ad esempio accendere/spegnere un led o utilizzare un pulsante.

Questo è quello che mi sento di consigliare a chi ha voglia di fare e di imparare nuove nozioni:
passate alla pratica e mettetevi a realizzare piccoli esperimenti, vi renderete conto che potete imparare da soli ad usare Arduino, senza troppe difficoltà e con molta soddisfazione.

Provate, sbagliate, pensate, riprovate.

Buon lavoro…

ListComPort elencare la porte com associate ad Arduino

$
0
0

ListComPort è l’utility per chi lavora spesso con Arduino

Spesso mi capita di usare diversi tipi di Arduino collegati allo stesso pc e diventa abbastanza frustrante capire quale sia la relativa porta COM, dato che nell’IDE viene elencato il nome della porta senza la descrizione del tipo di dispositivo associato.
Quindi devo accedere a gestione dispositivi e controllare nella voce Port (COM e LPT) quale sia questa associazione, in modo da caricare gli sketch sui giusto relativi dispositivi.
Il problema poi aumenta quando collego e scollego le schede dalla porta usb, magari invertendo l’ordine sulle porte, ottenendo così nuovi assegnamenti di COM che mi costringono a tenere aperta la finestra gestione dispositivi.

ListComPort

Ho scritto una piccola utility che elenca le porte COM con la descrizione del dispositivo collegato, in questo modo lavoro meglio e quando ricollego le schede posso cliccare sul pulsante aggiorna per ottenere la nuova lista aggiornata.

Magari capita anche a voi questa situazione e quindi potrebbe esservi utile usare questo programmino!

Il software è stato testato su Windows 7 e Windows XP e richiede l’installazione del .NET framework 4.0

Scarica ListCOMport.exe circa 50KB

Download ListCOMport_English Version

Graditi feedback!

Installare Arduino su Windows 8

$
0
0

Come installare Arduino su Windows 8

Qualche utente non è riuscito ad installare Arduino su Windows 8 perchè l’installazione automatica dei driver non va a buon fine. Niente paura, nonostante dicerie di qualche esperntone, che fanno pensare incompatibilità con Win8, potete seguire la procedura per Windows 7 (http://www.logicaprogrammabile.it/installare-arduino-su-windows-7/) che vi permette di installare i driver non firmati tramite semplice procedura manuale. Di seguito gli sreen shot di tutte le fasi.

Procedura installazione Arduino su Win8 Cattura di schermata (6) Cattura di schermata (7) Cattura di schermata (8) Cattura di schermata (9) Cattura di schermata (10) Cattura di schermata (11) Cattura di schermata (12) Cattura di schermata (13) Cattura di schermata (14) Cattura di schermata (16) Cattura di schermata (17) Cattura di schermata (18)

Buon lavoro con Arduino e Windows 8!


Utilizzare lo Spectrum Shield con Arduino

$
0
0

Spectrum shield come accendere diversi led a ritmo di musica

Un progetto che ha sempre attirato molta attenzione è il circuito VU meter sincronizzato con il ritmo della musica (il mitico luci psichedeliche ). Anche io quando ero alle superiori mi sono cimentato costruendone uno. Il circuito era formato da tre filtri analogici, uno passa basso uno passa banda e uno passa alto, che lavoravano rispettivamente alle frequenze 0-500Hz, 500Hz 4000Hz e 4000Hz-16000Hz. All’uscita dei filtri c’era un rilevatore di picco costruito con un operazionale che andava a pilotare dei driver che accendevano delle lampadine colorate.

Luci Psichedeliche

Oggi la tecnologia offre prodotti integrati a basso costo, specializzati in una vasta gamma di compiti che rendono più semplice la realizzazione dei nostri circuiti. Per quanto riguarda le nostre luci psichedeliche possiamo fa affidamento allo Spectrum shield per Arduino. Lo shield è molto semplice ed è composto principalmente da due integrati MSGEQ7 (Equalizzatore grafico a 7 bande). Lo schema a blocchi dell’integrato è il seguente:

MSGEQ7 Diagramma a blocchi

si osserva che in effetti il principio di funzionamento è molto simile a quello che si usava nei primi circuiti a luci psichedeliche, ma i filtri a disposizione sono ben 7 e le uscite dei filtri vengono multiplexate, in questo modo invece di avere 7 pin di output ne abbiamo solamente uno.
Inviando un primo impulso positivo al pin strobe avremmo in uscita il valore analogico proveniente dal filtro a 63Hz, inviandone un altro impulso avremmo in uscita il valore analogico del filtro a 160Hz e così via fino a tornare dopo 8 impulsi al filtro a 63Hz.

I due integrati MSGEQ7 presenti nello spectrum shield analizzano il segnale audio proveniente dal canale destro e dal canale sinistro. Per brevità utilizzerò un solo integrato (canale) visto che il codice è interscambiabile.
Le uscite analogiche dei due integrati sono collegate ai pin A0 e A1 mentre i pin Strobe e Reset sono collegati ai pin digitali D4 e D5.

Questo è il codice:

//Specifica i pin Reset, Strobe
int spectrumReset=5;
int spectrumStrobe=4;

//Specifico il canale di ingresso
//pin A0 per canale destro
//pin A1 per canale sinistro
int spectrumAnalog = 1; //canale sinistro

//creo un vettore per contenere i valori analogici
//delle 7 bande
int Spectrum[7];

void setup()
{
  //pin reset e strobe in output
  pinMode(spectrumReset, OUTPUT);
  pinMode(spectrumStrobe, OUTPUT);

  //inizializzo lo spectrum shield
  //Strobe
  digitalWrite(spectrumStrobe,HIGH);
  delay(1);
  digitalWrite(spectrumStrobe,LOW);
  delay(1)

  //Reset dei due chip
  digitalWrite(spectrumReset,HIGH);
  delay(1);
  digitalWrite(spectrumReset,LOW);
  delay(5);

  //definisco 7 uscite digitali per pilotare altrettanti led
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);

}

void loop()
{
  //esegui la lettura ogni 10mS
  readSpectrum();
  delay(10);
}

void readSpectrum()
{
  //Questa funzione legge il valore analogico per ogni banda
  //e ne rappresenta il valore tramite dei led

  byte Band;
  //questo ciclo for viene eseguito 7 volte
  for(Band = 0; Band < 7; Band++)
  {
    //eseguo due letture per poi dividerle per due tramite
    //spostamento di bit. Il valore ottenuto viene memorizzato
    //nel vettore
    Spectrum[Band] = (analogRead(spectrumAnalog) + analogRead(spectrumAnalog) ) >>1;

    //invio un impulso al pin strobe per passare al filtro successivo
    digitalWrite(spectrumStrobe,HIGH);
    digitalWrite(spectrumStrobe,LOW);
  }

  //una volta effettuata la memorizzazione dei dati
  //nel vettore, creo un altro ciclo for
  //per rappresentare gli stessi tramite led
  for (byte Ciclo = 0; Ciclo < 7; Ciclo++)
  {
    //recupero il valore memorizzato nel vettore
    //traslo il valore intero in un byte
    byte x = map(Spectrum[Ciclo], 0, 1023, 1, 254);

    //se il valore supera una soglia accendi il led
    //altrimenti spegnilo
    if( x > 120)
      digitalWrite(Ciclo + 6 , HIGH);
    else
      digitalWrite(Ciclo + 6, LOW);
  }
}

Mentre questo è il circuito elettrico

Luci psichedeliche con lo spectrum shield

Per poter collegare delle lampade a 220Vac è necessario usare dei triac con relativo stadio pilota fotoisolato.

Usare il potenziometro digitale MCP4131-103

$
0
0

Come usare Arduino per pilotare un potenziometro digitale

Molte applicazioni richiedono la variazione continua di alcuni parametri, come ad esempio un alimentatore, un amplificatore audio, un termostato o un varilight che solitamente impiegano un potenziometro analogico e l’intervento manuale di una persona per effettuare queste variazioni.
Possiamo digitalizzare questi sistemi impiegando lo stesso principio di regolazione basato su potenziometro ma invece di agire fisicamente sulla manopola di regolazione possiamo utilizzare dei comandi software per incrementare decrementare il valore resistivo del potenziometro.

Il componente che andremmo ad usare è l’integrato MCP4131-103 prodotto dalla Microchip. E’ un integrato a 8 pin che possiamo comandare tramite il protocollo seriale SPI.
Al suo interno troviamo un potenziometro da 10Kohm.

Diagramma interno MCP4131 103

Il potenziometro è composto da una rete resistiva composta da 128 elementi  il cui valore totale è, nel nostro modello, di 10Kohm. Tramite software possiamo spostare la posizione dello Wiper, che corrisponde al contatto strisciante di un potenziometro meccanico. Gli spostamenti dello Wiper vengono definiti steps e vanno dalla posizione 00H (Wiper collegato al pin P0A) alla posizione 80H(Wiper collegato al pin P0B).
Il potenziometro digitale MCP4131 permette un massimo di 129 steps.

MCP4131 Internal potentiometer diagram

Il datasheet è comune a diversi potenziometri digitali quindi per poter capire quale siano i comandi corretti per pilotare il nostro modello dobbiamo esaminare le parti che ci interessano. La prima sezione riguarda le Caratteristiche del dispositivo (Device Features)

Caratteristiche del dispositivo MCP4131-103

Da questa tabella deduciamo che il dispositivo ha un singolo potenziometro, che i valori della posizione dello Wiper sono memorizzati in RAM (piuttosto che sulla EEPROM). L’interfaccia di comunicazione è SPI, i numeri di Steps sono 129 e il range con cui possiamo alimentare l’integrato va da 1.8Vdc a 5.5Vdc.

L’MCP4131 supporta comandi a 8 bit e a 16 bit. Il comando a 8 bit permette di incrementare o decrementare il valore dello Wiper di uno steps per volta mentre il comando a 16 bit permette di scrivere direttamente sulla RAM il valore della posizione dello Wiper.

MCP4131command format

Nella figura il comando a 8 bit è composto da 2 bit di dati (che non vengono utilizzati), 2 bit di comando (incremento – decremento)  e 4 bit che definiscono l’indirizzo di memoria che vogliamo usare (indirizzo dello Wiper 00h).
Nella figura del comando a 16 bit la prima parte è identica a quella a 8 bit con la differenza che nei 2 bit di comando possiamo specificare se scrivere o leggere dall’area di memoria del dispositivo, i restanti 8 bit compongono il Data Byte che ci permette di indicare direttamente il valore dello Wiper.

Gli indirizzi di memoria disponibili sono i seguenti:

MCP4131 Memory Mapnel nostro caso utilizzeremmo l’indirizzo 00h, che corrisponde all’unico Wiper disponibile all’interno del nostro chip.

I bit di commando invece sono i seguenti:

MCP4131 Command Bits

Passando alla pratica, se volessi inviare un comando di incremento al Wiper dell’MCP4131, usando la modalità a 8bit, invierei tramite SPI il valore decimale 4

Arduino Leonardo MCP4131

Per decrementare il valore corrente dello Wiper bisogna spedire via SPI il valore decimale 8:

Arduino Leonardo MCP4131

Se volessi spostare il Wiper al centro della sua corsa, utilizzerei la modalità a 16 bit, inviando per primo il dato contenente l’indirizzo di memoria che vogliamo usare e il comando di scrittura

Leonardo mcp4131-103

Seguito dal valore della posizione dove vogliamo spostare lo Wiper, in questo esempio il valore 64 decimale (128/2) corrisponde a metà corsa.

Leonardo

Ora che conosciamo come utilizzare il chip possiamo passare alla pratica collegando la porta SPI dell’Arduino all’MCP4131. Nel mio caso ho utilizzato un Arduino Leonardo (la porta SPI è disponibile sui pin dell’header ICSP). Lo schema è il seguente:

Arduino Leonardo collegamento MCP4131-103

L’uscita W è collegata all’ingresso analogico A0 della Leonardo, in questo modo posso misurare il valore di tensione disponibile su tale piedino.
Il Pin B dell’MCP4131, corrispondente alla posizione 00H è collegato a massa mentre il pin A corrispondente alla posizione 80H è collegato alla 5Vdc.
Il codice seguente posiziona lo Wiper nella posizione 00H, ottenendo cosi una tensione pressochè nulla sul pin W (poiche internamente il pin W è collegato con il pin B).

#include <SPI.h>

void setup()
{
  //Definisco il pin come uscita
  //il pin 2 viene usato per selezionare il
  //chip all'interno di un collegamento SPI
  pinMode (2, OUTPUT);

  //Inizializzo la libreria SPI
  SPI.begin();

  //Inizializzo la porta seriale
  Serial.begin(9600);

  //metto alta la linea CS per
  //deselezionare il chip MCP4131
  digitalWrite(2, HIGH);

}

void loop()
{
  //Inizializzo la posizione dello Wiper
  byte Posizione = 0;

  //Per selezionare l'MCP4131
  //metto basso la linea CS del
  //potenziometro digitale
  digitalWrite(2, LOW);

  //Invio il primo byte per eseguire una scrittura
  //sul registro Wiper
  SPI.transfer(0);
  //Invio il valore della posizione dello Wiper
  //valori da 00H a 80H (0-128 in decimale)
  SPI.transfer(Posizione);

  //metto alta la linea CS per
  //deselezionare il chip MCP4131
  digitalWrite(2, HIGH);

  //eseguo la lettura sul pin analogico A0
  //in questo pin è collegato il pin Wiper
  //del potenziometro digitale
  int Data = analogRead(0);

  //spedisco il dato letto al serial Monitor
  //Valori da 0 a 1023
  Serial.println(Data);

  //ritardo di mezzo secondo
  delay(500);
}

Aprendo il serial monitor otterremmo dei valori prossimi allo zero poichè la tensione in ingresso del pin A0 sarà nulla. Questo è ciò che avviene all’interno dell’MCP4131:

Wiper to GND

Per posizionare lo Wiper verso il pin A, collegato alla 5Vdc, dobbiamo scrivere sull’indirizzo 00H il valore 80H, come descritto nel codice seguente:

#include <SPI.h>

void setup()
{
  //Definisco il pin come uscita
  //il pin 2 viene usato per selezionare il
  //chip all'interno di un collegamento SPI
  pinMode (2, OUTPUT);

  //Inizializzo la libreria SPI
  SPI.begin();

  //Inizializzo la porta seriale
  Serial.begin(9600);

  //metto alta la linea CS per
  //deselezionare il chip MCP4131
  digitalWrite(2, HIGH);

}

void loop()
{
  //Inizializzo la posizione dello Wiper
  byte Posizione = 128;

  //Per selezionare l'MCP4131
  //metto basso la linea CS del
  //potenziometro digitale
  digitalWrite(2, LOW);

  //Invio il primo byte per eseguire una scrittura
  //sul registro Wiper
  SPI.transfer(0);
  //Invio il valore della posizione dello Wiper
  //valori da 00H a 80H (0-128 in decimale)
  SPI.transfer(Posizione);

  //metto alta la linea CS per
  //deselezionare il chip MCP4131
  digitalWrite(2, HIGH);

  //eseguo la lettura sul pin analogico A0
  //in questo pin è collegato il pin Wiper
  //del potenziometro digitale
  int Data = analogRead(0);

  //spedisco il dato letto al serial Monitor
  //Valori da 0 a 1023
  Serial.println(Data);

  //ritardo di mezzo secondo
  delay(500);
}

In questo caso aprendo il serial monitor leggeremmo dei valori prossimi a 1023 in quanto sul pin analogico A0 sarà presente la tensione di 5Vdc.
Internamente otterremo questo risultato:

wiper to vcc

Di conseguenza per avere tutti gli altri valori intermedi potremmo cambiare il valore della variabile Posizione assegnandole valori tra 0 e 128.

Pilotare LED RGB

$
0
0

Come usare Arduino per pilotare strip led RGB

La tecnologia led si è ormai evoluta ed inizia ad essere presente in modo pronunciato in molti ambienti, dalla casa agli uffici fino ad arrivare all’illuminazione pubblica. I vantaggi in termini di risparmio energetico sono enormi e la qualità della luce emessa sta raggiungendo un comfort visivo soddisfacente.

Anche nell’arredamento troviamo soluzioni carine che vanno dalla lampada da salotto multicolore alle luci di cortesia nei piani cottura oppure alle barre led impermeabili poste nel box doccia.

Vista la nostra passione per l’auto-costruzione possiamo realizzare un dispositivo basato su Arduino per pilotare una barra led RGB. Per questo tutorial ho usato una Arduino Leonardo e uno spezzone di 10 cm di una strip led RGB da un metro. Questo modello viene alimentato a 12Vdc e un modulo assorbe, con tutti i led accesi circa 55mA. (quindi un metro assorbe circa 550mA).

Un elemento RGB è composto da 3 LED distinti (Rosso, Verde, Blu) disposti in modo da poter interagire tra loro per formare diversi colori complementari.

Stril Led RGB da 10 cm

Il modo più semplice per accendere i led è di collegare uno dei pin (B,R,G) verso massa; non è necessario utilizzare delle resistenze per limitare la corrente.

Vediamo ora come usare Arduino per accendere e spegnere singolarmente i vari led. Il circuito da realizzare è il seguente e si basa su tre transistor PNP tipo BC337.

Controllo strip led rbg

Le basi dei tre transistors sono collegate ai pin 3, 5 e 6 non a caso poiché su questi pin è disponibile anche il segnale PWM che utilizzeremo per andare a pilotare i led RGB in modo migliore.


void setup()
{
  //led Rosso
  pinMode(5, OUTPUT);
  //led verde
  pinMode(6, OUTPUT);
  //led blu
  pinMode(3, OUTPUT);

  //init seriale
  Serial.begin(9600);
}

void loop() {
  //se arrivano dati...
  if (Serial.available())
  {
    //leggi il carattere in arrivo
    byte data = Serial.read();

    if(data == 'q') //accende il led blu
      digitalWrite(3, HIGH);
    else if (data == 'w') //spegne il led blu
      digitalWrite(3, LOW);

    if(data == 'a') //accende il led verde
      digitalWrite(5, HIGH);
    else if (data == 's') //spegne il led verde
      digitalWrite(5, LOW);

    if(data == 'z') //accende il led rosso
      digitalWrite(6, HIGH);
    else if (data == 'x') //spegne il led rosso
      digitalWrite(6, LOW);
  }
}

Il codice precedente permette di accendere o spegnere i led inviando tramite serial monitor i caratteri corrispondenti.

Per un maggior controllo dei led RGB possiamo utilizzare il segnale PWM. In questo modo abbiamo la possibilità di creare dissolvenze per creare combinazioni di colori visivamente più interessanti.
Ad esempio il codice seguente permette di accendere e spegnere il led BLU in modo graduale tramite una dissolvenza


void setup()
{
  //led Rosso
  pinMode(5, OUTPUT);
  //led verde
  pinMode(6, OUTPUT);
  //led blu
  pinMode(3, OUTPUT);

  //init seriale
  Serial.begin(9600);
}

void loop()
{
  //Aumenta il duty cycle da 100% a 0%
  for(byte sfuma = 0; sfuma < 255; sfuma++)
  {
    analogWrite(3, sfuma);
    delay(40);
  }

//diminuisci il duty cycle da 100% a 0%
 for(byte sfuma = 255; sfuma > 0; sfuma--)
 {
   analogWrite(3, sfuma);
   delay(40);
 }
}

Se volessi miscelare i colori potrei scrivere qualcosa del genere


void setup()
{
  //led Rosso
  pinMode(5, OUTPUT);
  //led verde
  pinMode(6, OUTPUT);
  //led blu
  pinMode(3, OUTPUT);

  //init seriale
  Serial.begin(9600);
}

void loop()
{
  //accendo il led rosso
  digitalWrite(6, HIGH);

  //Aumenta il duty cycle da 100% a 0%
  for(byte sfuma = 0; sfuma < 255; sfuma++)
  {
    analogWrite(3, sfuma);
    delay(40);
  }

  //spengo il rosso
  digitalWrite(6, LOW);
  //accendo il verde
digitalWrite(5, HIGH);

  //diminuisci il duty cycle da 100% a 0%
  for(byte sfuma = 255; sfuma > 0; sfuma--)
  {
    analogWrite(3, sfuma);
    delay(40);
  }
}

Le combinazioni che possiamo creare sono innumerevoli, potete provare a sperimentare creando effetti luminosi che possono abbellire i vostri ambienti.

Webduino Based Authentication. Accedere ad una pagina privata

$
0
0

Come utilizzare la Based Authentication per accedere a una pagina protetta

La libreria Webduino implementa una semplice autenticazione basata sul protocollo http. Certamente non offre un livello di sicurezza impenetrabile ma può comunque essere utile utilizzare questa funzione per le nostre applicazioni.

Nell’esempio, viene caricata la pagina index.htm dove è presente un link che punta a una pagina protetta. per poter visualizzarne il contenuto è necessario inserire nome utente e password.

La based authentication si basa sulla codifica Base64. Il nume utente e la password, nella forma numeutente:password, vengono convertiti in un unica stringa  di caratteri.  Per la conversione, potete utilizzare diversi servizi online oppure scaricare la mia app ConvertBase64.

based authentication

Il codice seguente è pronto all’uso, dovete cambiare solamente l’indirizzo ip, adattando lo alla vostra rete locale.

#include "SPI.h"
#include "Ethernet.h"
#include "WebServer.h"

//definisco mac address e indirizzo ip
static uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
static uint8_t ip[] = { 192, 168, 1, 10};

//creo un oggetto webduino
WebServer webserver("", 80);

//funzione che crea la pagina principale del sito
void defaultCmd(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
  server.httpSuccess();
  if (type != WebServer::HEAD)
  {
    //invio al browser la pagina principale
    P(helloMsg) = "<h4>Accedi:</h4><a href=\"private.html\">Pagina Privata</a>";
    server.printP(helloMsg);
  }
}

//questa funzione permette di verificare il nome utente e la password
//e in caso di successo di visualizzare la pagina privata
void privateCmd(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
  //user= admin
  //password= admin

  //verifico nome utente e password
  if (server.checkCredentials("YWRtaW46YWRtaW4="))
  {
    //in caso affermativo...
    server.httpSuccess();
    if (type != WebServer::HEAD)
    {
      //invio al browser la pagina privata
      P(helloMsg) = "<h3>Buongiorno Admin!</h3>";
      server.printP(helloMsg);
    }
  }
  else
  {
    //creo una risposta http
    //nel caso in cui si tenta un accesso
    //no autorizzato
    server.httpUnauthorized();
  }
}

void setup()
{
  //inizializzo la ethernet shield
  Ethernet.begin(mac, ip);
  //definisco funzione che gestisce
  //la pagina principale del sito
  webserver.setDefaultCommand(&defaultCmd);
  webserver.addCommand("index.html", &defaultCmd);
  //definisco la funzione che gestisce la pagina privata
  webserver.addCommand("private.html", &privateCmd);

  //inizializzo la libreria webduino
  webserver.begin();
}

void loop()
{
  char buff[64];
  int len = 64;

  webserver.processConnection(buff, &len);
}

La libreria Webduino è molto flessibile e permette di realizzare applicazioni interessanti in modo molto veloce.

OpenPicus, prima installazione dell’ambiente di sviluppo

$
0
0

Openpicus: installare il FlyPort IDE ed il compilatore GCC

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.

Moduli Flyport

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).

Flyport Setup

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:

Select Lenguage

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

Install Flyport

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

Contratto

Continuiamo l’installazione cliccando nuovamente sul pulsante Avanti:

Flyport Setup

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:

Setup06

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

Openpicus setup

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

Openpicus setup

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

Flyport setup

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

Errore01

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

Errore03

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:

MPlab Setup

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

MPlab02

accettiamo il contratto e clicchiamo sul pulsante Avanti:

MPlab03

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:

C30 setup

selezioniamo l’installazione Completa:

MPlab05

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

MPlab06

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

MPlad C30 setup

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:

Openpicus

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

MPlab09

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

MPlab10

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

flyport

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

Flyport IDE

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:

Setting01

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

Setting02

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

Openpicus come programmare il Flyport Ethernet

$
0
0

Installare il miniUSB Prog per caricare il primo programma sul Flyport Ethernet

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:

Flyport openpicus makerkit

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:

Ftdi0

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

miniUSB Prog

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:

Ftdi02

l’installazione viene annullata:

Ftdi03

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

Ftdi10

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

Ftdi00

Clicchiamo sul pulsante Extract della seguente finestra:

Ftdi04

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

Ftdi05

Clicchiamo sul pulsante Avanti nella prima finestra della procedura guidata:

Ftdi06

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:

Ftdi07

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

Ftdi08

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

flyport

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.

Flyport Ethernet scrivere il primo programma

$
0
0

Come utilizzare il Flyport IDE per caricare il primo programma

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.

FlyporFirstApp

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

flyport tutorial first project

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

Openpicus

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.

Flyport IDE 2.3

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:

#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);
  }
}

Editor codice

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.

FlyporFirstApp04

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

openpicus flyport compilazione tutorial

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

Download firmware flyport

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:

flyport

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

FlyporFirstApp07

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

FlyporFirstApp08

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.


Caratteristiche tecniche del Flyport Ethernet

$
0
0

Informazioni dettagliate sul modulo Flyport Ethernet

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.

Flyport Ethernet

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 DIagramma a blocchi

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!

Flyport Ethernet, conoscere i pin digitali

$
0
0

Come configurare ed utilizzare i pin digitali del Flyport Ethernet

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:

Flyport Ethernet J1 Port mapping

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:

Flyport Ethernet Led blink

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:

#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);
  }
}

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:

Flyport ethernet input port

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:

#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);
  }
}

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.

Open Day Arduino e stampanti 3D

$
0
0

Open day campus camilla

Il 5 Luglio 2013, Campus Camilla organizza una giornata di formazione gratuita dedicata alla programmazione con Arduino e alle stampanti 3D.

Di seguito il programma della open day:

Ore 9:30

Presentazione della giornata

Ore 10:00

Logo 3DItaly

Introduzione alla Filosofia Makers

  • la nuova rivoluzione industriale
  • fabbricazione digitale fra bit e atomi
  • accesso alle tecnologie
  • i Fablab per le comunità
  • l’esperienza dell’artigianato
  • condivisione open
  • dal prototipo al prodotto finito
  • una nuova forma per il mondo industriale

3D printing: Introduzione alla stampa, alle risorse ed alle applicazioni

  • una guida pratica per la prima stampa 3D
  • open source software e hardware
  • i modelli open e le risorse disponibili online
  • i vari modelli di stampanti ed i materiali di stampa
  • le applicazioni ed i vari campi d’impiego
  • la stampa 3D per l’educazione e per il futuro del pianeta

Ore 11:30

Elettronica In: La nostra filosofia sulle stampanti 3D

Ore 12:30

Scaldiamo i motori!
Stampanti 3D in azione!

Buffet gratuito

Ore 14:30 – Corso gratuito su Arduino

Obiettivi del corso, cosa avrai imparato al termine del corso:

  • conoscere e aver installato l’IDE Arduino
  • conoscere le differenze tra Arduino Uno, Mini, Mega, Due;
  • conoscere le differenze tra segnale analogico e digitale
  • riconoscere un pin di aduino se analogico o digitale
  • conoscere l’ADC e i livelli di segnali convertiti
  • saper usare le principali librerie
  • riconoscere un motore, un led, un relé
  • riconoscere i sensori compatibili Arduino
  • conoscere le principali shield disponibili e la loro funzione
  • aver già realizzato almeno un proprio progetto
  • aver chiaro come si affronta un progetto con Arduino

Nello specifico, il corso tratterà i seguenti argomenti tecnici:

  • riconoscere e provare i pin di arduino
  • differenza tra pin digitali, analogici e PWM
  • basi di elettronica: led, motori cc, motori passo-passo
  • collegare attuatori ( led, motori, relè )
  • collegare sensori (pulsanti, potenziometri, ecc..)
  • leggere i sensori per interagire con l’ambiente
  • controllare velocità e verso dei motori
alcune shield disponibili con Arduino

Tutte le info per poter partecipare al corso le trovate sulla pagina http://www.internetdeglioggetti.it/openday/ un evento interessante che vi consiglio di non perdere.

Motore passo passo bipolare e driver L298N

$
0
0

Come pilotare un motore passo passo usando l’integrato L298N

Quando osservo i robot industriali assemblare, saldare, fresare o posizionare oggetti con una precisione sconcertante rimango affascinato dalla capacità umana di poter costruire queste macchine. Anche nelle nostre abitazioni sono presenti oggetti dotati di parti meccaniche, che compiono movimenti molto precisi, come ad esempio le stampanti, i plotter e gli scanner.
Questi dispositivi hanno in comune tra loro un particolare dispositivo chiamato motore passo passo (stepper motor). E’ un trasduttore elettromeccanico che converte degli impulsi elettrici in un movimento fisico. Ad ogni impulso elettrico corrisponde un movimento del rotore; questo spostamento viene chiamato step.
A differenza del motore in corrente continua i motori passo passo possono mantenere la propria velocità di rotazione costante, anche con carico applicato, senza usare sistemi di controreazione (tachimetriche o encoder). Il motore eroga una coppia elevata, anche con bassi numeri di giri, possiede accelerazioni e frenate repentine ed è capace di mantenere il carico applicato fermo in posizione, senza vibrazioni.
Naturalmente esistono anche degli svantaggi, tra cui la necessità di utilizzare un circuito elettrico di pilotaggio, un rendimento energetico basso, una velocità di rotazione ridotta ed un costo di acquisto elevato.

La figura seguente mostra, in maniera semplificata, il principio di costruzione di un motore passo passo.

Motore Passo Passo

Il movimento del rotore avviene alimentando le bobine in modo consecutivo. Eccitando solo la bobina A1 il rotore si posiziona verso NORD, eccitando solo la bobina B1 il rotore si posiziona in direzione EST, eccitando solo la bobina A2 il rotore si posiziona in direzione SUD ed infine eccitando solo la bobina B2 il rotore si posiziona in direzione OVEST.
La tabella seguente riassumere la sequenza.

Fasi di Alimentazione
A1 A2 B1 B2
Fase 1 + - - -
Fase 2 - - + -
Fase 3 - + - -
Fase 4 - - - +

Seguendo le fasi di alimentazioni A1-B1-A2-B2 il rotore si sposterà in senso orario, invertendo la sequenza B2-A2-B1-A1 il rotore si sposterà in senso antiorario. E’ importante alimentare le bobine in modo sequenziale perché il rotore deve seguire in maniera lineare il campo elettromagnetico generato dalle bobine.

Naturalmente nei motori passo passo reali la sequenza delle 4 fasi fa girare l’albero di un solo passo (step). Il numero dei passi è una caratteristica costruttiva del motore, solitamente ha un valore di 200 step/giro, ma ne esistono anche da 20, 24, 48 e 400 step/giro. Il numero di step può essere espresso in gradi sessagesimali, ad esempio un motore da 7.5° equivale ad uno con 48 step/giro (360°/7.5°=48).
Le 4 fasi di alimentazione delle bobine (considerando un ipotetico motore da 1 step/giro), viene rappresentata dalla figura seguente:

Fasi di alimentazione motore passo passo

La sequenza di alimentazione è solitamente gestita da un integrato a logica programmabile mentre il compito di fornire l’energia è demandato ad un ponte ad H. Abbiamo affrontato l’utilizzo del ponte H in questo precedente articolo. Per essere più precisi, avendo 4 fili, dobbiamo usare due ponti H uno che alimenta le bobine A1 e A2 e l’altro che alimenta le bobine B1 e B2.

In questo tutorial ho usato come microcontrollore la Arduino Leonardo e come doppio ponte H il driver L298N prodotto da ST Microelectronics. Il motore è un 48 passi/giro operante a 12Vdc, smontato da una vecchia stampante non più funzionante.

Collegamento dei componenti

Il circuito elettrico che permette di pilotare il motore è rappresentato nella figura seguente:

Schema L298N motore passo passo

riassumo i collegamenti tramite la tabella seguente

Motore Passo Passo Integrato L298N Arduino Leonardo
  1-8-15 GND
  6-9-11 VCC 5Vdc
  5 5
  7 4
  10 3
  12 2
 A1 14  
 A2 13  
 B1 3  
 B2 2  
Alimentazione Motore 12Vdc 4  

i diodi in contro fase servono per proteggere le uscite dell’integrato L298N da eventuali sovratensioni generate durante l’alimentazione delle bobine.

Il codice necessario per pilotare il motore rispecchia quanto detto precedentemente. In pratica è necessario alimentare in modo consecutivo le bobine rispettando le quatto fasi.


void setup()
{
  //i pin 2-3-4-5 sono
  //configurati come uscite
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);

  //forzo le uscite a livello logico basso
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
}

void loop()
{
  //FASE 1
  //Alimento solo la prima bobina
  digitalWrite(2, HIGH);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  delay(10);

  //FASE 2
  //Alimento solo la seconda bobina
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, HIGH);
  digitalWrite(5, LOW);
  delay(10);

  //FASE 3
  //Alimento solo la terza bobina
  digitalWrite(2, LOW);
  digitalWrite(3, HIGH);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  delay(10);

  //fase 4
  //Alimento solo la quarta bobina
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, HIGH);
  delay(10);

}

Una volta caricato lo sketch, l’albero del motore inizierà a girare in senso orario. Per invertire la rotazione è sufficiente alimentare le bobine dalla fase 4 alla fase 1.

Cambiando il valore del delay() otterremmo una variazione di velocità nella rotazione del rotore.

Se avete delle stampanti vecchie potete subito passare alla pratica realizzando piccoli meccanismi e semplici robot. Volendo si possono collegare alla Leonardo 2 driver L298N per pilotare altrettanti motori passo passo, questo vi permette di poter controllare i due motori simultaneamente creando sistemi meccanici più complessi.

Flyport Ethernet Speed Test

$
0
0

Risultati velocità di commutazione pin digitale

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:

Circuito Speed Test Flyport

mentre questo è il risultato della misura:

Flyport Ethernet Speed Test

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

Tipo Scheda Frequenza di commutazione
Flyport Ethernet 134.5 KHz
Arduino UNO 125 KHz
Arduino LEONARDO / MICRO 106 KHz
FEZ Panda II 12.7 KHz
Netduino Plus 2 43.8 KHz
Netduino 8.4 KHz

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

Viewing all 122 articles
Browse latest View live