Archivi tag: arduino

Tutorial: data logging con Arduino – Parte 2

Nel precedente articolo abbiamo dato una prima ossatura al nostro data logger.
Questa volta andremo ad inserire nel nostro sketch l’LDR e andremo a mediare i nostri valori dando un output più preciso possibile.

Lo schema di massima del collegamento è il seguente:

ldr_nightlight_breadboard fetch.php

Un primo sketch di massima potrebbe essere questo:

int photocellPin = 1;     // LDR connesso al pin analogico 1
int photocellReading;     // variabile di conversione photocellReading = analogRead(photocellPin);  
 Serial.print("Luce = ");
Serial.print(photocellReading);     // scriviamo sulla seriale la quantità di luce percepita

if (photocellReading < 10) {
  Serial.println(" - Scuro");
} 
else if (photocellReading < 200) {
  Serial.println(" - Poca luce");
} 
else if (photocellReading < 500) {
  Serial.println(" - Luce");
} 
else if (photocellReading < 800) {
  Serial.println(" - Luminoso");
} 
else {
  Serial.println(" - Molto luminoso");
}

Minore è il valore percepito più sarà buio.
In questo caso il valore letto è stato spalmato su 5 print, ottimo per il debug sulla seriale.

Ora bisogna riorganizzare la nostra basetta e montare assieme LDR, LED e LM35 (sembra uno scoglilingua!) per ottenere questo:

wiringok

 

Ora riorganizziamo lo sketch iniziale ed introduciamo media su 20 letture consecutive per poi ottenere questo sketch finale:

#include <SD.h>
#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 RTC;

const int chipSelect = 10;
short i=0;

void setup()
{
  //seriale aperta a 9600 baud
  Serial.begin(9600);
  Serial.println("Initializing SD card...");

  //inizializziamo i pin 3 e 4 per i led rosso-verde
  //pin 10 riservato al card reader
  pinMode(10, OUTPUT);
  pinMode(3, OUTPUT); 
  pinMode(4, OUTPUT); 

  //se il modulo sd non viene correttamente inizializzato
  if (!SD.begin(chipSelect)) {
    //messaggio di errore sul nostro monitor seriale
    Serial.println("Card failed, or not present");

    for (i=0;i<10;i++) {
      //blinking del led rosso
      digitalWrite(3, HIGH);   
      delay(100);              
      digitalWrite(3, LOW);     
      delay(100);
    }
    return;
  }

  //se correttamente inizializzata...
  Serial.println("card initialized.");
  //blinking led verde
  digitalWrite(4, HIGH);   
  delay(500);              
  digitalWrite(4, LOW);

  //inizializziamo l'RTC
  Wire.begin();
  RTC.begin();
  if (! RTC.isrunning()) {
    Serial.println("RTC is NOT running!");
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }
}

