Autoren: Phillip Blunck, Simon Kohfeld, Marius Schaffer

Aufgabe

Mit Hilfe der Ultraschallsensoren (Abb. 1) sollen Hindernisse erkannt werden. Dabei müssen die Sensoren an die Hauptplatine angeschlossen und softwareseitig in MATLAB für das Hauptprogramm bereitgestellt werden. Als redundantes System ist zusätzlich ein Bumper-Sensor vorgesehen,der seinen Status über eine boolsche Variable an die Hauptsteuerung weitergibt.

Einleitung

Dieser Artikel stellt alle Arbeitsmeilensteine dar, die während des Semesters von der Gruppe erarbeitet wurden oder noch zu erledigen sind.

Ultraschall

Anforderungen

Spezifikations-ID	Anforderungs-ID	Anforderung
0130	REQ10.2250	2.2 Hinderniserkennung. Statische und dynamische Objekte werden sensorisch erkannt und umfahren.
0131	REQ10.2251	Verbauen der US-Sensoren
0132	REQ10.2252	Basistest mit Matlab und Arduino
0133	REQ10.2253	Erfassungsbereich visualisieren
0134	REQ10.2254	Auf gegenseitige Störung prüfen
0135	REQ10.2255	Triangulationsmöglichkeit prüfen
0136	REQ10.2256	Schnittstelle zu 0170 absprechen
0137	REQ10.2257	Messfehler feststellen
0138	REQ10.2258	Schnittstelle zur Umfahren-Strategie

Technische Daten des Moduls

Messbereich

Messintervall

Messungen pro Sekunde

Versorgunsspannung

Pinbelegung

2cm - 300cm

0,3cm

maximal 50

VCC +5V +-10%, GND 0V

Pin 1:	Pin 2:	Pin 3:	Pin 4:
VCC 5V	Triggereingang	Echo	GND 0V

Link zum Datenblatt

Funktionsweise des Moduls

Durch eine fallende Flanke am Triggereingang für mindestens 10µs wird der Messzyklus gestartet. Anschließend wird nach ca. 250µs ein 40kHz Burst-Signal für 200µs gesendet und der Ausgang (Echo) wechselt auf ein H-Pegel. Daraufhin wartet das Modul auf dem Empfang des Echos. Falls es detektiert wird, fällt der Ausgang auf einen L-Pegel. 20ms nach der Triggerung kann eine neue Messung durchgeführt werden. Wird jedoch kein Echo detektiert bleibt der Ausgang für 200ms auf dem H-Pegel und eine erfolglose Messung ist eingetreten. Danach reagiert das Modul auf die nächste fallende Flanke am Triggereinang und die Messung beginnt neu. (Siehe Abb.2)

Verbauen der Ultraschallsensoren

In der Frontplatte (Abb.3) des Ardumowers sind sechs Bohrungen enthalten, welche für die Montage der drei Ultraschallsensoren (Abb.1) vorgesehen sind. Diese liegen zentral, links und rechts, damit ein möglichst großer Bereich erfasst werden kann.

Die Ultraschall Sensoren werden auf der Hauptplatine (Abb.5) an den vorgesehenen Pins angeschlossen. Dabei haben diese eine feste Pin-Belegung (Abb.4) am Arduino Mega:

Sensor Mitte: PIN24 = Trigger, PIN22 = Echo
Sensor Links: PIN34 = Trigger, PIN36 = Echo
Sensor Rechts: PIN30 = Trigger, PIN32 = Echo

Außerdem ist darauf zu achten wie die Sensoren an der Hauptplatine (Abb.8) verkabelt werden. Damit keine Fehler auftauchen sind die Pins nummeriert und haben dieselbe Reihenfolge:

1 = VCC +5V
2 = GND
3 = Trigger
4 = Echo.

Abb.4: Pinlayout Arduino Mega
Abb.5: Pinlayout auf der Hauptplatine
Abb.6: HC-SR04 am Mini
Abb.7: HC-SR04 am Ardumower
Abb.8: Pins auf der Hauptplatine

Basistest mit MATLAB und Arduino

Mit Hilfe von MATLAB und der Arduino IDE wurden Basistests durchgeführt, um die Funktion des Sensors zu testen und zu beobachten. Dabei wird eine Library für MATLAB verwendet, welche auch für Arduino eingesetzt werden kann, da sie für beide Software-Umgebungen eine fertige Funktion (Ausgabe der Distanz in Zentimeter) bereitstellt. Jedoch kann diese Bibliothek nur für MATLAB Skripts/Arduino verwendet werden und eine eigene Umsetzung in Simulink stellt deshalb ein Problem dar. Eine Lösung für Simulink wäre, den Arduino "C-Code" als S-Fuction umzuwandeln, um damit einen eigenen Simulink-Block zu generieren. Dabei könnten alle kompatiblen Bibliotheken für den HC-SR04 eingebunden werden oder man setzt folgenden Funktion als S-Function um.

