Robot Beginner Kit – l’evoluzione

Qualche tempo fa ho pubblicato tre articoli su come costruire il tuo primo robot partendo da un kit in vendita su internet: Robot Beginner Kit.

beginner robot kit II

questo articolo è stato così tanto apprezzato che ho deciso di far evolvere il robot con una serie di tutorial che possano aiutarti a sviluppare qualcosa di più divertente con pochi componenti aggiuntivi.

Se non conosci il robot ecco i tre articoli su come costruirlo:

  1. Robot Beginner Kit con Arduino – il montaggio
  2. Robot Beginner Kit con Arduino – l’elettronica
  3. Robot Beginner Kit con Arduino – il primo sketch

La prima evoluzione riguarda la parte “cognitiva” del robot, lo sketch precedente si limitava a individuare l’ostacolo e a girare sempre nella stessa direzione:

con le modifiche che apporterai al robot potrai valutare da quale lato lo spazio di manovra è migliore e in funzione di questa informazione girare a destra o a sinistra, risparmiando manovre e batteria 🙂 Il divertimento dura di più.

Modifica Hardware

Ne ho fatte 2, la prima riguarda il sensore che ho posizionato su di un mini servo, puoi prendre quello che esce dallo starter kit di arduino o acquistarne uno.

Ho scelto un miniservo sia perché non ho bisogno di grande forza, il sensore pesa pochi grammi, sia perché in questo modo il sensore non si solleva troppo rispetto al robot, l’ideale sarebbe poterlo fissare alla base inferiore e non a quella superiore, lascio a te l’ulteriore modifica hardware.

beginner robot kit

La seconda modifica riguarda la disposizione delle schede e l’aggiunta di una mini breadboard, anche questa contenuta nello starter kit, il cui scopo è solo quello di fare da zoccolo per l’alimentazione non essendoci abbastanza pin per alimentare da arduino il servo, i motori ed il sensore:

beginner robot kit - alto

Lo sketch

/*
 * Beginner Robot Kit - II evoluzione cognitiva
 *
 * Autore: Mauro Alfieri
 * Tw: @mauroalfieri
 */

#include <Servo.h>

#define PWMA 3
#define PWMB 5
#define AIN1 4
#define AIN2 7
#define BIN1 8
#define BIN2 12
#define STBY 2

#define motoreA 0
#define motoreB 0
#define AVANTI  0
#define INDIETRO  0
#define SENSIBILITA 200
#define pinTesta 11

int SHIR = A5;
int grad[] = {90,0,180};
int distanza = 0;
int direzione = 0;

Servo testa;

void setup()
{
  pinMode( STBY,OUTPUT );
  pinMode( PWMA,OUTPUT );
  pinMode( PWMB,OUTPUT );
  pinMode( AIN1,OUTPUT );
  pinMode( AIN2,OUTPUT );
  pinMode( BIN1,OUTPUT );
  pinMode( BIN2,OUTPUT );

  pinMode( SHIR,INPUT );

  digitalWrite( STBY,HIGH );

  testa.attach(pinTesta);
  testa.write(90);
}

void loop()
{

  int dist = analogRead(SHIR);

  if ( dist > SENSIBILITA ) { 
    int direz = valutaDirezione();

    if ( direz == 1 ) { giraD(); }
    if ( direz == 0 ) { avanti(); }
    if ( direz == 2 ) { giraS(); }
  }
  else { avanti(); }

}
void avanti()
{
    digitalWrite( AIN1,HIGH );
    digitalWrite( AIN2,LOW );
    digitalWrite( BIN1,HIGH );
    digitalWrite( BIN2,LOW );

    analogWrite( PWMA,100 );
    analogWrite( PWMB,100 );
}

void indietro()
{
    digitalWrite( AIN1,LOW );
    digitalWrite( AIN2,HIGH );
    digitalWrite( BIN1,LOW );
    digitalWrite( BIN2,HIGH );

    analogWrite( PWMA,100 );
    analogWrite( PWMB,100 );
}

void alt()
{
    analogWrite( PWMA,50 );
    analogWrite( PWMB,50 );

    digitalWrite( AIN1,LOW );
    digitalWrite( AIN2,LOW );
    digitalWrite( BIN1,LOW );
    digitalWrite( BIN2,LOW );
}

void giraD()
{
  // STOP x 1/2 sec
  alt();
  delay( 500 );

  // INDIETRO x 1/2 secondo
  indietro();
  delay( 500 );

  // STOP x 1/2 sec
  alt();
  delay( 500 );

  // Gira Destra
  digitalWrite( AIN1,HIGH );
  digitalWrite( AIN2,LOW );
  digitalWrite( BIN1,LOW );
  digitalWrite( BIN2,HIGH );

  analogWrite( PWMA,100 );
  analogWrite( PWMB,100 );

  delay( 300 );
}

