ASURO Library  2.80
Makrodefinitionen | Typdefinitionen | Funktionen | Variablen
asuro.h-Dateireferenz

Definitionen und Funktionen der ASURO Bibliothek. Mehr ...

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <avr/pgmspace.h>
#include <stdlib.h>
Include-Abhängigkeitsdiagramm für asuro.h:
Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define FALSE   0
 
#define TRUE   1
 
#define OFF   0
 
#define ON   1
 
#define GREEN   1
 
#define RED   2
 
#define YELLOW   3
 
#define LEFT   0
 
#define RIGHT   1
 
#define CENTER   2
 
#define K1   (1<<5)
 
#define K2   (1<<4)
 
#define K3   (1<<3)
 
#define K4   (1<<2)
 
#define K5   (1<<1)
 
#define K6   (1<<0)
 
#define ADC_CTRL_WHEEL_LEFT   0
 
#define ADC_CTRL_WHEEL_RIGHT   1
 
#define ADC_CTRL_SWITCHES   2
 
#define ADC_CTRL_IR_LEFT   3
 
#define ADC_CTRL_IR_RIGHT   4
 
#define ADC_CTRL_BATTERIE   5
 
#define ADC_CTRL_SWITCHED   6
 
#define Go(distance, speed)   GoTurn(distance,0,speed)
 
#define Turn(degree, speed)   GoTurn(0,degree,speed)
 
#define Batterie   Battery
 
#define OdometrieData   OdometryData
 
#define SerPrint_P(_str)   SerPrint_p(PSTR(_str))
 
#define GREEN_LED_ON   PORTB |= GREEN_LED
 
#define GREEN_LED_OFF   PORTB &= ~GREEN_LED
 
#define RED_LED_ON   PORTD |= RED_LED
 
#define RED_LED_OFF   PORTD &= ~RED_LED
 
#define FWD   _BV(PB5)
 
#define RWD   _BV(PB4)
 
#define BREAK   0x00
 
#define FREE   _BV(PB4) | _BV(PB5)
 
#define IRTX   _BV(PB3)
 
#define GREEN_LED   _BV(PB0)
 
#define RED_LED   _BV(PD2)
 
#define PWM   _BV(PB1) | _BV(PB2)
 
#define RIGHT_DIR   _BV(PB4) | _BV(PB5)
 
#define LEFT_DIR   _BV(PD4) | _BV(PD5)
 
#define SWITCHES   _BV(PD3)
 
#define SWITCH_ON   PORTD |= SWITCHES
 
#define SWITCH_OFF   PORTD &= ~SWITCHES
 
#define BATTERIE   _BV(MUX0) | _BV(MUX2)
 
#define SWITCH   _BV(MUX2)
 
#define IR_LEFT   _BV(MUX0) | _BV(MUX1)
 
#define IR_RIGHT   _BV(MUX1)
 
#define FRONT_LED   _BV(PD6)
 
#define ODOMETRIE_LED   _BV(PD7)
 
#define ODOMETRIE_LED_ON   PORTD |= ODOMETRIE_LED
 
#define ODOMETRIE_LED_OFF   PORTD &= ~ODOMETRIE_LED
 
#define WHEEL_LEFT   _BV(MUX0)
 
#define WHEEL_RIGHT   0
 

Typdefinitionen

typedef void(* voidFuncPtr )(void)
 

Funktionen

void Init (void)
 Initialisiert die Hardware: Ports, A/D Wandler, Serielle Schnittstelle, PWM
Die Init Funktion muss von jeden Programm beim Start aufgerufen werden.
 
unsigned long Gettime (void)
 Gibt die aktuelle Zeit in ms zurueck.
 
void Msleep (unsigned int ms)
 Wartefunktion in ms.
 
void Sleep (unsigned char time36kHz)
 Wartefunktion.
 
void EncoderInit (void)
 Den Interrupt Betrieb der Odometriesensoren-Messung initialisieren und starten.
 
void EncoderSet (int setl, int setr)
 Interruptbetriebene Odometriesensoren Werte vorbelegen.
 
void EncoderStop (void)
 Den Interrupt Betrieb der Odometriesensoren-Messung anhalten.
 
void EncoderStart (void)
 Den Interrupt Betrieb der Odometriesensoren-Messung starten.
 
void GoTurn (int distance, int degree, int speed)
 Faehrt eine bestimmte Strecke mit einer bestimmten Geschwindigkeit. (Autor: stochri)
ODER
Dreht um einen bestimmten Winkel mit einer bestimmten Geschwindigkeit. (Autor: stochri)
Benutzt die Odometrie Sensoren im Interrupt Betrieb.
Vor dem ersten Aufruf muss deshalb EncoderInit() aufgerufen werden.
 
int Battery (void)
 Liest die Batteriespannung und gibt sie zurueck.
Es erfolgt keine Konvertierung in einen Spannungswert.
 
void LineData (unsigned int *data)
 Liest die Daten der beiden Linienverfolgungssensoren.
Die Linien-Beleuchtungs-LED kann sowohl an- als auch ausgeschaltet sein.
 
void OdometryData (unsigned int *data)
 Liest die Daten der beiden Odometriesensoren (Radsensoren).
Diese Funktion schaltet die Odometrie-LED's immer an.
Diese Funktion schaltet die Back-LED's immer aus.
 
unsigned int ReadADC (unsigned int mux, unsigned int sleep)
 Liest die A/D Multiplexer Interupt Werte des gewuenschten A/D Kanals
.
 
void StatusLED (unsigned char color)
 Steuert die (lustige) mehrfarbige Status-LED.
 
void FrontLED (unsigned char status)
 Steuert die vorne, nach unten zeigende, Front-LED.
 
void BackLED (unsigned char left, unsigned char right)
 Steuert die beiden hinteren Back-LED's
Wenn diese Funktion aufgerufen wird, funktioniert die Odometriemessung
nicht mehr, da die gleichen Port-Pins (Port C:Pin 0 und 1) des Prozessors
hierfuer verwendet werden.
 
void MotorDir (unsigned char left_dir, unsigned char right_dir)
 Steuert die Drehrichtung der Motoren.
 
void MotorSpeed (unsigned char left_speed, unsigned char right_speed)
 Steuert die Geschwindigkeit der Motoren.
 
void MyMotorSpeed (unsigned char left_speed, unsigned char right_speed)
 Steuert die Geschwindigkeit der Motoren.
 
void SetMotorPower (int8_t leftpwm, int8_t rightpwm)
 Steuert die Motorgeschwindigkeit und Drehrichtung der Motoren.
 
void SerWrite (unsigned char *data, unsigned char length)
 Senden von Daten ueber die serielle Schnittstelle.
 
void SerRead (unsigned char *data, unsigned char length, unsigned int timeout)
 Lesen von Daten ueber die serielle Schnittstelle.
 
void UartPutc (unsigned char zeichen)
 Sendet einen einzelnen Character über die serielle Schnittstelle.
 
void SerPrint (char *data)
 Sendet einen null-terminierten String ueber die serielle Schnittstelle. Im Gegensatz zur SerWrite Funktion wird bei dieser Funktion kein Parameter mit der Anzahl der zu sendenden Zeichne benötigt. Es wird einfach bis zum Stringende (0-Character) gesendet.
 
void PrintInt (int wert)
 Ausgabe eines Integer Wertes als String ueber die serielle Schnittstelle.
 
void PrintLong (long wert)
 Ausgabe eines Long Wertes als String ueber die serielle Schnittstelle.
 
void SerPrint_p (const char *data)
 Sendet einen null-terminierten String aus dem FLASH Speicher ueber die serielle Schnittstelle.
 
void PrintFloat (float wert, char vorkomma, char nachkomma)
 Ausgabe eines Float Wertes als String ueber die serielle Schnittstelle.
 
unsigned char PollSwitch (void)
 Tastsensor Abfrage im 'Polling-Betrieb'.
 
void StartSwitch (void)
 'Interrupt-Betrieb' zur Tastsensor Abfrage einschalten.
 
void StopSwitch (void)
 Die globale Variable switched wird nicht mehr automatisch bei einem
Tastendruck gesetzt.
 
void Sound (uint16_t freq, uint16_t duration_msec, uint8_t amplitude)
 Soundausgabe ueber die Motoren.
 

Variablen

volatile unsigned int adcValue []
 
const char version [5]
 
volatile int switched
 Flag, dass der Interrupt SIG_INTERRUPT1 durch eine gedrueckte Taste
