Robot de détection humaine basé sur Arduino Uno : Intégration capteurs étape par étape

Composants et fournitures

Arduino UNO	×	1
Carte de développement, Shield contrôle moteur	×	1
Moteur servo SG90	×	1
Moteur DC 12V	×	4
Capteur ultrasonique HC-SR04 (générique)	×	1
Capteur température/humidité DHT11 (4 broches)	×	1
Batterie 9V (générique)	×	1
Fils de connexion (génériques)	×	1
Capteur PIR, 7 m	×	1

Outils et machines nécessaires

• Multitool, Tournevis
• Fer à souder (générique)
• Flux à souder, Soudure
• Fil à souder, sans plomb
• Pistolet à colle chaude (générique)

Applications et services en ligne

• Arduino IDE
• Microsoft Windows 10
• Application Android Control Center

À propos de ce projet

Ce système conçoit un véhicule robotique mobile de sauvetage basé sur Arduino pour aider les personnes à temps qui sont piégées dans des catastrophes naturelles comme les désastres, tremblements de terre, inondations, etc. Il reflète de manière opportune et précise la situation dynamique des humains dans la zone de catastrophe, comme dans les régions souterraines, vers la salle de contrôle, afin que l'équipe de secours d'experts et de médecins puisse être envoyée sur le lieu de la victime pour un traitement primaire et peut être envoyée vers un lieu sûr ou un hôpital. L'ensemble du processus se déroule en quelques secondes car le système est contrôlé par une unité Arduino.

Les capteurs PIR sont des capteurs infrarouges passifs qui détectent le mouvement des personnes grâce aux changements dans les niveaux d'infrarouge (chaleur) émis par les objets environnants. Le corps humain émet un rayonnement thermique à une longueur d'onde d'environ 10 microns. Il est reçu et manipulé par le capteur PIR pour détecter les êtres humains. Il fonctionne en 5V DC. Le mouvement de l'être humain peut être détecté en vérifiant un changement soudain dans les motifs IR environnants.

Le capteur d'obstacle détecte l'obstacle et envoie les signaux analogiques à l'Arduino. L'Arduino est programmé pour guider le robot automatiquement en fonction de l'obstacle détecté et pour envoyer les informations sur l'être humain vers le lieu de contrôle à distance via la technologie Bluetooth. Les données sont reçues à la Station de Base (Centre de Contrôle). En analysant les données, l'équipe de secours peut prendre les mesures nécessaires pour secourir les êtres humains piégés.

Code

Human Detection.ino (Arduino)

#include <NewPing.h>
// #include <AFMotor.h> // Vous pouvez télécharger la bibliothèque de code ci-dessous
#include <Servo.h>

// Configuration broches ultrasons
#define TRIG_PIN A0
#define ECHO_PIN A1
#define MAX_DISTANCE 400
#define MAX_SPEED 255
#define MAX_SPEED_OFFSET -8
#define COLL_DIST 20
#define TURN_DIST COLL_DIST+10
#define ACT_TIME 250

int calibrationTime = 30; // temps pendant lequel le capteur émet une impulsion basse
long unsigned int lowIn; // millisecondes pendant lesquelles le capteur doit être bas
// avant de supposer que tout mouvement s'est arrêté
long unsigned int pause = 5000;
boolean lockLow = true;
boolean takeLowTime;
int pirPin = A3; // broche numérique connectée à la sortie du capteur PIR
int ledPin = A2;

NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE);
// AF_DCMotor motorR(1, MOTOR12_1KHZ); // Moteur #1, PWM 1kHz
// AF_DCMotor motorL(4, MOTOR12_1KHZ); // Moteur #2, PWM 1kHz
Servo myservo; // Objet servo pour contrôler un servo

String motorSet = "";
int curDist = 0, pos, speedSet = 0;

void setup() {
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(pirPin, LOW);
  // donner du temps au capteur pour se calibrer
  Serial.print("calibrating sensor ");
  for(int i = 0; i < calibrationTime; i++) {
    Serial.print(".");
    delay(1000);
  }
  Serial.println(" done");
  Serial.println("SENSOR ACTIVE");
  delay(50);
  myservo.attach(9); // Attacher le servo sur la broche 9
  myservo.write(90); // Écrire 90 pour orienter le servo vers l'avant
  delay(2000);
  motorSet = "FORWARD";
  moveForward();
}

