Coder un capteur à ultrasons sur un robot pololu en arduino

International Français
1

Salut à tous, je suis en terminale STI2D, et mon projet pour cette année est de programmer un robot Pololu 3pi.
Jusqu'à maintenant je n'ai pas eu de problème pour programmer le robot à suivre des lignes, mais une nouvelle consigne m'a été donnée, je dois ajouter un capteur à ultrasons HC-SR04 pour que le robot s'arrête lorsqu'il s'approche trop près d'un obstacle.
La fin de l'année s'approchant à grand pas (une semaine OMG), je me tourne vers vous pour m'aider car seul, je n'y arriverais certainement pas.

Voici le code à modifier pour prendre en compte ce capteur:

#include <Pololu3pi.h>
#include <PololuQTRSensors.h>
#include <OrangutanMotors.h>
#include <OrangutanAnalog.h>
#include <OrangutanLEDs.h>
#include <OrangutanLCD.h>
#include <OrangutanPushbuttons.h>
#include <OrangutanBuzzer.h>

Pololu3pi robot;
unsigned int sensors[5]; // an array to hold sensor values

// This include file allows data to be stored in program space. The
// ATmega168 has 16k of program space compared to 1k of RAM, so large
// pieces of static data should be stored in program space.
#include <avr/pgmspace.h>

// Introductory messages. The "PROGMEM" identifier causes the data to
// go into program space.
const char welcome_line1[] PROGMEM = " Pololu";
const char welcome_line2[] PROGMEM = "3\xf7 Robot";
const char demo_name_line1[] PROGMEM = "Suiveur";
const char demo_name_line2[] PROGMEM = "de ligne";

// A couple of simple tunes, stored in program space.
const char welcome[] PROGMEM = ">g32>>c32";
const char go[] PROGMEM = "L16 cdegreg4";

// Data for generating the characters used in load_custom_characters
// and display_readings. By reading levels[] starting at various
// offsets, we can generate all of the 7 extra characters needed for a
// bargraph. This is also stored in program space.
const char levels[] PROGMEM = {
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000,
0b11111,
0b11111,
0b11111,
0b11111,
0b11111,
0b11111,
0b11111
};

// This function loads custom characters into the LCD. Up to 8
// characters can be loaded; we use them for 7 levels of a bar graph.
void load_custom_characters()
{
OrangutanLCD::loadCustomCharacter(levels + 0, 0); // no offset, e.g. one bar
OrangutanLCD::loadCustomCharacter(levels + 1, 1); // two bars
OrangutanLCD::loadCustomCharacter(levels + 2, 2); // etc...
OrangutanLCD::loadCustomCharacter(levels + 3, 3);
OrangutanLCD::loadCustomCharacter(levels + 4, 4);
OrangutanLCD::loadCustomCharacter(levels + 5, 5);
OrangutanLCD::loadCustomCharacter(levels + 6, 6);
OrangutanLCD::clear(); // the LCD must be cleared for the characters to take effect
}

