Programme robot Jardise de seb3000

#include <IRremote.h>
#include <Servo.h>

//Servomoteur
// Créer un objet pour contrôler un servomoteur
Servo myservo;
//Capteur de Distance infrarouge IR Sharp GP2Y0A02YK0F
int capteur = 0;
//Capteur de distance infrarouge Sharp GP2Y0A21
int capteur2 = 1;
// Variable pour lire la valeur du capteur de la broche analogique
int val;
// Variable pour lire la valeur du capteur2 de la broche analogique
int val2;
//LED bleu
int LEDBLEU = 2;

//Motoreducteur
const int vitesse1=6;
const int vitesse2=5;
const int direction1=7;
const int direction2=4;

// IR PIN module récepteur et variable
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;

//mode d'execution
const int MODE_AUTO = 0;
const int MODE_MANUEL = 1;
int mode = MODE_MANUEL;
const int MODE_STOP           = 10;
const int MODE_AVANCE         = 11;
const int MODE_RECULE         = 12;
const int MODE_AV_RAPIDE      = 13;
const int MODE_AR_RAPIDE      = 14;
const int MODE_DROITE         = 15;
const int MODE_GAUCHE         = 16;
const int MODE_AV_DROITE      = 17;
const int MODE_AV_GAUCHE      = 18;
const int MODE_AR_DROITE      = 19;
const int MODE_AR_GAUCHE      = 20;
const int MODE_LED            = 21;
int sous_mode_manuel = MODE_STOP;

void setup()
{
  // configure les broches de commande du moteur en sortie
  pinMode(vitesse1,OUTPUT);
  pinMode(vitesse2,OUTPUT);
  pinMode(direction1,OUTPUT);
  pinMode(direction2,OUTPUT);

 
  //LEDBLEU broche en mode sortie
  pinMode(LEDBLEU,OUTPUT);

 // Attache le servo sur la broche 3 à l'objet servo
  myservo.attach(3);

  int i;
  for(i=4;i<=8;i++)
  pinMode(i,OUTPUT); //Met les pin 4,5,6,7 en mode sortie

  Serial.begin(9600);

  // désactiver les moteur par défaut
  digitalWrite(vitesse2,LOW);
  digitalWrite(vitesse1,LOW);

  // début de récepteur IR
  irrecv.enableIRIn();
}

