next topic »

[on:]

Salve a tutti, son un giovane studente universitario alle prese con un semplice progetto .Ciò che vorrei fare per iniziare è avere una base con due motori controllati con la scheda di arduino ed un ponte h (l 293d   credo possa andare bene)....leggendo i vari forum e articoli su internet credo di aver capito perfettamnte come realizzare il controllo dei 2 motori come collegarli alla sheda, ed il programmino per farli girare avavnti o indietro.
Ciò che invece non mi è molto chiaro riguarda i sensori da utilizzare per rilevare gli ostacoli, e come programmarli per far tornare indietro il robot nel momento in cui si trova davanti  un ostacolo.
So che si può fare in molti modi e con vari tipi di sensori (luce, ultrasuoni, IR....ecc)ma non essendo un bravo programmatore ed avendo ancora solo basilari nozioni di elettronica avrei bisogno di qualche suggerimento per realizzare il tutto nella maniera più semplice possibile, o meglio se cè qualche tutorial di un progetto simile ad hoc con relativo sketch o esempio in modo da partire da una buona base ...grazie  a tutti...

[Reply #1 on:]

Se usi per sensori due micro switch a baffo forse ho un piccolo codice che potebbe essere utile.....

[Reply #2 on:]

ciao...non conosco questo tipo di sensori...di cosa si tratta?

[Reply #3 on:]

sono dei semplici bottoni con una forma particolare  a cui si attaca una resistenza da 10K e si crea così un sistema push pull in modo da mandare al micro gli stati logici 0-1 un secondo e cerco in rete uno schema...

[Reply #4 on:]

nn riesco a inserire l'immagine........ mandami la mail in privato che te lo mando

[Reply #5 on:]

Ringrazio Alessandro, ma se qualcuno ha suggerimenti per quanto riguarda sensori ad ultrasuoni, Ir o fotoresistenze sono molto graditi....

[Reply #6 on:]

ho trovato una cosa... x gli SFR05.....
larryBot v0.1-05 Arduino Robot Sketch
const int numOfReadings = 10;                   // number of readings to take/ items in the array
int readings[numOfReadings];                    // stores the distance readings in an array
int arrayIndex = 0;                             // arrayIndex of the current item in the array
int total = 0;                                  // stores the cumlative total
int averageDistance = 0;                        // stores the average value
// setup pins and variables for SRF05 sonar device
int echoPin = 12;                               // SRF05 echo pin (digital 2)
int initPin = 13;                               // SRF05 trigger pin (digital 3)
unsigned long pulseTime = 0;                    // stores the pulse in Micro Seconds
unsigned long distance = 0;                     // variable for storing the distance (cm)
int motor1Pin1 = 3;                             // pin 2 on L293D
int motor1Pin2 = 4;                             // pin 7 on L293D
int enable1Pin = 9;                             // pin 1 on L293D
int motor2Pin1 = 5;                             // pin 10 on L293D
int motor2Pin2 = 6;                             // pin  15 on L293D
int enable2Pin = 10;                            // pin 9 on L293D
void setup() {
  // set the motor pins as outputs:
  pinMode(motor1Pin1, OUTPUT);
  pinMode(motor1Pin2, OUTPUT);
  pinMode(enable1Pin, OUTPUT);
  pinMode(motor2Pin1, OUTPUT);
  pinMode(motor2Pin2, OUTPUT);
  pinMode(enable2Pin, OUTPUT);
  // set enablePins high so that motor can turn on:
  digitalWrite(enable1Pin, HIGH);
  digitalWrite(enable2Pin, HIGH);
  pinMode(initPin, OUTPUT);                     // set init pin 3 as output
  pinMode(echoPin, INPUT);                      // set echo pin 2 as input
  // create array loop to iterate over every item in the array
  for (int thisReading = 0; thisReading < numOfReadings; thisReading++) {
    readings[thisReading] = 0;
  }
}
void loop() {
  digitalWrite(initPin, HIGH);                  // send 10 microsecond pulse
  delayMicroseconds(10);                                // wait 10 microseconds before turning off
  digitalWrite(initPin, LOW);                   // stop sending the pulse
  pulseTime = pulseIn(echoPin, HIGH);           // Look for a return pulse, it should be high as the pulse goes low-high-low
  distance = pulseTime/58;                      // Distance = pulse time / 58 to convert to cm.
  total= total - readings[arrayIndex];          // subtract the last distance
  readings[arrayIndex] = distance;              // add distance reading to array
  total= total + readings[arrayIndex];          // add the reading to the total
  arrayIndex = arrayIndex + 1;                  // go to the next item in the array
  // At the end of the array (10 items) then start again
  if (arrayIndex >= numOfReadings)  {
    arrayIndex = 0;
  }
  averageDistance = total / numOfReadings;      // calculate the average distance
  delay(10);
  // check the average distance and move accordingly
  if (averageDistance <= 25){
    // go backwards
    digitalWrite(motor1Pin1, HIGH);
    digitalWrite(motor1Pin2, LOW);
    digitalWrite(motor2Pin1, HIGH);
    digitalWrite(motor2Pin2, LOW);
  }
  if (averageDistance <= 45 && averageDistance > 25) {
    // turn
    digitalWrite(motor1Pin1, HIGH);
    digitalWrite(motor1Pin2, LOW);
    digitalWrite(motor2Pin1, LOW);
    digitalWrite(motor2Pin2, HIGH);
  }
  if (averageDistance > 45)   {
    // go forward
    digitalWrite(motor1Pin1, LOW);
    digitalWrite(motor1Pin2, HIGH);
    digitalWrite(motor2Pin1, LOW);
    digitalWrite(motor2Pin2, HIGH);
  }
}

[Reply #7 on:]

ottimo...molto interessante gli darò un'occhiata molto approfondita per capire come funziona...

[Reply #8 on:]

ciao non so se ti puo tornare utile ma io ho fatto un tutorials per la costruzione di un robot.. qui trovi tutte le info... e sempre in questo sito puoi comprare i vari layer per fare il robot http://www.gioblu.com/tutorials/robotica/200-robot-octagon il robot è comandato con un sensore ultrasonico DFROBOT ed è possibile anche comandarlo via seriale dal pc con la tastiera e farlo muovere come vuoi... io lo comando via wifi con i moduli WPM... guardarlo e registrati al sito ci sono veramente tanti tutorials per imparare sulla robotica
qui il codice

Code:

#include <Servo.h>
#include "URMSerial.h"

Servo sservo; // Servo sinistro
Servo dservo; // Servo destro
Servo uservo; // Servo centrale Range Scanner
int ang=0;
int angolomax=0;
int distmax=0;
int value=100;
int ind=0;
int rotazione=0;

// Definizione delle misure
#define DISTANCE 1
#define TEMPERATURE 2
#define ERROR 3
#define NOTREADY 4

//angolo di riposo dei servi delle ruote
#define RIPOSOS 90
#define RIPOSOD 90

// inizializza l'oggetto della libreria urm del sensore ultrasuoni
URMSerial urm;
const int  buttonPin = 2;    // the pin that the pushbutton is attached to
int buttonPushCounter = 0;   // counter for the number of button presses
int buttonState = 0;         // current state of the button
int lastButtonState = 0;     // previous state of the button


void setup()
{
  Serial.begin(57600);  // Imposta il baud rate a 9600
  urm.begin(6,7,9600); // RX Pin, TX Pin, Baud Rate
  pinMode(13, OUTPUT);
  pinMode(buttonPin, INPUT);
  sservo.attach(10);   // Attacca il servo sinistro al pin 10
  dservo.attach(9);    // Attacca il servo destro al pin 9
  uservo.attach(3);    // Attacca il servo degli ultrasuoni al pin 3
  uservo.write(90);    // metti il servo degli ultrasuoni dritto
  sservo.write(RIPOSOS); // ferma il robot
  dservo.write(RIPOSOD); // ferma il robo
  delay(200);
}

void loop()
{

  int val;
  val=analogRead(0);   //Sensore Termoresistenza
  Serial.print("Quantità Luce ");
  Serial.println(val,DEC);//Stampa Valore Termoresistenza   
  delay(100);
  if ( val > 890)
  {
    digitalWrite(13, HIGH);
  }
  else if ( val < 600)
  {
    digitalWrite(13, LOW);
  }
  buttonState = digitalRead(buttonPin);

  // buttonState è diverso di lastButtonState
  if (buttonState != lastButtonState) {
    // se buttonState e on
    if (buttonState == HIGH) {
      //conta qualche volte
      buttonPushCounter++;
    }
  }
  //lastButtonState è uguale a buttonState
  lastButtonState = buttonState;


  // se buttonPushCounter è = a 0
  if (buttonPushCounter == 0){
    tasti();
  }

  if(buttonPushCounter == 1){
    sservo.write(RIPOSOS); // ferma il robot
    dservo.write(RIPOSOD); // ferma il robot
    sservo.write(RIPOSOS + 90); // fai andare il robot dritto
    dservo.write(RIPOSOD - 90); // fai andare il robot dritto

    // Richiedi la distanza al sensore ad ultrasuoni
    urm.requestMeasurement(DISTANCE);
    delay(50); // attendi allineamento dei servi
    if(urm.hasReading())
    {
      switch(urm.getMeasurement(value)) // Verifica che il valore letto sia una distanza
      {
      case DISTANCE: // Ulteriore verifica che sia una distanza

        if (value>0 & value<30)  // se il valore e' < 20 cm stiamo per sbatter
        {
          angolomax=0; // imposta l'angolo di migliore uscita a zero
          distmax=0; // imposta la distanza di uscita migliore a zero
          uservo.write(5);  // sposta il servo degli ultrasuoni a destra
          sservo.write(RIPOSOS);  // ferma il servo in posizione di riposo
          dservo.write(RIPOSOD);  // ferma il servo in posizione di riposo
          for (ang=0; ang<=9; ang++) // fai un ciclo per controllare dove sono gli ostacoli
          {
            uservo.write(ang*20); // imposta il servo degli ultrasuoni sul valore assunto da ang
            urm.requestMeasurement(DISTANCE); //richiedi una nuova lettura della distanza
            delay(50); //attendi allineamento servo ultrasuoni
            if(urm.hasReading()) // verifica se ha letto
            {
              switch(urm.getMeasurement(value)) // Verifica che il valore letto sia una distanza
              {
              case DISTANCE: // Ulteriore verifica che sia una distanza
                if (value > distmax) // verifica che la distanza letta sia maggiore del max
                {
                  angolomax=ang*20;  // se e' maggiore del max imposta il nuovo angolo max e
                  distmax=value;  // la nuova distanza max
                } //end if (value > distmax)
                break;                           
              } // end switch interno
            } // end if(urm.hasReading())
          } //end for (ang=0; ang<180; ang +=5)         

          uservo.write(90); //rimetti il servo degli ultrasuoni dritto
          // scrivi sulla seriale il max valore e il max angolo rilevati
          Serial.print("Angolo max \t");
          Serial.println(angolomax);

          //imposta i servi sull'angolo di max distanza per non toccare l'ostacolo

          if (angolomax > 180)
            angolomax=180;
          if (angolomax < 0)
            angolomax=0;

          rotazione=abs(angolomax-90); //serve per far durare di piu la rotazione

          // scrivi un po' di valori di controllo nel serial monitor
          Serial.print("Angolo inviato ai servi \t");
          Serial.println(RIPOSOS+angolomax-90);
          Serial.print("Valore di rotazione \t");
          Serial.println(rotazione / 5);

          // fai andare i servi verso l'angolo di max distanza
          for (ind=1; ind < rotazione/5; ind+=1)
          {
            sservo.write(RIPOSOS+angolomax-90);
            dservo.write(RIPOSOD+angolomax-90);
            delay (40); // attendi allineamento servi
          } // end for (ind=1; ind < rotazione / 9; ind+=1)
        } //  end if (value 0)
        break;   
      } // end switch esterno
    } // end if(urm.hasReading()) esterno
  } // end else Robot Seriale
} //end loop

char a;
long previousMillis = 0;       
long interval = 600;
long intervall = 400;

void tasti()
{

  if(Serial.available() > 0){
    a = Serial.read();
    sservo.write(RIPOSOS); // ferma il robot
    dservo.write(RIPOSOD); // ferma il robot
    switch(a){
    case 'w':
      previousMillis = millis();   
      while(millis() - previousMillis < interval ) {
        Serial.println("avanti");
        for( int throttle = 0.0001; throttle < 91; throttle++) {
          sservo.write(RIPOSOS + 90 + throttle); // fai andare il robot dritto
          dservo.write(RIPOSOD - 90 + throttle); // fai andare il robot dritto
        }
      }
      sservo.write(RIPOSOS); // ferma il robot
      dservo.write(RIPOSOD); // ferma il robot
      break;
    case 's':
      previousMillis = millis();   
      while(millis() - previousMillis < interval) {
        Serial.println("indietro");
        sservo.write(RIPOSOS - 90); // fai andare il robot indietro
        dservo.write(RIPOSOD + 90); // fai andare il robot indietro
      }
      sservo.write(RIPOSOS); // ferma il robot
      dservo.write(RIPOSOD); // ferma il robot
      break;
    case 'd':
      previousMillis = millis();   
      while(millis() - previousMillis < interval - intervall) {
        Serial.println("destra");
        sservo.write(RIPOSOS - 90); // fai andare il robot a destra
        dservo.write(RIPOSOD - 90); // fai andare il robot a destra
      }
      sservo.write(RIPOSOS); // ferma il robot
      dservo.write(RIPOSOD); // ferma il robot
      break;
    case 'a':
      previousMillis = millis();   
      while(millis() - previousMillis < interval - intervall) {
        Serial.println("sinistra");
        sservo.write(RIPOSOS + 90); // fai andare il robot a sinistra
        dservo.write(RIPOSOD + 90); // fai andare il robot a sinistra
      }
      sservo.write(RIPOSOS); // ferma il robot
      dservo.write(RIPOSOD); // ferma il robot
      break;
    case 'c':
      previousMillis = millis();   
      while(a != 'v') {
        //Serial.println("avanti tutta");
        a = Serial.read();
        sservo.write(RIPOSOS + 90); // fai andare il robot avanti continuo
        dservo.write(RIPOSOD - 90); // fai andare il robot avanti continuo
      }
      sservo.write(RIPOSOS); // ferma il robot
      dservo.write(RIPOSOD); // ferma il robot
      break;
    }
  }
}

[Reply #9 on:]

Grazie per la dritta....per esser sincero  avevo già visto il sito gioblu...lo trovo molto interessante...per il tutorial che mi hai proposto è sicuramente valido, ma per ora mi sembra di livello superiore rispetto a  ciò che voglio fare...vorrei iniziare per passi,e con qualcosa di più semplice, per capire il funzionamento e non fare un semplice copia incolla,  ed al momento il mio scopo è di controllare due motori in dc con l'aiuto di qualche sensore, l'ultrasuoni potrebbe andare bene....ho inoltre visto il sensore che avete progettato con i led ir, ed anche questa mi sembra una bella idea che probabilmente proverò a fare...cmq tengo sicuramente presente gli spunti che mi hai dato poichè in un secondo stadio potrebbe servirmi controllare un motore passo passo in modo da far "sterzare" le ruote per evitare un ostacolo.....   ... thanks

[Reply #10 on:]

guarda fabio il codice che ho postato è veramente facile.. è stato il codice del mio primo robot... cmq se hai bisogno chiedi pure... se hai msn lasciami il contatto in privato cosi se ti serve una mano posso aiutarti meglio