Dauerkalender

Flächenüberwachung mit Ultraschall

Mit wenigen Komponenten wird hier eine Schaltung, mit der eine Fläche überwacht werden soll, zusammengestellt. Wir stellen uns als Beispiel ein Gelände vor, das mit einem Ultraschallsensor erfasst werden soll. Ein Ultraschallsensor misst die Entfernung zu Gegenständen und liefert als Ergebnis den Abstand des Sensors zu dem jeweiligen erkannten Objekt. Diese Eigenschaft wird in der Schaltung genutzt. Wenn dank Messung der Entfernung auf dem Gelände ein Fremdkörper erkannt wird, soll dies gemeldet werden. In einem offenen Gelände wäre eine Flächenüberwachung auf diese Weise ziemlich problemlos. Ein Vergleich der gemessenen Entfernung mit der Reichweite des Sensors würde hier ausreichen.
Auf unserem Gelände befinden sich jedoch bereits feste Hindernisse wie ein Lagergebäude, ein Büro und ein Baum, die keine „unerwünschten“ Objekte darstellen. Dies gilt es bei der Auswertung der Messungen zu berücksichtigen.
Unsere zu überwachende Fläche wird in vier Bereiche unterteilt. Die Größe der Bereiche hängt von der Streuung des Ultraschallsensors ab. In unserem Fall kann man von einem 45° Winkel ausgehen. Der Ultraschallsensor wird auf der Welle eines Motors befestigt, so, dass jeder Bereich separat angefahren und vermessen werden kann. Für jeden Bereich wird ein Mindestabstand, der sich auf die in diesem Bereich bereits vorhandenen Objekte bezieht, ermittelt. Erst wenn diese für jeden Bereich spezifische Entfernung unterschritten wird, was auf das Vorhandensein eines unerwarteten Objektes hindeutet, erfolgt eine Warnung. Unser Beispielgelände sieht wie folgt aus:

Schaltplan

Ultraschallsensor

Als Ultraschallsensor kommt ein wasserdichter Ultraschallsensor mit Auswertungsmodul SR04M-2 zum Einsatz. Der Sensor kommuniziert über eine serielle Schnittstelle mit dem Mikrocontroller. Es werden bei SR04M-2 drei Modis zur Verfügung gestellt. In dem Beispiel nutzen wir den zweiten Modus. Er wird eingestellt, indem man an die Pins R27 einen Widerstand von 47kOhm anschließt. In dem Modus liefert der Sensor alle 100 ms eine Messung. Andere Modis werden eingestellt, indem man die R27 Pins unbeschaltet lässt oder dort einen Widerstand von 120 kOhm anschließt.

Schrittmotor

Um den Ultraschallsensor in seine Messposition zu bringen, verwenden wir den Stepp-Motor 28BYJ-48. Die Rolle des Motortreibers übernimmt ein Modul, das auf dem IC ULN2003 basiert. Die Komponenten arbeiten mit 5VDC.

Mikrocontroller

Die Berechnungen und Vergleiche werden von einem Arduino Nano erledigt. Damit man die Situation auf dem seriellen Monitor mitverfolgen kann, wurde hier eine neue Software Schnittstelle für die Kommunikation mit dem Ultraschall-Modul angelegt.

Testschaltung

Programm

#include <Stepper.h>                                       // Bibliothek Stepper.h einbinden
Stepper myStepper(2048, 2, 4, 3, 5);   

#include "SoftwareSerial.h"                                // Bibliothek SoftwareSerial.h einbinden
#define RX2_Pin 6                                          // Serielle Schnittstelle 2 RX: Pin 6
#define TX2_Pin 7                                          // Serielle Schnittstelle 2 TX: Pin 7
SoftwareSerial Serial2(TX2_Pin, RX2_Pin); 

int Taster_Linkslauf = A4;                                 // Taster Handbetrieb Linkslauf Pin A4
int Taster_Rechtslauf = A5;                                // Taster Handbetrieb Rechtslauf Pin A5
int Schalter_Auto = A3;                                    // Schalter Automatik Pin A3
int LED_Alarm = A2;                                        // Leuchtdiode Alarm Pin A6
int Bereich_Nummer;
int Bereichsentfernung_Min [4] = { 450, 650, 1000, 370 };
int Entfernung;

// ************************************************************************************************
void setup() {

    pinMode (Taster_Linkslauf, INPUT_PULLUP);              // IO-Konfiguration
    pinMode (Taster_Rechtslauf, INPUT_PULLUP);
    pinMode (Schalter_Auto, INPUT_PULLUP);
    pinMode (LED_Alarm, OUTPUT);
    myStepper.setSpeed(3);                                 // Geschwindigkeit 
    Serial.begin(9600);                                    // Serielle Schnittstellen aktivieren
    Serial2.begin(9600); 
}

// ************************************************************************************************
void loop() {

    if (digitalRead(Taster_Rechtslauf) == LOW) {      // Handbetrieb: Rechtslauf
        myStepper.step(1);                            // Motordrehung rechts
    }
    if (digitalRead(Taster_Linkslauf) == LOW) {       // Handbetrieb: Linkslauf
        myStepper.step(-1);                           // Motordrehung links
    }    
                                                      // Automatik start
    if (digitalRead(Schalter_Auto) == LOW) {
        Bereich_Nummer = 1;                           // Bereich Startnummer
        Bereich_untersuchen ();                       // Entfernung messen
        for (int i=0; i<3; i++) {                     // Rechtsdrehung
            myStepper.step(256);                      // Bereich-Mitte anfahren
            delay (500);                              // Wartezeit
            Bereich_Nummer++;
            Bereich_untersuchen ();                   // Entfernung messen
        }
        for (int i=0; i<3; i++) {                     // Linksdrehung
            myStepper.step(-256);                     // bereich-Mitte anfahren
            delay (500); 
            Bereich_Nummer--;
            Bereich_untersuchen ();                    // Entfernung messen
        }
    }
}

// ************************************************************************************************
void Bereich_untersuchen () {

    for (int i=0; i<30; i++) {
        if (Serial2.available()){                                           // Daten vorhanden 
            byte Puffer [3];                                                // Puffer-Variable
            byte Start_Byte = (byte)Serial2.read();                         // Startwert
            if (Start_Byte == 255){                                       
                Serial2.readBytes(Puffer, 3);                               // Puffer laden
                Entfernung = (Puffer [0]<<8) + Puffer [1];                  // Berechnung der Distanz
                byte QS = ((Start_Byte + Puffer [0] + Puffer [1])&0xFF);    // Quersumme
                if (QS == Puffer [2]) {                                     // Quersumme OK?
                    Serial.print("Entfernung = ");                          // Serieller Monitor
                    Serial.println(Entfernung);                             // 
                }
            }
        }
        delay (50);
    }

    if (Entfernung < Bereichsentfernung_Min [Bereich_Nummer - 1]) {
        digitalWrite (LED_Alarm, HIGH);                                     // LED für 3 Sek. an    
        delay (3000);
        digitalWrite (LED_Alarm, LOW);                                      // LED aus
        delay (3000);
    }
}

// ************************************************************************************************

        

Kurzvideo

Weitere Themen: