Rasensensor

Details

Tipp: Benutze das WIKI für aktuelle Informationen!

capactiy

Ein Rasensensor soll erkennen, ob der Roboter sich noch auf Rasen oder bereits über anderem Untergrund (z.B. Steinen) befindet. Mit anderen Worten, es soll herausgefunden werden, welches Medium (Luft oder Rasen) sich unter dem Roboter befindet. Dazu kann man z.B. die Kapazität eines Sensors messen, da diese durch Luft bzw. Rasen unterschiedlich beeinflußt wird. Hingegen keinen Unterschied gibt es hierbeit zwischen Rasen und Blumenbeet etc. - man sollte also beim Einsatz dieser Methode rings um den Rasen einen kleinen Abschnitt haben welcher dem Rasen nicht allzu ähnelt (z.B. Rindenmulch/Steine). Auch funktioniert so ein Rasensensor nicht besonders gut bei Nässe, da ggf. feuchter Rasen am Sensor hängen bleibt und der Sensor dann nicht mehr optimal messen kann.

Funktionsweise
Ein Rasensensor ist im Prinzip eine Kupferplatte, welche sich in einem Kunststoffgehäuse befindet. Um nun herauszufinden, ob das Sensorgehäuse Kontakt mit Rasen hat, mißt man die elektrische Kapazität eines Sensors. Setzt man den Roboter auf Rasen (Rasen ist quasi Dielektrikum), steigt die gemessene Kapazität leicht (um wenige pF) an.

Ambrogio L50 capacity measurement     lawn sensor       capsense

kein Rasen: ~0 pF
auf Rasen: 1-4 pF



Verdrahtung:

Rasensensor vorne:
Arduino Mega Pin 40 Receive Front ------------|

Arduino Mega Pin 41 Send    Front --- 2 MOhm -+---|   Rasen

Rasensensor hinten:
Arduino Mega Pin 42 Receive Back  ------------|

Arduino Mega Pin 43 Send    Back  --- 2 MOhm -+---|   Rasen
                            

Detaillierte Funktionsweise:
Der Sensor besteht z.B. aus einer (Kupfer-)Platte in einem geschlossenen Kunsstoffrohr welches in 2cm Abstand üben den Rasen geführt wird. Zunächst wird die Platte über den Send-Pin entladen (auf “Low” gezogen). Dann wird der Send-Pin auf “High” umgestellt, über einen Widerstand (2 Megaohm) wird die Platte Kabel jetzt langsam aufgeladen. Über den Receive-Pin Pin 2 wird nun die Zeit gemessen, bis dieser auf “High” liegt (Kapazitätsmessung). Da Mikrocontroller sehr schnell und genau in Zeitmessungen sind, kann man hiermit noch geringste Kapazitäten nachweisen.


Motortreiber

Details

Tipp: Benutze das WIKI für aktuelle Informationen!

Um einen Motor anzusteuern braucht’s einen Motortreiber, welcher im Grundprinzip eine  Schaltung ist, welche den Strom entweder in die eine oder andere Richtung durch den Motor schickt, je nachdem ob der Motor vorwärts oder rückwärts laufen soll (sog. H-Brücke). Viele Motortreiber gibt’s als fertig aufgebaute Platinen und einige können zwei Motoren ansteuern (Dual-H-Bridge) - schaltet man die beiden H-Brücken parallel kann der maximal mögliche Motorstrom verdoppelt werden.

Soll die Richtung des Motors nicht gesteuert werden (wie z.B. beim Mähwerk), braucht man hierfür keine H-Brücke, sondern nur einen einfachen “Schalter” (z.B. MOSFET-Transistor-Schaltung), also:

Antriebsmotor: ein Motortreibermodul je Motor
Mähmotor: eine MOSFET-Schaltung

Entscheidende Kaufkriterien

  • max. thermische Belastbarkeit (Kurzschlußstrom)
  • Preis

Vorschläge für Motortreibermodul

 

Antriebsmotor - Verdrahtung
Der Motortreiber wird über Steuersignale mit dem Arduino verbunden. Beispiel:

Arduino Digital Pin —> MOTOR-DIR Pin
Arduino PWM Pin —> MOTOR-PWM Pin
Arduino Analog Pin <— MOTOR-Stromsensor Pin

Ein Pin steuert die Richtung (vor/zurück), der andere die Geschwindigkeit. Ein analoger Eingangs-Pin wird mit dem Stromsensor verbunden. Das Stromsensormodul (ACS712-05A) wird in Reihe mit dem Motor geschaltet. Der nächste Abschnitt beschreibt wie das Stromsensormodul mit dem Arduino verbunden wird.

Arduino motor driver

(Hinweis: für vollständige Verdrahtung, siehe Schaltbild)


Verdrahtung (MC33926 Motortreiber)

mc33926      
mc33926 example       MC33926 schematics
M1_FB     --- Motor1 Stromsensorausgang (Arduino)
M1_PWM_D1 --- mit Jumper auf GND
M1_PWM_D2 --- mit Jumper auf VDD
M1_IN1    --- Motor1 PWM (Arduino)
M1_IN2    --- Motor1 Dir (Arduino)
EN        --- mit Jumper auf VDD
M2_FB     --- Motor2 Stromsensorausgang (Arduino)
M2_PWM_D1 --- mit Jumper auf GND
M2_PWM_D2 --- mit Jumper auf VDD
M2_IN1    --- Motor2 PWM (Arduino)
M2_IN2    --- Motor2 Dir (Arduino)
EN        --- mit Jumper auf VDD
VDD       --- Arduino 5V


Verdrahtung (L298N Motortreiber)

motordriver l298n     L298N schematics


1. Zunächst sicherstellen, dass die beiden Motortreiberbrücken (2A) parallel geschaltet wurden, so dass zwei Motorbrücken einen Motor antreiben (max. 4A):
l298driver

Dazu parallel schalten:
IN1 mit IN4
IN2 mit IN3
OUT1 mit OUT4
OUT2 mit OUT3
(IN1 ist jetzt also indentisch mit IN4 bzw. IN2 mit IN3)
(Die SENSE-Leitungen nur durchtrennen, falls der Strom über Shunt-Widerstände gemessen werden soll - siehe Abschnitt Stromsensor weiter unten).
2. Sicherstellen, dass auf ENA und ENB jeweils ein Jumper sitzt (also beide Brücken aktiviert sind).
3. Der Jumper S1 für den Spannungsregler muss ebenfalls sitzen (LED auf Platine leuchtet). Wenn man den Jumper S1 drinlässt, bekommt der Motortreiber seine +5V über den auf der Platine integrierten Spannungsregler (man braucht also nichts machen). Nimmt man ihn los, wird der Spannnungsregler deaktiviert und man muss die externen +5V anschliessen.
4. Nun Arduino Pins verbinden:
"IN2" wird auch manchmal als "C" bezeichnet, oder als "10" oder als PinPWM.
"IN1" wird auch manchmal als "D" bezeichnet, oder als "12" oder als PinDir.

L298 motor driver
IN2/C(10)/PinPWM    IN1/D(12)/PinDir
H                   L     Forward
L                   H     Reverse    