void giraS()
{
  // STOP x 1/2 sec
  alt();
  delay( 500 );

  // INDIETRO x 1/2 secondo
  indietro();
  delay( 500 );

  // STOP x 1/2 sec
  alt();
  delay( 500 );

  // Gira Sinistra
  digitalWrite( AIN1,LOW );
  digitalWrite( AIN2,HIGH );
  digitalWrite( BIN1,HIGH );
  digitalWrite( BIN2,LOW );

  analogWrite( PWMA,100 );
  analogWrite( PWMB,100 );

  delay( 300 );
}

int valutaDirezione() {
  alt();
  for ( int g=0; g<3; g++)
  {      
      testa.write( grad[g] );
      delay(1000);
      int val = analogRead(A5);

      if (distanza > val )
      {
        direzione = g;
      }
      distanza = val;
  }
  testa.write(90);
  return direzione;
}

Le modifiche fatto alla sketch riguardano un po’ tutto il listato, eccole linea per linea, non ti spiegherò le funzioni che già conosci o puoi rileggere negli articoli precedenti:

linea 08: includi la libreria Servo.h che utilizzerai per controllare il servo;

linea 11: modifica il pin a cui è collegato il PWMB, collegalo al pin 5 per non andare in conflitto con la libreria del servo;

linea 23: aggiungi la definizione del pin a cui colleghi il servo, io consiglio il pin 11;

linea 26: definisci un array di interi i cui valori indicano i gradi a cui il servo deve portarsi per eseguire le rilevazioni delle distanze;

linea 27-28: definisci due variabili di tipo integer assegnando il valore 0;

linea 30: inizializza un oggetto di tipo Servo, nell’esempio io l’ho chiamato testa in quanto ho immaginato che il sensore fosse posizionato sulla testa del robot 🙂

linee 46-47: indica all’oggetto testa quale è il pin a cui è collegato il servo (linea 46) e imposta a 90° ossia nella posizione centrale il servo con l’uso del metodo write;

La funzione loop() subisce una piccola modifica, all’interno dell’if che confronta la distanza tra robot ed oggetto rispetto al valore di SENSIBILITA impostato elimina il solo richiamo alla funzione gira e aggiungi le linee 56-60 il cui significato è:

linea 56: richiama una funzione nuova definita alle linee 150-166, il cui scopo è valutare la distanza di un oggetto secondo i punti in gradi definiti alla linea 26, vedrai cosa fa nelle prossime righe, per adesso ti interessa sapere che questa funzione ritorna un valore che può essere 0,1 o 2 secondo il lato con l’oggetto a maggiore distanza, quindi il lato verso cui dirigersi.

linea 58: se il risultato della linea precedente è 1 vuol dire che lo spazio maggiore, oggetto più lontano, è a destra e quindi richiama la dunzione giraD(), gira a destra;

linea 59: se il valore ritornato dalla linea 56 è 0 l’ostacolo più lontano è difronte, quindi va avanti;

linea 60: se il valore ritornato dalla linea 56 è 2 l’ostacolo più lontano è sainistra e quindi richiamo la funzione giraS(), gira a sinistra;

Le funzioni avanti(), indietro(), alt() restano invariate.

La funzione gira devi sdoppiarla ed a ciascuna copia aggiungere ina D ed una S nel nome, indicano Destra e Sinistra. Siccome il robot girava sempre a sinistra la giraS() resta invariata, mentre la giraD() vanno invertiti i comandi nelle linee 113-116 in modo che il robot possa girare a Destra.

La funzione cuore del nuovo sketch è la valutaDirezione() il cui compito è verificare in quale direzione far girare il robot in funzione della distanza che lo separa dall’oggetto più lontano:

linea 151: ferma i motori per eseguire la valorazione;

linea 152: inizia un ciclo di da 0 a 2 ( g < 3 ) in quanto la grandezza dell’array grad[] definito alla linea 26 è di 3 valori, se aggiungi più valori angolari ricordati di modificare la condizione del ciclo e il valore restituito;

linea 154: fa ruotare la testa del robot dei gradi definiti nell’array grad[ g ] dove g varia ad ogni ciclo;

linea 155: attende un secondo, prima di rilevare il valore, è un tempo arbitrario e ti serve per essere sicuro che il servo sia giunto in posizione e che la testa non stia vibrando evitando false misurazioni;

linea 156: verifica il valore rilevato dal sensore e lo immagazzina nella variabile val;

