Home Tecnica Programmazione Arduracing: come realizzare una robot-car intelligente con Arduino

In evidenza

SMAU a Bologna con Research to Business

SMAU a Bologna con Research to Business

Il 6 e 7 giugno il Roadshow Smau Business torna a far tappa al Padiglione 33 della Fiera di Bologna e...
Gli articolisti del Portale

Gli articolisti del Portale

Abbiamo deciso di dare più visibilità a tutti coloro che hanno pubblicato articoli per noi, questo perché...
SMAU festeggia il suo quinto anno nel NordEst a Padova

SMAU festeggia il suo quinto anno nel NordEst a Padova

Il 18 e 19 aprile al padiglione 5 di Padova Fiere si terrà la prossima tappa di SMAU Business Roadshow. All'evento...
SMAU risale l’Italia e arriva a Roma

SMAU risale l’Italia e arriva a Roma

Il 21 e 22 marzo nella Nuova Fiera di Roma si terrà la prossima tappa di SMAU Business Roadshow. L'evento...

Bandi di Concorso

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Avviso per incarico ad ingegnere informatico alla Provincia di Bergamo

Nell'ambito del progetto denominato "SOS badanti: la rete provinciale di sportelli per assistenti e collaboratori familiari” nell'ambito del programma "SAP - Servizi alla Persona" è stato pubblicato la Provincia di Bergamo ha pubblicato l'avviso per il reclutamento di una unità per incarico di...

21 Mag 2012 - Letture:1

Esperto di servizi e tecnologie cloud al Digit PA

Procedura comparativa per il conferimento di un incarico di collaborazione coordinata e continuativa per un profilo senior di “Esperto di servizi e tecnologie cloud”, nell’ambito del progetto europeo “Open Dai” presso l' Ente nazionale per la digitalizzazione della Pubblica Amministrazione...

18 Apr 2012 - Letture:34

Selezione per addetto servizi informatici all'Autorità Portuale di Brindisi