#define TRIGGER 3 
#define ECHO 2    

int getEntfernung()
{
  long d=0;
  long t=0;

  digitalWrite(TRIGGER, LOW);
  delayMicroseconds(3);
  noInterrupts();
  digitalWrite(TRIGGER, HIGH); //Trigger Impuls für 10 us
  delayMicroseconds(10);
  digitalWrite(TRIGGER, LOW);
  t = pulseIn(ECHO, HIGH); // Echo-Zeit messen
  interrupts();
  t = (t/2); // Zeit halbieren da doppelte Strecke zurückgelegt wird
  d = t / 29.1; // Zeit in cm umrechnen
  return(d);
}

Dieser Quelltext ist eine Umsetzung der Abläufe für eine Distanzmessung, welche nur mit der eigenen Arduino Bibliothek generiert werden kann, sodass man unabhängig von fertigen Libraries ist. Die Funktion gibt die Entfernung in Zentimeter aus und kann bspw. wie bereits gennant, als S-Funktion implementiert werden.

Auf gegenseitige Störung prüfen

Bei Distanzen unter 1m kann der Winkel zum Objekt 45° betragen

Bei einer Distanz von 3m muss das Objekt genau positioniert sein und im Sendekegel von 15° liegen.

Sensoren werden nacheinander ausgelesen, sodass keine Überschneidungen vorliegen

Messfehler feststellen

Bei Verwendung des Ultraschallmoduls können folgende Messfehler auftreten:

Auflösung: Die Auflösung beträgt ca. 3mm und erklärt sich durch die interne Abtastrate des Moduls
Objekte: Die Geometrie eines zu messenden Objektes beeinflusst maßgeblich die Qualität der Messung
Temperatur: Da die Schallgeschwindigkeit in der Luft temperaturabhängig ist, ergeben sich andere Messergebnisse bei unterschiedlichen Temperaturen. Bei einer Temperaturdifferenz von 20°C ergibt sich ein Messfehler von 3,4%.

Eine Lösung für die auftretenden Messfehler wäre eine Temperaturkompensation in die Messung zu integrieren. Da die Schallgeschwindigkeit im Temperaturbereich näherungsweise mit folgender Formel berechnet werden kann:

$c_{Luft}\approx (331,5+0,6\vartheta /^{\circ}C)\frac{m}{s}$ ,

könnte man mit Hilfe eines Temperatursensors im Ardumower den tatsächlichen Temperaturwert in die Berechnung der Distanz integrieren und die getätigten Messungen werden somit mit der richtigen Schallgeschwindigkeit durchgeführt.

Filtern der Messwerte

Die Rohmessungen werden mit Hilfe eines gewichteten gleitenden Mittelwertes gefiltert, um große Messausreißer zu mindern:

$m_x^{(n)}(t-\tau) = \sum_{i=0}^{n-1} w_i \cdot x(t-i)$ . Dabei ist $w_i$ die Gewichtung der Datenpunkte. Folglich ist eine Umsetzung in C-Code dargestellt.

//Gleitender Durchschnitt Gewichtet
int alt=0;
int mittel;
int entf;
int i;

delay(10);
alt=dis;
delay(10);
for (i=0; i<10; i++)
{
    entf=dis;
    mittel=(0.8*alt) + (0.2*entf);
    alt=mittel;
    delay(10);
}
      
d[0] = mittel; //Gefiltertes Ergebnis als OUTPUT

In Simulink wird der fertig verwendbare "Moving-Average-Block" (Gleitender Mitterlwert) für die Filterung der Rohwerte benutzt.

Umsetzung in Simulink

Für die Umsetzung wurde zunächst eine S-Function generiert, welche als Block in Simulink genutzt wird. Der Block enthält den folgenden Quellcode zum Auslesen des Ultraschallmoduls und wird drei mal verwendet, da drei Sensoren ausgelesen werden. Des Weiteren wurden Konstante Zahlen als Block eingefügt, die der Pinbelegung für die Sensoren auf der Hauptplatine entsprechen. Diese werden an die Eingänge des S-Function-Blocks angeschlossen, welche somit den Trigger- und Echo-PINs entsprechen. Schließlich werden die Ausgänge der Ultraschallsensoren mit Hilfe eines eines gleitenden Mittelwerts gefiltert und auf einen BUS gelegt, sodass die gemessenen Distanzen in Zentimeter für die anderen Module bereit stehen.

Quellcode der S-Function:

/*
 * Include Files
 *
 */
#if defined(MATLAB_MEX_FILE)
#include "tmwtypes.h"
#include "simstruc_types.h"
#else
#include "rtwtypes.h"
#endif