// This function displays the sensor readings using a bar graph.
void display_readings(const unsigned int *calibrated_values)
{
unsigned char i;

for (i=0;i<5;i++) {
// Initialize the array of characters that we will use for the
// graph. Using the space, an extra copy of the one-bar
// character, and character 255 (a full black box), we get 10
// characters in the array.
const char display_characters[10] = { ' ', 0, 0, 1, 2, 3, 4, 5, 6, 255 };

// The variable c will have values from 0 to 9, since
// calibrated values are in the range of 0 to 1000, and
// 1000/101 is 9 with integer math.
char c = display_characters[calibrated_values / 101];

  • // Display the bar graph character.*
  • OrangutanLCD::print(c);*
  • }*
    }
    // Initializes the 3pi, displays a welcome message, calibrates, and
    // plays the initial music. This function is automatically called
    // by the Arduino framework at the start of program execution.
    void setup()
    {
  • unsigned int counter; // used as a simple timer*
  • // This must be called at the beginning of 3pi code, to set up the*
  • // sensors. We use a value of 2000 for the timeout, which*
    _ // corresponds to 2000*0.4 us = 0.8 ms on our 20 MHz processor._
  • robot.init(2000);*
  • load_custom_characters(); // load the custom characters*
  • // Play welcome music and display a message*
  • OrangutanLCD::printFromProgramSpace(welcome_line1);*
  • OrangutanLCD::gotoXY(0, 1);*
  • OrangutanLCD::printFromProgramSpace(welcome_line2);*
  • OrangutanBuzzer::playFromProgramSpace(welcome);*
  • delay(1000);*
  • OrangutanLCD::clear();*
  • OrangutanLCD::printFromProgramSpace(demo_name_line1);*
  • OrangutanLCD::gotoXY(0, 1);*
  • OrangutanLCD::printFromProgramSpace(demo_name_line2);*
  • delay(1000);*
  • // Display battery voltage and wait for button press*
  • while (!OrangutanPushbuttons::isPressed(BUTTON_B))*
  • {*
  • int bat = OrangutanAnalog::readBatteryMillivolts();*
  • OrangutanLCD::clear();*
  • OrangutanLCD::print(bat);*
  • OrangutanLCD::print("mV");*
  • OrangutanLCD::gotoXY(0, 1);*
  • OrangutanLCD::print("Press B");*
  • delay(100);*
  • }*
  • // Always wait for the button to be released so that 3pi doesn't*
  • // start moving until your hand is away from it.*
  • OrangutanPushbuttons::waitForRelease(BUTTON_B);*
  • delay(1000);*
  • // Auto-calibration: turn right and left while calibrating the*
  • // sensors.*
  • for (counter=0; counter<80; counter++)*
  • {*
  • if (counter < 20 || counter >= 60)*
  • OrangutanMotors::setSpeeds(40, -40);*
  • else*
  • OrangutanMotors::setSpeeds(-40, 40);*
  • // This function records a set of sensor readings and keeps*
  • // track of the minimum and maximum values encountered. The*
  • // IR_EMITTERS_ON argument means that the IR LEDs will be*
  • // turned on during the reading, which is usually what you*
  • // want.*
  • robot.calibrateLineSensors(IR_EMITTERS_ON);*
  • // Since our counter runs to 80, the total delay will be*
    _ // 80*20 = 1600 ms._
  • delay(20);*
  • }*
  • OrangutanMotors::setSpeeds(0, 0);*
  • // Display calibrated values as a bar graph.*
  • while (!OrangutanPushbuttons::isPressed(BUTTON_B))*
  • {*
  • // Read the sensor values and get the position measurement.*
  • unsigned int position = robot.readLine(sensors, IR_EMITTERS_ON);*
  • // Display the position measurement, which will go from 0*
  • // (when the leftmost sensor is over the line) to 4000 (when*
  • // the rightmost sensor is over the line) on the 3pi, along*
  • // with a bar graph of the sensor readings. This allows you*
  • // to make sure the robot is ready to go.*
  • OrangutanLCD::clear();*
  • OrangutanLCD::print(position);*
  • OrangutanLCD::gotoXY(0, 1);*
  • display_readings(sensors);*
  • delay(100);*
  • }*
  • OrangutanPushbuttons::waitForRelease(BUTTON_B);*
  • OrangutanLCD::clear();*
  • OrangutanLCD::print("Go!"); *
  • // Play music and wait for it to finish before we start driving.*
  • OrangutanBuzzer::playFromProgramSpace(go);*
  • while(OrangutanBuzzer::isPlaying());*
    }
    // The main function. This function is repeatedly called by
    // the Arduino framework.
    void loop()
    {
    _ // Get the position of the line. Note that we must provide_
  • // the "sensors" argument to read_line() here, even though we*
  • // are not interested in the individual sensor readings.*
  • unsigned int position = robot.readLine(sensors, IR_EMITTERS_ON);*
  • if (position < 1000)*
  • {*
  • // We are far to the right of the line: turn left.*
  • // Set the right motor to 100 and the left motor to zero,*
  • // to do a sharp turn to the left. Note that the maximum*
  • // value of either motor speed is 255, so we are driving*
  • // it at just about 40% of the max.*
  • OrangutanMotors::setSpeeds(0, 125);*
  • // Just for fun, indicate the direction we are turning on*
  • // the LEDs.*
  • OrangutanLEDs::left(HIGH);*
  • OrangutanLEDs::right(LOW);*
  • }*
  • else if (position < 1500)*
  • {*
  • // Position intermédiaire gauche*
  • OrangutanMotors::setSpeeds(50, 125);*
  • OrangutanLEDs::left(HIGH);*
  • OrangutanLEDs::right(LOW);*
  • }*
  • else if (position < 2500)*
  • {*
  • // We are somewhat close to being centered on the line:*
  • // drive straight.*
  • OrangutanMotors::setSpeeds(125, 125);*
  • OrangutanLEDs::left(HIGH);*
  • OrangutanLEDs::right(HIGH);*
  • }*
  • else if (position < 3000)*
  • {*
  • // Position intermédiaire droite*
  • OrangutanMotors::setSpeeds(125, 50);*
  • OrangutanLEDs::left(LOW);*
  • OrangutanLEDs::right(HIGH);*
  • }*
  • else*
  • {*
  • // We are far to the left of the line: turn right.*
  • OrangutanMotors::setSpeeds(125, 0);*
  • OrangutanLEDs::left(LOW);*
  • OrangutanLEDs::right(HIGH);*
  • }*
    }[/quote]
    Aussi, j'ai bien installé le kit d'extension du robot, mais je ne sais pas à quelles bornes du robot connecter les broches "Trig" et Echo", si vous pouviez aussi m'indiquer ça ce serait super.
    Je sais que j'en demande peut-être beaucoup, mais mon bac en dépend certainement, je vous serais éternellement reconnaissant pour l'aide que vous m'apporterez. Le premier qui m'aide gagne un biscuit.
2

bonjour,
allez un peu de recherche sur ton ami :wink:
http://forum.pololu.com/viewtopic.php?f=29&t=6648

3

Ah merci, j'étais déjà tombé sur ce topic à plusieurs reprises, je n'avais pas vu qu'il y était indiqué sur quelles bornes brancher le capteur :cold_sweat:

Je vais essayer de voir ce que je peux tirer des quelques codes donnés.