Arduino Sensorsystem für THOMAS

0

Wie ich bereits vor einigen Wochen in diesem Artikel berichtete, haben wir uns entschlossen, den Roboter mit einem möglichst modularen System zur Erfassung von Sensordaten und zur Überwachung der Roboter-Hardware auszustatten. Zunächst hatten wir hierfür die Verwendung der myAVR-Hardware geplant, haben uns aus Kostengründen jedoch für eine Alternative in Form des Arduino Mega 2560 entschieden. Diesen konnte ich gestern bereits einem kleinen Test unterziehen.

Bestellt haben wir neben dem eigentlichen Board ein 4 x 20 Zeichen Character-LCD, das über die I²C-Schnittstelle mit dem Arduino-Baord kommuniziert. Hierdurch werden lediglich zwei Pins des Mikrocontrollers belegt und nicht wie in der 4- oder 8-bit Ansteuerung 8 bzw. 12 Pins. Zudem könnten über dieselben Pins, also die I²C-Schnittstelle, noch bis zu 1136 weitere Geräte adressiert werden. Weiterhin haben wir die ersten Sensoren für den Roboter bestellt. Hierbei handelt es sich um fünf Ultraschallsensoren vom Typ HC-SR04. Diese verfügen über zwei Pins, die mit dem Mikrocontroller verbunden werden. Einer dient als Trigger, der, sobald ein 10 Mikrosekunden langer High-Impuls ankommt, 8 Ultraschallpulse mit einer Frequenz von 40 Kilohertz auslöst. Ein weiterer Pin dient als Ausgang des Messignals. Hier wird eine Rechteckspannung ausgegeben, deren Frequenz proportional zur Entfernung des gemessenen Objekts ist. So wird eine einfache Berechnung der Distanz zwischen Sensor und Objekt ermöglicht.

Um die Funktion der einzelnen Bauteile zu überprüfen, habe ich einen Entfernungsmesser aufgebaut, der die Entfernung zu einem Objekt auf dem LCD ausgibt. Das ging dank entsprechender Libraries für das Display und die Sensoren überraschend schnell und problemlos. Dazu habe ich folgenden Code verwendet.

/*-----( Import needed libraries )-----*/ 
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

/*-----( Declare Constants )-----*/
#define I2C_ADDR    0x20  // Define I2C Address for the PCF8574A 
//---(Following are the PCF8574 pin assignments to LCD connections )----
// This are different than earlier/different I2C LCD displays
#define BACKLIGHT_PIN  7
#define En_pin  4
#define Rw_pin  5
#define Rs_pin  6
#define D4_pin  0
#define D5_pin  1
#define D6_pin  2
#define D7_pin  3

#define  LED_OFF  0
#define  LED_ON  1

/*-----( Declare objects )-----*/  
LiquidCrystal_I2C  lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);

int pingPin = 13;
int inPin = 12;
 
void setup() {
  lcd.begin (20,4);  // initialize the lcd
  lcd.setBacklightPin(BACKLIGHT_PIN,NEGATIVE);
  lcd.setBacklight(LED_ON);
}
 
void loop()
{
  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  long duration, inches, cm;
   
  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(pingPin, LOW);
   
  // The same pin is used to read the signal from the PING))): a HIGH
  // pulse whose duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(inPin, INPUT);
  duration = pulseIn(inPin, HIGH);
   
  // convert the time into a distance
  inches = microsecondsToInches(duration);
  cm = microsecondsToCentimeters(duration);

  // Reset the display  
  lcd.clear();
  lcd.home();
  
  // Print characters on the LCD
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Entfernung:");
  lcd.setCursor(12,0);
  lcd.print(cm, DEC);
  lcd.setCursor(17,0);
  lcd.print("cm");
  
  delay(200);
}
 
long microsecondsToInches(long microseconds)
{
// According to Parallax's datasheet for the PING))), there are
// 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
// second).  This gives the distance travelled by the ping, outbound
// and return, so we divide by 2 to get the distance of the obstacle.
return microseconds / 74 / 2;
}
 
long microsecondsToCentimeters(long microseconds)
{
// The speed of sound is 340 m/s or 29 microseconds per centimeter.
// The ping travels out and back, so to find the distance of the
// object we take half of the distance travelled.
return microseconds / 29 / 2;
}

In der Bildergalerie sehen Sie den Aufbau der Schaltung, der im Wesentlichen aus dem Arduino-Board und den Verbindungen zum Display bzw. Sensor besteht. Die zusätzlichen Bauteile auf dem Steckbrett gehören allerdings nicht zu dieser Schaltung.

Nächste Woche werde ich die Hardware meinen Nachfolgern im THOMAS-Projekt überlassen, sodass sie sich mit dem Problem der parallelen Ansteuerung mehrerer Sensoren befassen können. Ich werde mir jedoch privat das gleiche Setup kaufen, sodass ich ebenfalls am Sensorsystem mitarbeiten kann.

Hinterlasse eine Antwort

Ihre Email-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert.

*

Zu diesem Artikel sind bisher keine freigegebenen Kommentare vorhanden.