ausgeloesst wurde. 0 = keine Taste, 1 = Taste gedrueckt.
Kann im eigenen Programm immer abgefragt werden.
 
volatile int encoder [2]
 Odometriesensor Zaehler bei Interrupt Betrieb.
encoder[0] = links; encoder[1] = rechts.
 
volatile unsigned char count36kHz
 Counter fuer 36kHz.
 
volatile unsigned long timebase
 Sytemzeit in ms.
 
volatile int autoencode
 Steuert, ob die Odometrie-Sensor Abfrage im Interrupt Betrieb laufen soll.
 
volatile voidFuncPtr Ovr2IntFunc
 Zeiger auf User Funktion die von der Interupt Funktion aus aufgerufen wird.
 
volatile voidFuncPtr AdcIntFunc
 Zeiger auf User Funktion die von der Interupt Funktion aus aufgerufen wird.
 

Ausführliche Beschreibung

Definitionen und Funktionen der ASURO Bibliothek.

Revision:
2.70
Date:
07. Januar 2007
Author:
Jan Grewe, Robotrixer, Waste, Stochri, Andun, m.a.r.v.i.n
Version
V001 - 10.02.2007 - m.a.r.v.i.n
+++ my_t Neue Datenstruktur
Datenstruktur fuer die Asuro-Hardwareabhaengigen Parameter die jeder User fuer seinen Asuro in der Datei myasuro.h selber einstellen kann um die Asuro-Typischen Eigenschaften zu definieren.
V002 - 18.02.2007 - Sternthaler
+++ my_t
  • Neue Variable fuer MY_MOTOR_DIFF zum ausgleichen unterschiedlicher
    Motoren.
  • Aendern aller enthaltenen Variablen auf einen moeglichst kleinen
    Speicherbedarf. Notwendige Typumwandlungen muessen im Code durch
    casten erfolgen.
V003 - 20.02.2007 - m.a.r.v.i.n
+++ my_t Datenstruktur wieder entfernt
Es werden direkt die Defines aus der myasuro.h verwendet.
V004 - 06.04.2007 - m.a.r.v.i.n
Batterie und OdometrieData Funktionen umbenannt in Battery und OdometryData.
Alte Funktionsnamen ueber Defines beibehalten
V005 - 07.06.2007 - Sternthaler
Funktionen Go() und Turn() aus encoder.c zusammengefasst in GoTurn().
Alte Funktionsnamen ueber Defines beibehalten
V006 - 11.07.2007 - Sternthaler
Externe Variable encoder als volatile angegeben, da sie im Interrupt SIGNAL (SIG_ADC) benutzt wird.
V007 - 15.11.2007 - m.a.r.v.i.n
Variable switched als volatile definiert, da sie im Interrupt SIGNAL (SIG_INTERRUPT1) benutzt wird.
V008 - 29.03.2009 - rossir
A/D Wandler Abfrage ueber Interrupt.
V009 - 26.03.2010 - Sternthaler
+++ Msleep()
Parameter von "int" auf "unsigned int" umgestellt. (Tip von Valen)

Definiert in Datei asuro.h.

Makro-Dokumentation

#define ADC_CTRL_BATTERIE   5

Definiert in Zeile 282 der Datei asuro.h.

#define ADC_CTRL_IR_LEFT   3

Definiert in Zeile 280 der Datei asuro.h.

#define ADC_CTRL_IR_RIGHT   4

Definiert in Zeile 281 der Datei asuro.h.

#define ADC_CTRL_SWITCHED   6

Definiert in Zeile 283 der Datei asuro.h.

#define ADC_CTRL_SWITCHES   2

Definiert in Zeile 279 der Datei asuro.h.

#define ADC_CTRL_WHEEL_LEFT   0

Definiert in Zeile 277 der Datei asuro.h.

#define ADC_CTRL_WHEEL_RIGHT   1

Definiert in Zeile 278 der Datei asuro.h.

#define Batterie   Battery

Definiert in Zeile 440 der Datei asuro.h.

#define BATTERIE   _BV(MUX0) | _BV(MUX2)

ADC5 A/D Wandler Port fuer Batterie Abfrage

Definiert in Zeile 616 der Datei asuro.h.

#define BREAK   0x00

Motor bremsen

Definiert in Zeile 601 der Datei asuro.h.

#define CENTER   2

Definiert in Zeile 258 der Datei asuro.h.

#define FALSE   0

Definiert in Zeile 245 der Datei asuro.h.

#define FREE   _BV(PB4) | _BV(PB5)

Motor freilaufend

Definiert in Zeile 602 der Datei asuro.h.

#define FRONT_LED   _BV(PD6)

PD6 Port fuer Front LED

Definiert in Zeile 620 der Datei asuro.h.

#define FWD   _BV(PB5)

Motor vorwaerts

Definiert in Zeile 599 der Datei asuro.h.

#define Go (   distance,
  speed 
)    GoTurn(distance,0,speed)

Definiert in Zeile 414 der Datei asuro.h.

#define GREEN   1

Definiert in Zeile 251 der Datei asuro.h.

#define GREEN_LED   _BV(PB0)

PB0 Port fuer Gruene Status LED

Definiert in Zeile 605 der Datei asuro.h.

#define GREEN_LED_OFF   PORTB &= ~GREEN_LED

Gruene Status LED aus

Definiert in Zeile 595 der Datei asuro.h.

#define GREEN_LED_ON   PORTB |= GREEN_LED

Gruene Status LED an

Definiert in Zeile 594 der Datei asuro.h.

#define IR_LEFT   _BV(MUX0) | _BV(MUX1)

ADC3 A/D Wandler Port fuer Linienfolger Fototransistor links

Definiert in Zeile 618 der Datei asuro.h.

#define IR_RIGHT   _BV(MUX1)

ADC2 A/D Wandler Port fuer Linienfolger Fototransistor rechts

Definiert in Zeile 619 der Datei asuro.h.

#define IRTX   _BV(PB3)

PB3 Port fuer Infrarot Transmitter LED

Definiert in Zeile 604 der Datei asuro.h.

#define K1   (1<<5)

Definiert in Zeile 263 der Datei asuro.h.

#define K2   (1<<4)

Definiert in Zeile 264 der Datei asuro.h.

#define K3   (1<<3)

Definiert in Zeile 265 der Datei asuro.h.

#define K4   (1<<2)

Definiert in Zeile 266 der Datei asuro.h.

#define K5   (1<<1)

Definiert in Zeile 267 der Datei asuro.h.

#define K6   (1<<0)

Definiert in Zeile 268 der Datei asuro.h.

#define LEFT   0

Definiert in Zeile 256 der Datei asuro.h.

#define LEFT_DIR   _BV(PD4) | _BV(PD5)

PD4, PD5 Ports fuer Drehrichtung linker Motor

Definiert in Zeile 610 der Datei asuro.h.

#define ODOMETRIE_LED   _BV(PD7)

PD7 Port fuer Odometrie LED

Definiert in Zeile 622 der Datei asuro.h.

#define ODOMETRIE_LED_OFF   PORTD &= ~ODOMETRIE_LED

Odometrie LED aus

Definiert in Zeile 624 der Datei asuro.h.

#define ODOMETRIE_LED_ON   PORTD |= ODOMETRIE_LED

Odometrie LED an

Definiert in Zeile 623 der Datei asuro.h.

#define OdometrieData   OdometryData

Definiert in Zeile 441 der Datei asuro.h.

#define OFF   0

Definiert in Zeile 248 der Datei asuro.h.

#define ON   1

Definiert in Zeile 249 der Datei asuro.h.

#define PWM   _BV(PB1) | _BV(PB2)

PB1, PB2 Ports fuer Pulsweitenmodulation der Motor Geschwindigkeit

Definiert in Zeile 608 der Datei asuro.h.

#define RED   2

Definiert in Zeile 252 der Datei asuro.h.

#define RED_LED   _BV(PD2)

PD2 Port fuer Rote Status LED

Definiert in Zeile 606 der Datei asuro.h.

#define RED_LED_OFF   PORTD &= ~RED_LED

Rote Status LED aus

Definiert in Zeile 597 der Datei asuro.h.

#define RED_LED_ON   PORTD |= RED_LED

Rote Status LED an

Definiert in Zeile 596 der Datei asuro.h.

#define RIGHT   1

Definiert in Zeile 257 der Datei asuro.h.

#define RIGHT_DIR   _BV(PB4) | _BV(PB5)

PB4, PB5 Ports fuer Drehrichtung rechter Motor