Avviso di selezione pubblica per titoli e prova orale per l’assunzione di n. 1 “addetto ai servizi informatici”, a tempo pieno ed determinato triennale, previo periodo di prova, da inquadrare nell’Area Amministrativa. (Inquadramento al III Livello del C.C.N.L. dei Lavoratori...

12 Feb 2012 - Letture:435

Concorso pubblico per informatico alla Corte dei Conti

E' indetto un concorso pubblico, per   esami,   per   il reclutamento di tre unità di informatici da inquadrare nella III area, fascia retributiva F1, da destinare agli Uffici della Corte dei Conti con sede in Roma. Requisiti: laurea triennale in scienze e...

05 Feb 2012 - Letture:306

Istruttore informatico L.68/1999 al Comune di Potenza

Concorso pubblico, per esami, per la copertura di n. 2 posti di Istruttore Informatico, categoria C, posizione economica C1, a tempo pieno e indeterminato, con riserva assoluta alle categorie dilavoratori di cui all'art. 1 della legge n. 68/1999 (norme per...

21 Gen 2012 - Letture:244

Senior Business Consultant presso Lombardia Informatica

Selezione per figura Senior Business Consultant presso Lombardia Informatica. Il collaboratore dovrà fornire consulenza strategica e di business sulle tematiche verticali della Socio-Sanità. Requisiti di ammissione: Laurea in Ingegneria, Economia e Commercio o Scienze dell’Informazione; Percorsi di formazione professionale in ambito sanitario e socio-sanitario, su...

11 Gen 2012 - Letture:284

Bando progetto TAG (Toscana Area Giovani) per giovani talenti digitali

UPI Toscana ha indetto un avviso pubblico per la selezione di 20 giovani (2 per ciascuna delle 10 province della Toscana), da impiegare come formatori all'interno del Progetto TAG (Toscana Area Giovani). Il bando è finalizzato a valorizzare al meglio i...

03 Gen 2012 - Letture:271

I più attivi

Dati e punteggi dell'ultimo anno

Giovanna Casamassima Giovanna Casamassima
47 articoli
16,501 punti totali
Rodolfo Giometti Rodolfo Giometti
49 articoli
5,153 punti totali
Vittorio D'Aversa Vittorio D'Aversa
33 articoli
3,445 punti totali
Fulvio Lucchetti Fulvio Lucchetti
9 articoli
0,279 punti totali
Luigi Carbone Luigi Carbone
10 articoli
0,262 punti totali

Ci hanno visitato

Oggi:1284
Ieri:2110
Totali (14/04/09):1170459

I nostri numeri

Articoli pubblicati: 552
Iscritti al portale: 768
Iscritti all'Elenco: 184
Iscritti ML Discussioni: 351
Iscritti ML Articoli: 30
Iscritti ML Lavoro: 166
 

LIM: la lavagna multimediale con il wiimote

LIM sta per Lavagna Interattiva Multimediale, ed è un progetto che, tramite l'...

Multi puntatore su Ubuntu 10.4: ecco come

Tempo fa ebbi modo di dare un'occhiata al progetto MPX per un cliente. La cosa n...

Sabayon Linux 5.4 (32 e 64 bit)

E' stata rilasciata online la nuova versione 5.4 di Sabayon Linux, una tra ...

Mageia 1 alpha1 è tra noi

Finalmente è stata rilasciata la tanto attesa versione alpha1 principalmente riv...

Git in Eclipse

Chi mi conosce sa la mia avversione (del tutto personale, ci tengo a sottolinear...

SUN Wiki Publisher: scrivere facilmente su Wikipedia

Personalmente uso parecchio Mediawiki (il motore di Wikipedia); lo ritengo un ot...

Snom 870: il telefono con Linux

Definirlo solo telefono è sicuramente riduttivo, infatti lo Snom 870 è sicuramen...

Verificare spazio su disco su UNIX

Nella gestione si sistemi informativi capita spesso di accedere a postazioni ser...

L'SMS autoprodotto!

Tempo fa sulla mailing list di CFI ho provato a lanciare l'idea di effettuare un...

IPhone recupero file: un gioco di squadra!

Un giorno l'amico Armando Buzzanca mi chiama perchè deve recuperare una no...

GNU readline: un tool indispensabile per la linea di comando

Chiunque di voi abbia avuto a che fare con la linea di comando avrà senz'altro a...

Server Linux: tutti i trucchi per farlo al meglio

Volete fare un server Linux per la vostra impresa, ufficio o semplicemente per c...

Odroid: la piattaforma di gioco libera

Si chiama Odroid ed e basata su Android, è la prima piattaforma di gioco interam...

Come creare un NFS server ridondante

Quelli che mi conoscono sanno che il mio ambito lavorativo è nei sistemi embedde...

Installazioni di Linux su sistemi non convenzionali

Un'ottica convenzionale vede l'informatica come un insieme di applicazioni e sis...

Tenere i servizi sotto controllo con Monit

In questi giorni mi è capitato di dover risolvere un problema per un mio cliente...

Android-x86: quando il drone sbarca sui PC

Chi pensa che Andoird abbia vita bere farà bene a ricredersi perché, oltre alle ...

Cifratura wireless: TKIP vs AES

Una delle domande più frequenti di chi intende implementare una rete Wireless è...

Socat: quando i dati passano via rete

Lavorando coi sistemi embedded molte volte mi capita di dovermi arrangiare su di...

Nvidia 295.33, ecco i nuovi driver per linux versione 3.3

L'annuncio è di qualche giorno fa, Nvidia rilascia i nuovi driver 295.33 con sup...

Autenticarsi con la pen drive

La pen drive è ormai diventata come il cellulare, impossibile non averla, ma sie...

ettercap: il man-in-the-middle facile

Troppo spesso mi rendo conto che molti considerano la rete aziendale o quella ...

Geexbox: la mini distro MediaCenter Linux

Geexbox è un piccolo ma potente sistema operativo orientato alla riproduzione di...

SL4A e il drone parla più lingue

Chi come me non ama Java si sentirà a disagio volendo programmare una qualsiasi ...

Il settore danneggiato e l'acquisizione forense

Se si deve acquisire un hard disk in maniera forense, ossia con tutti i crismi n...

Virtualizzazione di Windows XP o altri SO su Ubuntu con Qemu

I pc odierni sono sempre più potenti e molto spesso sotto sfruttati, la virtua...

Programmare in C sull'N900

In questo articolo vedremo come sia semplice programmare in C sull'N900. In part...

Come gestire una presentazione con il Wiimote

Capitandomi spesso si tenere conferenze e workshop mi trovo sempre il problema d...

NBTempo: una GUI per le timeline

Svolgendo alcuni casi in cui serviva creare delle timeline per verificare l'att...

Compilare un programma C per Android

Essendo un programmatore C (uso anche altri linguaggi, ma il C e quello che uso ...

I-Memo: le password personali sempre con te

Prodotto dalla MensTecnica, una giovane azienda della Basilicata fondata nel 200...

Kameleon: oltre i limiti della virtualizzazione

Negli ultimi anni la potenza dei computer e la loro capacità è aumentata in modo...

Installare strace su Android

Quando si programma è importante avere buoni tool di debug e uno dei più importa...

"Impronte digitali" anche per le macchine fotografiche

Da www.hwupgrade.it: Una ricerca della Binghamton University ha messo a punto u...

Come saltare il proxy «blocca-tutto» aziendale

Mi capita spesso, ma non sempre, di andare da dei miei clienti e non potermi con...

Boxee Box: la TV facile di D-Link

Grazie alla D-Link possiamo presentare un nuovo gioiello della tecnologia: il me...

Clonare una macchina vera in 30 minuti con VirtualBox

Essendo uno sviluppatore mi son reso conto che la virtualizzazione di una macchi...

PyGTK su N900

Come programmatore avere un cellulare che in pratica è un computer (oramai il 10...

Multistrap: come ti creo un rootfs Debian dal nulla

Una volta c'era debootstrap, un tool fantastico che permetteva di creare un root...

Cloud Money

Discorrendo con un collega di cloud computing, si è finito, come al solito, a pa...

Il telefono… la tua voce!

Era lo slogan pubblicitario della Telecom di un po’ di anni fa. Certo, al concet...

Boot from SAN

Intendiamoci, non è l’ultima briciola tecnologica caduta da un banchetto alla NA...

Anomalie di partizionamento hard disk: un esperienza personale

Nonostante le decine di installazioni delle varie distribuzioni Linux eseguite s...

Linaro, la no-profit che produce distribuzioni Linux/ARM

Il progetto Linaro presentato nel 2010 da colossi del calibro di Freescale Semic...

Android: se non hai il telefono usa l'emulatore!

In questi giorni sto valutando di comprare un cellulare basato su Linux. Inizial...

Google +1: il «nemico» del «mi piace» di Facebook

Il tanto atteso nemico del "mi piace" targato Facebook è arrivato, il colosso de...

TurnKey Linux: accendi e vai!

Quanto tempo occorre per installare e configurare una macchina LAMP (Linux, Apac...

Installare Linux su una USB key: ecco come!

L’installazione  e l'avvio di una distribuzione Linux Live da un supporto U...

Generare un file pieno di 0xff

Per generare in file da 16Kbyte pieno di zeri su di un sistema UNIX/GNU-Linux si...

Cloud Computing: cos'è veramente?

Da qualche tempo si sente sempre più parlare di Cloud Computing. Sembra che ques...

Code Smells

Sempre più spesso il codice ha un cattivo odore. Sei sicuro di non scrivere cod...

Controllare MAME con Wiimote su N900!

Ecco un'altra dimostrazione delle potenzialità di questo telefono (se vogliamo c...

busybox & Android: la command line facile

Nei precedenti articoli abbiamo visto due tecniche per aggiungere nuovi programm...

F-Droid, e il FOSS su Android è servito!

Come Software Libre Evangelist mi son spesso trovato ad incoraggiare l'uso del s...

AVG Live CD Rescue: l'antivirus live!

Qualche giorno fa mi sono reso conto che in azienda sta per scadere la licenza d...

(in)sicurezza informatica

L'incremento nell'uso del computer ha portato con se una diversa concezione di s...

Universal USB Installer 1.8.04 e Ubuntu Linux 10.10

Rilasciata il 10.10(.2010) la nuova versione di Ubuntu Linux (la data corrispond...

Maemo extras: ancora più applicazioni per l'N900

Finalmente, grazie a Nokia, abbiamo a disposizione un esemplare dell'N900 su c...

Gimp, OpenOffice & C. su N900? Semplice con Debian!

Che Maemo fosse versatile me ne sono accorto subito, ma l'idea di poter installa...

Rete lenta? Vediamo chi consuma...

Molte volte capita di trovarsi la rete molto lenta e magari non abbiamo a dispos...

Arduracing: come realizzare una robot-car intelligente con Arduino Stampa E-mail
(5 voti, media 5.00 di 5)
Area Tecnica - Programmazione
Scritto da Matteo Lucchesi   
Mercoledì 30 Novembre 2011 17:54
Articolo letto 928 volte

arduracingArduracing è un progetto realizzato con Arduino in collaborazione con il Lucccalug che aspira alla creazione di una robot car in grado di muoversi autonomamente all’ interno di un circuito.

Il robot utilizza 4 sensori di distanza ad infrarossi per determinare la distanza dalle pareti laterali e frontali. Attraverso questi dati è in gradi di estrapolare la distanza e l’angolo delle curve. Il robot è in grado di sterzare e viaggiare a velocità variabile in avanti ed indietro. Il telaio è realizzato con il Lego. Il progetto è stato presentato durante il Linux Day 2011 a Lucca ed ha dato risultati soddisfacenti, sono ovviamente stati individuati degli errori di progettazione che sono espressi nella sezione conclusioni.

Principio di funzionamento

Il principio di funzionamento si basa sul seguente schema geometrico: posizionando due sensori di distanza paralleli alla vettura ai lati della stessa è possibile attraverso semplici formule goniometriche ricavare l'angolo di inclinazione della retta C, che non rappresenta altro che una linearizzazione del tratto di curva.

latex

Ovviamente avendo a disposizione le distanze d1 e d2 è possibile anche conoscere a che distanza si trova l'ostacolo oltre a conoscerne la sua inclinazione.

schema 1

Questo tipo di approccio permette al robot di differenziarsi da un classico line-follower in quanto è in grado di conoscere in anticipo le curve e quanto siano più o meno strette in modo di regolare la propria velocità o eseguire manovre correttive nel caso ad esempio che si trovi sul lato della pista corrispondente all'interno curva.

Casi particolari

Uno dei casi in cui l'argoritmo sopra espresso fallisce è espresso nella figura sottostante: In questo caso i due sensori "vedono" uno l'interno della pista e l'altro l'esterno. Sotto stimando l'angolo di sterzo necessario ad evitare l'interno curva.

Per ovviare a questo problema nell'esempio si calcola l'angolo utilizzando il sensore laterale destro ed il posteriore destro.

schema 2 

Un altro caso problematico si manifesta quando la parete interna è quasi parallela all'auto: in questo frangente si utilizzano i sensori laterali per evitare che l'auto sia avvicini troppo. Un ulteriore raffinazione dell'algoritmo sviluppato valuta non solo la distanza laterale ma anche la velocità di avvicinamento ai bordi in modo da poter sfruttare maggiormente la pista.

Hardware

  • 1 x Arduino UNO
  • 1 x Sparkfun Motor-Shield
  • 4 x sensori distanza sharp
  • 1 x servomotore
  • 4 x resistenze
  • 5 x condensatori
  • 1 x modellino LEGO

Filtri RC

Una prima analisi dei sensori di distanza ha evidenziato un notevole rumore sul segnale in uscita, per questo abbiamo deciso di costruire dei semplici filtri passa-basso passivi per ridurre le perturbazioni con una frequenza superiore a quella di taglio. Inoltre è stato connesso in serie all'alimentazione dei sensori un condensatore elettrolitico al fine di evitare una tensione di alimentazione instabile.Filtri RC

Telaio

Il telaio rappresenta la parte più complessa dal punto di vista realizzativo pratico e come meglio presentato nelle conclusioni, anche il punto di maggior debolezza del robot.

Per realizzarlo è stato utilizzato il LEGO e i veri componenti sono stati fissati a mezzo di banale colla a caldo.

Durante la sua realizazzione si sono manifestati diversi problemi: i principali sono stati gli attriti degli ingranaggi che generavano una quantità notevole di energia dissipata e lo sterzo in cui erano presenti innumerevoli "giochi". Per risolvere questi due problemi siamo ricorsi ad un motore che comprendesse già un rapporto di riduzione e lo sterzo è stato quanto più semplificato togliendo ad esempio il sistema di ammortizzatori, presente nella prima versione del robot.

Circuito di prova

Il circuito è realizzato per gran-parte in cartone, la base è stata realizzata con fogli di 100x80cm di spessore 3mm, mentre le pareti sono realizzate con delle bande ritagliate alte circa 30cm di cartoncino meno spesso.

Al fine di rendere la struttura più resistente agli urti del robot sono stati costruiti con materiale plastico e colla a caldo dei pilastri all'esterno delle pareti come evidente in foto.

Il software

La parte software è stata poco curata a causa dell'avvicinarsi dell'evento a cui dovevo presentare il progetto. In particolare non sono riuscito a sviluppare una funzione per "frenare" prima delle curve.

Le parti principali del codice verranno illustrate in una serie di articoli che gli dedicherò all'interno del mio blog. Di seguito è riportato il sorgente utilizzato per la dimostrazione:

 

#define sinistra 1
#define destra 0
#define avanti HIGH
#define indietro LOW
#define POT_MIN 110
#define N_misure 15
#define S 125
#define D 35
#define C 80

Servo myservo;                  // create servo object to control a servo
// a maximum of eight servo objects can be created
int pos = 90;
int pwm_a = 10;                 //PWM control for motor outputs 1 and 2 is on digital pin 10
int pwm_b = 11;                 //PWM control for motor outputs 3 and 4 is on digital pin 11
int dir_a = 12;                 //direction control for motor outputs 1 and 2 is on digital pin 12
int dir_b = 13;                 //direction control for motor outputs 3 and 4 is on digital pin 13
float AS, PD, AD, PS;
int dist_P_min, dist_P_max, dist_P_media, angolo_curva, dir_curva, inizio_curva;
int dist_A_min, dist_A_max, dist_A_media, rapporto;
int t;
int blocco = 0;

void setup()
{
// initialize the serial communication:
        Serial.begin(9600);
// initialize servo and motor-shield
        myservo.attach(9);
        pinMode(pwm_b, OUTPUT);
        pinMode(dir_b, OUTPUT);
// seti initial value for the motor
        digitalWrite(dir_b, HIGH);
        analogWrite(pwm_b, 0);
}

void aggiorna()
{
//vengono effettuate tutte le misure e ricalcolate le variabili
        AS = 0;
        AD = 0;
        PS = 0;
        PD = 0;
        int i = 0;
        for (i = 0; i < N_misure; i++) {
                AS += 2076.0 / (constrain(analogRead(A2), 80, 530) - 11.0);
                AD += 2076.0 / (constrain(analogRead(A4), 80, 530) - 11.0);
                PS += 9462.0 / (constrain(analogRead(A1), 80, 550) - 16.92);
                PD += 9462.0 / (constrain(analogRead(A3), 80, 550) - 16.92);
        }
        AS /= N_misure;
        AD /= N_misure;
        PS /= N_misure;
        PD /= N_misure;
        PD += 1.5;
        PD = constrain(PD, 0, 150);
        dist_P_min = min(PD, PS);
        dist_P_max = max(PD, PS);
        dist_P_media = (PD + PS) / 2;
        dist_A_min = min(AD, AS);
        dist_A_max = max(AD, AS);
        dist_A_media = (AD + AS) / 2;
        if ((PD - PS) > 0)
                dir_curva = 0;
        else
                dir_curva = 1;
        int angolo_curva_c = 9 - atan(abs(PD - PS) / 15.5) * (2 / 3.14) * 9;
        int angolo_curva_d = 9 - atan(abs(PD - 18) / AD) * (2 / 3.14) * 9;
        int angolo_curva_s = 9 - atan(abs(PS - 18) / AS) * (2 / 3.14) * 9;
//restituisce un valore da 0 a 10 per l'angolo
        if (AS < AD) {
                angolo_curva = max(angolo_curva_c, angolo_curva_s);
        } else {
                angolo_curva = max(angolo_curva_d, angolo_curva_c);
        }
}

void debug()
{
        Serial.print(AS);
        Serial.print("|");
        Serial.print(AD);
        Serial.print("|");
        Serial.print(PS);
        Serial.print("|");
        Serial.print(PD);
        Serial.print("|");
        Serial.println(angolo_curva);
}

void manuale()
{
        int a, b;
        if (Serial.available() > 1) {
                a = Serial.read();
                b = (Serial.read() - 48);
                switch (a) {
                case 'D':
                        sterzo(destra, b);
                        break;
                case 'S':
                        sterzo(sinistra, b);
                        break;
                case 'A':
                        motore(avanti, b, 0);
                        break;
                case 'R':
                        motore(indietro, b, 0);
                        break;
                }
        }
}

int stato()
{
//la funzione ritorna lo stato della vettura: 0 rettilineo, 1 curva, 2 collisione
        if (dist_P_min < 19 || dist_A_min < 5) {
                blocco++;
        } else
                blocco = 0;
        if (blocco > 25)
                return 2;
        if (dist_P_min > 35)
                return 0;
        else
                return 1;
}

void motore(boolean dir, int potenza, int angolo)
{
// la funzione compensa il maggior sforzo richiesto al motore con ruote sterzate e fissa il minimo della potenza
// la potenza deve avere un valore intero tra 0 e 10
        potenza = constrain(potenza, 0, 10);
        if (potenza != 0)
                potenza =
                    constrain(map
                              (potenza + angolo / 2 + 1, 1, 10, POT_MIN, 254),
                              POT_MIN, 214);
        digitalWrite(dir_b, dir);
        analogWrite(pwm_b, potenza);
//analogWrite(pwm_b, 0);
//Serial.println(dir);
}

void sterzo(int dir, int angolo)
{
        int a = 0;
// la funzione richiede in ingresso la direzione e l'angolo di sterzata
// l'angolo deve avere un valore tra 0 e 10
        angolo = constrain(angolo, 0, 10);
        if (dir == sinistra)
                a = map(angolo, 0, 10, C, S);
        if (dir == destra)
                a = map(angolo, 0, 10, C, D);
        myservo.write(a);
}

void sposta(int dir, int potenza, int tempo)
{
        motore(avanti, potenza, 4);
        if (dir == sinistra) {
                sterzo(sinistra, 4);
                delay(tempo);
                sterzo(destra, 4);
                delay(tempo);
                sterzo(sinistra, 0);
        }
        if (dir == destra) {
                sterzo(destra, 4);
                delay(tempo);
                sterzo(sinistra, 4);
                delay(tempo);
                sterzo(sinistra, 0);
        }
}

 

void loop()
{
        int x;
        aggiorna();
        float V_AS, V_AD;
        V_AS = AS;
        V_AD = AD;
        if (dist_P_min > 60) {
                delay(20);
                aggiorna();
                if (AD > V_AD - 0.2) {
                        sterzo(destra, (AD - V_AD) * 5);
                        delay(20);
                }
                if (AS > V_AS - 0.2) {
                        sterzo(sinistra, (AS - V_AS) * 5);
                        delay(20);
                }
        }
        switch (stato()) {
        case 0:
                motore(avanti, map(pow(dist_P_min / 10, 2), 0, 200, 1, 10), 0);
                if (AS < 6) {
                        sterzo(destra, 5);
                        break;
                }
                if (AD < 6) {
                        sterzo(sinistra, 5);
                        break;
                }
                if (AS < 7) {
                        sterzo(destra, 3);
                        break;
                }
                if (AD < 7) {
                        sterzo(sinistra, 3);
                        break;
                }
                if (AS < 8) {
                        sterzo(destra, 2);
                        break;
                }
                if (AD < 8) {
                        sterzo(sinistra, 2);
                        break;
                }
                if (V_AS > 14 && dir_curva == destra && angolo_curva > 5
                    && dist_P_min > 60)
                        sposta(sinistra, 1, 80);
                if (V_AD > 14 && dir_curva == sinistra && angolo_curva > 5
                    && dist_P_min > 60)
                        sposta(destra, 1, 80);
                sterzo(sinistra, 0);
                break;
        case 1:
//curva
//inizio_curva=((10-angolo_curva)*7)+5;
                if ((dir_curva == destra && AS < 9)
                    || (dir_curva == sinistra && AD < 9) || (dist_P_media < 41)
                    || (dir_curva == destra && PS < 27)
                    || (dir_curva == sinistra && PD < 27)) {
                        if (dist_P_media > 25) {
                                sterzo(dir_curva, angolo_curva);
                                motore(avanti,
                                       constrain((dist_P_min / 30) -
                                                 angolo_curva / 3, 1, 10),
                                       angolo_curva);
                        } else {
                                sterzo(dir_curva, 10);
                                motore(avanti, 1, 10);
                        }
                } else {
                        sterzo(sinistra, 0);
                }
                break;
        case 2:
//blocco
                motore(indietro, 1, 10);
                delay(30);
                if (dir_curva == sinistra)
                        sterzo(destra, 10);
                if (dir_curva == destra)
                        sterzo(sinistra, 10);
                while ((dist_P_min < 19) || (dist_A_min < 6)) {
                        aggiorna();
                }
                sterzo(sinistra, 0);
                motore(avanti, 1, 0);
                break;
        }
}

Messa in pista

Nel filmato seguente la prova in pista del robot:

Problemi

Personalmente mi ritengo molto soddisfatto del progetto anche se ha manifestato alcune lacune sotto elencate.

Durante la fase di test si sono evidenziati alcuni problemi che vado ad elencare in ordine di gravità.

Telaio poco rigido

Il telaio si è rivelato troppo poco rigido e durante i vari test ci si è spesso accorti che l'allineamento dei sensori non era corretto.

Sensori

Nonostante i filtri applicato il rumore sui sensori è ancora presente, una possibile soluzione sarebbe quella di comprare sensori di qualità maggiore.

Trasmissione

Pur avendo utilizzato al minimo il numero di ingranaggi LEGO, la trasmissione potrebbe essere migliorata utilizzando ingranaggi metallici ed inserito anche un differenziale.

differenziale

 
 

In primo piano

Simons Voss: un mondo senza chiavi

Simons Voss: un mondo senza chiavi

Il sistema di gestione e di controllo degli accessi 3060 si presenta come un’alternativa con enormi vantaggi...
Pubblicità mirata dei prodotti

Pubblicità mirata dei prodotti

Hai un prodotto o un servizio da pubblicizzare? Fallo su consulenti-ict.it! Pubblicizzare un prodotto...
Recensioni sul Portale

Recensioni sul Portale

Hai un prodotto hardware/software o un libro riguardante uno dei temi dell'ICT? Vuoi farlo conoscere...

Offerte di lavoro

Visualizza Topic »

Eventi

Non ci sono eventi in programma
Maggio 2012
D L M M G V S
29 30 1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31 1 2
Giugno 2012
D L M M G V S
27 28 29 30 31 1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30

Sondaggi

busyCaricamento Sondaggio...