void loop()
{

  int led_on =false;

  // Signal IR reçu
  if (irrecv.decode(&results))
  {   
    // changement de mode par le bouton rouge de la télécommande (POWER)
    //automatique  ou  manuel
    if(results.value==16580863)
    {
      if (mode == MODE_AUTO)
        mode = MODE_MANUEL;
      else
        mode = MODE_AUTO;
    }
    else if(mode == MODE_MANUEL)
    {
      if(results.value==16597183)          // Stop (FUNC / STOP) bouton de la télécommande
        sous_mode_manuel  = MODE_STOP;
    
      else if(results.value==16613503)      //  (VOL +) bouton de la télécommande faire avancer le robot
        sous_mode_manuel  = MODE_AVANCE;
    
      else if(results.value==16617583)      // (VOL-) bouton de la télécommande faire reculer le robot
        sous_mode_manuel  = MODE_RECULE;
    
      else if(results.value==16589023)      // rotation gauche (<<) touche recule rapide de la télécommande
        sous_mode_manuel  = MODE_GAUCHE;
     
      else if(results.value==16605343)      // rotation droite (>>) bouton avance rapide la télécommande
        sous_mode_manuel  = MODE_DROITE;
    
      else if(results.value==16609423)      // avant droite  avec la touche ( ST/REPT ) de la télécommande
        sous_mode_manuel  = MODE_AV_DROITE;
    
      else if(results.value==16621663)      // avant gauche (playe) bouton  de la télécommande
        sous_mode_manuel  = MODE_AV_GAUCHE;
    
      else if(results.value==16601263)       // inverse à droite (HAUT) bouton de la télécommande
        sous_mode_manuel  = MODE_AR_DROITE;
    
      else if(results.value==16584943)       // inverse à gauche (BAS) bonton de la télécommande
        sous_mode_manuel  = MODE_AR_GAUCHE;
    
      else if(results.value==16625743)    //Allume la LED bleu avec la touche ( EQ ) de la télécommande
        sous_mode_manuel  = MODE_LED;
    
     if(results.value==16593103)          // Arrêt de la LED bleu avec la touche ( 0 ) de la télécommande
     {
     digitalWrite(LEDBLEU,LOW);
     }
    }
    // recevoir la prochaine valeur
    irrecv.resume();
   
     // court délai d'attente pour répéter le signal IR
     // (L'empêcher d'arrêter si aucun signal reçu)
     delay(750);
  }
     
    // mode automatique
    if(mode == MODE_AUTO)
    {
      // Définit la position d'asservissement en fonction de la valeur à l'échelle
      myservo.write(val);
   
      // L'échelle pour l'utiliser avec le servo (valeur entre 0 et 300)
      val = analogRead(capteur);
      val = map(val, 0, 115, 0, 300);
      // Attend que le servo pour y arriver
      delay(200);
      val2 = analogRead(capteur2);
      val2 = map(val2, 0, 115, 0, 300);
   
      // Si on est à moins de quelque cm d'un obstacle pour les deux capteurs
      if ((val <=95) || (val2 <= 95)) 
      {
        moteur1(0,true);           //J'arrete le moteur 1
        moteur2(0,true);          // J'arrete le moteur 2
        delay(200);              //J'attend 2 seconde
        moteur1(180,true);      //J'avance tout droit
        moteur2(0,true);       // J'arrete le moteur 2
        delay(600);           //La valeur à mettre reste à définir en fonction de la vitesse du robot
        moteur1(180,true);   //J'avance tout droit
        moteur2(180,false); //J'avance tout droit
      }
        else
      {
        moteur1(180,true);   //J'avance tout droit
        moteur2(180,false); //J'avance tout droit
      }
   }
   else   // Mode Manuel controle le robot avec la télécommande
   {
    Serial.println(results.value, DEC);
     
    switch (sous_mode_manuel)
    {
      case MODE_LED:    //Allume la LED bleu avec la touche ( EQ ) de la télécommande
        if (led_on)
        {
          digitalWrite(LEDBLEU,LOW);
          led_on = false;
        }
        else
        {
          digitalWrite(LEDBLEU,HIGH);
          led_on = true;
        }
      break;
      case MODE_STOP:                      // Stop (FUNC / STOP) bouton de la télécommande
        digitalWrite(vitesse2,LOW);       // roue droite  a l'arrêt
        digitalWrite(vitesse1,LOW);      // roue gauche a l'arrêt
      break;
      case MODE_AVANCE://  (VOL +) bouton de la télécommande faire avancer le robot
        motor(235,235);
      break;
      case MODE_RECULE:// (VOL-) bouton de la télécommande faire reculer le robot
        motor(-235,-235);
      break;
      case MODE_DROITE:// rotation droite (>>) bouton avance rapide la télécommande
        motor(0,-130);
      break;
      case MODE_GAUCHE:// rotation droite (>>) bouton avance rapide la télécommande
        motor(0,130);
      break;
      case MODE_AV_DROITE:// avant droite  avec la touche ( ST/REPT ) de la télécommande
        motor(200,100);
      break;
      case MODE_AV_GAUCHE:// avant gauche (playe) bouton  de la télécommande
        motor(100,200);
      break;
      case MODE_AR_DROITE:// inverse à droite (HAUT) bouton de la télécommande
        motor(-235,-235);
      break;
      case MODE_AR_GAUCHE:// inverse à gauche (BAS) bonton de la télécommande
        motor(235,235);
      break;   
    }
  }
}
//Fonctions
//motoréducteur pour le mode déplacement automatique
void moteur1(int valeur_vitesse, boolean sens_avant)
{
  analogWrite(vitesse1,valeur_vitesse); //Valeur_vitesse = 0 à l'arrêt, et 255 pour vitesse maximum
  if(sens_avant)
  {
    digitalWrite(direction1,HIGH);
  }
  else
  {
    digitalWrite(direction1,LOW);
  }
}