Die Logik beim ansteuern ist wie folgt: Wird PinDir auf LOW (L) geschaltet, steuert PinPWM die Geschwindigkeit. Ist PinPWM dabei dauerthaft HIGH (H), fährt der Robot mit voller Leistung vorfährts. Je seltener PinPWM auf HIGH geschaltet wird, umso langsamer fährt der Robot vorfährts.
Wird PinDir auf HIGH (H) geschaltet, steuert PinPWM die Geschwindigkeit. Ist PinPWM dabei dauerhaft LOW (L), fährt der Robot mit voller Leistung rückwärts. Je seltener PinPWM auf LOW geschaltet wird, umso langsamer fährt der Robot rückwärts.


Verdrahtung (L9958
Motortreiber)

motor driver L9958

L9958 GND---GND
L9958 VCC---Arduino 5V
L9958 EN---Arduino 5V
L9958 DI---GND
L9958 DIR---Arduino MOTOR_DIR
L9958 PWM---Arduino MOTOR_PWM
L9958 MOTOR(+)---motor(+)
L9958 MOTOR(-)---motor(-)
L9958 POWER(+)---battery(+)
L9958 POWER(-)---battery(-)



Motortreiber-Test

Nun zum Testen (auch für spätere Dinge wie Sensoren etc.):
Am einfachsten ist es die Serielle Arduino-Konsole aufzumachen (CTRL+SHIFT+M), dann 19200 Baud einzustellen. Dort sieht man dann alle Sensorwerte etc. Nun drückt man 't' um in den Testmodus zu gelangen. Dort kann man dann die Motoren testen. Achja: Robot am besten dazu aufbocken (z.B. auf Karton). Und vorsichtig mit den Messern! ;-)
PS: Die Anschlüsse der Motoren (OUT1, OUT2) müssen evtl. getauscht werden wenn die Drehrichtung nicht stimmt (also vorwärts nicht vorwärts ist).

warning Warnhinweis: Aus Sicherheitsgründen für's erste Testen Mähmotor immer ohne Messer betreiben!

 

Mähmotor (Variante "PWM-Modul")

pwm motor modul

Hierbei wird für den Mähmotor ein fertiges PWM-Modul verwendet (z.B. 10A PWM Modul = DC Motor Speed Controller).
Es gibt mehrere Fertig-Module (5A bis 15 A) die über PWM einen DC Motor treiben können. I.d.R. sind diese mit einem Poti und einem NE555 für die PWM-Erzeugung aufgebaut. Diese Module passen für einen (direkten) Anschluss an einen Arduino nicht unbedingt. Es gibt nun 2 Möglichkeiten diese Module anzuschliessen:

1. an einen Arduino PWM-Ausgang wird ein Tiefpass angeschlossen. Dieser erzeugt aus dem PWM-Signal eine analoge Spannung von 0-5V. Der Tiefpass ist (einfach) ein Widerstand (ca. 4,7kOhm) und ein Kondensator (Elko 1 bis 10 uF, gepolt ca.35V) gegen GND/0V. Damit wird der Eingang (=Poti-Spannung) des 10A-Moduls angesteuert. Hierzu wird das am Modul vorhandene Poti ausgelötet oder abgeklemmt und der Poti-Schleifer-Punkt (C) an den Tiefpass angeschlossen. PWM-Frequenz und Prinzip des Moduls bleiben erhalten.

PWM 10A Modul Poti (A) --- offen lassen
PWM 10A Modul Poti (B) --- offen lassen
PWM 10A Modul Poti (C) --- 4,7k ---+-----  Arduino Digital Out (PWM)
10uF
+
GND
PWM 10A Modul GND --- Batterie (-)

PWM 10A Modul VCC --- Batterie (+)

2. Der PWM-Signal-Ausgang des Arduino wird direkt im Modul angeschlossen. Hierzu ist leider keine allg. Umbauanleitung möglich, da jedes Modul etwas anders aufgebaut ist. Bei Module mit dem NE555 zur PWM-Erzeugung wird jedoch immer der Ausgang des NE555 durch den PWM-Ausgang des Arduino direkt ersetzt. Es muss also min. eine Leiterbahn im Modul geändert, neu angeschlossen werden. PWM-Frequenz des Moduls bleibt nicht erhalten.

Zum Nachbau wird derzeit die Variante 1 empfohlen. Eine Umbau- Anleitung für ein bestimmtes 10A-Modul für die Variante 2 gibt es hier.

Nachteile: Alle Module haben keine elektronische Überstromsicherung. Einige nur eine 10A Schmelzsicherung als Schutz. Das ist nicht sehr elegant, aber ausreichend für eine einfache Motorsteuerung.

 

Mähmotor (Variante "MOSFET")
Hierbei wird für den Mähmotor eine MOSFET-Schaltung verwendet. Der verwendete MOSFET-Transistor IRLIZ44N (Alternativen: IRF1404, IRL540N, RFP30N06LE, FQP30N06L) kann beim 5V-Arduino-Steuersignal bereits 30A durchschalten (N-LogL). Der 10K Widerstand zieht das Gate nach Masse wenn der Arduino bootet und dessen Ausgang hochohmig ist. Der 180 Ohm Widerstand begrenzt den Umladestrom des Gate bei einem Pegelwechsel auf ca. 30mA (Umschaltstrom am Gate durch PWM). Die Rücklaufdiode (MBR1045) schützt die Schaltung gegen die induktive Motorlast. Ein Stromsensormodul (ACS712-30A) wird in Reihe mit dem Motor geschaltet.

Arduino motor       mosfet

Sensor für Strommessung
Um besondere Umstände zu erkennen (Roboter fährt gegen Hindernis / Blockade eines Motors) sollte der Motorstrom im Betrieb fortlaufend gemessen werden.
Es gibt hierfür zwei Ansätze.

Strommessung (Variante "Hall-Sensor-Modul")
Diese Variante kommt ohne Löten aus. Die Stromsensor-Module gibt es für verschiedene Arbeitsbereiche, z.B.

  • ACS712ELC-05A (185mV/A, max. 5A)
  • ACS712ELC-20A (100mV/A, max. 20A)
  • ACS712ELC-30A (66mV/A, max. 30A)
  • Je niedriger der Arbeitsbereich, desto höher die Meßauflösung.


Strommessung (Variante "Shunt-Widerstand")
Bei dieser Variante ist etwas Lötarbeit erforderlich. Der Motorstrom wird über sehr kleinen Widerstand geschickt und der dort erzeugte Spannungsabfall wird mit dem Arduino gemessen.

Beispiel für STL298N Dual H-Bridge (zwei H-Bridges werden parallel geschaltet):

gemessener Motorkurzschlußstrom: 4,5A
=>Motorkurzschlußstrom pro H-Bridge: 2,25A
gewählter Meßwiderstand: 0,5 Ohm (Achtung: Widerstand mit hoher Leistung verwenden)
=> Spannungsabfall am Meßwiderstand:
U=R*I=0,5 Ohm*2,25 A=1,125V
=> max. verbrauchte Leistung am Meßwiderstand:
P=I^2*R=2,25A^2*0,5Ohm=2,5W
=> Meßauflösung (Arduino Analog-Pin 1024 Bit):
Volt pro Bit: 5V/1024 Bit=0,00488V/Bit
Auflösung (Schritte): 1,25V / 0,00488V=256
Meßauflösung: 2,25A/256=9 mA
Wichtig: die ermittelten Leistungswerte treten nur im Worst-Case, d.h. für einen Bruchteil einer Sekunde auf (Motorkurzschlußstrom)