Definiert in Zeile 609 der Datei asuro.h.

#define RWD   _BV(PB4)

Motor rueckwaerts

Definiert in Zeile 600 der Datei asuro.h.

#define SerPrint_P (   _str)    SerPrint_p(PSTR(_str))

Definiert in Zeile 547 der Datei asuro.h.

#define SWITCH   _BV(MUX2)

ADC4 A/D Wandler Port fuer Tastsensor

Definiert in Zeile 617 der Datei asuro.h.

#define SWITCH_OFF   PORTD &= ~SWITCHES

Tastsensor aus

Definiert in Zeile 614 der Datei asuro.h.

#define SWITCH_ON   PORTD |= SWITCHES

Tastsensor an

Definiert in Zeile 613 der Datei asuro.h.

#define SWITCHES   _BV(PD3)

PD3 Port fuer Tastsensor

Definiert in Zeile 612 der Datei asuro.h.

#define TRUE   1

Definiert in Zeile 246 der Datei asuro.h.

#define Turn (   degree,
  speed 
)    GoTurn(0,degree,speed)

Definiert in Zeile 415 der Datei asuro.h.

#define WHEEL_LEFT   _BV(MUX0)

ADC1 A/D Wandler Port fuer Odometrie Sensor links

Definiert in Zeile 626 der Datei asuro.h.

#define WHEEL_RIGHT   0

ADC0 A/D Wandler Port fuer Odometrie Sensor rechts

Definiert in Zeile 627 der Datei asuro.h.

#define YELLOW   3

Definiert in Zeile 253 der Datei asuro.h.

Dokumentation der benutzerdefinierten Typen

typedef void(* voidFuncPtr)(void)

Definiert in Zeile 343 der Datei asuro.h.

Dokumentation der Funktionen

void BackLED ( unsigned char  left,
unsigned char  right 
)

Steuert die beiden hinteren Back-LED's
Wenn diese Funktion aufgerufen wird, funktioniert die Odometriemessung
nicht mehr, da die gleichen Port-Pins (Port C:Pin 0 und 1) des Prozessors
hierfuer verwendet werden.

Parameter
[in]leftSchaltet die linke LED an bzw. aus. [ ON | OFF ]
[in]rightSchaltet die rechte LED an bzw. aus. [ ON | OFF ]
Rückgabe
nichts
Hinweis:
Obwohl die uebergebenen Parameter nicht geprueft werden, treten hier keine
unerwarteten Reaktionen am Port C auf.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Linke LED aus; Rechte LED an

Definiert in Zeile 155 der Datei leds.c.

{
if (left || right)
{
PORTD &= ~(1 << PD7); // Rad-LED's OFF
DDRC |= (1 << PC0) | (1 << PC1); // Port als Output => KEINE Odometrie
PORTC |= (1 << PC0) | (1 << PC1);
}
if (!left)
PORTC &= ~(1 << PC1);
if (!right)
PORTC &= ~(1 << PC0);
}
int Battery ( void  )

Liest die Batteriespannung und gibt sie zurueck.
Es erfolgt keine Konvertierung in einen Spannungswert.

Rückgabe
10-Bit-Wert der Batteriespannung (Bereich 0..1023)
Die Spannung in Volt kann mit folgende Formel berechnet werden:
Umess[V] = (Uref / 2 ^ ADC-Bitsanzahl) * Batterie ()
Ubat[V] = ((R1 + R2) * Umess) / R2

Dabei sind:

Uref = 2.56 Volt
ADC-Bitsanzahl = 10 Bit
R1 = 12000 Ohm auf der ASURO-Platine
R2 = 10000 Ohm auf der ASURO-Platine

Oder einfach:

Ubat[V] = 0,0055 * Battery ()
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// In Variable wert den 10-Bit-Bateriespannungswert lesen
// und bei Unterschreitung von 810 eine alles_stop-Funktion
// aufrufen.
int wert;
wert = Battery();
if (wert < 810) // 810 entsprechen ca. 4,455 Volt
alles_stop (); // Spannung zu klein, Akkus schonen

Definiert in Zeile 84 der Datei adc.c.

{
int data = 28*ReadADC(BATTERIE, 10)/25; // data=1,12*x dann stimmt Wert von Interrupt ADC mit Poll ADC überein
// Rückwärtskompatibel?!
return data;
}
void EncoderInit ( void  )

Den Interrupt Betrieb der Odometriesensoren-Messung initialisieren und starten.

Siehe auch
autoencode, encoder
Funktionsweise:
Globale Variable autoencode auf TRUE.
Diese Funktion wird nun verlassen und das aufrufende Hauptprogramm arbeit
weiter. In der Zwischenzeit ist der AD-Wandler beschaeftigt um das Mess-
ergebniss zu ermitteln.
Ist der Wandler fertig, wird der Interrupt zum AD-Wandler aufgerufen und in
der dazu vorhandene Interrupt-Funktion aus asuro.c bearbeitet.
Dort wird nun AUTOMATISCH das Messergebnis ausgewertet, ein erkannter
Hell- Dunkel-Wechsel an der Encoderscheibe erkannt und dadurch der Zaehler
in der globalen Variablen encoder[] weitergezaehlt.
Ausserdem wird dort dann der AD-Wandler fuer die andere Seite gestartet.
Da dies dann immer im Wechsel laeuft, kann das Hauptprogramm, ohne
weiters Zutun von nun ab auf die Zaehlerwerte in encoder[] zugreifen.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
int main (void)
{
Init ();
MotorSpeed (150, 150);
while (1)
(
// Dein Programm
if (encoder [0] > 500)
{
MotorSpeed (0, 0);
}
}
return 0;
}

Definiert in Zeile 94 der Datei encoder_low.c.

{
/*
Alle definierten Interrupts im Asuro sperren.
*/
cli();
/*
Odometrie im Interruptbetrieb weiter bearbeiten.
*/
/*
Die Odometrie Hell-/Dunkel-Zaehler zuruecksetzen/initialisieren.
*/
EncoderSet (0, 0);
/*
Alle definierten Interrupts im Asuro wieder zulassen.
*/
sei();
}
void EncoderSet ( int  setl,
int  setr 
)

Interruptbetriebene Odometriesensoren Werte vorbelegen.

Parameter
[in]setlWert fuer links
[in]setrWert fuer rechts
Hinweis:
Initialisiert die beiden Werte in der globalen Variable encoder.
Normalerweise werden die Zaehlerwerte mit 0 initialisiert. Fuer einige
Anwendungen kann es sinnvoll sein auch schon bestimmte Werte vorzubelegen.
Siehe auch
Die globale Variable encoder wird hier initialisiert.
Beispiel:
(siehe unter den examples)

Definiert in Zeile 182 der Datei encoder_low.c.

{
encoder [LEFT] = setl;
encoder [RIGHT] = setr;
}
void EncoderStart ( void  )

Den Interrupt Betrieb der Odometriesensoren-Messung starten.

Siehe auch
Die globale Variable autoencode hier auf TRUE gesetzt.
Beispiel:
(siehe unter EncoderInit bzw. in den examples)

Definiert in Zeile 153 der Datei encoder_low.c.

void EncoderStop ( void  )

Den Interrupt Betrieb der Odometriesensoren-Messung anhalten.

Siehe auch
Die globale Variable autoencode hier auf FALSE gesetzt.
Funktionsweise:
Durch das setzen der globalen Variablen autoencode auf FALSE wird in
der AD-Wandler-Interruptfunktion der Teil zur Bearbeitung uebersprungen.
Dadurch wird der Wandler nicht mehr neu gestartet und somit stopp die
Automatik.
Beispiel:
(siehe unter EncoderInit bzw. in den examples)

Definiert in Zeile 135 der Datei encoder_low.c.

void FrontLED ( unsigned char  status)

Steuert die vorne, nach unten zeigende, Front-LED.

Parameter
[in]statusSchaltet die LED an bzw. aus. [ ON | OFF ]
Rückgabe
nichts
Hinweis:
Diese Funktion ist als 'inline'-Funktion definiert.
Achtung:
Der uebergeben Parameter wird nicht geprueft, und kann evl. zu unerwarteten
Reaktionen fuehren, da der Port D anhand dieses Wertes manipuliert wird.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// schalte die Front-LED an.

Definiert in Zeile 120 der Datei leds.c.

{
PORTD = (PORTD &~(1 << PD6)) | (status << PD6);
}
unsigned long Gettime ( void  )

Gibt die aktuelle Zeit in ms zurueck.

