Projektlabor Robotik MINTgrün

Roboter sollen mit ihrer Umgebung interagieren, um das zu tun müssen sie zunächst in der Lage sein ihre Umgebung wahrzunehmen. Ähnlich wie Menschen über sensorische Hilfsmittel verfügen kann auch ein Roboter mit Sensoren ausgestattet werden die ihm Informationen über seine Umgebung liefern. Jedoch sind unsere Sinnesorgane seit Jahren mit uns verwachsen und unser Gehirn hat sich exakt auf sie eingestellt. Würde man seine Ohren austauschen gegen die seines Nachbarn könnten wir zwar noch immer hören aber das Signal würde sich fehlerhaft anhören aufgrund der veränderten Filtereigenschaften des Aussenohres.
Möchte man seinem Roboter also nicht nur irgendwelche Ohren aufsetzen, sondern genau justierte, sollte man wissen wie das Signal aussieht das aus ihnen rauskommt. Im Folgenden betrachten wir dazu den Distanzen-Sensor von Sharp GP2Y0A60SZLF.

Der erste Schritt führt zum Datenblatt des Sensors, alle wichtigen technischen Daten sind dort zu finden: Datenblatt Sharp bzw. auf der Website des Herstellers Pololu: Sharpy. So erfahren wir das der Sensor alle 16.5 ± 3.7 ms ein neues Messergebnis liefert.
Frequenz = 1/Periode ⇒ Wenn man auf Nummer sicher geht also eine Messfrequenz von 50Hz.

Angenommen wir haben den Sharp-Sensor am Arduino Pin A6 angeschlossen. Nun lesen wir die Spannung aus die an A6 anliegt, diese entspricht unserem Messwert, und eine weitere Messung nach 1ms. Unsere erste Annahme könnte nun sein das die beiden Werte gleich sein müssen bzw. das wir genau vor und nach einem Mess-Update des Sharp-Sensors gemessen haben. Um diese Annahme zu prüfen lassen wir den Arduino so schnell messen wie er kann und speichern die Daten via eines Processing-Sketch in einer Text-Datei um sie anschließend auszuwerten.

Das Arduino Programm sollte so schlank sein wie möglich um sicherzustellen das der Arduino nicht mit anderen Aufgaben beschäftigt ist:

//In dieser Variable wird die momentane Systemzeit gespeichert.
unsigned long currentMicros = 0;
 
void setup() {
    //Serielle Kommunikation (schnellste Baudrate)
    Serial.begin(115200);
}
 
void loop() {
    //aktuelle Zeit
    currentMicros = micros();
    //ausgabe des Messwertes
    Serial.print(analogRead(A6));
    //"tabstop" um den Messwert vom Messzeitpunkt zu trennen
    Serial.print("\t");
    //Messzeitpunkt
    Serial.print(currentMillis);
    //"newline" um die Messungen voneinander zu trennen
    Serial.print("\n");
}

Der Processing-Sketch liest die Daten aus dem Serial-Port aus und schreibt die in eine Text-Datei:

// This program shows how to read numbers in a human readable "ASCII" format from the Serial Port 
// and saves them to a text file
// Created 2013 by Felix Bonowski
// extended 2015 by Corvin Jaedicke
// This code is in the public Domain.
 
import processing.serial.*; //the functionality for using the Serial Port lies in a speical library. This tells Processing to use it.
Serial myPort;        // Create a "serial port" object/variable. "Serial" is the type of the object (just like "int"), "myPort" is the name of the variable
PrintWriter output; // Object that writes to .txt file
 
//this function gets called at the beginnign of the program
void setup () {
  //The file we write to. If not declared otherwise it will be saved in your sketch folder.
  output = createWriter("sharpSensor.txt"); 
  // Initialze Serial communication. There may be multiple serial ports on your computer, so we have to select one:
  String[] portNames=Serial.list();//Serial.list() returns an array of port names
  println(portNames);  //print them to the user
  // initialize the Serial port Object using the last name from the list and a Baudrate of 115200
  myPort = new Serial(this, portNames[portNames.length-1], 115200);
 
  // Set up the screen:
  size(1024, 512); // set size of the window
  background(0);// set  background color to black
  stroke(255); // set the color of things we draw to white
 
  // make the loop run as fast as it can so we dont loose any data
  frameRate(2000);
}
 
//Press mouse to end the programm
void mousePressed() {
    println("Writing to file");
    output.flush();  // Writes the remaining data to the file
    output.close();  // Finishes the file
    exit();  // Stops the program
}
 
//this function is called continously, just as "loop" in arduino
void draw () {
  // get data from the Serial Port and write to file
  readLineFromSerial(myPort);
}
 
 
//this function reads a line from the serial port and writes it to a text file
//multiple numbers can be received if they are separated by tab stops ("\t") 
void readLineFromSerial(Serial  port) {
  byte temp[] = port.readBytesUntil('\n'); //read data from buffer until a new line is finished
 
  // check if any data is available
  if (temp == null) {
     //got nothing - print nothing
  }   
  else {
    String inBuffer = new String(temp); //convert raw data to a string
    inBuffer = trim(inBuffer); //cut off whitespace
    output.print(inBuffer); //print to .txt
    output.print("\n"); //add new line as marker
    output.flush(); //sometimes not everything has been written to the file. This does the job.
  }
}

Für die erste Messung wurde der Sharp-Sensor direkt an den Arduino angeschlossen und mit der Board-Spannung versorgt. Die Entfernung zu einem Hindernis wurde konstant gehalten.

Das Signal zeigt ein starkes rauschverhalten mit Spannungssprüngen von 30mV. Solch große Schwankungen sind für eine präzise Messung natürlich sehr ungünstig. Zwei Lösungen bieten sich hier:

1. Die Messwerte über einen geeigneten Zeitraum (e.g. 20ms) aufsummieren und Mitteln in der Hoffnung dass man größtenteils ein Messplateau erwischt. Vorteil, einfach zu programmieren. Nachteil, kostet viel Rechenzeit, ungenau, im Extremfall völlig falsche Ergebnisse.
2. Ein Tiefpass-Filter der das Signal direkt glättet. Vorteil, sehr schnell und zuverlässig. Nachteil, schlecht gewählte Bauteile beeinträchtigen die Messung.

Ein Tiefpass besteht aus einer Widerstand-Kondensator-Kombination welche man auch RC-Glied nennt. Als Schaltskizze lässt sich das folgendermaßen darstellen:

Wenn sich die Eingangsspannung Ue sprunghaft ändert folgt ihr die Ausgangsspannung Ua mit einer gewissen Trägheit und im Verlauf wie eine Exponentialfunktion bis dieselbe Spannung erreich ist die am Eingang anliegt. In unserem Fall ist es wichtig das die Schaltung nicht zu träge reagiert, da unsere Messungen sonst verfälscht werden. Ein solches Negativbeispiel ist in der nachfolgenden Abbildung zu sehen. Einem Spannungssprung folgt das gefilterte Signal sehr langsam und erreicht nie das Spannungsniveau der Eingangsspannung.

Was sich jedoch schon abzeichnet ist, dass die Spannung-Spikes des Eingangssignals geglättet werden. Wählt man nun eine bessere Kombination des RC-Glieds erhält man ein geglättetes Signal das aber schnell genug auf Spannungsänderungen reagiert (siehe nachfolgende Abbildung). Weitere Informationen insbesondere zur Dimensionierung eures RC-Glieds findet ihr hier: RC-Glied Rechner