void loop()
{
  //chiediamo il tempo all'RTC
  DateTime now = RTC.now();
  int tempPin=0; //pin del sensore di temperatura
  int ldrPin=1; //pin del sensore di luce

  int campioni=20; //20 campioni
  int ii=0;
  float  tempc1=0; // variabile per la temperatura
  long unsigned int light=0; //variabile per la luce
  float samples1[campioni]; // array di campioni per la temperatura e luce
  int samples2[campioni];  

  //aspettiamo 3secondi
  delay(2900);

  for(ii = 0; ii <= campioni-1 ; ii++)
  {
    //nell'II-esimo elemento dell'array Samples1 inseriamo il valore convertito della temperatura
    samples1[ii] = (( 5.0 * analogRead(tempPin) * 100.0) / 1024.0);
    //sommiamo le temperature di volta in volta in un altra variabile
    tempc1 = tempc1 + samples1[ii];

    //non abbiamo bisogna di convertire il valore della quantità di luce, la recuperiamo direttamente
    samples2[ii] = analogRead(ldrPin);
    light=light + samples2[ii];
  }

  //dividiamo la sommatoria per N
  tempc1 = tempc1/campioni; 
  light = light /campioni;

  //stampiamo sul nostro monitor seriale per eventuale debugging
  Serial.print(tempc1);
  Serial.println(" C");
  Serial.print(light);
  Serial.println(" light"); 

  //apriamo in scrittura il file sulla sd
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  //Scriviamo: LUCE - TEMPERATURA - ORA:MINUTI:SECONDI
  if (dataFile) {
    dataFile.print(light);
    dataFile.print(" - ");
    dataFile.print(tempc1);
    dataFile.print(" - ");
    dataFile.print(now.hour(), DEC);
    dataFile.print(":");
    dataFile.print(now.minute(), DEC);
    dataFile.print(":");
    dataFile.println(now.second(), DEC);
    //chiudiamo il file
    dataFile.close(); 

    //blinking led verde
    digitalWrite(4, HIGH);   
    delay(100);              
    digitalWrite(4, LOW);
  }  
  else {

    //errore nell'apertura del file o card rimossa
    Serial.println("error opening datalog.txt");
    for (i=0;i<10;i++) {
      //blinkig led rosso
      digitalWrite(3, HIGH);   
      delay(100);              
      digitalWrite(3, LOW);     
      delay(100);
    }
  } 
}

Perchè mediare?

Nello sketch finale ho inserito questo codice:

  for(ii = 0; ii <= campioni-1 ; ii++)
  {
    //nell'II-esimo elemento dell'array Samples1 inseriamo il valore convertito della temperatura
    samples1[ii] = (( 5.0 * analogRead(tempPin) * 100.0) / 1024.0);
    //sommiamo le temperature di volta in volta in un altra variabile
    tempc1 = tempc1 + samples1[ii];

    //non abbiamo bisogna di convertire il valore della quantità di luce, la recuperiamo direttamente
    samples2[ii] = analogRead(ldrPin);
    light=light + samples2[ii];
  }

  //dividiamo la sommatoria per N
  tempc1 = tempc1/campioni; 
  light = light /campioni;

I motivi principali sono due:

  1. una precisione leggermente migliore della lettura fatta col codice del primo articolo
  2. in realtà, la media via software può essere evitata se venisse introdotto un piccolo circuito tra sensori e pin.

Campionare 20 volte successivamente, mi permette di evitare di introdurre altra circuiteria.
Questo workaround ci permette di non avere valori sballati dovuti ad un effetto collaterale, a livello hardware, del “Sample and Hold

Sul nostro file datalog.txt avremo finalmente i valori nel formato che ci eravamo prefissi di avere…

Arduino for dummies

Arduino è il nome di una piattaformahardware per lo sviluppo di applicazioni basate sui microcontrollori ATMEL.

Ideata in Italia nel 2005, è basata su una semplicissima scheda di I/O e su un ambiente di sviluppo che usa una libreria Wiring per semplifi care la scrittura di programmi in C e C++ da far girare sulla scheda.

Il progetto Arduino ha preso avvio in Italia ad Ivrea, nel 2005, con lo scopo di rendere disponibile a progettisti, studenti e semplici hobbisti, un dispositivo di sviluppo facile ed allo stesso tempo più economico rispetto a simili sistemi di prototipazione.

A ottobre 2008 erano già stati venduti più di 50.000 esemplari di Arduino in tutto il mondo.

Le schede uffi ciali usano i chip della serie megaAVR (nello specifi co, i modelli ATmega8, ATmega168, ATmega328, e ATmega1280) ma i loro cloni sono disponibili anche con altri microcontrollori.

atmega328

La scheda Arduino è pre-programmata con un bootloader che semplifi ca il caricamento dei programmi nella memoria Flash incorporata nel chip, rispetto ad altri dispositivi che richiedono, solitamente, un programmatore esterno.

