breadboard

Tutti gli articoli con tag breadboard

ISArduino – Micro Robot Inseguitore solare con Arduino

Pubblicato da Luca Soltoggio in 29 febbraio 2012
Pubblicato in: Arduino, Progetti Arduino. Tag: , , , , , , . 77 commenti

Ecco qui un semplice inseguitore solare, realizzato con Arduino…
E’ solo una bozza, uno spunto da migliorare per creare nuovi progetti.
L’idea è molto semplice. Utilizzando due fotoresistenze (LDR), una che punta leggermente verso destra e l’altra leggermente verso sinistra, andiamo a leggerne i valori e muoviamo un servo a rotazione continua nella direzione della fotoresistenza che riceve più luce, finchè la luminosità non è circa uguale.
Il risultato finale è quello che vediamo nel seguente video:

Come potete vedere ho utilizzato Arduino Mini Pro come piattaforma, ma non cambia assolutamente nulla rispetto all’utlizzo con Arduino UNO. L’unica differenza è che nell’alimentare l’Arduino Pro Mini ho dovuto usare un regolatore esterno, perchè quello interno non è sufficiente per pilotare il servo.
Ma veniamo all’elenco dei materiali necessari:
1 – Una board Arduino UNO (o Duemilanove o qualsiasi altra board compatibile)
2 – Due fotoresistenze LDR da 20K (eventualmente con pochi aggiustamenti possono andare bene anche di altri valori)
3 – Due resistenze da 4.7K (eventualmente con condizione di luce differenti si possono usare valori differenti)
4 – Un servo a rotazione continua. (Difficili e/o costosi da trovare, ho modificato un servo standard seguendo le indicazioni che trovate a  uno di questo link (http://www.gioblu.com/tutorials/azionamenti/188-modifica-rotazione-continua-microservi oppure http://robodroid.wordpress.com/2011/12/29/micro-servo-a-rotazione-continua/ oppure ancora http://www.robot-italy.com/article_info.php?articles_id=1)
5 – Una batteria da 9V, una breadboard, dei supporti di plastica e poco altro

I componenti vanno collegati nel seguente modo ad Arduino:

Come vedete il tutto è molto molto semplice.
Se volete scaricare il file in formato fritzing, questo è il link.
http://fritzing.org/media/fritzing-repo/projects/i/isarduino-micro-robot-inseguitore-solare-con-ardui/fritzing/ISArduino.fzz
Veniamo ora al codice che è il seguente:

/*
ISArduino 0.1
Inseguitore Solare con Arduino
by Luca Soltoggio - 2012
https://arduinoelettronica.wordpress.com
*/

#include <Servo.h> 
#include <Narcoleptic.h>
/* 
Libreria che permette di mandare in standby il microcontrollore
nei momenti di inattività (delay), risparmiando parecchia energia.
Si può eventualmente anche non utilizzare (in tal caso va sostituita
l'ultima istruzione Narcoleptic.delay(15) con delay(15).
*/
 
Servo myservo;
int Value;
int Center=105; 
/*
La variabile Center rappresenta il valore di centratatura
del servo a rotazione continua. Nel mio caso è 105, di solito è 90. 
Con questo valore il servo deve restare fermo.
*/

void setup() { 
  Serial.begin(9600);
  myservo.attach(9); // Collega il servo al PIN 9
}

void loop() {
  int sensorValue = analogRead(A0);  // Legge il valore del sensore LDR di sinistra
  int sensorValue2 = analogRead(A1); // Legge il valore del sensore LDR di destra
  
  Value=(sensorValue-sensorValue2)/10;  
  /* 
  Calcola la differenza tra i due sensori e li divide per 10, 
  in questo modo una differenza di 10 equivale a 1, una differenza
  di 53 equivale a 5 e cosi via
  */
  
  if (Value==0) myservo.detach(); else myservo.attach(9); 
  /* 
  Se la differenza è uguale a 0 scollega il servo altrimenti lo 
  collega (serve per risparmiare energia)
  */
  
  if (Value>10) Value=10; 
  if (Value<-10) Value=-10;
  /* 
  Limita la differenza massima tra -10 e + 10
  (per evitare una velocità eccessiva)
  */
  
  Serial.println(Value); // Debug - Visualizza il valore sulla seriale
  myservo.write(Center+Value); 
  /* 
  Se il valore di Value è positivo, sposta il Servo a DX, se è negativo a SX.
  La velocità è direttamente proporzionale al valore assoluto di Value
  */
  
  Narcoleptic.delay(15);
  /* 
  Invece che usare un semplice delay, usiamo questo, così risparmiamo energia.
  Si può eventualmente sostituire con delay(15).
  */
}

Anche il codice è molto semplice ed autoesplicativo, quindi non mi dilungo più di tanto.
Se volete scaricare lo sketch per Arduino, lo trovate qui:
http://fritzing.org/media/fritzing-repo/projects/i/isarduino-micro-robot-inseguitore-solare-con-ardui/code/inseguitore_solare.ino

Qui di seguito trovate invece il link alla pagina Fritzing del progetto:
http://fritzing.org/projects/isarduino-micro-robot-inseguitore-solare-con-ardui/

Caricamento bootloader su Arduino standalone – Arduino UNO ISP

Pubblicato da Luca Soltoggio in 7 febbraio 2012
Pubblicato in: Arduino, Programmazione Arduino. Tag: , , , , , , , , , , , . 16 commenti

Nel post precedente abbiamo visto come programmare un Arduino in modalità standalone.
Uno dei requisiti era quello che il bootloader fosse già precaricato.
Ma se avessimo un Atmega328 vergine, oppure volessimo programmare il nostro micro per essere utlizzato senza un oscillatore esterno come dobbiamo fare?
Se abbiamo già un programmatore AVR, la cosa è semplicissima, e non la descrivo qui, anche perchè non tutti possediamo tale accessorio.
Vediamo quindi come usare la nostra Arduino UNO come programmatore ISP.
Si dice che con la UNO non sia possibile ma in realtà con un piccolo escamotage, è possibile bypassare il problema.
Non scoraggiatevi se ci sono problemi di sincronizzazione durante l’upload del bootloader, per ogni problema c’è la soluzione… ma vediamo la procedura.
Per prima cosa consiglio vivamente di utlizzare la versione 0022 dell’IDE di Arduino. Con la versione 1.0 sono riuscito saltuariamente e con difficolta.
Consiglio quindi di tenere le due installazioni del software installate. In una cartella la 1.0 e in un’altra la 0022. Possono coesistere entrambe senza darsi fastidio più di tanto l’una con l’altra.
Apriamo quindi l’IDE 0022 a carichiamo dai file di esempio lo sketch ArduinoISP. Questo esempio permette di trasformare la nostra board in un programmatore AVR. Una volta che l’upload è stato eseguito possiamo collegare la nostra UNO secondo il seguente schema:

Dobbiamo quindi collegare come in figura il pin 10 della UNO al pin RESET dell’Atmega, e i pin 11, 12, 13 ai pin 17, 18, 19 del microcontroller (o ai pin 11, 12, 13 di un’altra board Arduino).
Nello schema non è segnato, ma prima di procedere oltre dobbiamo assolutamente collegare un condensatore da 22uF tra il GND e il RESET della board Arduino altrimenti durante l’upload avverrà l’autoreset e l’IDE darà un errore di sync in fase di upload.
A questo punto possiamo tranquillamente selezionare dal menu Tools –> Board –> Arduino Duemilanove or Nano w/ ATmega328 e lanciare Burn Bootloader –> w/ Arduino as ISP e se tutto è stato eseguito correttamente dovremmo avere il nostro bootloader caricato sul microcontroller, pronto per essere programmato tramite seriale come indicato nel post precedente. La nostra Arduino UNO possiamo invece riprogrammarla normalmente (ricordiamoci di togliere il conensatore inserito precedentemente).
Ovviamente possiamo caricare il bootloader non solo su un Arduino standalone o su breadboard, ma anche su un’altra scheda Arduino UNO, 2009, Mini, ecc.
Se invece volessimo programmare la board con una configurazione minmale, senza oscillatore esterno?
La procedura è leggermente diversa perchè nelle Board predefinite dell’IDE non c’è una configurazione di questo tipo.
Va aggiunta manualmente quindi nel file boards.txt che si trova nella cartella di arduino (sotto hardware\arduino) la seguente configurazione:

##############################################################

atmega328bb.name=ATmega328 on a breadboard (8 MHz internal clock)

atmega328bb.upload.protocol=stk500
atmega328bb.upload.maximum_size=30720
atmega328bb.upload.speed=57600

atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0x05
atmega328bb.bootloader.path=arduino:atmega
atmega328bb.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F

atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
atmega328bb.build.core=arduino:arduino

##############################################################

A questo punto avremo uno schema tipo il seguente:

Ricordiamoci sempre di inserire il condensatore da 22uF tra GND e RESET, e verifichiamo che lo sketch ArduinoISP sia caricato sulla nostra board.
A questo punto possiamo caricare il bootloader selezionando Tools –> Board –> ATmega328 on a breadboard (8 MHz internal clock)
Se tutto va bene, dovremmo avere il nostro Atmega328 con il bootloader Arduino caricato e funzionante a 8Mhz. In questa modalità potremo alimentare il nostro circuito definitivo con 3.3V (se vogliamo) permettendo un consumo minore del nostro progetto.
Se l’upload a 16Mhz è andato a buon fine e quello a 8Mhz no, è perchè il primo caricamento di bootloader a 8Mhz va fatto con il circuito configurato ancora con il cristallo esterno, in quanto se togliamo l’oscillatore il circuito non è in grado di comunicare con il programmatore ISP. Successivamento ogni ulteriore caricamento può essere fatto senza il circuito oscillatore.
E qui anticipo una chicca che sarà oggetto del nostro prossimo post. Se io ho finito il mio progetto e quindi non mi serve più utilizzare il bootloader di Arduino (perchè non mi interessa più la possibilità di fare l’upload via seriale – vedi post precedente), posso fare l’upload dello sketch direttamente nella memoria dell’Atmega328 sovrascrivendo il bootloader. E per farlo devo semplicemente utilizzare gli stessi collegamenti visti qui sopra…
Ma per ora ci fermiamo e continueremo a parlarne nel prossimo post.

Arduino standalone (Arduino senza Arduino)

Pubblicato da Luca Soltoggio in 6 febbraio 2012
Pubblicato in: Arduino. Tag: , , , , , , , , , . 7 commenti

In questo post vorrei mostrare come utilizzare Arduino in configurazione standalone, ovvero utlizzare l’Atmega328 (munito di bootloader) in circuito senza dover portarsi dietro tutta la nostra board Arduino Uno (o quella che avete).
Il concetto è questo: ho finito il mio progetto con Arduino (ad esempio una con LED RGB) e sono pronto per realizzare la versione definitiva da inscatolare in una lampada.
Potrei si usare la board Arduino, ma sarebbe sconveniente sia dal punto di vista del costo, che dal punto di vista delle dimensioni e dei consumi… In realtà quello che a noi serve è semplicemente il microcontroller dotato di bootloader e pochi altri componenti esterni.
Se il nostro Atmega non ha il bootloader, dobbiamo caricarglielo, ma andiamo con ordine… Poniamo che al momento abbiamo già il bootloader onboard.
Per poter fare l’upload degli sketch dobbiamo utlizzare i collegamenti come indicato in figura:

E’ importante rimuove il microcontroller dalla scheda con cui andiamo a programmare, altrimenti programmeremmo quello al posto del nostro Atmega standalone.
Come vedete lo schema è molto semplice, si collega l’alimentazione, i pin TX e RX dei rispettivi microcontroller e il pin RESET.
A questo punto dal nostro Arduino IDE possiamo andare a fare l’upload dello sketch, dopo aver selezionato ovviamente “Arduino Duemilanove or Nano w/ ATmega328” dal menu Tools –> Board. E’ il gioco è fatto.
Ovviamente lo stesso discorso varrebbe se l’Atmega fosse programmato per lavorare con l’oscillatore interno a 8mhz. Con la differenza che non ci sarebbero i due condensatori e il cristallo indicati in figura. Per utilizzare però l’oscillatore interno, va riprogrammato il bootloader (lo vedremo nel prossimo post).
Qualora avessimo a disposizione (e vi consiglio di prenderlo perchè è un’accessorio che costa poco ed è veramente utile) un convertitore USB/Seriale tipo lo Sparkfun FTDI Basic o l’Arduino USB-Serial Light il collegamento sarebbe tipo il seguente:

Non è niente di complicato, semplicemente i collegamenti sono quasi come prima: VCC, GND, RX, TX, mentre il reset è un po’ diverso perchè richiede un condensatore da 100nF tra il PIN DTR (o RTS – da non confondere con RST) e il PIN RST dell’Atmega.
Abbiamo quindi visto come programmare un Atmega328 in standalone con il bootloader già preinstallato; nel prossimo post vedremo come caricare il bootloader su un’Atmega328 vergine sia in versione con cristallo esterno a 16mhz, sia in versione con oscillatore interno a 8mhz.