Schaltbild/Verdrahtung:
l298n module circuit

Der Meßwiderstand (hier 0,5 Ohm) wird zwischen SENA (SENB) und Masse geschaltet (bei der fertigen Motorplatine mussten hierfür Leiterbahnen durchtrennt werden. Die abgegriffene Meßspannung geht über einen 5K Vorwiderstand in den Arduino-Analog-Eingang, ein Kondensator eliminiert das Schwingen durch die PWM-Ansteuerung).
Die gezeigte Lösung ist nicht ganz optimal, da der Shunt-Widerstand relativ viel Leistung verbraucht. Ggf. noch kleineren Shunt-Widerstand verwenden und Spannungsabfall mit Operationsverstärker verstärken.

 

Wahl des richtigen Motortreibers (Kurzschlußstrom)
Damit man den Motortreiber nicht gleich beim ersten Betrieb in den sicheren Überhitzungstod schickt, sollte man bereits vor der Auswahl eines Motortreibers ermitteln, welcher Strom überhaupt maximal über den Motor fließen kann. Hierfür kann man z.B. den Motorkurzschlußstrom ermitteln. Mein Aufbau hierfür:

Akku === Amperemeter === Motor

Das Amperemeter (z.B. vom Modellbau) sollte für den zu messenden Kurzschlußstrom ausgelegt sein (z.B.  30A). Der zu messende Motor wird bei diesem Stromtest mechanisch blockiert (so dass er sich nicht drehen kann).

Achtung:

  • bei Mähmotor unbedingt Messer abschrauben!
  • den Motor nur für sehr kurze Zeit (1-5 Sekunden) betreiben
  • immer Kabel mit ausreichend Querschnitt verwenden!

Beispiel-Messung:

  • Rotenbach SPM08-320
    • Antriebsmotor: 8A
    • Mähmotor:

  • Ambrogio L50
    • Antriebsmotor: 4,5A
    • Mähmotor: 22A
  • Tianchen TC-G158
    • Antriebsmotor: 5,4A
    • Mähmotor: 16A (beide zusammen 32A)

Die  ermittelten Were treten in der Regel nur im Worst-Case auf, d.h. nur beim Anlaufen des Motors oder bei einer Blockade und nur für den Bruchteil einer Sekunde (Der Akku liefert den hohen Motorkurzschlußstrom nur für sehr kurze Zeit, dann brechen Strom und Spannung ein).

Kompaß, Beschleunigung, Gyro

Details

Tipp: Benutze das WIKI für aktuelle Informationen!

Kompaßmodul (GY-80)


Beschleunigungssensor
(zur Erkennung der Orientierung/Lage des Roboters)
Ein Beschleunigungssensor mißt die Erdanziehungskraft (m*s^2) in allen 3 Roboter-Achsen (x/y/z). Damit kann ausrechnen welche Orientierung zum Erdmittelpunkt (Roll=Längsachse, Pitch=Querachse) der Roboter gerade hat.

ardumower pitch roll yaw

Bewegungen um die Hochachse (Yaw) kann man hiermit nicht erfassen - hierzu benötigt man einen Gyro. Ein Beschleunigungssensor ist auch empfindlich gegen Stöße - daher sollte man die Meßwerte mitteln.

Gyro (zur Erkennung von Drehbewegungen des Roboters)
Ein Gyro mißt die Drehgeschwindigkeit (Grad/Sekunde) in allen 3 Roboter-Achsen (Roll=Längsachse, Pitch=Querachse, Yaw=Hochachse). Ausgewertet wird aber nur die Hochachse (Yaw). Damit kann man den Roboter wieder auf “Kurs” bringen falls er mal durch nassen Rasen/Steigung etc. eine zufällige Drehbewegung macht. Ein MEMS-Gyro hat auf Dauer einen "Drift" (d.h. der so ermittelte Kurs "0 Grad" weicht mit der Zeit immer weiter vom realen ab).

Kompaß (zur Erkennung des Kurses)
Lässt man einen Mähroboter auf eine Fläche mit Gefälle laufen, bemerkt man sehr schnell dass der Roboter dort niemals richtig geradeaus fährt, sondern immer in Richtung “Gefälle nach unten” driftet und sich die meiste Zeit auch dort aufhält. Abhilfe schafft ein Kompaß. Dann fährt der Roboter wieder geradeaus.

Ein Kompaß lässt sich sehr leicht von Motoren, Metall etc. ablenken - daher ist es notwendig, diesen nach dem Einbau zu kalibrieren.

Ein Kompaß hat noch ein Problem: kippt man ihn (bzw. den Roboter), beziehen sich die gemessenen Kompaßwerte (x,y,z) auf den gekippten Roboter. Man muss diese Werte also wieder durch die gemessene Neigung (Roll, Pitch) des Roboters kompensieren. Typischerweise werden auch Kompaßwerte gemittelt, um stabile Werte zu erhalten.

Fusion aller Sensoren
Optimalerweise werden alle 3 Sensoren verwendet, um die Nachteile der einzelnen Sensoren zu kompensieren (IMU - Inertial Measurement Unit) - Ein "IMU" ist Hauptbestandteil eines Inertialen Navigationssystems):

1. Berechnung der kurzfristigen Neigung über Gyro
2. Berechnung des kurzfristigen Kurses über Gyro
3. Berechnung der langfristigen Neigung über Beschleunigungssensor
4. Berechnung des langfristigen Kurses über Kompaß (und Neigungs-Korrektur)

ardumower sensor fusion


Die Fusion alle Sensor-Werte kann z.B. über Komplementär-Filter (s. Bild) oder über Kalman-Filter erfolgen.
 

Nine Axis IMU Module (GY-80)

 GY-80        GY80-Schematic

  • Beschleunigungssensor: ADXL345B
  • Kompaßsensor: HMC5883L
  • Gyro: L3G4200D
  • Drucksensor: BMP085  (wird hier nicht verwendet)


Verdrahtung

Das IMU-Modul (GY-80) wird an einem Arduino Nano angeschlossen, welche Kompaß, Gyro und Beschleunigungssensor ausliest und zu einem Kurs auswertet. Für die genaue Verdrahtung, siehe Schaltbild.


Einbau
Die Platine wird wie gezeigt in Fahrtrichtung eingebaut (der schwarze Pfeil am Rohr gibt die Fahrtrichtung an). Das hier verwendete Rohr diente nur für den Prototyp - das Modul kann nun direkt im Roboter befestigt werden.

gy80 direction

Einbau-Hinweise zum GY80

Einbaulage des Moduls:
horizontal, Bauteilseite nach oben
Ausrichtung des Moduls:
immer in Fahr-Richtung einbauen.
Hinweise auf dem Modul beachten
Entfernung des Moduls von mag.Störfelder:
so weit wie möglich, aber > 20cm
Weitere wichtige Einbau-Infos:
Betriebspannung-Kabel aller Motore verdrillen.
Mech. Dämpfung des Moduls vorsehen.

DEMO-Videos

video   Kompaßtest ('robot dance')

video  Kompaß korrigiert Spur

video  Roboter fährt Bahnen



Schritt 1: Beschleunigungssensor-Kalibrierung

Diese einmalig Kalibrierung soll sicherstellen, dass alle 3 Achsen gleichgewichtet messen. Diese Kalibrierung kann auch außerhalb des Roboters durchgeführt werden.