L’ambiente di programmazione integrato (IDE) di Arduino è un’applicazione multipiattaforma scritta in Java, ed è derivata dall’IDE creato per il linguaggio di programmazione Processing e adattato al progetto Wiring. È concepito per introdurre alla programmazione hobbisiti e neofiti, a digiuno di pratica nello sviluppo di software.

Per poterla programmare da remoto senza alcun specifico programmatore, il microcontrollore viene fornito preprogrammato con uno specifico bootloader che instraderà in modo corretto il firmware nell’apposita area di memoria EEPROM durante la fase di programmazione.

Collegare l’arduino al nostro pc è estremamente semplice, bisogna collegare tramite cavetto USB l’arduino al PC

usbplugged_t

Una volta collegata la nostra arduino alla porta usb avvengono due cose:
1. viene data alimentazione alla nostra scheda che eseguirà da subito l’ultimo codice da noi caricato.
Solitamente, la scheda arduino viene venduta con lo sketch “blink” già caricato su di essa, infatti un led smd post al di sotto del pin 13 inizierà a lampeggiare.

diecledplaced

2. arduino verrà riconosciuta dal nostro pc come periferica esterna: se si ha una duemilanove bisogna installare i driver del chipset (non open) FTDI, se è una UNO verrà riconosciuta automaticamente.

I programmi, nel mondo arduino, vengono chiamati “sketch”.
Gli sketch vengono scritti, compilati e caricati sulla nostra scheda tramite l’IDE ufficiale.

Una volta scaricata l’IDE dal sito ufficiale arduino.cc accertiamoci di aver selezionato la giusta porta COM della nostra arduino:

winportselect

E come target-board, la giusta scheda:

Arduino_IDE_Board_Select

Sulla nostra ide 1.0.1 avremo i seguenti pulsanti:

cattura3a
Verifica, Carica, Nuovo, Apri, Salva e Monitor Seriale.

Possiamo tradurre i tasti in questo modo:

Verifica: compila ma non carica il binario nel chip

Carica: compila e carica il binario

Nuovo: apre un nuovo file

Apri: un file salvato

Salva: un file da noi scritto

Monitor Seriale: apre un monitor in ascolto sulla seriale di arduino, sarà la nostra finestra di colloquio con arduino. Riceveremo e mandermo caratteri.

Avremo a disposizione decine di sketch già preconfezionati da poter testare da subito sulla nostra scheda:

immaginesui

Il primo sketch che andremo a compilare e caricare sulla nostra scheda è un pò come il nostro primo “hello world” scritto in C qualche anno fa.
In particolare apriremo l’esempio “blink”:

/*
  Blink
  Accende il LED per un secondo, lo spegne per un altro secondo, ripetutamente
 */

//Il pin 13 ha un LED smd già saldato sulla maggior parte delle schede Arduino
//diamogli un nome:
int led = 13;

//la routine setup gira una sola volta dopo aver dato alimentazione o premuto il tasto reset
void setup() {                
  // inizializza il pin digitale 13 come output
  pinMode(led, OUTPUT);     
}

// la routine loop esegue le istruzioni all'infinito
void loop() {
  digitalWrite(led, HIGH);   // accende il led (HIGH il massimo voltaggio 5v)
  delay(1000);               // wait per un secondo
  digitalWrite(led, LOW);    // spegne il led (LOW è la più bassa tensione)
  delay(1000);               // aspetta per un secondo
}

Premiamo sul pulsante “Carica” e….

myblinkupload

Eventualmente, si può innestare un led esterno (correttamente orientato) tra il pin GND e 13 come in molti esempi:

ngled_t

Non è propriamente corretto inserirlo direttamente in quanto il led verrebbe sovralimentato, andrebbe collegato con una resistenza da 1KOhm in serie, in questo modo:

led13bb_t lesson3sch4

 

Il nostro primo “hello world” è terminato!

 

fonti:
adafruit.com
elettronicaIN

Indicatore livello GPL a valori continui

Ciao a tutti i miei fans (4 gatti)!

Oggi vorrei proporvi una mod per le vostre vetture molto cool: un indicatore del livello del GPL a valori continui.