void moteur2(int valeur_vitesse, boolean sens_avant)
{
  analogWrite(vitesse2,valeur_vitesse); //Valeur_vitesse = 0 à l'arrêt, et 255 pour vitesse maximum
  if(sens_avant)
  {
    digitalWrite(direction2,HIGH);
  }
    else
  {
    digitalWrite(direction2,LOW);
  }
}
// fonction pour contrôler le moteur
void motor(int left, int right)
{
  // limiter la vitesse max
  if(left>255)left=255;//gauche
  else if(left<-255)left=-255;//gauche
  if(right>255)right=255;//droite
  else if(right<-255)right=-255;//droite
 
  // roue gauche roue avant
  if(left>0)//gauche a l'arrét
  {
    digitalWrite(direction1,HIGH);       // direction roue gauche avant
    analogWrite(vitesse1,left);      // vitesse de la roue gauche
  }
 
  //inverser la roue gauche
  else if(left<0)
  {
    digitalWrite(direction1,LOW);      // inverse à gauche en direction
    analogWrite(vitesse1,-left);      // vitesse de la roue gauche
  }
  else       // roue gauche a l'arrêt
  {
    digitalWrite(vitesse1,LOW);
  }
  if(right>0)      // roue droite avant
  {
    // direction de la roue droite avant
    digitalWrite(direction2,LOW);
    analogWrite(vitesse2,right);
  }
  else if(right<0)      // roue droite en arrière
  {
    // inverse à droite en direction
    digitalWrite(direction2,HIGH);
    analogWrite(vitesse2,-right);
  }
  else      // roue droite a l'arrêt
  {
    // roue droite a l'arrêt
    digitalWrite(vitesse2,LOW);
  }
}
 // SEB03000

Programme pour afficher les codes sur l'IDE d'arduino de n'importe quelle télécommande IR

#include <IRremote.h>
int RECV_PIN = 2;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}
void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); // Receive the next value
  }
}

Photorésistance ldr arduino

LDR stands for Light dependant resistor.An LDR is usually made of a semiconductor material(Normally Silicon) doped with a small percentage of a valency 5 material (commonly Arsenic), to make it an "N" material.
Another word for LDR is photoresistor.
The resistance of LDR decreases with  increase in the intensity of light.An LDR works in the similar manner as any other analog device would work.
Symbol of LDR:

For this tutorial  you will need

1. 1  arduino
2. 1  LDR
3. 1  10K resistor
4. 1 breadboard

Connect the LDR in this way.
LDRs are non-polarized.That means you can connect it either way.

Code for LDR

---

int ldr = 0;             //analog pin to which LDR is connected
int ldr_value = 0;        //variable to store LDR values

void setup()
{
  Serial.begin(9600);   //start te serial monitor
}

void loop()
{
  ldr_value = analogRead(ldr);          //reads the LDR values
  Serial.println(ldr_value);                 //prints the LDR values to serial monitor
  delay(50);                  //wait
}

---

After uploading the code to arduino you can see the readings from LDR on serial monitor of arduino IDE.The value of LDR or any analog device when used with arduino ranges between 0 to 1023.

arduino liquid crystal 16x2

To wire your LCD screen to your Arduino, connect the following pins:

• LCD RS pin to digital pin 12
• LCD Enable pin to digital pin 11
• LCD D4 pin to digital pin 5
• LCD D5 pin to digital pin 4
• LCD D6 pin to digital pin 3
• LCD D7 pin to digital pin 2

Additionally, wire a 10K pot to +5V and GND, with it's wiper (output) to LCD screens VO pin (pin3).

click the images to enlarge

image developed using Fritzing. For more circuit examples, see the Fritzing project page

Code

/*
  LiquidCrystal Library - Hello World

 Demonstrates the use a 16x2 LCD display.  The LiquidCrystal
 library works with all LCD displays that are compatible with the
 Hitachi HD44780 driver. There are many of them out there, and you
 can usually tell them by the 16-pin interface.

 This sketch prints "Hello World!" to the LCD
 and shows the time.

  The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)

 Library originally added 18 Apr 2008
 by David A. Mellis
 library modified 5 Jul 2009
 by Limor Fried (http://www.ladyada.net)
 example added 9 Jul 2009
 by Tom Igoe
 modified 22 Nov 2010
 by Tom Igoe

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("hello, world!");
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis()/1000);
}

programme télécommande IR arduino

programme télécommande IR

 #include "IRremote.h"
/*-----( Declare Constants )-----*/
int receiver = 11; // pin 1 of IR receiver to Arduino digital pin 11
/*-----( Declare objects )-----*/
IRrecv irrecv(receiver);           // create instance of 'irrecv'
decode_results results;            // create instance of 'decode_results'
/*-----( Declare Variables )-----*/