1. Den PC mit dem Arduino Nano verbinden. Am PC die serielle Konsole (19200 Baud) in der Arduino-Umgebung öffnen. Nach der automatischen Gyro-Kalibrierung erscheint das Menü (dieses kann jederzeit mit der Taste "m" + ENTER dargestellt werden).

2. Mit der Taste "1" + ENTER die Kalibrierung starten.

2.1. Nach der Kalibrierung soll jede der 6 Seiten des Moduls einmal nach "unten" und einmal nach "oben" (um 180° gedreht) gucken. Das Modul hat 6 Seiten, also muss es 6 mal gedreht werden, so dass jede Seite einmal (in Waage) auf dem Tisch liegt (dabei ggf. das Modul mit der Hand festhalten ohne es zu bewegen). Nach jedem Kalibrierungsschritt ENTER drücken. Ziel der Kalibrierung ist es, die Erdbeschleunigung für jede Achse zu ermitteln (genauer: den Minimum/Maximum-Wert). Dabei darf das Modul aber nicht künstlich beschleunigt werden. Die Reihenfolge der Seiten spielt keine Rolle.

ardumower pitch roll yaw imu
Zum Schluß werden die Kalibrierungswerte für Beschleuinigungssensor und Kompaß ausgegeben.


Schritt 2: Kompaß-Kalibrierung (Kugelkalibrierung)
Diese einmalige Kalibrierung soll sicherstellen, dass Kabel, Metall etc. welches sich im Roboter in der Nähe des IMU-Moduls befindet, keine Auswirkung auf die Kompaßdaten hat.

Ein Meßwert (x,y,z) eines 3D-Kompaß zeigt (gesehen von seinem Urpsprung 0,0,0) immer in eine Richtung: zum Nordpol. Wenn man nun den 3D-Kompaß um alle seine Achsen dreht, liegen alle Meßwerte auf einer Kugel:

compass sphere

Bringt man nun eine starke Störung (z.B. Metall/Magnet) in die Nähe des Kompaß, zeigen die Meßwerte vom Ursprung (0,0,0) des Sensors gesehen plötzlich nur noch in eine Richtung - Warum?
Es gibt zwei Arten von Störungen des Magnetfeldes welche die Kugel-Meßwerte verändern/verschieben:

Hartmetall (z.B. Magnete): die Kugel verschiebt sich
Weichmetall (z.B. Metalle): die Kugel verformt sich (zu einem Ellipsoid)

Beispielmessungen

compass ellipsoid    compass ellipsoid cal1    compass ellipsoid cal2

(links: die unkalibrierte Meßwerte liegen nicht auf einer Kugel sondern auf einem Ellipsoid und haben sich vom Ursprung des Sensors verschoben
mitte: dieselben Meßwerte um die Verschiebung korrigiert
rechts: die kalibrierten Werte liegen nun unverformt wieder auf einer Kugel, zentriert um den Urpsprung des Sensors) 

Ziel der Kalbrierung ist es, dass die Meßwerte wieder auf einer Kugel zentriert um den Ursprung des Sensors liegen.


Kalibrierungsschritte:


Zunächst sicherstellen, dass sich das IMU-Modul an der endgültig eingebauten Position befindet und der gesamte Roboter von elektronischen Geräten sowie metallischen Gegenständen 30cm oder mehr entfernt ist (also nicht von metallischen Gegenständen in seiner Umgebung abgelenkt werden kann).

1. ArduMag-Kalibrierungstool für Android herunterladen.
2. Android-Gerät mit dem Bluetooth-Modul "paaren" (falls noch nicht durchgeführt). Hierfür am Android-Gerät das Symbol "Einstellungen" (im Android-Startbildschirm) anwählen. Dann unter "Drahtlos und Netzwerke->Bluetooth-Einstellungen" auswählen "Geräte suchen". Abschließend auswählen "Mit diesem Geräte koppeln" und die Pin eingeben (meist "1234"). Das Bluetooth-Modul sollte nun als "gekoppelt" erscheinen.
3. In der ArduMag-App die Menü-Taste des Android-Gerätes drücken und "Bluetooth" aus dem Menü auswählen und mit dem passenenden Bluetooth-Modul (also dem Roboter) verbinden. Der Roboter bestätigt die Verbindung mit einem Ton. Nun sollte die Anzahl der Meßwerte ansteigen.

Für die Kalibrierung den Roboter langsam um alle Achsen und Seiten (also 6 mal) für mindestens 360 Grad drehen:

ardumower compass calibrate

Die Reihenfolge der Achsendrehungen sowie die Drehrichtung spielt keine Rolle. Beispielsweise kann man pro Seite erst 180 Grad nach rechts und dann nochmal 180 Grad nach links drehen (ergibt insgesamt 360 Grad Drehung). Die Meßwerte liegen in der Regel (durch oben genannte Ursachen) nicht auf einer Kugel.
Beispiele:

ardumag1   ardumag2   ardumag3


4. Zum Abschluß der Kalibrierung in der ArduMag-App 'Calibrate' betätigen. Der Roboter bestätigt die neue Kalibrierung mit zwei Tönen. Die Kalibrierung ist damit abgeschlossen. Nun sollten die Meßwerte auf einer Kugel liegen.
Beispiele:

ardumag4    ardumag5



Schritt 3: Kompaß-Kalibrierung (Deviation)


Diese Kalibrierung soll sicherstellen, dass die vom Kompaß ermittelten Kurse Winkeltreu sind (d.h. dass beispielsweise der Südkurs exakt dem Nordkurs + 180 Grad entspricht).

1. Den Roboter auf einer ebenen, möglichst glatten Fläche um sich selbst im Uhrzeigersinn drehen lassen (pfodApp: "Commands->Auto rotate" solange antippen, bis der Roboter sich dreht). Falls die Fläche groß genug ist, kann man den Roboter alternativ auch einen Kreis (im Uhrzeigersinn) fahren lassen (pfodApp: "Manual->Right" solange antippen, bis der gewünschte Radius erreicht ist).

2. Die Deviation-Kalibrierung starten (pfodApp: "Settings->IMU->Start Com Cal Dev"). Nach jeweils 10 Grad blinkt die Nano-LED kurz auf. Wenn 360 Grad erreicht sind, hört die Nano-LED auf zu blinken und die Kalibrierung ist abgeschlossen.

 

Testen des Kompaß/der Neigung (über serielle Konsole)
Es werden fortlaufend ausgegeben:

yaw: Kurs/Yaw (s. Grafik oben)
pitch: Neigung um die Pitch-Achse (s. Grafik oben)
roll: Neigung um die Roll-Achse (s. Grafik oben)
frequency: Anzahl Messungen pro Sekunde (100)
latency: Anzahl Verzögerungen (0)
access: Anzahl externe Zugriffe (vom Arduino Mega)


Kompaß-Funktionstest
(über LED)
Den Kompaß jeweils nach Norden, Süden, Osten, Westen ausrichten - dabei sollte die LED angehen. Dazwischen sollte sie ausgehen. Norden, Süden bzw. Osten, Westen sollten genau gegenüberliegen.


Funktionstest via pfodApp (Android)
Man kann sich die Ergebnisse des IMU-Moduls (Yaw, Pitch, Roll) auch mit der pfodApp plotten lassen:

ardumower imu plotting       ardumower screenshot IMU




IMU-Kalibrierung (SVN-Version)