Da der Asuro keine Atomuhr hat, ist es die vergangene Zeit seitdem er eingeschaltet wurde.
Genauer: nachdem der Interrupt Timer2 aktiviert wurde.

Rückgabe
Einschaltzeit in Millisekunden (Bereich: unsigned long 0..286331153)
Das sind ca. 79.5 Stunden. Fuer die, die ihren Asuro also ohne Solarzellen
betreiben, reicht diese Zeitangabe bevor der Accu leer ist.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Alle 500 ms die Front-LED umschalten.
unsigned long zeit;
unsigned char on_off = TRUE;
zeit = Gettime ();
while (1)
{
if (Gettime () > zeit + 500)
{
zeit = Gettime ();
FrontLED (on_off);
on_off ^= 1;
}
}

Definiert in Zeile 78 der Datei time.c.

{
return ((timebase * 256) + count36kHz) / 36;
}
void GoTurn ( int  distance,
int  degree,
int  speed 
)

Faehrt eine bestimmte Strecke mit einer bestimmten Geschwindigkeit. (Autor: stochri)
ODER
Dreht um einen bestimmten Winkel mit einer bestimmten Geschwindigkeit. (Autor: stochri)
Benutzt die Odometrie Sensoren im Interrupt Betrieb.
Vor dem ersten Aufruf muss deshalb EncoderInit() aufgerufen werden.

Parameter
[in]distanceDistanz in mm (- rueckwaerts, + = vorwaerts)
Bei 0 wird degree fuer einen Turn benutzt.
[in]degreeWinkel (- rechts, + links)
[in]speedGeschwindigkeit (Wertebereich 0...255)
Rückgabe
nichts
Siehe auch
MACRO Go() und MACRO Turn() koennen weiterhin aufgerufen werden um bestehenden Programmcode nicht umschreiben zu muessen.
In der globale Variable encoder, werden die Hell-/Dunkelwechsel der
Encoderscheiben im Interruptbetrieb gezaehlt.
Hinweis:
Die Berechnung der zu fahrenden Ticks beruht auf der Annahme, dass die
Anzahl der schwarzen Teilstuecke und die Raddurchmesser wie bei stochri sind.
(Sternthaler) Vermutung, dass der Hersteller unterschiedlich grosse Raeder
ausgeliefert hat, da die Berechnung in dieser Form bei Sternthaler nicht
funktioniert.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Laesst den Asuro ein Quadrat von 200 mm fahren,
// bei einer Geschwindigkeit von 150.
for (i = 0; i < 4; i++)
{
GoTurn (200, 0, 150); // entspricht Go (200, 150)
GoTurn ( 0, 90, 150); // entspricht Turn (90, 150)
}

Definiert in Zeile 128 der Datei encoder.c.

{
unsigned long enc_count;
int tot_count = 0;
int diff = 0;
int l_speed = speed, r_speed = speed;
/* stop the motors until the direction is set */
MotorSpeed (0, 0);
/* if distance is NOT zero, then take this value to go ... */
if (distance != 0)
{
/* calculate tics from mm */
enc_count = abs (distance) * 10000L;
enc_count /= MY_GO_ENC_COUNT_VALUE;
if (distance < 0)
else
}
/* ... else take the value degree for a turn */
else
{
/* calculate tics from degree */
enc_count = abs (degree) * MY_TURN_ENC_COUNT_VALUE;
enc_count /= 360L;
if (degree < 0)
else
}
/* reset encoder */
EncoderSet (0, 0);
/* now start the machine */
MotorSpeed (l_speed, r_speed);
while (tot_count < enc_count)
{
tot_count += encoder [LEFT];
diff = encoder [LEFT] - encoder [RIGHT];
if (diff > 0)
{ /* Left faster than right */
if ((l_speed > speed) || (r_speed > 244))
l_speed -= 10;
else
r_speed += 10;
}
if (diff < 0)
{ /* Right faster than left */
if ((r_speed > speed) || (l_speed > 244))
r_speed -= 10;
else
l_speed += 10;
}
/* reset encoder */
EncoderSet (0, 0);
MotorSpeed (l_speed, r_speed);
Msleep (1);
}
Msleep (200);
}
void Init ( void  )

Initialisiert die Hardware: Ports, A/D Wandler, Serielle Schnittstelle, PWM
Die Init Funktion muss von jeden Programm beim Start aufgerufen werden.

Siehe auch
Die Funktionen Sleep() und Msleep() in time.c werden mit dem hier
eingestellten 36 kHz-Takt betrieben.
Funktionsweise der Zeitfunktionen:
Msleep() ruft Sleep() auf. In Sleep() wird die globale Variable count36kHz
zur Zeitverzoegerung benutzt. Diese Variable wird jedesmal im Interrupt
TIMER2_OVF_vect um 1 hochgezaehlt.
Der Interrupt selber wird durch den hier eingestellten Timer ausgeloesst.
Somit ist dieser Timer fuer die Zeitverzoegerung zustaendig.
Siehe auch
Die globale Variable autoencode fuer die automatische Bearbeitung der
Odometrie-ADC-Wandler wird hier auf FALSE gesetzt.
Hinweis zur 36 kHz-Frequenz vom Timer 2
Genau diese Frequenz wird von dem Empfaengerbaustein benoetigt und kann
deshalb nicht geaendert werden.
In der urspruenglichen, vom Hersteller ausgelieferten LIB, war diese
Frequenz allerdings auf 72 kHz eingestellt. Durch eine geschickte
Umkonfigurierung durch waste konnte diese aber halbiert werden.
Sinnvoll ist dies, da der durch diesen Timer2 auch ausgeloesste Timer-
Interrupt dann nur noch die Haelfte an Rechenzeit in Anspruch nimmt.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Die Init()-Funktion MUSS IMMER zu Anfang aufgerufen werden.
int main (void)
{
int wert;
Init ();
while (1)
(
// Dein Programm
}
return 0;
}

Definiert in Zeile 228 der Datei asuro.c.

{
/*
Timer2, zum Betrieb mit der seriellen Schnittstelle, fuer die
IR-Kommunikation auf 36 kHz eingestellt.
*/
#if defined(__AVR_ATmega168__)
// fast PWM, set OC2A on compare match, clear OC2A at bottom, clk/1
TCCR2A = _BV(WGM20) | _BV(WGM21) | _BV(COM2A0) | _BV(COM2A1);
TCCR2B = _BV(CS20);
// interrupt on timer overflow
TIMSK2 |= _BV(TOIE2);
#else
// fast PWM, set OC2A on compare match, clear OC2A at bottom, clk/1
TCCR2 = _BV(WGM20) | _BV(WGM21) | _BV(COM20) | _BV(COM21) | _BV(CS20);
// interrupt on timer overflow
TIMSK |= _BV(TOIE2);
#endif
// 36kHz carrier/timer
OCR2 = 0x91;
/*
Die serielle Schnittstelle wurde waerend der Boot-Phase schon
programmiert und gestartet. Hier werden die Parameter auf 2400 1N8 gesetzt.
*/
#if defined(__AVR_ATmega168__)
UBRR0L = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1);
UBRR0H = (F_CPU/(BAUD_RATE*16L)-1) >> 8;
UCSR0B = (1<<RXEN0) | (1<<TXEN0);
UCSR0C = (1<<UCSZ00) | (1<<UCSZ01);
#else
UBRRH = (((F_CPU/BAUD_RATE)/16)-1)>>8; // set baud rate
UBRRL = (((F_CPU/BAUD_RATE)/16)-1);
UCSRB = (1<<RXEN)|(1<<TXEN); // enable Rx & Tx
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // config USART; 8N1
#endif
/*
Datenrichtung der I/O-Ports festlegen. Dies ist durch die Beschaltung der
Asuro-Hardware nicht aenderbar.
Port B: Seriell Senden; Richtungsvorgabe Motor links; Takt fuer die
Geschwindigkeit beider Motoren; Grueneanteil-Status-LED
Port D: Richtungsvorgabe Motor rechts; Vordere LED;
Odometrie-LED (Radsensor); Rotanteil-Status-LED
*/
DDRB = IRTX | RIGHT_DIR | PWM | GREEN_LED;
DDRD = LEFT_DIR | FRONT_LED | ODOMETRIE_LED | RED_LED | SWITCHES; // Port-Bits als Output
/*
PWM-Kanaele OC1A und OC1B auf 8-Bit einstellen.
Sie werden fuer die Geschwindigkeitsvorgaben der Motoren benutzt.
*/
TCCR1A = _BV(WGM10) | _BV(COM1A1) | _BV(COM1B1);
TCCR1B = _BV(CS11); // tmr1-Timer mit MCU-Takt/8 betreiben.
/*
Sonstige Vorbereitungen.
- Alle LED's ausschalten
- Motoren stoppen und schon mal auf Vorwaerts einstellen.
- Globale Variable autoencoder ausschalten.
*/
MotorSpeed (0, 0);
/*
* Vorbereitung für WHEEL-Interrupts (Encoder)
Port C als Input => dadurch gehen die Back-LED aus ...
*/
DDRC &= ~ (_BV(PC0) | _BV(PC1));
/*
... aber nun koennen die LED's am Rad eingeschaltet werden, und die
Sensoren koennen gemessen werden.
*/
/*
Linken Odometrie-Sensor auswaehlen. (AVCC ref. with external capacitor)
*/
ADMUX = _BV(ADLAR) | _BV(REFS0) | WHEEL_LEFT;
/*
AD-Wandler einschalten, Parameter einstellen und Starten. (clk/128)
Startet den ADC im 'free running'-Mode (ADFR). Das heisst, der Wandler
nach einer Messung automatisch wieder neu startet.
*/
ADCSRA = _BV(ADEN) | _BV(ADFR) | _BV(ADIE) | _BV(ADSC) | _BV(ADPS0) | _BV(ADPS1) | _BV(ADPS2);
/*
Funktion zum ALLGEMEINEN ZULASSEN von Interrupts.
*/
sei ();
}
void LineData ( unsigned int *  data)