void setup()   /*----( SETUP: RUNS ONCE )----*/
{
  Serial.begin(9600);

  irrecv.enableIRIn(); // Start the receiver
}/*--(end setup )---*/

void loop()   /*----( LOOP: RUNS CONSTANTLY )----*/
{
  if (irrecv.decode(&results)) // have we received an IR signal?
  {
//    Serial.println(results.value, HEX);  UN Comment to see raw values
    translateIR();
    irrecv.resume(); // receive the next value
  } 
}/* --(end main loop )-- */
/*-----( Declare User-written Functions )-----*/
void translateIR() // takes action based on IR code received
// describing KEYES Remote IR codes
{
  switch(results.value)
  {
  case 0xFF629D: Serial.println(" FORWARD"); break;
  case 0xFF22DD: Serial.println(" LEFT");    break;
  case 0xFF02FD: Serial.println(" -OK-");    break;
  case 0xFFC23D: Serial.println(" RIGHT");   break;
  case 0xFFA857: Serial.println(" REVERSE"); break;
  case 0xFF6897: Serial.println(" 1");    break;
  case 0xFF9867: Serial.println(" 2");    break;
  case 0xFFB04F: Serial.println(" 3");    break;
  case 0xFF30CF: Serial.println(" 4");    break;
  case 0xFF18E7: Serial.println(" 5");    break;
  case 0xFF7A85: Serial.println(" 6");    break;
  case 0xFF10EF: Serial.println(" 7");    break;
  case 0xFF38C7: Serial.println(" 8");    break;
  case 0xFF5AA5: Serial.println(" 9");    break;
  case 0xFF42BD: Serial.println(" *");    break;
  case 0xFF4AB5: Serial.println(" 0");    break;
  case 0xFF52AD: Serial.println(" #");    break;
  case 0xFFFFFFFF: Serial.println(" REPEAT");break; 
  default:
    Serial.println(" other button   ");
  }// End Case
  delay(500); // Do not get immediate repeat

} //END translateIR

/* ( THE END ) */

télécommande IR arduino

Télécommande par infrarouge - Tutoriel Arduino

Matériel utilisé

• 1 récepteur infra-rouge 3 broches 38 kHz (portée 18 fts), type WS 1838B seul ou module monté sur PCB avec led témoin (mieux pour vos premiers essais).
• 1 petite télécommande IR standard à 20 boutons avec sa pile bouton (retirer la languette pour activer la pile).
• 1 télécommande de téléviseur
• 1 carte Arduino Uno R3
• 1 breadboard et fils de câblage mâle/mâle à connecteur Dupont

* kit de télécommande

..

Principe de fonctionnement
Une diode émet des pulses en infra-rouge pour transmettre un signal de télécommande codé, vers à un récepteur infra-rouge placé dans un appareil que l'on commande à distance.

C'est le principe de télécommande utilisé sur tous les téléviseurs, magnétoscopes, appareils photos...
On peut l'utiliser pour ses projets personnels de robotique, domotique... à partir d'une petite télécommande standard, ou en décodant sa propre télécommande de téléviseur par exemple.

La portée est de plusieurs mètres, en ligne droite sans obstacles, le signal est invisible à l'œil humain.

Il existe de nombreux protocoles de transmissions (NEC, Sony SIRC, Philips RC5, Philips RC6, données brutes...) et plusieurs manières de coder les informations. Certains protocoles demande de répéter trois fois l'information.
Heureusement une bonne librairie pour Arduino gère tout ça.