A) Beschleunigungssensor kalibrieren

Jede der 6 Seiten des Moduls einmal exakt hochkant hinstellen, nicht bewegen und den Punkt zur Kalibrierung der nächsten Seite auswählen:

i) In der seriellen Konsole "IMU acc calibration next side" oder
ii) In der pfodApp "Settings->IMU->acc calibration next side"

Während der Messung einer Seite das Modul nicht bewegen! Die Messung wird begleitet von einem kurzen Ton.

Diesen Schritt für alle 6 Seiten wiederholen. Wenn alle 6 Seiten kalibriert wurden, ertönt ein kurze Melodie.


gy80 acc calibration

B) Kompaß kalibrieren

Modul außer Reichweite von magnetischen oder eisenhaltigen Quellen bringen! Kompaß-Kalibrierung starten:

i) In der seriellen Konsole "IMU com calibration start/stop" oder
ii) In der pfodApp "Settings->IMU->com calibration start/stop"

Jede der 6 Seiten des Moduls einmal Richtung Norden halten und das Modul solange kippen bis sich das Minimum und Maximum der Achsen nicht mehr ändert (kein Ton mehr ausgegeben wird):

gy80 com calibration

iii) Kalibrierung beenden mit erneuter Auswahl von "IMU com calibration start/stop". Es ertönt eine kurze Melodie.

C) Kalibrierung testen

Zum Testen der Kalibrierung Modul (Bauteilseite nach oben) mit einer Seite gegen eine Tischkante halten und nicht bewegen. Den Yaw-Wert notieren (Beispiel: -95,45). Dann das Modul um 180 Grad drehen und wieder gegen die Tischkante halten. Jetzt sollte der Yaw-Wert um 180 Grad entfernt liegen (Beispiel: -95,45 + 180 = 84,55). Diesen Test mit den beiden anderen Seiten des Moduls ebenfalls durchführen. 

gy80 calibration check

... Modul mit einer Seite gegen Tischkante gehalten ...

calls=30    yaw=-95.56    pitch=0.02    roll=2.52    com=-95.91    com180=84.09    gyroZ=0.00
calls=30    yaw=-95.48    pitch=-0.11    roll=2.33    com=-95.81    com180=84.19    gyroZ=-0.01
calls=30    yaw=-95.42    pitch=0.03    roll=2.42    com=-95.65    com180=84.35    gyroZ=-0.00
calls=30    yaw=-95.45    pitch=-0.21    roll=2.38    com=-95.35    com180=84.65    gyroZ=-0.00

... Modul mit derselben Seite um 180 Grad gedreht gegen Tischkante gehalten...

calls=30    yaw=85.06    pitch=-2.50    roll=0.04    com=84.91    com180=-95.09    gyroZ=-0.03
calls=30    yaw=84.90    pitch=-2.59    roll=0.05    com=84.63    com180=-95.37    gyroZ=-0.02
calls=30    yaw=85.19    pitch=-2.55    roll=0.01    com=84.73    com180=-95.27    gyroZ=-0.01
calls=30    yaw=84.98    pitch=-2.73    roll=0.02    com=84.85    com180=-95.15    gyroZ=-0.01

Falls die Abweichung mehr als ein Grad beträgt, Kalibrierung von Beschleunigungssensor und Kompaß erneut durchführen!

 

Ladeelektronik

Details

Tipp: Benutze das WIKI für aktuelle Informationen!

charging


Grundprinzip: Über eine Induktionsschleife findet der Roboter zur Ladestation wo er sich erneut aufladen kann. Dabei wird die Induktionsschleife solange (im Uhrzeigersinn) abgefahren bis die Ladekontakte des Roboters eine Spannung erkennen (Ladespannung). Dort stoppt der Roboter.


Ladegerät
Das Ladegerät befindet sich in der Ladestation (oder wird an diese angeschlossen). Das Ladegerät sollte folgende Dinge bewerkstelligen (hier: Lithium-Ionen - Bleiakku ist ähnlich, nur weniger kritisch):
-Akku über die Lade-Pins des Roboters laden
-Maximale Lade-Endspannung/Ladeschlußspannung einhalten (Ladespannung begrenzen)
-Maximalen Lade-Strom einhalten (Ladestrom begrenzen)
Falls Du eine vorhandene Ladestation verwendest, wurden diese Dinge mit hoher Wahrscheinlichkeit bereits dort umgesetzt.

Roboter
Im Roboter selber wird die Akku-Spannung überwacht (siehe Schaltbild unten). So kann festgestellt werden wann der Roboter an die Ladestation fahren muss. Im Roboter wird auch die Spannung und der Strom beim Laden überwacht. So kann festgestellt werden ob der Roboter die Ladestation erreicht hat und wann der Akku wieder voll geladen ist. Idealerweise kann die Ladestation auch den Schleifensender speisen:

charging station circuit:

Power supply => Charger 24V (+)----- Charging station charger pin(+)
                GND         (-)----- Charging station charger pin(-)

                Charger 24V (+)----- DC-DC converter 5V  => Perimeter sender Arduino Nano 
                Charger 24V (+)----- DC-DC converter 12V => Perimeter sender MC motor driver

robot charging circuit:

Charging station (+)---+------+-- relais ---- current sensor ----- battery (+)
                              |
                              ---- voltage sensing
                      
                     
                      
Charging station (-)-- +------------------------------------------ battery (-)

 

Schaltung

siehe Schaltbild


Ladekurve etc.
Über pfodApp (Android) kann man sich eine Ladekurve plotten lassen.

ardumower battery plotting


Ladestation -
Ideen

l50 laden    ardumower charging     ardumower charging station example   ardumower perimeter   ardumower charging station1   ardumower charging station2    ardumower charging station3

video   Ambrogio "Ardumower" (in Ladestation hineinfahren)

video   Ambrogio "Ardumower" (in Ladestation hinein- und herausfahren)

 

Induktionsschleife / IR-Baken

Details

Tipp: Benutze das WIKI für aktuelle Informationen!

Eine Induktionsschleife ist wie ein “virtueller” Zaun: er weist den Roboter in seine Schranken. Eine Schleife ist praktisch aber nicht zwangsläufig für jede Umgebung notwendig (ein Rasensensor ist eine Alternative). Eine weitere Möglichkeit zum Erreichen der Ladestation sind Infrarotbaken (s.u.).

Grundprinzip
Man verlegt eine Schleife (ein Kabel) im Garten durch welches ein Signal geschickt wird welches der Roboter detektieren kann. Es werden dazu benötigt: ein Sender (um das Signal auf die Schleife zu geben) und ein Empfänger (um das Signal im Roboter zu detektieren).

ardumower perimeter


Wie wird ein Überfahren der Schleife detektiert?
Das Signal der Schleife wird mit einer (oder zwei) Empfängerspulen empfangen. Je näher man der Schleife kommt, umso stärker ist das Signal. Beim Überfahren der Schleife passiert aber noch etwas interessantes: das Signal wechsel die Polarität, d.h. negative und positive Spannung kehren sich um. Grundsätzlich gibt es also zwei Arten wie man ein Überfahren der Induktionsschleife detektieren kann. Ersteres haben wir mit "Perimeter v1" bereits umgesetzt und letzteres befindet sich in der Entwicklung ("Perimeter v2" - siehe weiter unten).