Cosa significa?
Scommetto che molti di voi, per colpa di questa crisi, hanno acquistato un auto a gpl/metano o hanno installato un impianto sulle vostre auto a benzina.

La cosa che mi rende un pò sconcertato è il modo con cui viene indicata la quantità di gpl nei nostri toroidi.
Tutto viene affidato ad un pic che, tra le tante cose, pilota 5 led: riserva 1/4, 2/4, 3/4 e 4/4.
Dunque, rappresentano la quantità in modo discreto e non continuo: non avete modo di capire quanto gpl avete effettivamente!

19052012015

Facciamo un paio di conti:
Ipotizziamo un toroide di 45litri.
Ogni led rappresenta circa 45/4 del totale, ovvero 11.25 litri.
Se abbiamo 11.3 litri, quasi certamente, il vostro pic accenderà il 2° led che vi trarrà in inganno perchè penserete di avere 22.5 litri!
Per non parlare poi di quando camminate a riserva pensando di avere un bel pò di gas quando poi….

Come risolvere, dunque, questo problemino fastidioso?
Prima però, dovremmo rispondere ad un’altra domanda…. Come funziona esattamente il meccanismo che accende i led?

Proverò a spiegarvelo a parole mie…
Su di ogni toroide c’è un sensore resistivo che varia a secondo del livello di liquido all’interno del toroide.
Questo grazie ad un meccanismo a me ignoto, ma che ipotizzio sia realizzabile con qualche galleggiante a calamita.
Il sensore indica il livello in modo analogico (con una lancetta) e lo trasforma sotto forma di tensione che andrà direttamente al commutatore, che spalmerà la suddetta tensione, su 4 led:

dscn0733l

Nel mio caso ho un sensore resistivo aeb1050 ed un commutatore aeb722a:

19052012012 19052012013 19052012014

Aprendo il commutatore ho notato che:

1. E’ fatto davvero bene. Una bella pcb, ottime saldature, ottimi componenti, ottima elettronica: ho notato un pò di diodi di protezione.

2. La tensione del sensore va quasi direttamente all’entrata RC5 di un pic della famiglia 16F-qualcosa-

3. Ogni led corrisponde ad una porta del pic

4. Altra elettronica che penso servi a commutare l’impianto da gas a benzina e viceversa… tipo dei piccoli relè

Dunque, se i calcoli non mi ingannano, la tensione doveva variare tra 0~5v.
Studiando bene lo schema di montaggio ed altre caratteristiche dell’impianto, consultabile nel pdf al link: http://www.aeb.it/prodotti/commutatori/722
…si capisce in un batter d’occhio che il cavetto bianco (se correttamente installato dal vostro meccanico) porta direttamente al sensore.

captureuxg

Ho così splittato il cavetto e l’ho chiuso con un pò di guaina termorestringente:

dscn0737hc dscn0738g

Ho collegato il tester in questo modo: il positivo al cavo bianco appena splittato e il negativo ad un qualsiasi negativo… io ho usato quello del posacenere.

capturetx

…e bingo!

dscn0740v dscn0741n

La mia bellissima tensione!
Come si può evincere è molto vicina a 0v… 1.6v, quasi un pieno!
Più precisamente:
5v : 45litri = 1.67v : x
x = (45*1.67)/5 = 15.03 litri al pieno
y = 45 – x
y = 29.97 ~ 30litri effettivi!

(però non credo che il mio toroide sia da 45litri… dovrebbe essere tipo 42litri)

Ho avuto modo di camminare col tester attaccato e ho fatto anche un pò di gas.
Proprio come in una vera lancetta a benzina, il valore varia con la quantità di gpl.
Non solo… ad ogni buca, salita/discesa il valore cambiava proporzionalmente: in salita diminuiva e in discesa aumentava.