linea 158: confronta il valore della variabile distanza, la prima volta vale 0 come impostato alla linea 27, con val, il valore rilevato alla linea 156, se la distanza dell’oggetto è maggiore di quella rilevata la condizione è verificata;

linea 160: assegna alla variabile direzione definita alla linea 28, il valore dell’indica g in questo momento, sarà questo valore ad indicare alla funzione loop() in che direzione spostarsi, secondo queste regole:

  • g=0 -> grad[g]=90 -> davanti c’è l’oggetto più lontano;
  • g=1 -> grad[g]=0 -> a destra c’è l’oggetto più lontano;
  • g=2 -> grad[g]=180 ->  sinistra c’è l’oggetto più lontano;

linea 162: assegna il valore letto dal sensore alla variabile distanza questo comporta che al prossimo ciclo di for il valore distanza sarà quello letto al ciclo precedente, quindi il confronto alla linea 158 sarà tra la distanza rilevata al ciclo precedente e quella rilevata al ciclo attuale;

linea 164: posiziona la testa al centro, 90°;

linea 165: ritorna il valore impostato nella variabile direzione in modo che il loop(9 possa decidere dove spostare il robot.

Ecco un esempio del robot in azione:

Buon divertimento !!!

Cortesemente, prima di inserire i commenti leggi il regolamento

Permanent link to this article: http://www.mauroalfieri.it/elettronica/robot-beginner-kit-evoluzione.html

53 comments

Skip to comment form

    • Roberto on 29 luglio 2012 at 20:53
    • Reply

    Complimenti per come hai sviluppato l’idea Mauro (ti ricordi di me, no?), io avevo realizzato più o meno la stessa cosa ma non ho avuto il tempo di perfezionarla causa impegni universitari.

    Mi piacerebbe sapere dove è possibile trovare quelle piccole staffe metalliche, perché non sono riuscito a installare il microservo in modo stabile. Ho dovuto ricorrere a dell’orrendo nastro adesivo e non è decisamente una buona soluzione visto che non sono riuscito nemmeno a fissare in maniera decente il sensore.

    Grazie in anticipo, Roberto (:

    1. Ciao Roberto, certo che mi ricordo, è proprio dalla tua idea che sono partito.

      Le staffe in alluminio le ho realizzate io da una L in alluminio comprata in un brico, mi sembra che sia una 20x10mm, si vende in barre da 1m e costa 2/3 euro.

      Se fai evolvere il progetto in altre direzioni segnalamelo che pubblico volentieri altre evoluzioni.

      Mauro

    • andrea on 18 agosto 2012 at 13:21
    • Reply

    ciao scusa ma come hai fatto a guidarlo senza fili?cioè come è alimentato l’arduino?non dovrebbe essere collegato al cavo usb?

    1. Ciao Andrea,
      il beginner kit ha un proprio pacco batterie, se leggi gli articoli precedenti vedrai come è fatto e come montarlo e collegarlo ad arduino.

      L’idea di fondo è proprio di realizzare il tuo primo robot autonomo con questo kit della robot-domestici 🙂

      Se vuoi delle dritte sono a disposizione

      Mauro

    • Anto on 13 ottobre 2012 at 22:11
    • Reply

    Ciao, grazie alle tue istruzioni sono riuscito a costruire il beginner robot. Ho aggiunto però un alimentatore esterno perchè col pacco pile non aveva abbastanza potenza. Aggiunti poi dei led, un buzzer per dare voce al robottino, e un pulsante per avere la possibilità di fare girare diverse procedure senza il bisogno di dover di volta in volta uploadare i diversi programmi. Premendolo in qualsiasi momento si può cambiare la funzione che il robot deve eseguire. Ti mando il listato se può servire a qualcuno e mi scuso se ho spudoratamente copiato-incollato il tuo sketch e per le varie inesattezze che avro’ commesso ma non sono proprio del settore.

    ….

    Anto.

    1. Ciao Anto,
      grazie per il tuo prezioso contributo ho deciso di pubblicare il tuo lavoro
      ed ho scritto un articolo che potrai condividere anche con i tuoi amici su FaceBook
      mostrando cosa hai fatto e il tuo lavoro pubblicato su un Blog.

      Trovi l’articolo qui: http://www.mauroalfieri.it/elettronica/robot-beginner-kit-variante-di-anto.html

    • Franco on 16 ottobre 2012 at 18:43
    • Reply

    Ciao, ho realizzato il tuo interessantissimo progetto , ma c’è un problema che non riesco a risolvere: ho alimentato il rover con 4 batterie da 1,5 volt (tot 6 volt) ma il rover gira piano e sembra perdere subito potenza sebbene le batterie rimangono a 1,5 volt, infatti il problema lo fa anche utilizzando un alimentatore esterno da 6 volt. Aumentando la tensione di alimentazione a 9 volt la velocità del rover diventa accettabile (equiparabile a quella del filmato da te postato). Il problema è nella motor driver ? Che tensione misuri in uscita con motore collegato e non ? Grazie dell’info

    1. Ciao Franco,
      il problema che rilevi è dovuto all’alimentazione, il filmato è stato girato utilizzando un’alimentazione supplementare da 9v.
      Il RobotBeginner, per la sua natura di robot da primi passi, non ha la pretesa di essere velocissimo, quindi nello sketch io ho ridotto la velocità di motori regolando il PWM a 100, ma puoi aumentare questo valore fino a 255 secondo le tue esigenze di velocità, non sarà mai un robot da corsa 🙂

      Se vuoi iniziare con la programmazione dei robot ti consiglio di leggere bene l’articolo, ho decritto tutti i comandi dello sketch, questo kit è un’ottima base di partenza e puoi farci molti esperimenti se comprendi i come è programmato.

      Mauro

    • Gilberto on 6 dicembre 2012 at 16:09
    • Reply

    Grazie Alfieri per le istruzioni sempre chiarissime
    Ho realiazato il robot beginner seguendo le istruzioni quasi senza problemi mi era solo sfuggita questa istruzione “linea 11: modifica il pin a cui è collegato il PWMB, collegalo al pin 5 per non andare in conflitto con la libreria del servo;” e non riuscivo a capire perche’ nel robot funzionava un solo dopo aver montato il servo. Ma spesso ci si limita leggere parzialmente anche se il ci interessa il contenuto.
    Ho apportato alcune modifiche al robot.
    1) ho montato il servo su cui e’ montato il sensore inclinato di circa 60 gradi perche il mio servo con angolo 0 li braccio risultava non perpendicolare al servo e non sono riuscito a fare compiere rotazioni negative al servo.
    2) Ho messo due batterie da 9V ricaricabili in parallelo al posto di quelle fornite con il kit in quanto stilo 4 AA in serie non mi fornivano una tensione sufficiente per fare funzionare il tutto in modo soddisfacente.
    3) Ho inserito due led a infrarossi e utilizzati come sensore di distanza quando il roboot procedeva a marcia indietro per evitare che urtasse ostacoli anche se la marcia indietro era temporizzata.
    4) Ho carenato il robot utilizzando i pezzi del meccano che usavo per giocare quando ero piccolo.
    5) Ho inserito alcuni paraurti in gomma sia davanti che dietro per attutire gli eventuali urti anche se con il sensore davanti motorizzato e quello dietro sono veramente pochi ma a volte il robot urta oggetti.
    6) Ho modificato le velocita’ dei motori inserendo delle costanti per differenziare marcia avanti, marcia indietro , e gira.

    Allego il codice modificato

    #include

    #define PWMA 3
    #define PWMB 5
    #define AIN1 4
    #define AIN2 7
    #define BIN1 8
    #define BIN2 12
    #define STBY 2

    #define SENSIBILITA 300
    #define SENSIBILITA1 300

    #define pinTesta 11

    // sensore dietro
    #define irEmitter 13 // polo positivo emettitore
    #define irReceiverN 6 // polo negativo ricevitore
    #define irReceiverP 10 // polo positivo ricevitore
    long distance = 0;
    int interval = 0;
    //

    int SHIR = A5;

    int grad[] = {30,70,130};
    int distanza = 0;
    int direzione = 0;

    int vavanti=180;
    int vindietro=130;
    int vgira=100;
    int t=50; //ritardo

    Servo testa;

    void setup()
    {
    pinMode( STBY,OUTPUT );
    pinMode( PWMA,OUTPUT );
    pinMode( PWMB,OUTPUT );
    pinMode( AIN1,OUTPUT );
    pinMode( AIN2,OUTPUT );
    pinMode( BIN1,OUTPUT );
    pinMode( BIN2,OUTPUT );

    pinMode( SHIR,INPUT );

    digitalWrite( STBY,HIGH );
    testa.attach(pinTesta);

    testa.write(grad[1]);

    Serial.begin( 9600 );
    // sensore dietro

    pinMode(irEmitter, OUTPUT); // il led emettitore è un output
    pinMode(irReceiverP, OUTPUT); // il polo positivo del let ricevitore è un output
    digitalWrite(irReceiverP, LOW); // e deve essere LOW

    }

    void loop()
    {
    int dist = analogRead(SHIR);

    if (dist >SENSIBILITA)

    {

    int direz = valutaDirezione();

    if ( direz == 1 )
    {
    giraD();
    }
    if ( direz == 0 )
    {
    avanti();

    }
    if ( direz == 2 )
    {
    giraS();
    }

    }
    else
    {
    avanti();
    }
    }

    void avanti()
    {
    Serial.print( “avanti”);
    Serial.print( ” “);
    Serial.print( analogRead(SHIR) );
    Serial.println( “”);

    digitalWrite( AIN1,HIGH );
    digitalWrite( AIN2,LOW );
    digitalWrite( BIN1,HIGH );
    digitalWrite( BIN2,LOW );

    analogWrite( PWMA,vavanti );
    analogWrite( PWMB,vavanti );
    }

    void indietro()
    {
    Serial.print( “indietro”);
    Serial.print( ” “);
    Serial.print( analogRead(SHIR) );
    Serial.println( “”);

    focus(115);
    focus(115);
    focus(115);

    Serial.print( “sensore dietro”);
    Serial.print( ” “);
    Serial.print( distance);
    Serial.println( “”);
    if (distance>7000)
    {
    gira();
    }
    else
    {
    digitalWrite( AIN1,LOW );
    digitalWrite( AIN2,HIGH );
    digitalWrite( BIN1,LOW );
    digitalWrite( BIN2,HIGH );

    analogWrite( PWMA,vindietro );
    analogWrite( PWMB,vindietro );
    }
    }

    void alt()
    {
    Serial.print( “alt”);
    Serial.print( ” “);
    Serial.print( analogRead(SHIR) );
    Serial.println( “”);

    analogWrite( PWMA,50 );
    analogWrite( PWMB,50 );

    digitalWrite( AIN1,LOW );
    digitalWrite( AIN2,LOW );
    digitalWrite( BIN1,LOW );
    digitalWrite( BIN2,LOW );
    }

    void giraD()
    {
    Serial.print( “gira des”);
    Serial.print( ” “);
    Serial.print( analogRead(SHIR) );
    Serial.println( “”);
    // STOP x 1/2 sec
    alt();
    delay( 500 );

    // INDIETRO x 1/2 secondo
    indietro();
    delay( 500 );

    // STOP x 1/2 sec
    alt();
    delay( 500 );

    // Gira
    digitalWrite( AIN1,HIGH );
    digitalWrite( AIN2,LOW );
    digitalWrite( BIN1,LOW );
    digitalWrite( BIN2,HIGH );

    analogWrite( PWMA,vgira );
    analogWrite( PWMB,vgira );

    delay( 300 );
    }

    void giraS()
    {
    Serial.print( “gira sin”);
    Serial.print( ” “);
    Serial.print( analogRead(SHIR) );
    Serial.println( ” “);

    // STOP x 1/2 sec
    alt();
    delay( 500 );

    // INDIETRO x 1/2 secondo
    indietro();
    delay( 500 );

    // STOP x 1/2 sec
    alt();
    delay( 500 );

    // Gira Sinistra
    digitalWrite( AIN1,LOW );
    digitalWrite( AIN2,HIGH );
    digitalWrite( BIN1,HIGH );
    digitalWrite( BIN2,LOW );

    analogWrite( PWMA,vgira );
    analogWrite( PWMB,vgira );

    delay( 300 );
    }

    void gira()
    {
    Serial.print( “gira”);
    Serial.print( ” “);
    Serial.print( analogRead(SHIR) );
    Serial.println( ” “);

    // STOP x 1/2 sec
    alt();
    delay( 500 );

    // Gira Sinistra
    digitalWrite( AIN1,LOW );
    digitalWrite( AIN2,HIGH );
    digitalWrite( BIN1,HIGH );
    digitalWrite( BIN2,LOW );

    analogWrite( PWMA,vgira );
    analogWrite( PWMB,vgira );

    delay( 300 );
    }

    int valutaDirezione()
    {
    alt();
    for ( int g=0; g val )
    {
    direzione = g;
    }
    distanza = val;
    }

    testa.write(grad[1]);

    return direzione;
    }

    void focus(int focusPoint)
    {
    interval = focusPoint;
    distance = readLight(true) – readLight(false);
    if(distance < 0) distance = 0;
    // processing
    Serial.println(distance);
    }

    double readLight(boolean lightOn)
    {
    digitalWrite(irEmitter, lightOn ? HIGH : LOW);
    pinMode(irReceiverN, OUTPUT);
    digitalWrite(irReceiverN, HIGH); //carico ricevitore di induttanza
    long reading = 0;
    pinMode(irReceiverN, INPUT);
    digitalWrite(irReceiverN, LOW);
    long lightTime = millis();
    while((millis() – lightTime) < interval)
    if(digitalRead(irReceiverN) == 0)
    reading++;

    return reading;
    }

    Al momento non riesco a fotografare il robot in quanto e’ smontato sto utilizzando l’arduino leonardo 328 che pilo tava il robot per pilotare le luci dell’albero di natale e mandato il robot in ferie natalizie forzate.

    Distintamente saluto e ringrazio per le lezioni sempre chiarissime che mi hanno aiutato a scoprire arduino.

    1. Ciao Gilberto,
      sei eccezionale !!!
      Hai non sono eseguito delle modifiche al software facendo evolvere il tuo Robot Beginner, ma lo hai anche dotato di scocca.
      Non vedo l’ora di vedere le foto e se vorrai gli dedicherò un articolo, lo meriti.

      Mauro

    • claudio franzan on 7 gennaio 2013 at 21:08
    • Reply

    salve mauro, seguendo i suoi articoli ho montato il robot in kit, e funziona bene,mio figlio di 7 anni ne e’ entusiata.Ora volevo inserigli una musichetta, ma dopo varie prove (sono un dilettante all’inizio) l’ide mi da’ sempre errore,mi da’ un consiglio?

    comunque, grazie a lei e al suo progetto ho imparato ad amare arduino.

    1. Ciao Claudio,
      mi permetto di darti del tu, come faccio con tutti gli appassionati, anche perchè se hai un figlio di 7 anni forse siamo coetanei o quasi.
      Mi fa piacere che ti sia appassionato ad Arduino grazie ai miei articoli.

      Che tipo di errore ti da l’IDE?
      Hai usato il codice suggerito nel mio tutorial sui suoni con arduino per aggiungere la musica?
      Anche se hai usato altro codice, scrivimelo, se hai usato il mio è più semplice xchè lo conosco.

      Ti chiedo di non pubblicarmi tutto il codice che hai scritto ma solo le parti che ti restituiscono errore.

      Mauro

    • Lorenzo on 18 maggio 2013 at 21:43
    • Reply

    Ciao Mauro!! Son ancora qui ad interrogarti! ho bisogno di alcuni chiarimenti: 1) il mio servo motore gira prima a sinistra e poi a destra. quindi ho pensato di invertire le righe 58 e 60 del tuo sketch, è corretto? 2) il pin L di arduino se alimentat con batterie, anche da 9 V, lampeggia a scatti, e riavvia ogni volta lo sketch! quale potrebbe essere il problema!
    Grazie in anticipo!
    Buona domenica!
    Lorenzo

    1. Ciao Lorenzo,
      io invertirei la sequenza dei gradi da 0,90,180 in 180,90,0
      Agisci sulla rotazione del servo non sulla valutazione.

      Potresti anche solo invertire il servo sulla basetta 🙂
      Mauro

    • arnaldo on 26 maggio 2013 at 10:45
    • Reply

    Ciao Mauro,
    nel Robot che grazie alle tue splendide spiegazioni sono riuscito a far funzionare bene ( ho sostituito al driver dei motori una shield RV3 ) vorrei inserire un Line Follower Parallax che ho visto sul sito di Robot-Domestici.
    Come integrare lo sketch con questo elemento?
    Puoi darmi qualche indicazione?
    Grazie Mille.
    Arnaldo

    1. Ciao Arnaldo,
      sono contento che tu ci sia riuscito e è abbia eseguito anche la modifica di un componente da solo, é indice che hai capito come funziona e sei diretto verso nuove idee e progetti.

      Il line-follower non l’ho ancora provato e non saprei darti info sul suo funzionamento, immagino che ti restituisca un segnale per ognuno dei 4 sensori da cui puoi determinare se la linea sia più vicina a destra o sinistra e correggere il tuo moto.

      Mauro

    • Federico on 20 giugno 2013 at 12:33
    • Reply

    Ciao,
    Mi puoi dare il link del servomotore 180 gradi? Perché ho visto sullo store di Arduino e sono finiti.
    E poi un’altra cosa: se volessi utilizzare il sensore che usi te (5v)+ srf05 ad ultrasuoni (5v) + i motori del robot + il servo motore, come da te illustrato, ce la faccio ad alimentare il tutto con 9 v?
    Grazie

    1. Ciao Federico,
      il materiale io solitamente lo acquisto su robot-domestici, dove trovi anche il mio kit da assemblare.
      Per l’alimentazione i 9v vanno bene per alimentare arduino ed i motori ma il servo dovresti alimentarlo a 6v se ci vai diretto ed il sensore SRF05 a 5v.
      Puoi prelevare i 5v da Arduino per alimentare dia il sensore sia il servo, tuttavia non credo che la corrente che transita da arduino ti sia sufficente per alimentare entrambi.

      Mauro

    • Federico on 20 giugno 2013 at 21:41
    • Reply

    Potrebbe andare bene questo servo per fare il progetto come l’hai fatto te ? http://www.robot-domestici.it/joomla/component/virtuemart/robotica-domotica/servomotori/servo-small
    Il resto del robot l’ho già costruito, adesso devo farlo evolvere 🙂

    1. Ciao Federico,
      non l’ho provato ma mi sembra indicato per il tuo beginner kit.

      Mauro

    • Alb on 10 luglio 2013 at 12:44
    • Reply

    Che alimentazione hai usato? 9v + 6v ?
    Il servo motore quanta energia necessita?
    Secondo te se si collega il sensore direttamente a 6 volt non si danneggia? e come si collega visto che c’è solo il cavetto rosso di alimentazione ?
    Grazie

    1. Ciao Alb,
      io ho utilizzato i 6v del pacco batterie fonito al tempo con il Beginner Kit, poi ho chiesto a robot-domestici di sostituire il pacco con uno a 6 pile da 1,5v = 9v nei modelli venduti da un mese ad oggi.
      In ogni caso per il sensore ed il servo utilizzo i 5v di Arduino.
      Il servo che ho usato è piccolo e ce la fa senza problemi, se cambi il servo dovrai alimentarlo a 6v diretto dalle pile.

      Mauro

        • Alb on 10 luglio 2013 at 17:15
        • Reply

        Mi dici che servo utilizzare , e dove l’hai comprato?
        Mi dai il link?

        1. Ciao Alb,
          il servo l’ho acquistato con uno degli starter kit della robot-domestici.it
          Puoi prendere uno dei microservo che vendono se non vuoi acquistare tutto il kit.

          Mauro

    • Rob on 19 novembre 2013 at 22:16
    • Reply

    Ma se dovessi alimentare il servo che fa girare il sensore con 9 v diretti invece che con 5v rischia di bruciarsi o posso farlo ?

    1. Ciao Rob,
      i servo di solito funzionano a 4,8v o 6v per alcuni modelli.
      9v di certo lo brucia, magari non subito ma dopo qualche secondo di utilizzo.

      Mauro

    • Maurizio on 17 febbraio 2014 at 06:20
    • Reply

    Ciao Mauro, ho acquistatio io robot beginner per progettare la tesina per il diploma.
    Vorrei anche io evolvere il mio robot con un mini servo.
    non ho capito quale servo è ideale da utilizzare e come alimentare il tutto

    1. Ciao Maurizio, ottimo progetto per iniziare con la robotica, io ho usato un mini servo che h preso dallo starter kit che uso per i corsi online, in generale usa un mini servo di quelli che trovi su robot-domestici, vanno bene tutti.

      L’alimentazione esterna dei servo puoi leggerla in un mio articolo sui servo e l’alimentazione di qualche settimana fa.

      Mauro

    • Maurizio on 17 febbraio 2014 at 09:56
    • Reply

    grazie per tutto.
    comunque posso alimentare il tutto con una sola pila da 9 volt invece di acquistare una slot da 6 ??

    1. Ciao Maurizio,
      fai attenzione a quanti Volt invii al servo.
      I servo che uso io lavorano da 4,8 a 6v max

      Mauro

    • Maurizio on 17 febbraio 2014 at 12:09
    • Reply

    io intendo a dare i 9 volt all’Arduino, capace di alimentare il tutto.
    6 volt sono insufficienti per alimentare servo ecc..

    • Maurizio on 17 febbraio 2014 at 14:10
    • Reply

    forse devo collegare i 9V ad Arduino
    più 6 volt a parte dedicati per il servo
    giusto ?

    1. Certo Maurizio.

      Mauro

    • Maurizio on 17 febbraio 2014 at 17:24
    • Reply

    Devo seguire questo schema?
    http://www.mauroalfieri.it/elettronica/tutorial-arduino-servo-con-alimentazione-esterna.html#
    Se è si, come collego il positivo e il negativo allo slot pile??

    1. Ciao Maurizio,
      puoi usare due fili saldati direttamente al connettore di alimentazione arduino.

      Maur

    • Maurizio on 20 febbraio 2014 at 06:36
    • Reply

    ciaoooooooo
    comunque volevo dirti che ho preso il tutto
    Un servo molto piccolo in modo da alimentarlo con i 5v di Arduino a sua volta alimentato da una batteria a 9 volt.
    devi spiegarmi solo come hai fatto a mettere il sensore in modo stabile sul servo

    1. Ciao Maurizio,
      bravo, io ho usato un pezzo di alluminio a L, come vedi nelle foto, forato e legato con del fil di ferro, dire stabile è un azzardo, ma funziona.

      Se non ricordo male su robot-domestici c’è una staffa per il sensore fatta a posta.

    • Maurizio on 20 febbraio 2014 at 19:46
    • Reply

    Ciao Mauro. mi funziona tutto, c’è solo un problema…
    La ruota sinistra non va, gira solo quella destra…
    Se inserisco il codice precedente partono tutti e due
    Come mai??

    1. Ciao Maurizio, ti ho risposto all’altro commento, penso sia questione di alimentazione insufficiente.

    • Maurizio on 21 febbraio 2014 at 08:27
    • Reply

    Ma anche quando lo collego al pc, non parte…
    Non credo sia un problema di alimentazione

    1. Ciao Maurizio,
      io per fugare ogni dubbio proverei con una alimentazione esterna.
      Se il comportamento non cambia dovrai indagare nel codice o sul corretto funzionamento dei componenti.

      Mauro

    • Maurizio on 1 marzo 2014 at 23:24
    • Reply

    Salve Mauro, volevo dirti che il mio progetto sta andando avanti; ho risolto tutti i problemi.
    Ora vorrei renderlo mio… ho acquistato un modulo bluethoot hc 06.
    Una volta che lo collego, posso utilizzare qualsiasi applicazione da android?? E il codice può essere simile al modulo IR e il telecomando?

    1. Ciao Maurizio,
      non ho ancora provato le shield bluetooth ma dubito che siano simili al controllo IR.
      Il Bluetooth è più simile al collegamento seriale.

      Mauro

    • Maurizio Grieco on 3 marzo 2014 at 14:41
    • Reply

    Secondo te funziona bene il modulo hc06?
    Non è una shield
    Funziona seriale
    La piedinatura è TX, Rx, GND, 5V

    1. Ciao Maurizio,
      non lo conosco, non l’ho mai provato 🙁

    • Maurizio Grieco on 3 marzo 2014 at 20:02
    • Reply

    Grazie di tutto
    Mi hai dato un enorme mano per la mia tesina

    1. Bene Maurizio,
      sono contento.

    • Maurizio on 29 aprile 2014 at 21:07
    • Reply

    Ciao Mauro volevo dirti che ho terminato il mio progetto.
    l’ho comando io da smartphone utilizzando una apk.
    gestisco anche i fari e il clacson con un cicalino.
    nonostante il controllo remoto evita ugualmente gli ostacoli per gente distratta.

    1. Bellissimo Maurizio,
      se ti va di condividere il progetto pubblicando foto, video, schemi e descrizione dei passaggi e del sw il blog è a tua disposizione.
      Inviami tutto il materiale con la descrizione alla casella info del blog.

    • Federico on 2 maggio 2014 at 18:51
    • Reply

    *************IMPORTANTE PER TUTTI !********************
    utilizzando un servo, il controllo dei motori normali con pwm subisce delle variazioni:

    “On boards other than the Mega, use of the library disables analogWrite() (PWM) functionality on pins 9 and 10, whether or not there is a Servo on those pins. On the Mega, up to 12 servos can be used without interfering with PWM functionality; use of 12 to 23 motors will disable PWM on pins 11 and 12.”
    [ http://arduino.cc/en/Reference/Servo ]

    Lo stesso problema con un ir led che non permetterà il controllo pwm di alcuni pin:

    “Finally, as to solving your problem, I would personally go the route of not using pins 11 and 3 (timer2). Yes it will require a small rewiring, but that way you can free up timer2 for the IR library to use.”

    [ http://stackoverflow.com/questions/18705363/arduino-uno-pwm-pins-conflict ]

    Mauro,sarebbe meglio se scrivessi un appunto su ogni pagina di robotica del sito con arduino, perchè è un problema ricorrente e di difficile individuazione !

    1. Ciao Federico,
      grazie per la segnalazione.
      Ho trattato l’argomento Timer in un apposito articolo che puoi leggere sul blog.

      Infatti troverai che spesso nei progetti in cui utilizzo i servo e motori in PWM evito di incrociare i pin con medesimo Timer per i due utilizzi.

    • Luca on 9 giugno 2014 at 19:44
    • Reply

    ma il circuito come è stato modificato???
    potete mettere un’immagine di fritzing o mettete delle immagini dove si possano capire tutti i collegamenti???

    1. Ciao Luca,
      chiedo all’autore di questa evoluzione se può inviarmi uno schema in modo che io possa pubblicarlo.
      Nell’attesa prova a ricavare i collegamenti dallo sketch e se riesci inviami il tuo contributo per la pubblicazione.

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.