Sender/Empfänger-Prinzip über Signalstärke (Perimeter v1)
Man kann den Sender eines fertigen Mähroboters verwenden (der hier gezeigte Sender ist kompatibel mit Tianchen oder Rotenbach-Mährobotern) oder baut sich einen eigenen Sender.

Nun zum Sender und Empfänger:

Sender für Induktionsschleife
Ein Arduino (z.B. Nano) generiert ein Rechtecksignal, mit welchem die Drehrichtung eines Motortreiber (L298N) mit 7,8 Khz geschaltet wird. Dabei schaltet der Motortreiber-Ausgang ständig zwischen VCC und GND. Ein Schwingkreis verstärkt die Spitzen des Signals da er so dimensioniert ist, dass dessen Resonanzfrequenz der Schaltfrequenz entspricht (7,8 Khz). Der Motortreiber braucht daher nur mit 5V betrieben werden (statt mit 12V). Das Netzteil sollte für 2W (d.h. 400mA bei 5V) ausgelegt sein. Über eine Diode und einen Spannungsteiler geht ein Teil Signals in den Arduino (ADC). Hierüber kann eine Unterbrechung der Induktionsschleife erkannt werden. Etwa 150 mA fließen durch die Induktionsschleife (Querschnitt 2-3 mm^2). Diese sollte nicht wesentlich länger als 500m sein.

arduino perimeter sender

Da man nicht überall eine passende Spule bekommen kann, hier ein paar
mögliche Kombinationen für Spule/Kondensator (ergeben alle etwa dieselbe Resonanzfrequenz 7,8 Khz):
Variante 1: Spule: 160µH, Elko: 3,3µF/50V  (getestet)
Variante 2: Spule 33mH, Kondensator: 12nF (ungetestet)
Variante 3: Spule 220µH, Kondensator: 2.2µF/160V (getestet)
s. auch: Schwingkreisrechner (externer Link)


Spannungsversorgung
Die 5V Spannungsversorgung sollte über einen Step-Down-Spannungsregler (z.B. Modul mit LM2596) erfolgen, welcher die stabilisierte 5V Spannung generiert. Dazu zuvor den Spannungsregler auf 5V einstellen. Achtung: auf keinen Fall mehr als 5V in den Arduino 5V-Pin schicken, dadurch würde der Arduino zerstört. Daher immer die Spannung der 5V-Spannungsversorgung messen bevor man diese an den Arduino 5V-Pin anschließt!


Arduino-Code
Siehe Downloads.

Funktionstest (Sender)
1. Nach dem Übertragen des Codes und Anschließen der Induktionsschleife sollte die Arduino-LED (L) leuchten. Nun die Induktionsschleife zum Test entfernen - die Arduino-LED (L) sollte ausgehen.
2. Falls dies nicht funktioniert: Mit einem Multimeter einmal am Arduino Pin D9 und am einmal am Motortreiberausgangs-Pin (OUT_1) gegen Masse messen - es muss dort jeweils eine Gleichspannung (DC) von 2,5 Volt anliegen.
3. Falls ein Oszilloskop zur Verfügung steht, dieses anstelle der Induktionsschleife einbauen. Des so gemessene Signal sollte wie folgt aussehen:

Das Ausgangssignal weist eine deutliche höhere Amplitude (stärkere Spitzen) auf als das Eingangssignal:

perimeter signal    ardumower perimeter sender schematics     arduino perimeter sender photo

(links: Signalverlauf direkt am Schleifensenderausgang, rechts: Funktionsprinzip)

Erklärung des "Ringings": das "Nachschwingen" beim Sender erklärt sich dadurch, dass der Schwingkreis mit einem Rechteck-Signal angeregt wird, d.h. der Schwingkreis wird nicht nur mit einer Grund-Frequenz angeregt, sondern auch mit den harmonischen Frequenzen. Die Grund-Frequenz ist gewünscht für die Resonanz.

4. Wenn der Schleifensender richtig arbeitet, kann man zum Empfangstest einfach ein Oszilloskop an die Empfängerspule anschließen und dann die Induktionsschleife quer über die Spule legen. Das am Oszilloskop gewonnen Signal sollte ungefähr so aussehen:

Dieses Signal kann man dann gut mit einer Spule detektieren:
coilsignal     fft     ardumower perimeter spectrum plot

(links: Signalverlauf der Spule am Schleifenempfänger, mitte: Signal im Frequenzspektrum, überlagert mit Störungen vom Motor, rechts: Frequenzspektrum via pfodApp)



Empfänger für Induktionsschleife

Hierfür befinden sich mindestens 2 Spulen (rechts und links) im Roboter. Es werden die Signalstärke von rechter und linker Spule ausgewertet, um diese miteinander vergleichen zu können.

Prinzip:
1. Verstärken des Wechselsignals mit einem OPV
2. ADC-Sampling am Arduino
3. Optional: Bandpaß-Filterung, um Störsignale (Motor etc.) herauszufiltern - wir verwenden hierfür einen digitalen Filter (FFT-Algorithmus).
4. Auswertung der Signalstärke von linker und rechter Spule

Vorteil dieser Empfängervariante: Die analoge Regelung funktioniert sehr gut.
Nachteil: Man kann nicht feststellen, wo man sich gerade befindet (innen/außen) wenn man das Überfahren der Schleife einmal nicht mitbekommen hat. Man kann in diesem Fall auch nicht feststellen ob man die Induktionsschleife links oder rechts herum abfährt.
arduino perimeter receiver

Eine Spule empfängt das Signal vom Sender. Ein Schwingkreis (Kondensator) verstärkt das gesuchte Signal bei Resonanzfrequenz (7,8 Khz). Die eigentliche Verstärkung des Signals passiert mit einem LM386 (hier: Arduino Sound Sensor mit Spule anstatt Mikro). Ein Arduino Nano führt den Bandpaß auf 7,8 Khz durch (filtert nur diese Frequenz mit einem digitalen Filter heraus: FFT) und erzeugt am Ausgang ein PWM-Signal (Pulsweite proportional zur Signalstärke). Ein Tiefpaß wandelt dieses in eine Gleichspannung Spannung um.
Achtung: Die Verdrahtung zum Arduino-Mega wurde vereinfacht - siehe Schaltbild für exakte Verdrahtung.

Wir haben folgende Kombinationen von Verstärker und Spule getestet:
soundsensor    YwRobot Sensor   YwRobot circuit    coil 85mh
(links außen: Verstärkung des Signals mit "Arduino Sound Sensor" und Spule anstatt Mikro.
links: Arduino Sound Sensor (LM386)
rechts: Schaltbild Arduino Sound Sensor - das Schaltbild für den Arduino Sound Sensor findet man auch hier
rechts außen: Spulen mit 85 mH)

lm386 amplifier     lm386 modified      lm386 circuit      coil small

(links außen: LM386-Verstärker (200 fache Verstärkung)
mitte: Schaltbild LM386-Verstärker
rechts: Spule mit 104 mH)
Wichtig: Bei diesem Verstärker sollte der Kondensator C3 überbrückt werden (ergibt einen VCC/2 Offset passend für Arduino) und die Spule an "IN" und "GND" angeschlossen werden.


Arduino Code

Siehe Downloads