Les signaux IR sont modulés à 38 kHz pour éviter les interférences avec la lumière ambiante. Le récepteur 38 kHz gère cette modulation directement.
Ceci permet de ne pas brouiller les appareils IR entre eux et d'avoir plusieurs fonctions par télécommande (on/off, choix de chaîne, réglage du volume...).

Applications

• Télécommande par infrarouge de ses projets (robot, commande de volet roulant, domotique, éclairage...)
• Enregistrer les codes d'une télécommande existante et les ré-émettre à l'identique pour cloner la télécommande
• Regrouper plusieurs télécommandes en une seule (TV + Magnétoscope + DVD + éclairage du salon + chauffage).
• Utilisation d'une télécommande existante pour un autre appareil.
• Remplacement d'une télécommande perdue

Emission infra-rouge

Pour l'émission on peut utiliser

• Une télécommande existante (TV, magnétoscope DVD...) dont on analyse les codes.
• Une simple diode infra-rouge branchée sur sortie numérique (pin3), avec une résistance R1 100 Ω pour limiter le courant.
• Une petite télécommande standard (21 boutons) à usage assez universel (solution la plus pratique)

Réception du signal
Le détecteur (3 broches) est branché sur une broche digitale pin11.
.

Récepteur -->Arduino

• De gauche à droite, vu de face, broches 1 OUT, 2 GND, 3 VCC sur le composant seul.
• Attention, sur la plaquette PCB le brochage est inversé, de gauche à droite on a
  GND (indiqué -), VCC (au centre), OUT (indiqué S)

Ne pas inverser le câblage au risque de griller le récepteur.


Le bon fonctionnement du récepteur est indiqué par une petite led rouge sur le PCB qui s'allume à chaque réception.

Câblage :
.



Programmation
Télécharger et installer la librairie #include <IRremote.h>
Elle comporte deux fichiers IRremote.cpp et IRremote.h et un sous-répertoire examples
Il faut aussi installer la librairie IRremoteInt.h

Exemple de code de réception

Code: Tout sélectionner

#include <IRremote.h>

int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Initialise le recepteur
}

void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume(); // Recoit la valeur suivante
  }
}

Utilisation
Le serial monitor de l'IDE Arduino va directement afficher les codes reçus par la télécommande.
La petite led témoin sur la plaquette du récepteur s'allume lors d'une réception de signal de télécommande IR.

Décodage des touches de la télécommande standard à 21 boutons
Petit modèle simple, assez universel et bon marché, qui convient à la plupart des projets.

ultrason , capteur de contact et moteur cc (video sur le blog onglet en haut)

int pwm_a = 9;
int pwm_b = 10;
int dir_a = 7;
int dir_b = 8;
#define BUTTON 4
#define BUT 3
int val = 0;
int vall =0;
#define trigPin 6
 #define echoPin 5

void setup()
{
  Serial.begin (9600);
   pinMode(trigPin, OUTPUT);
   pinMode(echoPin, INPUT);
  pinMode(pwm_a, OUTPUT);
  pinMode(pwm_b, OUTPUT);
  pinMode(dir_a, OUTPUT);
  pinMode(dir_b, OUTPUT);
  pinMode(BUTTON,INPUT);// bouton gauche
  pinMode(BUT,INPUT);
  analogWrite(pwm_a,127);
  analogWrite(pwm_b,127);
  }
  void loop()
  {
   long duration, distance;
   digitalWrite(trigPin, LOW); 
   delayMicroseconds(2);
   digitalWrite(trigPin, HIGH);
 //  delayMicroseconds(1000);
   delayMicroseconds(10); //
   digitalWrite(trigPin, LOW);
   duration = pulseIn(echoPin, HIGH);
   distance = (duration/2) / 29.1;
  val  = digitalRead(BUTTON);
  vall = digitalRead(BUT);
  if (val == HIGH){
    digitalWrite(dir_a,LOW);
    digitalWrite(dir_b,LOW);
 analogWrite(pwm_a,127);
  analogWrite(pwm_b,127);
  }
  else{
    digitalWrite(dir_b,HIGH);
    digitalWrite(dir_a,HIGH);
    delay(250);
    digitalWrite(dir_b,LOW);
    digitalWrite(dir_a, HIGH);
    delay(500);
   
  }
  if (vall == HIGH){
    digitalWrite(dir_a,LOW);
    digitalWrite(dir_b,LOW);
analogWrite(pwm_a,127);
  analogWrite(pwm_b,127); 
}
  else{
    digitalWrite(dir_b,HIGH);
    digitalWrite(dir_a,HIGH);
    delay(250);
    digitalWrite(dir_b,HIGH);
    digitalWrite(dir_a,LOW);
    delay(500);
  }  
   if (distance < 8) { 
     digitalWrite(dir_b,HIGH);
    digitalWrite(dir_a,HIGH);
    delay(500);
    digitalWrite(dir_b,HIGH);
    digitalWrite(dir_a,LOW);
    delay(2000);
 }
   else {
    digitalWrite(dir_a,LOW);
    digitalWrite(dir_b,LOW);
analogWrite(pwm_a,127);
  analogWrite(pwm_b,127);  
  
 }
  }
 

