AlphaBot: Ultraschall Notbremse: Unterschied zwischen den Versionen

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen
 
(10 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 7: Zeile 7:
* Wir sind vorwärts gefahren und haben 20 cm eine Notbremsung gemacht.
* Wir sind vorwärts gefahren und haben 20 cm eine Notbremsung gemacht.


== Programmablaufplan ==
[[Datei:Notbremse.jpg|right|200px|Abb. 1: Programmablaufplan]]<br/>
[[Datei:Notbremse.jpg|left|550px]]


== Quelltext ==
== Quelltext ==
Zeile 22: Zeile 21:


// KONSTANTEN deklarieren
// KONSTANTEN deklarieren
const byte PORT_ENC_L=2;                // Die linke Lichtschranke (CNTL) liegt an Arduino D2
const byte PORT_ENC_R=3;                // Die rechte Lichtschranke (CNTR) liegt an Arduino D3
const byte ANZAHL_INCREMENTE=40;        // Die Encoderscheibe hat 20 Löcher und somit 40 Zustände
const int TRIG = 11;                    // US Trigger an D11
const int TRIG = 11;                    // US Trigger an D11
const int ECHO = 12;                    // US Echo an D12
const int ECHO = 12;                    // US Echo an D12
Zeile 38: Zeile 34:
float messeUSAbstand()                    // Abstand in cm
float messeUSAbstand()                    // Abstand in cm
{
{
   float USAbstand = 0;                   // Rückgabewert initialisieren
   float fUSAbstand = 0;                   // Rückgabewert initialisieren
  float fSignalLaufzeit=0;                // Messwert der Signallaufzeit         
 
   digitalWrite(TRIG, LOW);                // setze Trigger auf LOW für 2μs
   digitalWrite(TRIG, LOW);                // setze Trigger auf LOW für 2μs
   delayMicroseconds(2);
   delayMicroseconds(2);
Zeile 44: Zeile 42:
   delayMicroseconds(10);
   delayMicroseconds(10);
   digitalWrite(TRIG, LOW);                // setze Trigger auf LOW
   digitalWrite(TRIG, LOW);                // setze Trigger auf LOW
   float fSignalLaufzeit = pulseIn(ECHO, HIGH);  // Messung der Signallaufzeit des Impulses
   fSignalLaufzeit = pulseIn(ECHO, HIGH);  // Messung der Signallaufzeit des Impulses
    
    
   USAbstand = fSignalLaufzeit/58;         // Umrechnung Laufzeit in s in Abstand in cm             
   fUSAbstand = fSignalLaufzeit/58;       // Umrechnung Laufzeit in s in Abstand in cm             
   //Y m =(X s * 344)/ 2;  
   //Y m =(X s * 344)/ 2;  
   //X s =( 2 * Y m)/ 344;
   //X s =( 2 * Y m)/ 344;
   //X s = 0.0058 * Y m;
   //X s = 0.0058 * Y m;
   //cm = us /58
   //cm = us /58
   return USAbstand;                       // Rückgabewert
   return fUSAbstand;                     // Rückgabewert
}   
}   


Zeile 60: Zeile 58:
   Serial.begin(9600);            // Serieller Monitor mit 9600 Baud
   Serial.begin(9600);            // Serieller Monitor mit 9600 Baud
   AlfServo.write(90);            // Der Servo soll sich an die Mitte drehen  
   AlfServo.write(90);            // Der Servo soll sich an die Mitte drehen  
   delay(15);
   delay(15);                     // Drehung abwarten
   Alf.MotorRun(80,80);            // Alf fährt vorwärts; Leistung 100
   Alf.MotorRun(80,80);            // Alf fährt vorwärts; Leistung 100
}
}

Aktuelle Version vom 28. April 2022, 14:28 Uhr

Autor: Prof. Dr.-Ing. Schneider

Inhalt des siebten Termins

  • Wir haben die Servoansteuerung wiederholt.
  • Wir haben den Ultraschall-Sensor mittig ausgerichtet.
  • Wir haben Abstandswerte gemessen.
  • Wir sind vorwärts gefahren und haben 20 cm eine Notbremsung gemacht.
Abb. 1: Programmablaufplan
Abb. 1: Programmablaufplan


Quelltext

// Bibliotheken einbinden 
#include "AlphaBot.h"         
#include <Servo.h>

// Instanzen erzeugen
AlphaBot Alf = AlphaBot();               // Instanz des AlphaBot erzeugen
Servo AlfServo;                          // Servo Instanz

// KONSTANTEN deklarieren
const int TRIG = 11;                     // US Trigger an D11
const int ECHO = 12;                     // US Echo an D12
const int nServoPort = 9;                // Der Servo liegt auf D9


void initUltraschall()
{
  pinMode(TRIG, OUTPUT);                  // Ultraschall Trigger als Ausgang deklarieren 
  pinMode(ECHO, INPUT);                   // Ultraschall Echo als Eingang deklarieren  
}

float messeUSAbstand()                    // Abstand in cm
{
  float fUSAbstand = 0;                   // Rückgabewert initialisieren
  float fSignalLaufzeit=0;                // Messwert der Signallaufzeit           

  digitalWrite(TRIG, LOW);                // setze Trigger auf LOW für 2μs
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);               // setze Trigger auf HIGH für mind. 10 us
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);                // setze Trigger auf LOW
  fSignalLaufzeit = pulseIn(ECHO, HIGH);  // Messung der Signallaufzeit des Impulses
  
  fUSAbstand = fSignalLaufzeit/58;        // Umrechnung Laufzeit in s in Abstand in cm            
  //Y m =(X s * 344)/ 2; 
  //X s =( 2 * Y m)/ 344;
  //X s = 0.0058 * Y m;
  //cm = us /58
  return fUSAbstand;                      // Rückgabewert
}  

void setup()                      // Einmalige Systeminitialisierung
{
  initUltraschall();              // US initialisieren
  AlfServo.attach(nServoPort);    // Servo verbinden
  Serial.begin(9600);             // Serieller Monitor mit 9600 Baud
  AlfServo.write(90);             // Der Servo soll sich an die Mitte drehen 
  delay(15);                      // Drehung abwarten
  Alf.MotorRun(80,80);            // Alf fährt vorwärts; Leistung 100
}

void loop()                       // Main Schleife
{
  float USAbstand =0;
  USAbstand = messeUSAbstand();   // US Abstand messen 
  Serial.println(USAbstand);
  if (USAbstand<20){
    Serial.println("Notbremse");
    Alf.Brake();                  // Anhalten
  } 
}

Hausaufgaben bis zum 8. Termin

  • Suche mit dem Ultraschall den Bereich 0°-180° vor dem AlphaBot ab.
  • Fahre auf das nächstgelegene Ziel im Sichtbereich zu.
  • Stoppe 10 cm vor dem Ziel.

Musterlösung


→ zurück zum Hauptartikel: Projekt Alf