Funktionstest (Empfänger)
1. Zunächst sicherstellen, dass der Sender funktioniert (siehe oben).
2. Am Sound-Sensor die Empfindlichkeit (Verstärkung) über das Poti auf Maximum einstellen (gegen den Uhrzeiger drehen).
3. Nach dem Übertragen des Codes eine Spule in die Nähe der Induktionsschleife bringen (bzw. die Induktionsschleife direkt auf die Spule legen). Die Arduino-LED (L) sollte anfangen zu blinken. Nun beide Spulen in gleichem Abstand über die Induktionsschleife halten. Jetzt sollte die Arduino-LED (L) dauerleuchten.
4. Falls dies nicht passiert, die serielle Konsole öffnen (19200 Baud) und Werte beobachten.

Digitaler Filter
Der FFT-Algorithmus teilt das Frequenzband in Abschnitte gleicher Breite ein ("Bins") und liefert uns für jeden Bin wie stark dieser Frequenzabsschnitt im Signal vorkommt. Zum Filtern schauen wir uns den "Bin" mit der gesuchten Frequenz an und werten dort die Signalstärke aus.

Wahl der Spule
Spulenmathematik, aber nur als einfache Näherungsformel:

L = 1nH x n² x ((D² / mm² ) / (l / mm))
l = Länge der Spule
D = Durchmesser der Spule

Beispiel: 85 mH erfordern bei einem Durchmesser von 10 mm und
bei einer Länge von 40 mm etwa 5830 Windungen.

Diese Induktivität 85 mH ergibt mit einer Kapazität von 4,7 nF eine Resonanzfrequenz von 7963 kHz.

Da man nicht überall eine passende Spule bekommen kann, hier ein paar
mögliche Kombinationen für Spule/Kondensator (ergeben alle etwa dieselbe Resonanzfrequenz 7,8 Khz):
Variante 1: Spule: 85mH (115 Ohm), Kondensator: 4,7nF  (getestet)
Variante 2: Spule 104mH, Kondensator: 4nF (getestet)
s. auch: Schwingkreisrechner (externer Link)



Anordnung der Spulen

Die Spulen befinden sich flach am Boden, etwa 90 Grad zueinander, beide um 45 Grad gedreht.

ardumower spulen

Beispiel  (Ambrogio L50):

l50 coils    l50 parcours


Vergleichsmessung der Signalstärke
Für eine Vergleichsmessung wurden die Signalstärken bei verschiedenen Abständen ermittelt. Die Signalstärke (d.h. der ermittelte ADC-Wert) wird in der Android-pfodApp angezeigt. Die Entfernung ist der Abstand (cm) von Induktionsschleife zur Spule im eingebautem Zustand.

perimeter plot


Wie ändert sich das Signal bei Drehung der Spule?
Es wird für die Regelung beim Abfahren der Schleife immer nur die Signalstärke ausgewertet (also wie stark der Signalausschlag ist).
Man sieht, dass die Stärke des Signalausschlages auch von der Orientierung abhängig ist (und nicht nur von der Entfernung zum Induktionskabel).

ardumower coil signal

Ordnet man nun 2 Spulen (90 Grad versetzt) an, so würde die Summe aus beiden Spule ein Signal ergeben welches unabhängig von der Orientierung ist. Es würde nur noch der Abstand zum Induktionskabel gemessen.


Verlegung der Schleife
Es ist wichtig, dass die Schleife rund verläuft - Angenommen sie ist eckig verlegt und der Roboter fährt genau über die Ecke, wird er die Schleife nicht detektieren können. Denn genau für den Fall, dass Spule und Schleife gleich ausgerichtet sind, wird kein Signal empfangen (s.o.). Daher ist es wichtig, in der Schleife niemals Ecken zu verlegen, so dass mindestens eine Spule etwas empfangen kann.
schleifen blind

Demo-Videos

video  Ambrogio-Arduimower: Induktionsschleifentest (Stopp)

video Ambrogio-Ardumower: Schleifenfahrttest

video Ambrogio-Ardumower: Hineinfahren in die Schleife im Uhrzeigersinn

video Rotenbach-Ardumower: Suchen und Abfahren der Schleife

Abfahren der Induktionsschleife
Das Abfahren der Induktionsschleife wird mit Hilfe eines digitalen Reglers (PID) bewerkstelligt. Der PID-Regler kann über die Handy-App (pfodApp) konfiguriert werden.

ardumower perimeter pid

Weitere Informationen über digitale Regler findet ihr hier.


Abschirmung / Störungen
Da die Spule nur Spannungen im Bereich bis ca. 150mV empfängt, spielt Abschirmung eine große Rolle.

  • Abschirmung der Spule selber (in Ferritkern/Stahlrohr setzen)
  • Operationsverstärker (LM386) abschirmen (Alufolie umwickeln)
  • Welligkeit der Batteriespannung entfernen (paralleler Puffer-Kondensator)
  • Motorgehäuse auf Masse legen
  • Motoren abschirmen (Stahlbleche im rechten Winkel)

 



Sender/Empfänger-Prinzip über Polaritätswechsel ("Perimeter v2" - In Entwicklung)

Beim Überfahren der Schleife passiert etwas interessantes: das Signal wechsel die Polarität, d.h. negative und positive Spannung kehren sich um. Bei diesem Ansatz wird ein Überfahren der Schleife (innen/außen) durch diesen Polaritätswechsel erkannt. Wir verwenden wieder (wie bei "Perimeter v1") einen Motortreiber zum Erzeugen des Signals und eine fertige Operationsverstärkerschaltung zum Empfang.

Prinzip:
1. Verstärken des Wechselsignals mit einem OPV
2. ADC-Sampling am Arduino
3. Signal-Filterung und Detektion mit einem digitalen Filter (Matched Filter Algorithmus).
4. Auswertung des Filters


ardumower perimeter2            perimeter sampling

Signalform, Filter und Simulation: wir experimentieren noch mit dem optimalen Signalform - das Signal könnte wie "pseudonoise4_pw" aus dem Simulator-Applet aussehen. Wir verwenden einen Matched Filter um das Signal zu detektieren, d.h. einen digitalen Korrelations-Filter mit "PN-Code" wie er beispielsweise auch beim GPS-System verwendet wird. Wir möchten das Signal nicht nur Nahe der Schleife sondern auch noch in der Mitte des Gartens (also in der Mitte der Schleife) empfangen. Der Matched Filter liefert uns auch dann noch hervorragende Ergebnisse wenn das (im Vergleich relativ schwache) Signal durch Motorstörungen überlagert wurde. Weiterhin liefert uns der Matched Filter einen positiven Peak wenn das Signal gefunden wurde und einen negativen Peak wenn das invertierte Signal gefunden wurde (die Schleife also überfahren wurde).

Im Simulations-Applet kann dies alles nachvollzogen werden:

applet matchedfilter

Sender

Der Motortreiber wird mit 3,2 Khz angesteuert (genauer: Pulsweite mit abwechselnd 4,8 Khz und 2,4 Khz). Die Schaltung verbraucht max. 20W (12V, 1.7A). Es wird ein Motortreiber mit integrierter Strombegrenzung und thermischer Schutzabschaltung empfohlen (z.B. MC33926).

sender circuit:

motor driver M1OUT1     o---------- perimeter loop (20-450 meters)--+
                                                                    |

motor driver M1OUT2     o---------- perimeter loop -----------------+
motor driver Vin        o-- 12V
motor driver M1IN1      o-- Arduino Nano pinIN1
motor driver M1IN2      o-- Arduino Nano pinIN2
motor driver M1PWM_nD2  o-- Arduino Nano pinPWM
motor driver M1nSF      o-- Arduino Nano pinFault
motor driver M1FB       o-- Arduino Nano pinFeedback