Ora viene il bello, come inscatolare il tutto rendendo più elegante questa lettura?
A mio avviso il modo più semplice è acquistare un piccolo voltimetro a pannello a 7 segmenti (o lcd) che si accende all’accensione dell’auto (o con uno switch in serie) che indica il voltaggio sul cavo bianco: 0v pieno, 5v serbatoio vuoto.
Tipo questo:

captureuud

E’ la soluzione più economica (meno di 3euro dalla cina), facile e pulita.
Ma se volete una cosa più elaborata, precisa e figa… beh… arduino!
Collegate la tensione all’input analogico, fate un piccolo sketch di conversione, mediate i vostri valori e rappresentateli su un bel display luminoso.

A voi la scelta!!

19052012005

PS
Ovviamente, non mi assumo nessuna responsabilità circa quello che andrete a fare sul vostro impianto!

PPSS
Ovviamente, il tutto varia da impianto a impianto… bisognerebbe riapplicare un pò di teoria e modificare leggermente (spero per voi) questa mod.

Nota_1:
Cosa abbastanza strana è che si può regolare anche i litri di gpl che indicano la riserva, cito il manuale: È possibile effettuare una piccola rettifica del numero di chilometri che possono essere percorsi in riserva; ruotando il sensore nella sede della multivalvola in senso antiorario, i chilometri che si possono percorrere in riserva diminuiscono mentre ruotandolo in senso orario i chilometri che si possono percorrere aumentano.

Flashing con l’IDE Arduino di Optiboot 4.4 su Arduino Nano (e non solo)

Oggi mi è arrivato l’Arduino Nano, una versione ridotta dell’arduino duemilanove.
Stesso mcu (atmega 328p) , stesso ftdi, ma diverso package. Pensavo fosse un pochino più grande ma con mia grande sorpresa è davvero piccolino! Chissà la versione arduino mini quant’è piccolo a questo punto!
Non ho resistito e subito ho montato l’opitboot 4.4 (che è compatibile anche con arduino nano).

Questa volta, per aggirare l’ostacolo della compatibilità dei driver USBasp su Win 7 x64, ho flashato su un secondo pc Win7 x32 usando, però, l’ide e l’usbasp.
Quindi, niente bit bang e collegamenti strani.
Il procedimento è stato molto semplice:

1. installazione dei driver usbasp versione libusb_0.1.12.1
2. collego correttamente l’usbasp all’isp dell’arduino nano
3. modifica dell’ide 1.0 in questo modo:

  • Aprire il file programmers.txt nel path: C:…arduino-1.0hardwarearduino
  • Editare il file e aggiungere queste due righe in coda al file:

usbasp.name=USBasp
usbasp.protocol=usbasp

4. aprire l’ide, selezionare Tools>Boards> Arduino UNO
5. selezionare in Tools>Programmaer> USBasp
6. Tools> Burn Bootloader

Attendere qualche minuto e il vostro arduino nano adesso avrà l’optiboot 4.4!!!

Note:

1. Non dimenticate, però, che da adesso in poi il vostro nano è un arduino UNO a tutti gli effetti, quindi, quando andrete a caricare i vostri sketch, selezionate come target board Arduino UNO

2. Questo stesso procedimento è valido anche per arduino duemilanove, uno, etc etc… per tutte le versioni che hanno l’atmega328p

img20120228151506

Installare/ripristinare Optiboot su Arduino Duemilanove

Oggi avevo taaaaaanta voglia di installare il “nuovo” bootloader OptiBoot 4.4  sulla mia duemilanove… risultato: brickata e poi debrickata (dubbi??).
Ora cercherò di spiegarvi come installare l’ultima versione del’optiboot sul vostro microcontroller.
Ma cos’ha di così tanto speciale l’OptiBoot?
Prima di tutto OptiBoot è il bootloader nuovo utilizzato dalle Arduino UNO in poi, il link del progetto ufficiale è questo: http://code.google.com/p/optiboot/
Dalla home del progetto leggiamo:

  • Possibilità di scrivere sketch più grandi. Optiboot è grande 0.5k (un quarto più più piccolo rispetto al bootloader del duemilanove) significa che guadagnamo 1.5k di spazio per il codice. Per un totale di 32256 byte
  • Upload degli sketch molto più veloce. Velocità di upload 115200baud
  • Permette di far girare prima i propri sketch senza watchdog.