void loop() {
  checkPath();
  if(digitalRead(pirPin) == HIGH) {
    digitalWrite(ledPin, HIGH); // la LED visualise l'état de la broche de sortie du capteur
    if(lockLow) {
      // s'assurer qu'on attend une transition vers LOW avant toute sortie supplémentaire
      lockLow = false;
      Serial.println("---");
      Serial.print("motion detected at ");
      Serial.print(millis()/1000);
      Serial.println(" sec");
      delay(50);
    }
    takeLowTime = true;
  }
  if(digitalRead(pirPin) == LOW) {
    digitalWrite(ledPin, LOW); // la LED visualise l'état de la broche de sortie du capteur
    if(takeLowTime) {
      lowIn = millis(); // sauvegarder l'heure de la transition de HIGH vers LOW
      takeLowTime = false; // s'assurer que ceci n'est fait qu'au début d'une phase LOW
    }
    // si le capteur est bas pendant plus que la pause donnée,
    // on suppose qu'il n'y aura plus de mouvement
    if(!lockLow && millis() - lowIn > pause) {
      // s'assurer que ce bloc de code n'est exécuté à nouveau qu'après
      // qu'une nouvelle séquence de mouvement a été détectée
      lockLow = true;
      Serial.print("motion ended at ");
      // sortie
      Serial.print((millis() - pause)/1000);
      Serial.println(" sec");
      delay(50);
    }
  }
}

void checkPath() {
  int curLeft = 0;
  int curRight = 0;
  int curFront = 0;
  curDist = 0;
  checkForward();
  myservo.write(135);
  delay(100);
  for (pos = 135; pos >= 45; pos -= 45) {
    myservo.write(pos);
    delay(170);
    curDist = readPing();
    if (curDist < COLL_DIST) {
      checkCourse();
      break;
    }
    if (curDist < TURN_DIST) {
      changePath();
    }
  }
}

int readPing() {
  int cm = 0;
  while (cm < 2) {
    int uS = sonar.ping();
    cm = uS/US_ROUNDTRIP_CM;
  }
  return cm;
}

void checkForward() {
  if (motorSet == "FORWARD") {
    // motorR.run(FORWARD);
    // motorL.run(FORWARD);
  }
}

void changePath() {
  if (pos < 90) {
    veerLeft();
  }
  if (pos > 90) {
    veerRight();
  }
}

void veerRight() {
  // motorR.run(BACKWARD);
  // motorL.run(FORWARD);
  delay(ACT_TIME);
  // motorR.run(FORWARD);
  // motorL.run(FORWARD);
  motorSet = "FORWARD";
}

void veerLeft() {
  // motorL.run(BACKWARD);
  // motorR.run(FORWARD);
  delay(ACT_TIME);
  // motorL.run(FORWARD);
  // motorR.run(FORWARD);
  motorSet = "FORWARD";
}

void checkCourse() {
  moveBackward();
  delay(ACT_TIME);
  moveStop();
  setCourse();
}

void setCourse() {
  if (pos < 90) {
    turnRight();
  }
  if (pos > 90) {
    turnLeft();
  }
}

void moveBackward() {
  motorSet = "BACKWARD";
  // motorR.run(BACKWARD); // Moteur droit en arrière
  // motorL.run(BACKWARD); // Moteur gauche en arrière
  for (speedSet = 0; speedSet < MAX_SPEED; speedSet += 2) {
    // motorL.setSpeed(speedSet);
    // motorR.setSpeed(speedSet + MAX_SPEED_OFFSET);
    delay(5);
  }
}

void moveForward() {
  motorSet = "FORWARD";
  checkForward();
  for (speedSet = 0; speedSet < MAX_SPEED; speedSet += 2) {
    // motorL.setSpeed(speedSet);
    // motorR.setSpeed(speedSet + MAX_SPEED_OFFSET);
    delay(4);
  }
}

void moveStop() {
  // motorR.run(RELEASE);
  // motorL.run(RELEASE);
}

void turnRight() {
  motorSet = "RIGHT";
  // motorR.run(FORWARD); // Moteur droit en avant
  // motorL.run(BACKWARD); // Moteur gauche en arrière
  delay(ACT_TIME);
  motorSet = "FORWARD";
  checkForward();
}

void turnLeft() {
  motorSet = "LEFT";
  // motorR.run(BACKWARD); // Moteur droit en arrière
  // motorL.run(FORWARD); // Moteur gauche en avant
  delay(ACT_TIME);
  motorSet = "FORWARD";
  checkForward();
}

Schémas

Ce diagramme de blocs montre l'interfaçage entre les capteurs et la carte Arduino

Ce diagramme de circuit montre les configurations de connexion entre les différents capteurs et la carte Arduino Uno

Ce diagramme de flux montre comment le système fonctionne