Liest die Daten der beiden Linienverfolgungssensoren.
Die Linien-Beleuchtungs-LED kann sowohl an- als auch ausgeschaltet sein.

Parameter
[out]dataZeiger auf die gelesenen Daten:
data[0] linker Sensor (Bereich 0..1023)
data[1] rechter Sensor (Bereich 0..1023)
Siehe auch
Die globale Variable autoencode wird temporaer auf FALSE gesetzt und am Ende
der Funktion mit dem alten Wert restauriert.
Hinweis:
Die Linien-Beleuchtungs-LED kann vorher mit der Funktion FrontLED()
im aufrufenden Programmteil an- bzw. ausgeschaltet werden.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
unsigned int data [2];
LineData (data);
if (data [0] > 100) // 0 ist der linke Sensor ...
tu_diese (); // linker Sensor > 100
if (data [1] < 50) // ... 1 ist der rechte Sensor
tu_das (); // rechter Sensor < 50

Definiert in Zeile 125 der Datei adc.c.

{
/*
Linken Linien-Sensor lesen
*/
data[LEFT] = ReadADC(IR_LEFT, 0);
/*
Rechten Linien-Sensor lesen
*/
data[RIGHT] = ReadADC(IR_RIGHT, 0);
}
void MotorDir ( unsigned char  left_dir,
unsigned char  right_dir 
)

Steuert die Drehrichtung der Motoren.

Parameter
[in]left_dirRichtung des linken Motors [ FWD | RWD | BREAK | FREE ]
[in]right_dirRichtung des rechten Motors [ FWD | RWD | BREAK | FREE ]
Rückgabe
nichts
Hinweis:
Diese Funktion ist als 'inline'-Funktion definiert.
Arbeitsweise:
Ueber die Parameter werden die Port-Pin's zu den H-Bruecken beider Motoren so
gesetzt, dass die jeweils 4 beteiligten Transitoren einer Bruecke den Strom
durch die Motoren entweder
  • FWD vorwaerts durchleiten
  • RWD rueckwaerts durchleiten
  • BREAK den Motor kurzschliessen (Bremswirkung)
  • FREE oder von der Stromversorgung trennen (Motor laeuft aus)
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Setze die Richtung fuer den rechten Motor auf Rueckwaerts
// und blockiert den linken Motor.

Definiert in Zeile 126 der Datei motor_low.c.

{
PORTD = (PORTD &~ ((1 << PD4) | (1 << PD5))) | left_dir;
PORTB = (PORTB &~ ((1 << PB4) | (1 << PB5))) | right_dir;
}
void MotorSpeed ( unsigned char  left_speed,
unsigned char  right_speed 
)

Steuert die Geschwindigkeit der Motoren.

Parameter
[in]left_speedGeschwindigkeit linker Motor (Bereich 0..255)
[in]right_speedGeschwindigkeit rechter Motor (Bereich 0..255)
Rückgabe
nichts
Siehe auch
Die Initialisierung der PWM-Funktionalitaet erfolgt in der Funktion Init().
Hinweis:
Diese Funktion ist als 'inline'-Funktion definiert.
Arbeitsweise:
Ueber die Parameter werden die beiden Kanaele der PWM-Funktionalitaet im
Prozessor angesteuert. Diese Art der Geschwindigkeitsreglung beruht darauf,
dass ein digitaler Output-Pin in schneller Folge an- und ausgeschaltet wird.
Mit dem Parameter wird nun gesteuert wie lange der Strom im Verhaeltniss
zur Zykluszeit angeschaltet ist.
Wird z.B. ein Wert von 150 fuer einen Parameter uebergeben, dann wird fuer
150 / 255-tel der Zykluszeit der Port auf 1 geschaltet und somit ist die
Motorleistung entsprechend reduziert.
Daraus ergibt sich auch dass der Asuro noch nicht bei einem Wert von
20 fahren wird, da diese Leistung nicht ausreicht ihn 'anzuschieben'.
(PWM = Pulsweitenmodulation)
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Setzt die Geschwindigkeit fuer den linken Motor
// auf 150 und stoppt den rechten Motor.
MotorSpeed (150, 0);

Definiert in Zeile 83 der Datei motor_low.c.

{
OCR1A = left_speed;
OCR1B = right_speed;
}
void Msleep ( unsigned int  ms)

Wartefunktion in ms.

Diese Funktion nutzt die Sleep()-Funktion um mit dem uebergeben Parameter
Pausen in ms-Einheiten zu erhalten.

Parameter
[in]dauerWartezeit in Millisekunden.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// 1.5 Sekunde warten
Msleep (1500);

Definiert in Zeile 137 der Datei time.c.

{
unsigned int z;
for (z = 0; z < ms; z++)
Sleep (36);
}
void MyMotorSpeed ( unsigned char  left_speed,
unsigned char  right_speed 
)

Steuert die Geschwindigkeit der Motoren.

Parameter
[in]left_speedGeschwindigkeit linker Motor (Bereich 0..255)
[in]right_speedGeschwindigkeit rechter Motor (Bereich 0..255)
Rückgabe
nichts
Siehe auch
Die Initialisierung der PWM-Funktionalitaet erfolgt in der Funktion Init().
Arbeitsweise:
Ueber die Parameter werden die beiden Kanaele der PWM-Funktionalitaet im
Prozessor angesteuert. Diese Art der Geschwindigkeitsreglung beruht darauf,
dass ein digitaler Output-Pin in schneller Folge an- und ausgeschaltet wird.
Mit dem Parameter wird nun gesteuert wie lange der Strom im Verhaeltniss
zur Zykluszeit angeschaltet ist.
Wird z.B. ein Wert von 150 fuer einen Parameter uebergeben, dann wird fuer
150 / 255-tel der Zykluszeit der Port auf 1 geschaltet und somit ist die
Motorleistung entsprechend reduziert.
Daraus ergibt sich auch dass der Asuro noch nicht bei einem Wert von
20 fahren wird, da diese Leistung nicht ausreicht ihn 'anzuschieben'.
(PWM = Pulsweitenmodulation)
Der Define MY_MOTOR_DIFF aus myasuro.h wird jeweils zur Haelfte auf die
beiden Motoren verteilt. Es werden die Grenzen von 0 und 255 beruecksichtigt.
So lange es geht, wird die angegebene Differenz aus MY_MOTOR_DIFF erhalten.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Setzt die Geschwindigkeit fuer den linken Motor
// auf 150 und stoppt den rechten Motor.
MotorSpeed (150, 0);

Definiert in Zeile 80 der Datei my_motor_low.c.