/* %%%-SFUNWIZ_wrapper_includes_Changes_BEGIN --- EDIT HERE TO _END */
# ifndef MATLAB_MEX_FILE
# include <math.h>
# include <Arduino.h>
# endif
/* %%%-SFUNWIZ_wrapper_includes_Changes_END --- EDIT HERE TO _BEGIN */
#define u_width 1
#define y_width 1

/*
 * Create external references here.  
 *
 */
/* %%%-SFUNWIZ_wrapper_externs_Changes_BEGIN --- EDIT HERE TO _END */
/* extern double func(double a); */
/* %%%-SFUNWIZ_wrapper_externs_Changes_END --- EDIT HERE TO _BEGIN */

/*
 * Output functions
 *
 */
void sfun_us_Outputs_wrapper(const uint8_T *e,
			const uint8_T *t,
			uint32_T *d,
			const real_T *xD)
{
/* %%%-SFUNWIZ_wrapper_Outputs_Changes_BEGIN --- EDIT HERE TO _END */
if (xD[0]==1) {
    # ifndef MATLAB_MEX_FILE
	  //Aufruf für Distanz
	  long dis=0;
      long zeit=0;
      
      digitalWrite(t[0], LOW);
      delayMicroseconds(2);
      digitalWrite(t[0], HIGH); //Trigger Impuls 10 us
      delayMicroseconds(10);
      digitalWrite(t[0], LOW);
      zeit = pulseInLong(e[0], HIGH, 6000); // Echo-Zeit messen
	  if(zeit == 0){
		  zeit = 6000;
	  }
      zeit = (zeit / 2); // Zeit halbieren
      dis = (zeit / 29); // Zeit in Zentimeter umrechnen
      
      delay(10);

      if (dis>100)
	  {
		  dis=100;
	  }
      d[0] = dis; //Ergebnis als OUTPUT
    # endif
}
/* %%%-SFUNWIZ_wrapper_Outputs_Changes_END --- EDIT HERE TO _BEGIN */
}

/*
 * Updates function
 *
 */
void sfun_us_Update_wrapper(const uint8_T *e,
			const uint8_T *t,
			uint32_T *d,
			real_T *xD)
{
/* %%%-SFUNWIZ_wrapper_Update_Changes_BEGIN --- EDIT HERE TO _END */
if (xD[0]!=1) {
    # ifndef MATLAB_MEX_FILE
    pinMode(t[0], OUTPUT);
    pinMode(e[0], INPUT);
    digitalWrite(t[0], HIGH);
    # endif
    
    xD[0]=1;
}
/* %%%-SFUNWIZ_wrapper_Update_Changes_END --- EDIT HERE TO _BEGIN */
}

Bumper

Der Bumper ist unter dem Namen Bumperduino schon vollständig von den Entwicklern des Ardumower umgesetzt worden. Die Steuerung befindet sich auf einer separaten Platine, die lediglich an die vorgesehenen Pins der Hauptplatine angeschlossen werden muss. Das Auslesen ist über eine Open-Collector-Schaltung vorgesehen. Bei der Integration des Bumpers treten Probleme mit dem Auslesen über den Open-Collector auf. Aus diesem Grund wird die Steuerungsplatine umprogrammiert und es werden direkt die HIGH und LOW Signale an zwei freien Pins ausgelesen.

Zusammenfassung & Ausblick

SS2017

Zusammenfassend lässt sich festhalten, dass die festgelegten Ziele im Pflichtenheft zu den jeweiligen Meilensteinen umgesetzt worden sind. Die Ultraschallsensoren konnten erfolgreich in MATLAB und Arduino in Betrieb genommen, die Sensoren im Ardumower verbaut und auch am Ardumower-Mini getestet werden. Jedoch die Einbindung in das Simulink-Modell stellte sich als schwierig dar, weil es keinen Simulink-Block für den Ultraschallsensor gibt.

Für das nächste Semester soll nun eine S-Function generiert werden, welche dann als Simulink-Block eingesetzt wird. Wenn dieser Schritt erfolgreich umgesetzt wurde, können die Absprachen mit der Gruppe Mähstrategie durchgeführt werden. Damit verbunden müssen bspw. die Objektbildung und Koordinatentransformationen in das Fahrzeugkoordinatensystem, die Filterung der Rohmessungen und die Fehlerkompensation umgesetzt werden.

WS2017

Zum 3. Meilenstein wurden die Ultraschallmodule erfolgreich in das Hauptprogramm eingebunden. Dies geschah mit Hilfe einer selbst erstellten S-Function. Außerdem wurde ein Gleitender Mittelwert als Filter für das Rohsignal verwendet.

ArduMower: Umfeldsensorik

Inhaltsverzeichnis