capteur de contact et moteur cc robot zumo pololu

// contrôle de 2 moteurs cc avec 2 capteurs de contact avec chassis pololu zumo

int pwm_a = 9;               // Entrée PWMA du zumo shield  arduino sur broche 9
int pwm_b = 10;            // Entrée PWMB du zumo shield  arduino  sur broche10
int dir_a = 7;                 // Entrée DIRA          "          "           "          sur broche 7
int dir_b = 8;                // Entrée DIRB           "          "           "          sur broche 8
#define BOUTTON_A 4    // capteur de contact A sur broche 4
#define BOUTTON_B 3    // capteur de contact B  sur broche 3
int val = 0;                          // les données val et vall sont égale à 0
int vall =0;                         
void setup()
{
  pinMode(pwm_a, OUTPUT);   // met la broche 9 en sortie
  pinMode(pwm_b, OUTPUT);   //met la broche 10 en sortie
  pinMode(dir_a, OUTPUT);                    
  pinMode(dir_b, OUTPUT);
  pinMode(BOUTTON_A,INPUT);// bouton_A gauche en entrée
  pinMode(BOUTTON_B,INPUT);
  analogWrite(pwm_a,127); // moteurs à 50% de la vitesse maxi (valeur max 255)
  analogWrite(pwm_b,127);
  }
  void loop()
  {
  
  val  = digitalRead(BOUTTON_A); //  les capteurs de contact
  vall = digitalRead(BOUTTON_B);
  if (val == HIGH){                           // si boutton_A égal high (pas de contact)
    digitalWrite(dir_a,LOW);            // moteurs tournent dans un sens
    digitalWrite(dir_b,LOW);
 analogWrite(pwm_a,127);             // à 50% de la vitesse max
  analogWrite(pwm_b,127);
  }
  else{                                             // sinon ,
    digitalWrite(dir_b,HIGH);        //changer de sens moteur
    digitalWrite(dir_a,HIGH);
    delay(250);                                // attendre 2,5 sec
    digitalWrite(dir_b,LOW);         // permet de tourner selon le contact
    digitalWrite(dir_a, HIGH);
    delay(250);
   
  }
  if (vall == HIGH){
    digitalWrite(dir_a,LOW);
    digitalWrite(dir_b,LOW);
analogWrite(pwm_a,127);
  analogWrite(pwm_b,127); 
}
  else{
    digitalWrite(dir_b,HIGH);
    digitalWrite(dir_a,HIGH);
    delay(250);
    digitalWrite(dir_b,HIGH);
    digitalWrite(dir_a,LOW);
    delay(250);
    
   
 
}
  }

Capteur US(ultrason) HC-SR04

#define trigPin 10
#define echoPin 12

void setup() {

Serial.begin (9600);

pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}

void loop() {
long duration, distance;
digitalWrite(trigPin, LOW); // Added this line
delayMicroseconds(2); // Added this line

digitalWrite(trigPin, HIGH);
// delayMicroseconds(1000); - Removed this line
delayMicroseconds(10); // Added this line
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);
distance = (duration/2) / 29.1;
if (distance >= 200 || distance <= 0){
Serial.println("Out of range");
}
else {
Serial.print(distance);

Serial.println(" cm");

}
delay(500);
}