{
int l_speed;
int r_speed;
if (MY_MOTOR_DIFF != 0)
{
/*
Das Ganze macht nur Sinn, wenn mindestens ein Motor fahren soll.
*/
if (left_speed > 0 ||
right_speed > 0)
{
/*
Bei positivem MY_MOTOR_DIFF wird der rechte Motor verstaerkt.
Bei negativem MY_MOTOR_DIFF wird der linke Motor verstaerkt.
*/
l_speed = left_speed - MY_MOTOR_DIFF / 2;
r_speed = right_speed + MY_MOTOR_DIFF / 2;
/*
Wertebereich von 0 bis 255 pruefen.
Unterscheiden nach positiver, bzw. negativer Vorgabe.
*/
if (MY_MOTOR_DIFF > 0)
{
/*
Bei positivem MY_MOTOR_DIFF kann nur die rechte Seite > 255 werden.
*/
if (r_speed > 255)
{
/*
Um die Differenz von MY_MOTOR_DIFF weiterhin zu erhalten, wird nun
die linke Seite noch weiter reduziert, und die rechte Seite auf
das zulaessige Maximum gesetzt.
*/
l_speed -= (r_speed - 255);
r_speed = 255;
}
if (l_speed < 0)
{
/*
Die linke Seite ist nun unter dem zulaessige Minimum von 0.
Auch dies muss korrigiert werden.
*/
l_speed = 0;
}
}
else
{
/*
Bei negativem MY_MOTOR_DIFF kann nur die linke Seite > 255 werden.
*/
if (l_speed > 255)
{
/*
Um die Differenz von MY_MOTOR_DIFF weiterhin zu erhalten, wird nun
die rechte Seite noch weiter reduziert, und die linke Seite auf
das zulaessige Maximum gesetzt.
*/
r_speed -= (l_speed - 255);
l_speed = 255;
}
if (r_speed < 0)
{
/*
Die rechte Seite ist nun unter dem zulaessige Minimum von 0.
Auch dies muss korrigiert werden.
*/
r_speed = 0;
}
}
left_speed = l_speed;
right_speed = r_speed;
}
}
MotorSpeed(left_speed, right_speed);
}
void OdometryData ( unsigned int *  data)

Liest die Daten der beiden Odometriesensoren (Radsensoren).
Diese Funktion schaltet die Odometrie-LED's immer an.
Diese Funktion schaltet die Back-LED's immer aus.

Parameter
[out]dataZeiger auf die gelesenen Daten:
data[0] linker Sensor,
data[1] rechter Sensor. (Bereich 0..1023)
Hinweis:
Die Odometrie-Beleuchtungs-LED's muessen zur Messung der Odometrie-
sensoren wegen der Hardware im ASURO immer eingeschaltet sein.
Die Hardware ist so ausgelegt, dass dadurch allerdings die hinteren
Back-LED's ausgeschaltet werden.
Da die Odometrie-Beleuchtungs-LED's in dieser Funktion EIN-geschaltet
werden, funktionieren dann die Back-LED's nicht mehr. Sie koennen im
Programm nach dieser Funktion mit BackLED() bei Bedarf wieder
eingeschaltet werden.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
unsigned int data [2];
OdometryData (data);
if (data [0] > data [1]) // 0 linker Sensor; 1 ist rechter Sensor
fahre_links (); // Ein bisschen nach links fahren
if (data [0] < data [1])
fahre_rechts (); // Ein bisschen nach rechts fahren
BackLED (ON, OFF); // linke Back-LED mal wieder anschalten

Definiert in Zeile 174 der Datei adc.c.

{
/*
Vorbereitung zum lesen der Odometrie-Sensoren.
*/
DDRC &= ~((1 << PC0) | (1 << PC1)); // Port auf Input=>Back-LEDs gehen aus
ODOMETRIE_LED_ON; // Odometrie-LED's einschalten
/*
Linken Odometrie-Sensor lesen
*/
data[LEFT] = ReadADC(WHEEL_LEFT, 0);
/*
Rechten Odometrie-Sensor lesen
*/
data[RIGHT] = ReadADC(WHEEL_RIGHT, 0);
}
unsigned char PollSwitch ( void  )

Tastsensor Abfrage im 'Polling-Betrieb'.

Rückgabe
Tastenwert bitorientiert, K1 = Bit5, K2 = Bit4, K3 = Bit3, K4 = Bit2, K5 = Bit1, K6 = Bit0
Hinweis:
In dieser Funktion ist ein Sleep() Aufruf vorhanden. Der wird benoetigt
damit IsrStandard() genügend Zeit bekommt so, dass der zweite PollSwitch aufruf auch garantiert einen neuen Wert zur Verfügung hat.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
uint8_t t1, t2;
unsigned char text [16];
while (1)
{
t1 = PollSwitch ();
t2 = PollSwitch ();
// 2x PollSwitch aufrufen und beide Rueckgabewerte auf Gleichheit ueberpruefen
if (t1 && t2 && t1 == t2) // irgendeine Taste gedrueckt
{
itoa (t1, text, 10); // Tastenwert senden
SerPrint (text);
SerPrint ("\r\n"); // Zeilenvorschub
}
Msleep (500); // 0,5 sek warten
}

Definiert in Zeile 88 der Datei switches.c.

{
unsigned int i;
if (!switched) return 0; // Kehrt sofort zurück, falls kein Taster gedrueckt ist
i = ReadADC(SWITCH, 15); // sleep 15 ms -> Rückwärtskompatibel?! und wg. timing da draussen und drinnen (IsrStandard())
if (i>=MY_SWITCH_THRESHHOLD) return 0; // Eher rauschen -> raus hier!
// Es wurde "ganz sicher" eine Taste gedrückt.
/*
Die Original Umrechenfunktion von Jan Grewe - DLR wurde ersetzt durch
eine Rechnung ohne FLOAT-Berechnungen.
return ((unsigned char) ((( 1024.0/(float)i - 1.0)) * 61.0 + 0.5));
Wert 61L evtl. anpasssen, falls fuer K1 falsche Werte zurueckgegebn werden.
*/
return ((10240000L / (long)i - 10000L) * MY_SWITCH_VALUE + 5000L) / 10000;
}
void PrintFloat ( float  wert,
char  vorkomma,
char  nachkomma 
)

Ausgabe eines Float Wertes als String ueber die serielle Schnittstelle.

Parameter
[in]wertAuszugebender Float Wert (32Bit)
[in]vorkommaAnzahl der Vorkomma Stellen
[in]nachkommaAnzahl der Nachkomma Stellen
Autor
M1.R
Version
V001 - 16.11.2007 m.a.r.v.i.n
first implementation (Idee von M1.R)
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
SerPrint ("\r\n");
PrintFloat (123.4567, 3, 4);
SerPrint ("\r\n");
SerPrint ("\r\n");
PrintFloat (-123.4567, 5, 2);
SerPrint ("\r\n");
SerPrint ("\r\n");
PrintFloat (-1.234567, 1, 6);
SerPrint ("\r\n");
SerPrint ("\r\n");
PrintFloat (1.234567, 1, 3);
SerPrint ("\r\n");

Definiert in Zeile 54 der Datei printf.c.

{
char text [10];
dtostrf(wert, vorkomma, nachkomma, text);
SerPrint (text);
}
void PrintInt ( int  wert)

Ausgabe eines Integer Wertes als String ueber die serielle Schnittstelle.

Parameter
[in]wertAuszugebender Integer Wert (16Bit)
Autor
Robotrixer, marvin
Version
beta - 31.03.2005 - Robotrixer
first implementation
2.60 - 28.09.2005 - m.a.r.v.i.n
strlen verwenden, anstelle fester Laenge
2.61 - 20.11.2006 - m.a.r.v.i.n
Initialisierung text String kann zu Fehler
beim Flashen mit RS232/IR Adapter fuehren
(Bug report von francesco)
2.70b- 07.01.2007 - m.a.r.v.i.n
SerPrint Funktion anstelle SerWrite verwenden
2.70rc2- 09.02.2007 - m.a.r.v.i.n
Text Laenge auf 7 erhoeht, fuer Ausgabe negativer Werte (Bug Report von HermannSW)
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Beispiel fuer zeilenweise Ausgabe der Encoder Werte
While(1)
{
SerPrint (" ");
SerPrint ("\n\r");
MSleep (500); //0,5sek. warten
}

Definiert in Zeile 102 der Datei print.c.

{
char text [7]; // "-12345"
itoa (wert, text, 10);
SerPrint (text);
}
void PrintLong ( long  wert)

Ausgabe eines Long Wertes als String ueber die serielle Schnittstelle.

Parameter
[in]wertAuszugebender Long Wert (32Bit)
Autor
HermannSW, marvin
Version
2.70rc2 - 09.02.2007 m.a.r.v.i.n
first implementation (Idee von HermannSW)
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Beispiel fuer Ausgabe der Batterie Werte
long data;
While(1)
{
data = Batterie ();
PrintLong (data);
SerPrint ("\n\r");
MSleep (500); //0,5sek. warten
}

