2008-09-22T19:55:04Z

Uwegw:

Dieser Artikel beschreibt die Ansteuerung des Ultraschallsensors [[Sensorarten#SRF08|SRF08]] mit der Programmiersprache C (avr-gcc).
Für die I2C-Kommunikation wird die I2C-Master-lib von Peter Fleury verwendet, die unter [http://homepage.hispeed.ch/peterfleury/avr-software.html] zu finden ist.

Der SRF08 hat gegenüber dem SRF05 den Vorteil, dass man die Entfernung direkt als digitalen Wert auslesen kann, und nicht die Länge eines Pulses messen muss. Daher kann man die Messung starten, und den Controller erst einmal andere Aufgaben erledigen lassen, bevor man den Messwert ausliest. Der Messvorgang dauert bis zu etwa 70ms, und in dieser Zeit kann der Controller sich anderen Aufgaben widmen. Im [[Sensorarten#SRF08_Programmbeispiel|Bascom-Beispielprogramm]] wird von dieser Möglichkeit nicht Gebrauch gemacht. Dies vereinfacht das Programm zwar enorm, verschwendet aber reichlich Rechenzeit. Daher wurde in diesem Artikel ein anderer Ansatz gewählt. Er ist zwar deutlich komplexer, man kann aber die Programmdateien einfach übernehmen und in sein eigenes Projekt einbinden, ohne sich mit den Details der Umsetzung beschäftigen zu müssen.

===Prinzip des Programms===
Es wird fortlaufend gemessen, der Messwert wird ständig aktualisiert. Dazu muss die Funktion SRF08_task()regelmäßig aufgerufen werden, die den Ablauf steuert. Dies sollte in einem Timer-Interrupt passieren. Es muss sichergestellt werden, dass währenddessen von keiner anderen Funktion auf den I2C-Bus zugegriffen wird!

Die Messung wird durch eine state machine gesteuert, die von SRF08_task() periodisch aufgerufen wird.

Zu Beginn ist die state machine im state SRF08_WARTEN_AUF_FREIGABE. Nur wenn die Messung aktiviert wurde (per set_SRF08_automessung(1);), wird auf SRF08_MESSUNG_STARTEN gewechselt. Hier wird das Kommando zum Start der Messung gesendet.

Der Sensor lässt sich abfragen, ob er fertig mit der Messung ist und ausgelesen werden kann. Diese Abfrage geschieht in SRF08_MESSEN.

Wenn die Messung beendet ist, wird in SRF08_AUSLESEN der Messwert einlesen und gespeichert.

Zwischen zwei Messungen kann optional eine kurze Pause eingelegt werden. Dies wird in SRF08_PAUSE erledigt. Danach wird in SRF08_NEUSTART geprüft, ob eine neue Messung gestartet werden soll, und der Vorgang beginnt von vorne.

===Header===
<pre>
/*
Auslesen des SRF08 Ultraschallsensors über I2C
Der Sensor wird fortlaufend ausgelesen und neu gestartet. Dazu muss SRF08_task() regelmäßig aufgerufen werden.
Mit den Funktionen get_SRF08_distance() und get_SRF08_light() kann man den letzten Messwert abrufen
uwegw, 22.9.08
*/

#ifndef SRF08_H
#define SRF08_H

#include "i2cmaster.h" //I2C-master-lib von P. Fleury verwenden
#include <inttypes.h>
#include <avr/io.h>

//I2C-Busadresse
#define SRF08_adress 0xE0

//Pause zwischen zwei Messungen.
// Task-Aufrufintervall * SRF08_DELAY = Pausenzeit
#define SRF08_DELAY 10

//Task für die State Machine, alle 10ms aufrufen!
extern void SRF08_task(void);

//Automatische Messung aktivieren/deaktivieren
// on: 1 oder 0, Automessung an/aus
extern void set_SRF08_automessung(uint8_t on);

//Verstärkung setzen
extern void set_SRF08_gain(uint8_t gainvalue);

//max. Reichweite festlegen
extern void set_SRF08_range(uint8_t rangevalue);

//gemessene Entfernung in cm zurückgeben
extern uint16_t get_SRF08_distance(void);

//gemessene Lichtstärke (0..255) zurückgeben
extern uint8_t get_SRF08_light(void);

#endif

</pre>

=== Quellcode ===
<pre>
/*
Auslesen des SRF08 Ultraschallsensors über I2C
Der Sensor wird fortlaufend ausgelesen und neu gestartet. Dazu muss SRF08_task() regelmäßig aufgerufen werden.
Mit den Funktionen get_SRF08_distance() und get_SRF08_light() kann man den letzten Messwert abrufen
uwegw, 22.9.08
Die Messung ist als state machine realisiert.
SRF08_WARTEN_AUF_FREIGABE: abwarten, bis Automessung aktiviert wurde
SRF08_MESSUNG_STARTEN: messvorgang starten
SRF08_MESSEN: Messung läuft, warten auf Ende
SRF08_AUSLESEN: Messwert einlesen
SRF08_PAUSE: Pause zwischen zwei Messungen
SRF08_NEUSTART: prüfen, ob Messung erneut gestartet werden soll.
*/

#include "SRF08.h"

volatile unsigned char srf08_auto_aktiv=0;

volatile uint16_t SRF08_messwert=0;
volatile uint8_t SRF08_light=0;

volatile uint8_t SRF08_gainvalue=5;
volatile uint8_t SRF08_rangevalue= 140; //6m default

//Deklarationen für interne Funktione, nicht im Header enthalten
void SRF08_messung_starten(void);
uint8_t srf08_ready(void);
void srf08_auslesen(void);

enum SRF08_STATES {SRF08_WARTEN_AUF_FREIGABE,SRF08_MESSUNG_STARTEN,SRF08_MESSEN,SRF08_AUSLESEN,SRF08_PAUSE,SRF08_NEUSTART};
uint8_t srf08_state=0;

void SRF08_task(void)
{
static volatile uint8_t srf_delaycnt=0;

switch(srf08_state)
{

case SRF08_WARTEN_AUF_FREIGABE: //Messung war abgeschaltet, warten bis wieder aktiviert SRF08_WARTEN_AUF_FREIGABE
if(srf08_auto_aktiv)
{
srf08_state=SRF08_MESSUNG_STARTEN; //im nächsten Zyklus neue Messung beginnen
}

//messung starten SRF08_MESSUNG_STARTEN
case SRF08_MESSUNG_STARTEN:
SRF08_messung_starten();
srf08_state=SRF08_MESSEN;
break;

//messung läuft noch, warten bis Ende SRF08_MESSEN
case 2:
if(srf08_ready())
{
srf08_state=SRF08_AUSLESEN;
}
break;

//messung fertig, Werte auslesen SRF08_AUSLESEN
case 3:
srf08_auslesen();
srf08_state=SRF08_PAUSE;
srf_delaycnt=SRF08_DELAY;
break;

//messung fertig, evtl Pause machen SRF08_PAUSE
case SRF08_PAUSE:
if(srf_delaycnt)
{
srf_delaycnt--;
}
else
{
srf08_state=SRF08_NEUSTART;
}

break;

//wenn weiterhin gemessen werden soll, im nächsten zyklus nächste Messung starten SRF08_NEUSTART
case SRF08_NEUSTART:
if(srf08_auto_aktiv)
{
srf08_state=SRF08_MESSUNG_STARTEN; //im nächsten Zyklus neue Messung beginnen
}
else
{
srf08_state=SRF08_WARTEN_AUF_FREIGABE; //Automessung stoppen
}
break;

default:
break;
}
}

void SRF08_messung_starten(void)
{
if(srf08_ready())
{
i2c_start(SRF08_adress+I2C_WRITE);
i2c_write(0x01);//Gainregister
i2c_write(SRF08_gainvalue);//Gain setzen
i2c_write(SRF08_rangevalue);

i2c_rep_start(SRF08_adress+I2C_WRITE);
i2c_write(0x00);//Befehlsregister wählen
i2c_write(0x51);//Messung starten, Ergebnis in cm

i2c_stop();

}
}

uint16_t get_SRF08_distance(void)
{
return SRF08_messwert;
}

uint8_t get_SRF08_light(void)
{
return SRF08_light;
}

void set_SRF08_automessung(uint8_t on)
{
if(on){ srf08_auto_aktiv=1;} else {srf08_auto_aktiv=0;}
}

void set_SRF08_gain(uint8_t gainvalue)
{
SRF08_gainvalue=gainvalue;
}

void set_SRF08_range(uint8_t rangevalue)
{
SRF08_rangevalue=rangevalue;
}

uint8_t srf08_ready(void)
{

if(!(i2c_start(SRF08_adress+I2C_WRITE)))
{ i2c_stop();
return 1;
}
i2c_stop();
return 0;
}

void srf08_auslesen(void)
{
if(srf08_ready())
{
i2c_start(SRF08_adress+I2C_WRITE);
i2c_write(0x01);//Ergebnisregister Lichtsensor wählen
i2c_rep_start(SRF08_adress+I2C_READ);

SRF08_light= i2c_readAck();
SRF08_messwert = ((i2c_readAck())<<8); //highbyte
SRF08_messwert += (i2c_readNak()); //lowbyte
i2c_stop();
}

}
</pre>

=== Beispiel für den Aufruf im Hauptprogramm ===
<pre>
...

</pre>

2008-08-08T16:08:48Z

Uwegw: /* Befestigung mit einem speziellen Felgenadapter */

Für fahrbare Roboter werden oft die unterschiedlichsten Räder genutzt. Entweder Modellbauräder, Räder aus dem Baumarkt oder Eigenkonstruktionen (z.B. umfunktionierte CDs). Wie auch immer, die einzelnen Räder haben gewöhnlich völlig unterschiedliche Bohrlöcher für die Achse. Dies schwankt duchaus von 4 mm bis 12mm. Übliche Getriebemotoren und Schrittmotoren dagegen haben oft eine 4-mm-,5-mm- oder 6-mm-Achse.
Die Befestigung des Rades an der Motorwelle ist daher oft das erste Problem vor dem ein Robotik-Bastler steht.

Es gibt unzählige verschiedene Möglichkeiten zur Befestigung eines Rades. Einige Lösungen werden nun hier vorgestellt. Dabei sagen die Bilder mehr als tausend Worte.

Einige Hilfmittel, die im Handel angeboten werden, um die Befestigung zu erleichtern. Auf dem Bild sehen Sie z.B. Potikupplungen, Propellernaben und spezielle Modellbaubefestigungen für sehr große Räder.

[[Bild:achskupplungen.jpg|Verschiedene Hilfsmittel]]

==Einfache Möglichkeit mittels Gewindestange und Achskupplung==
Eine besonders einfache Möglichkeit ist die Verwendung einer kurzen Gewindestange. Dabei kann man je nach Bohrloch des Rades einfach eine Gewindestange entsprechenden Durchmessers verwenden und das Rad mit gegenläufigen Muttern auf beiden Seiten festschrauben. Bei besonders schweren Robotern kann ein Tropfen Sekundenkleber zudem noch das Durchdrehen bei starker Belastung verhindern. Die Gewindestange selbst kann man einfach über eine Kupplung an der Welle befestigen.
Im Handel gibt es spezielle Wellenkupplungen für diese Aufgabe, jedoch sind die professionellen Ausführungen recht teuer (oft über 20 Euro pro Stück, ähnlich nachfolgender Abbildung).

[[Bild:wellenkupplung.jpeg]]
[[Bild:wellenkupplung2.jpeg]]

In der Praxis hat sich für Bastler eine preiswerte Lösung mit Potikupplungen als durchaus sinnvoll erwiesen.

[[Bild:kupplung6.jpg|center]]

Potikupplungen gibt es bei vielen Anbietern (Conrad, Reichelt, robotikhardware usw.) für 6 mm auf 6-mm-Achsen und 4 mm auf 6-mm-Achsen. Da die meisten Motoren eine 6-mm-Achse besitzen, ist dies also eine gute Lösung. Die Bilder zeigen, wie ein Modellbaurad mit 4-mm-Loch an einem Motor mit 6-mm-Achse befestigt wird.

[[Bild:achskupplung1.jpg|center|Gewindestange mit Welle verbinden]] 
[[Bild:achskupplung2.jpg|center|Gewindestange verschrauben]] 
[[Bild:achskupplung3.jpg|center]] 
[[Bild:achskupplung4.jpg|center]] 

Alternativ könnte man natürlich die 4-mm-Bohrung im Modellbaurad auch sehr leicht mit einem 6-mm-Bohrer auf 6 mm erweitern und dann eine 6- auf 6-mm-Kupplung verwenden. Die Lösung eignet sich natürlich für Schritt- als auch Getriebemotoren. Je nach Befestigung des Motors und vorhandenem Platz kann man natürlich das Rad auch umgekehrt befestigen.

[[Bild:achskupplung5.jpg|center]]

Auf dem nachfolgenden Foto sieht man, wie die Befestigung von Motor und Rad nach oben beschriebener Methode aussehen könnte. Statt dem Stückchen Gewindestange wurde hier einfach eine Gewindeschraube genutzt.

[[Bild:achskupplungen_pebisoft.jpg|center]]

==Einfache Alternative mit Propellernaben==
Auch sogenannte Propellernaben lassen sich sehr gut zur Befestigung von Rädern nutzen. Damit lassen sich sehr gut auch größere Räder (Dinge) an kleinen Achsen wie 3 mm oder 5 mm befestigen. Leider gibt es wohl keine Propellernaben mit 6-mm-Innenloch. Da viele jedoch aus leichtem Aluminium bestehen, kann man das Innenloch durchaus mit einem Bohrer auf 6 mm erweitern. Die Befestigung an der Welle erfolgt immer per Madenschraube oder notfalls Sekundenkleber. Der Außendurchmesser der Propellernabe ist in der Regel 8 mm. Dadurch lassen sich also schon eine ganze Reihe von Rädern direkt mit einer Mutter anschrauben.
Die nachfolgenden Bilder zeigen, wie man sehr große Modellbauräder mit einem großen 12-mm-Loch durchaus auch sehr leicht mit Propellernabe und spezieller Modellbauradbefestigung an kleinen 5-mm- oder 6-mm-Achsen befestigt. Die Propellernaben stammen von Conrad Elektronik.

[[Bild:achskupplungen_b.jpg|center]]
[[Bild:achskupplungen_c.jpg|center]]
[[Bild:achskupplungen_d.jpg|center]]
[[Bild:achskupplungen_e.jpg|center]]
[[Bild:achskupplungen_f.jpg|center]]
[[Bild:achskupplungen_g.jpg|center]]

Auf den Bildern wurden nur Muttern zur Befestigung genutzt. Bei schweren Robotern sollte die Welle durchbohrt und der mitgelieferte Splint eingesetzt werden. Dadurch wird ein Durchdrehen oder Lösen der Muttern verhindert. Ein Tropfen Sekundenkleber erreicht das Gleiche, jedoch bekommt man dies dann selbst nie mehr auseinander.

Auf dem Bild sehen wir, das Propellernaben durchaus auch bei Motoren mit sehr kleinem Wellendurchmesser eingesetzt werden können:

[[Bild:achskupplungen_h.jpg|center]]

==Umgehen der direkten Befestigung des Rades==
Man kann natürlich das Problem der Radbefestigung auch ganz einfach umgehen indem man die Räder auf einer anderen Welle / Getriebestange befestigt und die Verbindung einfach über ein Zahnriemenrad herstellt. Zahnriemenräder gibt es für viele Achsdurchmesser, die Befestigung ist oft mittels Madenschraube sehr einfach möglich. Wenn man dann noch die Räder auf einer Gewindestange statt Stahlwelle befestigt, ist das Ganze sehr einfach zu realisieren. Die Gewindestange kann man dann über Kugellager auf beiden Seiten lagern. Der Fachmann wird eine Gewindestange als Welle in der Regel nicht nutzen oder empfehlen, weil dadurch mit der Zeit die Lager beschädigt werden können und die Reibung nicht ganz optimal ist. Allerdings ist in der Praxis die Lösung durchaus für viele Dinge ausreichend und übersteht oft die übliche Lebensdauer eines Hobby-Roboters.

[[Bild:achskupplungen_j.jpg|center]]

==Befestigung durch Aufbohren einer Gewindestange==
Bei dem nachfolgenden Bild wurde ein 6-mm-Loch in eine größere Gewindestange gebohrt. Zusätzlich wurde ein kleines Loch für eine Art Madenschraube gebohrt und mit Gewinde versehen. Dadurch läßt sich die Gewindestange direkt auf die Welle aufstecken und mittels Schraube befestigen. Das Rad selbst kann wieder mit gegenläufigen Muttern angeschraubt werden. Diese Lösung ist sehr günstig, erfordert jedoch ein wenig mechanisches Geschick.

[[Bild:achskupplungen_lukas.jpg|center]]

==Befestigung mit einem speziellen Felgenadapter==
Die recht beliebten Räder aus dem RC-Modellbaubereich (wie sie auch bei den Fotos zu den anderen Befestigungsmöglichkeiten zu sehen sind) haben an der Innenseite eine 12mm-Sechskantaufnahme. Hier lässt sich ein Adapterstück mit einem 12mm-Sechskantprofil und einer Bohrung für die Motorwelle anbringen. Dies ergibt eine stabile und kraftschlüssige Befestigung. Ein solches Adapterstück ist jedoch ohne teures Werkzeug (Fräse, Drehmaschine) nicht gerade einfach anzufertigen, da schon etliches an Präzision gefragt ist, damit die Räder nicht eiern. Es gibt jedoch mittlerweile einen Anbieter für Adapter aus Edelstahl. Die Bohrung ist 6mm groß, was auf viele Getriebemotoren passt.

EDIT: mittlerweile sind diese Adapter dort leider nicht mehr erhältlich!

[[Bild:radadapter.jpg|center|thumb|400px|Anwendungsbeispiel Radadapter]]

==Weitere Lösungen==
Es gibt noch eine ganze Reihe weiterer Lösungen, wie das einfache Ankleben oder Schneiden von Außengewinde auf eine Welle. Gerne kann jeder weitere hier im Artikel erläutern.

--[[Benutzer:Frank|Frank]] 14:40, 14. Nov 2005 (CET)

[[Category:Robotikeinstieg]]
[[Category:Praxis]]
[[Category:Mechanik]]