0. Prima di tutto dobbiamo fare dei collegamenti tra l’FTDI e l’interfaccia ICSP della nostra scheda:

2754610263_7d147df701_o

1. Ciò di cui abbiamo bisogno è l’ultima versione dell’optiboot scaricabile dal sito ufficiale, in particole questo file presente nel file zip: optiboot_atmega328.hex

  • In alternativa, se si vuole ripristinare il vecchio bootloader arduino duemilanove, esso è presente all’interno della cartella: arduino-0023hardwarearduinobootloadersatmegaATmegaBOOT_168_atmega328.hex

2. Ora scarichiamo e unzippiamo il package che ho preparato, da qui:     SCARICAMIII

3. Apriamo avrdude-gui.exe

3. Selezionare avrdude.exe presente nella directory appena unzippataa

4. Come programmer impostiamo: FT232R Synchronous BitBang (diecimila)

5. Device: ATmega328P

6. Command option: -P ft0 -B 4800

7. Impostare i fuse in questo modo:

  • High Fuse: 0xDE per l’OptiBoot 0xDA per la versione vecchia del bootloader duemilanove
  • Low Fuse: 0xFF
  • Extended Fuse: 0x05
  • Lock Bit: 0x0F

Se avete dubbi, potete prendere questi valori direttamente dal’ultima versione dell’IDE e precisamente nel file: arduino-0023hardwareboards.txt

8. Selezioniamo dalla casella Flash l’OptiBoot scaricato e unzippato che desideriamo installare, precisamente: optiboot_atmega328.hex

Dovreste avere una cosa del genere:

catturanh

9. Collegare il cavo USB al pc: led POWER si accende

10. Ora cliccate su “Erase – Write – Verify”

11. Aspettate un pò di tempo: circa 10 minuti.

Ora che è andato tutto a buon fine, provate ad uploaddare lo sketch “blink” nel folder degli esempi, se avete messo l’optiboot ricordandovi di impostare come target board la board UNO.

Se blinka…. avete l’ultima versione dell’optiboot sulla vostra arduino duemilanove!

Se mettete l’optiboot sulla duemilanove ricordate di cambiare le impostazioni dell’ide: ora come target board dovete mettere “Arduino UNO” e NON più duemilanove. OK???

Fonti:
http://dereenigne.org/electronics/arduino/arduino-duemilanove-optiboot
http://www.geocities.jp/arduino_diecimila/bootloader/index_en.html

PS

Declino ogni responsibilità su probabilissimi brick delle vostre schede.

Aggiornamento:

questa è la mia guida che vi permette di aggiornare il vostro Arduino Duemilanove con l’IDE ufficiale utilizzando usbasp: http://blackstufflabs.com/2012/02/28/optiboot-4-4-su-arduino-nano

Stringa connessione DB per hosting 7hostfree.com

Stringa di connessione ad un db Access 2002-2003 .mdb con hosting gratuito 7host.com

Path: ./App_Data/mydb.mdb

|DataDirectory| = App_Data

 

<?xml version=”1.0″?>
<!–
Per ulteriori informazioni su come configurare l’applicazione ASP.NET, visitare il sito Web all’indirizzo
http://go.microsoft.com/fwlink/?LinkId=169433
–>
<configuration>
<connectionStrings>
<add name=”database” connectionString=”Provider=Microsoft.Jet.OleDb.4.0;Data Source=|DataDirectory|mydb.mdb;Persist Security Info=True”/>
</connectionStrings>
<system.web>
<customErrors mode=”Off”/>
<globalization culture=”IT-it” uiCulture=”IT-it”/>
</system.web>
</configuration>