Definiert in Zeile 141 der Datei print.c.

{
char text [12]; // '-'1234567891'\0'
ltoa (wert, text, 10);
SerPrint (text);
}
unsigned int ReadADC ( unsigned int  mux,
unsigned int  sleep 
)

Liest die A/D Multiplexer Interupt Werte des gewuenschten A/D Kanals
.

Parameter
muxNummer des A/D Kanal Multiplexer
sleepoptionale Wartezeit
Rückgabe
10 Bit A/D Wert (Bereich 0..1023)

Definiert in Zeile 34 der Datei adc_low.c.

{
unsigned int adc;
if (sleep)
Sleep(sleep);
cli();
adc=adcValue[mux];
sei();
return adc>>6;
}
void SerPrint ( char *  data)

Sendet einen null-terminierten String ueber die serielle Schnittstelle. Im Gegensatz zur SerWrite Funktion wird bei dieser Funktion kein Parameter mit der Anzahl der zu sendenden Zeichne benötigt. Es wird einfach bis zum Stringende (0-Character) gesendet.

Zum Senden von Rohdaten (keine ASCII Zeichen) sollte sattdessen die Funktion SerWrite verwendet werden.

Parameter
[in]datanull-terminierter String
Siehe auch
SerWrite
Autor
stochri
Version
sto1 - 07.01.2007 - stochri
first implementation
V005 - 18.08.2007 - marvin
signed char als Parameter wg. Compilerwarnungen
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Beispiel fuer SerPrint
SerPrint ("Hallo ASURO!\r\n");

Definiert in Zeile 224 der Datei print.c.

{
unsigned char i = 0;
while (data [i] != 0x00)
UartPutc (data [i++]);
}
void SerPrint_p ( const char *  data)

Sendet einen null-terminierten String aus dem FLASH Speicher ueber die serielle Schnittstelle.

Parameter
[in]datanull-terminierter String
Autor
marvin
Version
V001 - 07.02.2008 - marvin
first implementation
Erlaeuterung:
Alle String Variablen belegen normalerweise neben dem Speicherplatz im
Programmspeicher (FLASH) zusätzlich denselben Speicherplatz im RAM.
Den Speicherplatz im RAM laesst sich vermeiden, indem man den Bezeichner
PROGMEM bei der Deklaration des Strings angibt.
Zum Auslesen einzelner Zeichen des Strings aus dem Programmspeicher
wird die Funktion pgm_read_byte aus der Standard Library verwendet.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Beispiel fuer SerPrint_p
const char Text_im_FLASH[] PROGMEM = "FLASH String";
SerPrint_p (Text_im_FLASH);

Definiert in Zeile 263 der Datei print.c.

{
char c;
while ((c = pgm_read_byte(data)) != 0)
{
UartPutc (c);
data++;
}
}
void SerRead ( unsigned char *  data,
unsigned char  length,
unsigned int  timeout 
)

Lesen von Daten ueber die serielle Schnittstelle.

Die empfangenen Daten werden in der als Pointer uebergeben Variable data
dem Aufrufer zur verfuegung gestellt.
Der Aufrufer bestimmt ueber den Parameter Timeout, ob diese Funktion im
'blocking'- oder im 'nonblocking'-Mode laufen soll. Im 'blocking'-Mode
bleibt diese Funktion auf alle Faelle so lange aktiv, bis die, uber den
Parameter length, geforderte Anzahl Zeichen empfamgen wurde.

Parameter
[out]dataZeiger auf die einzulesenden Daten
[in]lengthAnzahl der zu lesenden Zeichen
[in]timeout0 = blockierender Mode
Wird hier ein Wert groesser 0 uebergeben, wird nur eine gewisse Zeit
lang versucht ein weiteres Zeichen ueber die Schnittstelle zu empfangen.
Kommt in dieser Zeit kein weiteres Zeichen, wird im zurueckgegeben
Parameter date das erste Zeichen auf 'T' gesetzt und die Funktion
kehrt zum Aufrufer zurueck.
Ansonsten wird die Funktion auf alle Faelle verlassen, wenn die als
Parameter length geforderte Anzahl Zeichen empfangen werden konnten.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Empfangen von 5 Zeichen. Aber spaetestens nach 20 Versuchen wieder
// im Programm weiter machen.
char emfangene_daten [10];
SerRead (emfangene_daten, 5, 20);
if (emfangene_daten [0] == 'T')
SerWrite ("Mist, timeout", 13);
else
SerWrite ("5 Zeichen empfangen", 19);

Definiert in Zeile 158 der Datei uart.c.

{
unsigned char i = 0;
unsigned int time = 0;
UCSRB = (1<<RXEN); // Empfaenger einschalten
if (timeout != 0)
{
/*
Die Funktion wird auf alle Faelle, auch ohne empfangene Daten, wieder
verlassen. --> nonblocking mode
*/
while (i < length && time++ < timeout)
{
if (UCSRA & (1<<RXC))
{
data [i++] = UDR;
time = 0;
}
}
if (time > timeout)
data [0] = 'T';
}
else
{
/*
Die Funktion wird auf alle Faelle erst nach dem Empfang von der
vorgegebenen Anzahl Zeichen verlassen. blocking mode
*/
while (i < length)
{
if (UCSRA & (1<<RXC))
data [i++] = UDR;
}
}
}
void SerWrite ( unsigned char *  data,
unsigned char  length 
)

Senden von Daten ueber die serielle Schnittstelle.

Die zu senden Daten werden nicht als 0-terminierter C-String erwartet, sondern
es werden grundsaetzlich so viele Zeichen gesendet wie im 2.ten Parameter
angegeben werden. Deshalb sollte die Funktion eher zum Senden von Rohdaten verwendet werden (keine ASCII Zeichen) Zum Senden von Strings sollte stattdessen die Funktion SerPrint verwendet werden. Bei der aktuellen WinAVR Version (2007055) gibt es eine Warnung, falls ein String als 1. Parameter übergeben wird

Version
V003 - 25.07.2007 - Sternthaler (Gemeldet von helmut_w)
  • Abschalten des Senders nach der Datenuebertragung zum sparen von Energie.
  • Erklaerungsversuch fuer die Warteschleife am Ende der Funktion.
V004 - 31.07.2007 - Sternthaler
Parameter
[in]*dataZu sendende Daten
[in]lengthDie Anzahl der zu sendenden Zeichen.
Siehe auch
Die Initialisierung vom Timer 2-Interrupt erfolgt in der Funktion Init().
SerPrint
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Senden von Rohdaten ueber die Schnittstelle.
unsigned char buf[4] = {0x55, 0xaa, 0xab, 0xcd);
SerWrite (buf, 4);

Definiert in Zeile 93 der Datei uart.c.

{
unsigned char i = 0;
UCSRB = (1<<TXEN); // Sender einschalten
while (length > 0) // so lange noch Daten da sind
{
if (UCSRA & (1<<UDRE))
{ // warten, bis der Sendebuffer leer ist
UDR = data[i++];
length --;
}
}
while (!(UCSRA & (1<<TXC))) // abwarten, bis das letzte Zeichen
; // uebertragen wurde.
UCSRA |= (1<<TXC); // transmission completed Flag setzen
UCSRB &= ~(1<<TXEN); // Sender ausschalten / Powersave
}
void SetMotorPower ( int8_t  leftpwm,
int8_t  rightpwm 
)

Steuert die Motorgeschwindigkeit und Drehrichtung der Motoren.

Parameter
[in]leftpwmlinker Motor (-rückwaerts, + vorwaerts) (Wertebereich -128...127)
[in]rightpwmrechter Motor (-rückwaerts, + vorwaerts) (Wertebereich -128...127)
Hinweis:
Da der Wertebereich dieser Funktion nur von -128 bis +127 reicht, aber die
urspruengliche Funktion MotorSpeed() einen Wertebereich bis +255 hat, werden
die hier uebergebene Parameter als Absolutwert mit 2 multipliziert
weitergegeben.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Setzt die Geschwindigkeit fuer den linken Motor auf 60 (vorwaerts),
// und für den rechten Motor auf -60 (rueckwaerts)
// Asuro soll auf der Stelle drehen.
SetMotorPower (60, -600);

Definiert in Zeile 89 der Datei motor.c.