motor driver EN         o-- Arduino Nano pinEnable
motor driver VDD        o-- Arduino +5V
motor driver M1D1       o-- GND (via Jumper)
motor driver SLEW       o-- VDD (via Jumper)

              |---------o-- GND
Potentiometer 100k -----o-- Arduino Nano pinPot
              |---------o-- Arduino +5V

ACS712-05 OUT ------o-- Arduino Nano pinChargeCurrent    
ACS712-05 A   ------o-- charging pin (+)
ACS712-05 B   ------o-- battery charger +24V
battery charger GND-o-- charging pin (-)

      

Über den Stromsensor (ACS712-05) wird erkannt wenn der Roboter die Lade-Pins der Ladestation erreicht hat, so dass die Induktionsschleife während der Ladezeit abgestellt werden kann. 
Über das Potentiometer kann die Maximal-Leistung für den Motortreiber eingestellt werden (Strom). Zunächst IMAX auf Null stellen, den Roboter in die Mitte des Gartens stellen und dann ganz langsam IMAX mit dem Poti erhöhen. Im pfodApp-Plot ("Plot->Perimeter") sollte nun 'sig' nach einiger Zeit (10 Sekunden) größer werden. An der Stelle wo 'sig' das Maximum erreicht, IMAX belassen. Der richtige IMAX-Wert hängt mit der Leistungsanpassung zusammen. Ist IMAX für die Schleifenlänge zu groß gewählt, reduziert der Motortreiber automatisch die Leistung und das Signal wird schlechter.

Einige Beispiel-Werte für IMAX:
Schleifenlänge=60m, IMAX=0.14
Schleifenlänge=120m, IMAX=2.0

Besonderheit zum MC33926: der Treiber erkennt Kurzschluß bzw. Überstrom und schaltet dann einfach ab - für diesen Fall Versorgungsspannung kurzfristig trennen!

Das Signal bei geöffneter Schleife sollte etwa so aussehen:

perimeter2 sender open    


Achtung: Schleifenlänge beachten. Für Tests in der Wohnung folgende Simulationsschaltung verwenden welche eine lange Schleife simuliert:


Simulationsschaltung
einer langen Schleife
Für Tests in der Wohnung sollte man eine längere Schleife (150m) simulieren, damit das Signal ähnlich ist. Die benötigte Spule kann mich sich schnell selber bauen: einen Ferritkern ca. 30 mal mit Kabel umwickeln (so dass sich eine Induktivität von ca. 200 µH +/- 50% ergibt ). Der Motortreiber sollte für diesen Fall mit 5V betrieben werden.

sender 'long perimeter simulation' circuit:

MC motor driver M1OUT1 o---------- 8 Ohm resistor 20W --- coil (200 µH, 1.7A) --------------------+
                                                                                                  |

MC motor driver M1OUT2 o--------------------  perimeter loop (1-5 meters)  -----------------------+
...


Empfänger

ardumower one center coil
Es wird nur noch eine einzige aufrecht (hochkant) stehende Spule verwendet (mittig im Roboter, vertikale Lage). Diese muss an "pinPerimeterLeft" angeschlossen werden. Die LC-Kombination soll Störungen des Mähmotors beseitigen. Der Ausgangs-Elko des LM386-Moduls muss überbrückt werden, damit der Null-Pegel Offset bei 2,5V liegt!

receiver circuit:

                                     LM386 IN  o------- capacitor 4,7nF ----------- coil 100 mH
Arduino pinPerimeterLeft   o------o  LM386 OUT
                                     LM386 GND o----------------------------------- coil

Das Signal wird mit 19,2 Khz gesampelt und via Matched Filter ausgewertet.


Das Signal am Ausgang des LM386 sollte nahe der Schleife etwa so aussehen: ein Wechselsignal beim dem die Länge eines Pulses durch eine Signal-Code-Folge (sog. PN-Code) vorgegeben ist, d.h. das Signal hält den Zustand (Hi oder Lo) anhand einer Code-Folge. Für weitere Details, siehe Signal "pseudonoise4_pw" im Simulations-Applet.

perimeter2 receiver coil     perimeter2 receiver coil pwm

(links: Signal, rechts: Signal mit Stromregelung über PWM)

Wichtig: wenn Spule und Mähmotor gleich ausgerichtet sind, kann der Motor stören - dann sollte die Spule leicht gekippt werden. die Ausrichtung der Spule muss ausgetestet werden. Man führt dazu den Mäher mit eingeschaltetem Mähmotor über die Schleife und schaue ob innen und außen zuverlässig erkannt wird (innerhalb der Schleife sollte die LED an gehen, außerhalb aus - andernfalls Spulenanschlüsse tauschen!). Je nach Kippen der Spule (vorne, hinten, rechts, links) ergibt sich ggf. eine Verbesserung.

ADC-Kalibrierung
Damit das Signal (sig) symmetrisch um Null verläuft, einmalig eine ADC-Kalibrierung bei ausgeschaltetem Schleifensender durchführen ("pfodApp->ADC Calibration").


Beispiel-Plots (pfodApp)

Der Plot beinhaltet:

sig
:  das Spulen-Signal
mag: Filterergebnis (negativ: innen, positiv: außen - Stärke: Entfernung zur Schleife) - zur Detektion der Schleife beim Abfahren
smag: Filterergebnis ohne Vorzeichen, aber mit Tiefpaß - zur Schleifenausfallerkennung
in:  innen (1) oder außen (0)
cnt:  Anzahl "innen-nach-außen" Übergange (Zähler)
on:  Schleife aktiv (1) oder inaktiv (0)


150m Schleife, Motortreiber mit 12V

Der Mäher wurde in die Mitte der Schleife gesetzt. Der Mähmotor wurde eingeschaltet. Das Schleifen-Signal (sig) ist stärker als beim Betrieb mit 5V. Der Matched-Filter (mag) liefert "innen" (d.h. innerhalb der Schleife) durchgängig ein negatives Signal, außerhalb durchgängig ein positives Signal. Die Schleife wird als eingeschaltet (on) erkannt.
perimeterV2screenshot    perimeter2 plot 12v    ardumower perimeter2 test


150m Schleife, Motortreiber mit 5V
Der Mäher wurde in die Mitte der Schleife gesetzt. Der Mähmotor wurde eingeschaltet. Das Schleifen-Signal (sig) ist schwächer als beim Betrieb mit 12V. Die gelegentlichen "Ausreißer" verursacht der Mähmotor. Der Matched-Filter (mag) liefert kein durchgängig negatives Signal (d.h. ein "innen"), die gelegentlichen Spitzen in den positiven Bereich kommen vom Mähmotor. Es wird dennoch durchgängig ein "innen" (in) detektiert. Die Schleife wird als eingeschaltet (on) erkannt.
perimeter2 plot 5v
 


video  Perimeter2-Demo


Weitere Informationen zum Matched Filter (Blog)

Infrarotbaken
Eine weitere Möglichkeit zum Erreichen der Ladestation sind Infrarotbaken. Eine Schaltung zum Nachbauen findet man hier.

 

Weitere Beiträge...

  1. Handy-Steuerung, Bluetooth
   
© Ardumower