{
unsigned char left, right;
if (leftpwm < 0) // Ein negativer Wert fuehrt ...
{
left = RWD; // ... zu einer Rueckwaertsfahrt, ...
leftpwm = -leftpwm; // aber immer positiv PWM-Wert
}
else
left = FWD; // ... sonst nach vorne, ...
if (leftpwm == 0)
left = BREAK; // ... oder bei 0 zum Bremsen.
if (rightpwm < 0)
{
right = RWD;
rightpwm = -rightpwm;
}
else
right = FWD;
if (rightpwm == 0)
right = BREAK;
MotorDir (left, right); // Drehrichtung setzen
/*
Die Geschwindigkeitsparameter mit 2 multiplizieren, da der Absolutwert
der Parameter dieser Funktion nur genau die Haelfte von der MotorSpeed()-
Funktion betraegt.
*/
MotorSpeed (leftpwm * 2, rightpwm * 2);
}
void Sleep ( unsigned char  time36kHz)

Wartefunktion.

Die maximale Wartezeit betraegt 7ms. Fuer laengere Wartezeiten siehe Msleep().
Diese Funktion nutzt den Timer 2-Interrupt um ein 'zeitgefuehl' zu erhalten.
Der Interrupt wird mit 36 kHz, durch die Init()-Funktion initialisiert,
aufgerufen und zaehlt dort die globale Variablen count36kHz weiter.
Diese Funktion nutzt diesen Zaehler und berechnet daraus mit dem uebergeben
Parameter den Zeitpunkt wann die Pausenzeit erreicht ist, Danach bricht sie
ab, und im Hauptprogramm ist eben eine Wartezeit eingelegt worden.

Parameter
[in]time36kHzWartezeit x/36kHz (sec)
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// 1 Millisekunde warten
Sleep (36);

Definiert in Zeile 108 der Datei time.c.

{
unsigned char ziel = (time36kHz + count36kHz) & 0x00FF;
while (count36kHz != ziel)
;
}
void Sound ( uint16_t  freq,
uint16_t  duration_msec,
uint8_t  amplitude 
)

Soundausgabe ueber die Motoren.

Parameter
[in]freqFrequenz in Hz
[in]duration_msecLaenge in Millisekunden
[in]amplitudeAmplitude
Rückgabe
nichts
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Laesst den Asuro einen Ton von 1kHz für eine 1/2 Sekunde
// mit max. Amplitude (255) spielen.
Sound (1000, 500, 255);

Definiert in Zeile 65 der Datei sound.c.

{
uint16_t wait_tics;
uint32_t n,k,period_usec,dauer_usec;
period_usec = 1000000L / freq;
dauer_usec = 1000 * (uint32_t) duration_msec;
k = dauer_usec / period_usec;
//IR Interuptfreq=36KHz
//Wavefreq=18KHz
wait_tics = 18000 / freq;
MotorSpeed (amplitude, amplitude);
for (n = 0; n < k; n++)
{
Sleep (wait_tics);
Sleep (wait_tics);
}
MotorSpeed (0, 0);
}
void StartSwitch ( void  )

'Interrupt-Betrieb' zur Tastsensor Abfrage einschalten.

Hinweis:
Ueber die globale Variable switched kann nach diesem Funktionsaufruf im
Hauptprogramm geprueft werden, ob eine Taste gedrueckt wurde und kann dann
bei Bedarf die Funktion PollSwitch() aufrufen.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
while (!switched) // wartet auf Tastendruck
;
// an dieser Stelle kann mit Pollswitch geprüft werden
// welche Taste gedrückt wurde, wenn nötig.
switched = FALSE; // Vorbereitung für neuen Aufruf von StartSwitch()

Definiert in Zeile 132 der Datei switches.c.

{
// ADC Wert von Switchen wird immer abgefragt
// siehe ISRStandard() dort auch das handling von switched=TRUE
cli ();
sei ();
}
void StatusLED ( unsigned char  color)

Steuert die (lustige) mehrfarbige Status-LED.

Parameter
[in]colorZu setzende Farbe. [ OFF | GREEN | RED | YELLOW ] Bei einem nicht definierten Wert von 'color' aendert sich nichts an der LED.
Rückgabe
nichts
Hinweis:
Diese Funktion ist als 'inline'-Funktion definiert.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// Schaltet die Status-LED abwechselnd auf gruen und rot.
while (1)
{
Msleep (500);
MSleep (500);
}

Definiert in Zeile 68 der Datei leds.c.

{
if (color == OFF)
{
}
if (color == GREEN)
{
}
if (color == YELLOW)
{
}
if (color == RED)
{
}
}
void StopSwitch ( void  )

Die globale Variable switched wird nicht mehr automatisch bei einem
Tastendruck gesetzt.

Beispiel:
(Nicht vorhanden)

Definiert in Zeile 153 der Datei switches.c.

{
// ADC Wert von Switchen wird immer abgefragt
}
void UartPutc ( unsigned char  zeichen)

Sendet einen einzelnen Character über die serielle Schnittstelle.

Parameter
[in]zeichenauszugebendes Zeichen
Autor
stochri
Version
sto1 - 07.01.2006 stochri
first implementation
V004 - 25.07.2007 - Sternthaler (Gemeldet von helmut_w)
Abschalten des Senders nach der Datenuebertragung zum sparen von Energie.
Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
// 'wunderbaren' Text als einzelne Zeichen senden.
UartPutc ('H');
UartPutc ('e');
UartPutc ('l');
UartPutc ('l');
UartPutc ('o');

Definiert in Zeile 179 der Datei print.c.

{
UCSRB = 0x08; // enable transmitter
UCSRA |= 0x40; // clear transmitter flag
while (!(UCSRA & 0x20)) // wait for empty transmit buffer
;
UDR = zeichen;
while (!(UCSRA & 0x40)) // Wait for transmit complete flag (TXC)
;
UCSRB = 0x00; // disable transmitter / powersave
}

Variablen-Dokumentation

volatile voidFuncPtr AdcIntFunc

Zeiger auf User Funktion die von der Interupt Funktion aus aufgerufen wird.

Siehe auch
Interruptfunktion SIGNAL (SIG_ADC) in asuro.c
EncoderInit() in encoder_low.c

Definiert in Zeile 126 der Datei globals.c.

volatile unsigned int adcValue[]

Definiert in Zeile 78 der Datei asuro.c.

volatile int autoencode

Steuert, ob die Odometrie-Sensor Abfrage im Interrupt Betrieb laufen soll.

Siehe auch
Interruptfunktion SIGNAL (SIG_ADC) in asuro.c
EncoderInit(), EncoderStart(), EncoderStop() in encoder_low.c

Definiert in Zeile 104 der Datei globals.c.

volatile unsigned char count36kHz

Counter fuer 36kHz.

Siehe auch
Interruptfunktion SIGNAL (SIG_OVERFLOW2) in asuro.c
Gettime(), Sleep() in time.c

Definiert in Zeile 78 der Datei globals.c.

volatile int encoder[2]

Odometriesensor Zaehler bei Interrupt Betrieb.
encoder[0] = links; encoder[1] = rechts.

Siehe auch
Interruptfunktion SIGNAL (SIG_ADC) in asuro.c
EncoderInit(), EncoderStop(), EncoderStart(), EncoderSet(), Go(),
Turn() in encoder.c

Definiert in Zeile 65 der Datei globals.c.

volatile voidFuncPtr Ovr2IntFunc

Zeiger auf User Funktion die von der Interupt Funktion aus aufgerufen wird.

Siehe auch
Interruptfunktion SIGNAL (SIG_OVERFLOW2) in asuro.c
InitRC5(), in rc5.c

Definiert in Zeile 115 der Datei globals.c.

volatile int switched

Flag, dass der Interrupt SIG_INTERRUPT1 durch eine gedrueckte Taste
ausgeloesst wurde. 0 = keine Taste, 1 = Taste gedrueckt.
Kann im eigenen Programm immer abgefragt werden.

Siehe auch
Interruptfunktion SIGNAL (SIG_INTERRUPT1) in asuro.c
StartSwitch(), StopSwitch(), PollSwitch() in switches.c

Definiert in Zeile 50 der Datei globals.c.

volatile unsigned long timebase

Sytemzeit in ms.

Siehe auch
Interruptfunktion SIGNAL (SIG_OVERFLOW2) in asuro.c
Gettime() in time.c

Definiert in Zeile 91 der Datei globals.c.

const char version[5]

Asuro Lib Versions String

Definiert in Zeile 193 der Datei version.c.