RN-Wissen.de - Benutzerbeiträge [de]

TWI Slave mit avr-gcc

2012-10-19T16:12:46Z

Chypsylon: /* Slave sourcecode */

Programm für einen AVR mit [[TWI]] (Hardware-[[I2C]])-Schnittstelle als Slave.
Manchmal stellt sich die Aufgabe, mehrere AVRs per [[I2C]] zu vernetzen. Ein Beispiel ist die Erweiterung eines bestehenden Systems um einen leistungsstärkeren Controller. Dies ist etwa beim [[Asuro]] oder [[Yeti]] denkbar, um z.B. mehr Ein/Ausgänge oder Speicherplatz zu bekommen.

Man kann aber beim Bau eines Roboters auch von Anfang an auf ein System von mehreren vernetzten Controllern setzen. So kann man verschiedene Aufgabe, die weitgehend unabhängig voneinader gleichzeitg erledigt werden müssen, besser verteilen. Denkbar ist z.B. ein Controller für die Motorsteuerung, einer für die Sensorik, einer für Ein-und Ausgabe (wie LCD und Bedientaster),... , und ein zentraler Controller, der die Richtung vorgibt und alle anderen Controller mit Befehlen versorgt. Ein konkretes Beispiel ist der Roboterbausatz Nibo (siehe: [http://www.nicai-systems.de/nibo.html]) von nicai-systems, der einen Atmel ATmega128 als Hauptcontroller und zwei Atmel ATtiny44 als Controller für die Motorsteuerung und die IR-Sensorik einsetzt. Die Kommunikation läuft mit 400 kHz über den I2C-Bus mit dem ATmega128 als Master.
Schließlich kann ein entsprechend programmierter AVR auch als Ersatz für handelsübliche I2C-Bauteile dienen. Der kleinste AVR mit Hardware-I2C, der ATmega48, ist mit 1,30€ (Reichelt) billiger als viele normale I2C-ICs. Er kann bei entsprechender Programmierung z.B. die Aufgaben von zwei PCF8574 (8bit-Portexpander, 1,25€) und einem PCF8591 (4fach AD-Wandler, 2,35€) übernehmen und außerdem noch als I2C-EEPROM mit 256 Bytes dienen.

Das System ist als eine Art Dualport-RAM konzipiert, Master und Slave teilen sich also einen Speicherbereich und können darüber Daten austauschen. Die Ansteuerung läuft wie bei den bekannten I2C-EEPROMs. Der Master schreibt erst die Adresse, die er lesen bzw- schreiben will. Bei einem Schreibzugriff überträgt er nun die Daten. Bei einem Lesezugriff wird ein repeated start im Lesemodus durchgeführt, dann können die Daten byteweise eingelesen werden. Die Adressen werden dabei automatisch weitergezählt, sodass mehrere Bytes in Folge verarbeitet werden können.

Getestet wurde der Code für zwei Mega32 mit dem AVR Studio. Beachte: im AVR-Studio ist default ein ATmega128 eingestellt, unter Projekt -> Configuration Options kann das Device geändert werden, außerdem ist die Taktfrequenz des Controllers einzustellen. Im Projekt wird für den Master die Dateien twimaster.c und i2cmaster.h hinzugefügt, und für den Slave die twislave.c und twislave.h.
Wenn stattdessen ein makefile verwendet wird, müssen dort unter SRC die c-Dateien eingetragen werden.

Die Verbindung zwischen Master und Slave erfolgt über die Pins SCL und SDA, außerdem muss ein gemeinsamer GND vorhanden sein. Abschlusswiderstände (4,7kOhm) nicht vergessen, am besten beim Master, siehe auch I2C-Definitionen.

Das folgende Programm (twislave.c) steuert das TWI (Hardware-I2C)-Interface eines AVRs als Slave an. Es müsste auf allen AVRs der Mega-Reihe funktionieren, die über eine TWI-Schnittstelle verfügen.

== Master ==
Ein Testprogramm für den Master. Es wird die [http://homepage.hispeed.ch/peterfleury/avr-software.html#libs I2C-Master-Bibliothek von Peter Fleury] verwendet.
Es wird geprüft, ob der Slave bereit ist, dann werden drei Bytes erst in den Slave geschrieben, und anschließend wieder ausgelesen.
<pre>

// I2C-Master-Routinen von Peter Fleury verwenden
// siehe http://homepage.hispeed.ch/peterfleury/avr-software.html#libs
// Hier sind auch die Dateien: i2cmaster.h und twimaster.c zu finden, die benötigt werden
// Letztes Update des Codes 5. April 2010 durch HannoHupmann

#include <avr/io.h>
#include "i2cmaster.h"
#define SLAVE_ADRESSE 0x50

uint8_t byte1 = 42;
uint8_t byte2 = 43;
uint8_t byte3 = 44;

int main(void)
{
i2c_init(); // init I2C interface

if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum schreiben?
{
i2c_write(0x00); // Buffer Startadresse setzen
i2c_write(byte1); // Drei Bytes schreiben...
i2c_write(byte2);
i2c_write(byte3);
i2c_stop(); // Zugriff beenden
}
else
{
/* Hier könnte eine Fehlermeldung ausgegeben werden... */
}

if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum lesen?
{
i2c_write(0x00); //Buffer Startadresse zum Auslesen
i2c_rep_start(SLAVE_ADRESSE+I2C_READ); //Lesen beginnen

byte1= i2c_readAck(); // Bytes lesen...
byte2= i2c_readAck();
byte3= i2c_readNak(); // letztes Byte lesen, darum kein ACK
i2c_stop(); // Zugriff beenden
}
else
{
/* Hier könnte eine Fehlermeldung ausgegeben werden... */
}

if ((byte1 != 42)||(byte2 != 43)||(byte3 != 44))
{
/* Die Bytes wurden nicht korrekt übertragen und wieder gelesen! */
}
for(;;);
}

// Code wurde von HannoHupmann auf einem Mega32 getestet
</pre>

== Slave ==
Hier soll nun der Code behandelt werden der für den Slave-Controller notwendig ist. Der vorgestellte Code schreibt die Register des Slaves an die Serielle Schnittstelle, mit einem Terminal Programm kann man sich die Ausgabe ansehen und überprüfen ob alles korrekt funktioniert.
Der Code ist wieder an den von Peter Fleury angelehnt.

Der Slave sollte ohne Master folgende Ausgabe liefern:
<pre>
i2cdata:
10
11
12
13
usw.
</pre>
Die Register werden der Reihe nach mit ihrem Wert angezeigt. Wird der Master hinzugefügt sollte nun folgende Ausgabe im Terminal erscheinen:
<pre>
i2cdata:
42
43
44
13
usw.
</pre>

== Slave Testprogramm ==
Ein Testprogramm für den Slave. Es verwendet zur Ausgabe die UART-lib von P. Fleury, die auf derselben Homepage wie die TWI-Master-Lib zu finden ist.
<pre>
/*
Testprogramm für den Slave
Der Buffer wird mit Werten gefüllt. Dann wird er fortlaufend über die serielle Schnittstelle ausgegeben.
Nun kann man dort sehen, wenn der Master einen Wert ändert
*/
#include <util/twi.h> //enthält z.B. die Bezeichnungen für die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur Behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t
#include "twislave.h"
#include "uart.h" //UART-Lib von P- Fleury
#include <stdlib.h> //nötig für Zahlumwandlung mit itoa
#include <util/delay.h>

#define BAUD 9600 //Baudrate
#define SLAVE_ADRESSE 0x50 //Die Slave-Adresse

//Hilfsfunktion, um Zahlen über das UART auszugeben
void uart_puti( const int val )
{
char buffer[8];
uart_puts( itoa(val, buffer, 10) );

}

int main (void)
{
//TWI als Slave mit Adresse slaveadr starten
init_twi_slave(SLAVE_ADRESSE);

//i2cdatamit Werten füllen, die der Master auslesen und ändern kann
for(uint8_t i=0;i<i2c_buffer_size;i++)
{
i2cdata[i]=10+i;
}

//Serielle Schnittstelle aktivieren
uart_init((UART_BAUD_SELECT((BAUD),F_CPU)));
uart_puts("I2C-Test\r\n");
uart_puts("Teste I2C-Slave mit Adresse "); uart_puti(SLAVE_ADRESSE);
uart_puts("\r\n");
uart_puts("\r\n"); //Leerzeile

//in einer Endlosschleife den Inhalt der Buffer ausgeben
while(1)
{
uart_puts("i2cdata:\r\n");
for(uint8_t i=0;i<i2c_buffer_size;i++)
{
uart_puti(i2cdata[i]);
uart_puts("\r\n");
}
uart_puts("\r\n");//leerzeile
_delay_ms(500);
} //end.while
} //end.main

</pre>

== Slave sourcecode ==
Die twislave.c für den Slave. Stand: 05.09.2012
<pre>
#include <util/twi.h> //enthält z.B. die Bezeichnungen für die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur Behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t
#include "twislave.h"

//%%%%%%%% Globale Variablen, die vom Hauptprogramm genutzt werden %%%%%%%%
/*Der Buffer, in dem die Daten gespeichert werden.
Aus Sicht des Masters läuft der Zugrif auf den Buffer genau wie bei einem I2C-EEPROm ab.
Für den Slave ist es eine globale Variable
*/
volatile uint8_t buffer_adr; //"Adressregister" für den Buffer

/*Initaliserung des TWI-Inteface. Muss zu Beginn aufgerufen werden, sowie bei einem Wechsel der Slave Adresse
Parameter adr: gewünschte Slave-Adresse
*/
void init_twi_slave(uint8_t adr)
{
TWAR= adr; //Adresse setzen
TWCR &= ~(1<<TWSTA)|(1<<TWSTO);
TWCR|= (1<<TWEA) | (1<<TWEN)|(1<<TWIE);
buffer_adr=0xFF;
sei();
}

//Je nach Statuscode in TWSR müssen verschiedene Bitmuster in TWCR geschreiben werden(siehe Tabellen im Datenblatt!).
//Makros für die verwendeten Bitmuster:

//ACK nach empfangenen Daten senden/ ACK nach gesendeten Daten erwarten
#define TWCR_ACK TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);

//NACK nach empfangenen Daten senden/ NACK nach gesendeten Daten erwarten
#define TWCR_NACK TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);

//switch to the non adressed slave mode...
#define TWCR_RESET TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(1<<TWSTO)|(0<<TWWC);

/*ISR, die bei einem Ereignis auf dem Bus ausgelöst wird. Im Register TWSR befindet sich dann
ein Statuscode, anhand dessen die Situation festgestellt werden kann.
*/
ISR (TWI_vect)
{
uint8_t data=0;

switch (TW_STATUS) //TWI-Statusregister prüfen und nötige Aktion bestimmen
{

// Slave Receiver

case TW_SR_SLA_ACK: // 0x60 Slave Receiver, Slave wurde adressiert
TWCR_ACK; // nächstes Datenbyte empfangen, ACK danach senden
buffer_adr=0xFF; //Bufferposition ist undefiniert
break;

case TW_SR_DATA_ACK: // 0x80 Slave Receiver, ein Datenbyte wurde empfangen
data=TWDR; //Empfangene Daten auslesen
if (buffer_adr == 0xFF) //erster Zugriff, Bufferposition setzen
{
//Kontrolle ob gewünschte Adresse im erlaubten bereich
if(data<i2c_buffer_size+1)
{
buffer_adr= data; //Bufferposition wie adressiert setzen
}
else
{
buffer_adr=0; //Adresse auf Null setzen. Ist das sinnvoll? TO DO!
}
TWCR_ACK; // nächstes Datenbyte empfangen, ACK danach, um nächstes Byte anzufordern
}
else //weiterer Zugriff, nachdem die Position im Buffer gesetzt wurde. NUn die Daten empfangen und speichern
{

if(buffer_adr<i2c_buffer_size+1)
{
i2cdata[buffer_adr]=data; //Daten in Buffer schreibe
}
buffer_adr++; //Buffer-Adresse weiterzählen für nächsten Schreibzugriff
TWCR_ACK;
}
break;

//Slave transmitter

case TW_ST_SLA_ACK: //0xA8 Slave wurde im Lesemodus adressiert und hat ein ACK zurückgegeben.
//Hier steht kein break! Es wird also der folgende Code ebenfalls ausgeführt!

case TW_ST_DATA_ACK: //0xB8 Slave Transmitter, Daten wurden angefordert

if (buffer_adr == 0xFF) //zuvor keine Leseadresse angegeben!
{
buffer_adr=0;
}

if(buffer_adr<i2c_buffer_size+1)
{
TWDR = i2cdata[buffer_adr]; //Datenbyte senden
buffer_adr++; //bufferadresse für nächstes Byte weiterzählen
}
else
{
TWDR=0; //Kein Daten mehr im Buffer
}
TWCR_ACK;
break;
case TW_SR_STOP:
TWCR_ACK;
break;
case TW_ST_DATA_NACK: // 0xC0 Keine Daten mehr gefordert
case TW_SR_DATA_NACK: // 0x88
case TW_ST_LAST_DATA: // 0xC8 Last data byte in TWDR has been transmitted (TWEA = “0”); ACK has been received
default:
TWCR_RESET;
break;

} //end.switch (TW_STATUS)
} //end.ISR(TWI_vect)

////Ende von twislave.c////

</pre>

== Slave header ==
Die zugehörige Headerdatei twislave.h für den Slave. Stand: 05.09.2012
<pre>

#ifndef _TWISLAVE_H
#define _TWISLAVE_H

#include <util/twi.h> //enthaelt z.B. die Bezeichnungen fuer die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t

/**
* @defgroup twislave TWI-Slave
* @code #include "twislave.h" @endcode
*
* @brief Betrieb eines AVRs mit Hardware-TWI-Schnittstelle als Slave.
* Zu Beginn muss init_twi_slave mit der gewuenschten Slave-Adresse als
* Parameter aufgerufen werden.
*
* Der Datenaustausch mit dem Master erfolgt ueber den Buffer i2cdata,
* auf den von Master und Slave zugegriffen werden kann.
* Dies ist fuer den Slave eine globale Variable (Array aus uint8_t).

* Der Zugriff durch den Master erfolgt aehnlich wie bei einem
* normalen I2C-EEPROM.
* Man sendet zunaechst die Bufferposition, an die man schreiben will,
* und dann die Daten.
* Die Bufferposition wird automatisch hochgezaehlt, sodass man mehrere
* Datenbytes hintereinander schreiben kann, ohne jedesmal die
* Bufferadresse zu schreiben.
*
* Um vom Master aus zu lesen, uebertraegt man zunaechst in einem
* Schreibzugriff die gewuenschte Bufferposition und liest dann nach
* einem repeated start die Daten aus. Die Bufferposition wird
* automatisch hochgezaehlt, sodass man mehrere Datenbytes
* hintereinander lesen kann, ohne jedesmal die Bufferposition zu
* schreiben.
*
* Abgefangene Fehlbedienung durch den Master:
* - Lesen ueber die Grenze des txbuffers hinaus
* - Schreiben ueber die Grenzen des rxbuffers hinaus
* - Angabe einer ungueltigen Schreib/Lese-Adresse
* - Lesezugriff, ohne vorher Leseadresse geschrieben zu haben
*
* @author uwegw
*/

/*@{*/

//%%%%%%%% von Benutzer konfigurierbare Einstellungen %%%%%%%%
/**@brief Groesse des Buffers in Byte (2..254) */
#define i2c_buffer_size 10// I2C_REG_ANZAHL 254 Hier kann eingestellt werden wieviele Register ausgegeben werden

//%%%%%%%% Globale Variablen, die vom Hauptprogramm genutzt werden %%%%%%%%
/**@brief Der Buffer, in dem die Daten gespeichert werden.
* Aus Sicht des Masters laeuft der Zugrif auf den Buffer genau wie
* bei einem I2C-EEPROm ab.
* Fuer den Slave ist es eine globale Variable
*/
volatile uint8_t i2cdata[i2c_buffer_size];

/**@brief Initaliserung des TWI-Inteface. Muss zu Beginn aufgerufen werden, sowie bei einem Wechsel der Slave Adresse
* @param adr gewuenschte Slave-Adresse */
void init_twi_slave(uint8_t adr);

//%%%%%%%% ab hier sind normalerweise keine weiteren Aenderungen erforderlich! %%%%%%%%//
//____________________________________________________________________________________//

//Bei zu alten AVR-GCC-Versionen werden die Interrupts anders genutzt, daher in diesem Fall mit Fehlermeldung abbrechen
#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304
#error "This library requires AVR-GCC 3.4.5 or later, update to newer AVR-GCC compiler !"
#endif

//Schutz vor unsinnigen Buffergroessen
#if (i2c_buffer_size > 254)
#error Buffer zu gross gewaehlt! Maximal 254 Bytes erlaubt.
#endif

#if (i2c_buffer_size < 2)
#error Buffer muss mindestens zwei Byte gross sein!
#endif

#endif //#ifdef _TWISLAVE_H
////Ende von twislave.h////

</pre>

== Andere Bibliotheken ==

* [http://www.jtronics.de/avr-projekte/library-i2c/twi-slave-avr http://www.jtronics.de/avr-projekte/library-i2c/twi-slave-avr]
* [http://www.ermicro.com/blog/?p=1239 http://www.ermicro.com/blog/?p=1239]

[[Kategorie:Microcontroller]]
[[Kategorie:Quellcode C]]

TWI Slave mit avr-gcc

2011-12-05T15:07:42Z

Chypsylon: /* Andere Bibliotheken */

Programm für einen AVR mit [[TWI]] (Hardware-[[I2C]])-Schnittstelle als Slave.
Manchmal stellt sich die Aufgabe, mehrere AVRs per [[I2C]] zu vernetzen. Ein Beispiel ist die Erweiterung eines bestehenden Systems um einen leistungsstärkeren Controller. Dies ist etwa beim [[Asuro]] oder [[Yeti]] denkbar, um z.B. mehr Ein/Ausgänge oder Speicherplatz zu bekommen.

Man kann aber beim Bau eines Roboters auch von Anfang an auf ein System von mehreren vernetzten Controllern setzen. So kann man verschiedene Aufgabe, die weitgehend unabhängig voneinader gleichzeitg erledigt werden müssen, besser verteilen. Denkbar ist z.B. ein Controller für die Motorsteuerung, einer für die Sensorik, einer für Ein-und Ausgabe (wie LCD und Bedientaster),... , und ein zentraler Controller, der die Richtung vorgibt und alle anderen Controller mit Befehlen versorgt. Ein konkretes Beispiel ist der Roboterbausatz Nibo (siehe: [http://www.nicai-systems.de/nibo.html]) von nicai-systems, der einen Atmel ATmega128 als Hauptcontroller und zwei Atmel ATtiny44 als Controller für die Motorsteuerung und die IR-Sensorik einsetzt. Die Kommunikation läuft mit 400 kHz über den I2C-Bus mit dem ATmega128 als Master.
Schließlich kann ein entsprechend programmierter AVR auch als Ersatz für handelsübliche I2C-Bauteile dienen. Der kleinste AVR mit Hardware-I2C, der ATmega48, ist mit 1,30€ (Reichelt) billiger als viele normale I2C-ICs. Er kann bei entsprechender Programmierung z.B. die Aufgaben von zwei PCF8574 (8bit-Portexpander, 1,25€) und einem PCF8591 (4fach AD-Wandler, 2,35€) übernehmen und außerdem noch als I2C-EEPROM mit 256 Bytes dienen.

Das System ist als eine Art Dualport-RAM konzipiert, Master und Slave teilen sich also einen Speicherbereich und können darüber Daten austauschen. Die Ansteuerung läuft wie bei den bekannten I2C-EEPROMs. Der Master schreibt erst die Adresse, die er lesen bzw- schreiben will. Bei einem Schreibzugriff überträgt er nun die Daten. Bei einem Lesezugriff wird ein repeated start im Lesemodus durchgeführt, dann können die Daten byteweise eingelesen werden. Die Adressen werden dabei automatisch weitergezählt, sodass mehrere Bytes in Folge verarbeitet werden können.

Getestet wurde der Code für zwei Mega32 mit dem AVR Studio. Beachte: im AVR-Studio ist default ein ATmega128 eingestellt, unter Projekt -> Configuration Options kann das Device geändert werden, außerdem ist die Taktfrequenz des Controllers einzustellen. Im Projekt wird für den Master die Dateien twimaster.c und i2cmaster.h hinzugefügt, und für den Slave die twislave.c und twislave.h.
Wenn stattdessen ein makefile verwendet wird, müssen dort unter SRC die c-Dateien eingetragen werden.

Die Verbindung zwischen Master und Slave erfolgt über die Pins SCL und SDA, außerdem muss ein gemeinsamer GND vorhanden sein. Abschlusswiderstände (4,7kOhm) nicht vergessen, am besten beim Master, siehe auch I2C-Definitionen.

Das folgende Programm (twislave.c) steuert das TWI (Hardware-I2C)-Interface eines AVRs als Slave an. Es müsste auf allen AVRs der Mega-Reihe funktionieren, die über eine TWI-Schnittstelle verfügen.

== Master ==
Ein Testprogramm für den Master. Es wird die [http://homepage.hispeed.ch/peterfleury/avr-software.html#libs I2C-Master-Bibliothek von Peter Fleury] verwendet.
Es wird geprüft, ob der Slave bereit ist, dann werden drei Bytes erst in den Slave geschrieben, und anschließend wieder ausgelesen.
<pre>

// I2C-Master-Routinen von Peter Fleury verwenden
// siehe http://homepage.hispeed.ch/peterfleury/avr-software.html#libs
// Hier sind auch die Dateien: i2cmaster.h und twimaster.c zu finden, die benötigt werden
// Letztes Update des Codes 5. April 2010 durch HannoHupmann

#include <avr/io.h>
#include "i2cmaster.h"
#define SLAVE_ADRESSE 0x50

uint8_t byte1 = 42;
uint8_t byte2 = 43;
uint8_t byte3 = 44;

int main(void)
{
i2c_init(); // init I2C interface

if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum schreiben?
{
i2c_write(0x00); // Buffer Startadresse setzen
i2c_write(byte1); // Drei Bytes schreiben...
i2c_write(byte2);
i2c_write(byte3);
i2c_stop(); // Zugriff beenden
}
else
{
/* Hier könnte eine Fehlermeldung ausgegeben werden... */
}

if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum lesen?
{
i2c_write(0x00); //Buffer Startadresse zum Auslesen
i2c_rep_start(SLAVE_ADRESSE+I2C_READ); //Lesen beginnen

byte1= i2c_readAck(); // Bytes lesen...
byte2= i2c_readAck();
byte3= i2c_readNak(); // letztes Byte lesen, darum kein ACK
i2c_stop(); // Zugriff beenden
}
else
{
/* Hier könnte eine Fehlermeldung ausgegeben werden... */
}

if ((byte1 != 42)||(byte2 != 43)||(byte3 != 44))
{
/* Die Bytes wurden nicht korrekt übertragen und wieder gelesen! */
}
for(;;);
}

// Code wurde von HannoHupmann auf einem Mega32 getestet
</pre>

== Slave ==
Hier soll nun der Code behandelt werden der für den Slave-Controller notwendig ist. Der vorgestellte Code schreibt die Register des Slaves an die Serielle Schnittstelle, mit einem Terminal Programm kann man sich die Ausgabe ansehen und überprüfen ob alles korrekt funktioniert.
Der Code ist wieder an den von Peter Fleury angelehnt.

Der Slave sollte ohne Master folgende Ausgabe liefern:
<pre>
i2cdata:
10
11
12
13
usw.
</pre>
Die Register werden der Reihe nach mit ihrem Wert angezeigt. Wird der Master hinzugefügt sollte nun folgende Ausgabe im Terminal erscheinen:
<pre>
i2cdata:
42
43
44
13
usw.
</pre>

== Slave Testprogramm ==
Ein Testprogramm für den Slave. Es verwendet zur Ausgabe die UART-lib von P. Fleury, die auf derselben Homepage wie die TWI-Master-Lib zu finden ist.
<pre>
/*
Testprogramm für den Slave
Der Buffer wird mit Werten gefüllt. Dann wird er fortlaufend über die serielle Schnittstelle ausgegeben.
Nun kann man dort sehen, wenn der Master einen Wert ändert
*/
#include <util/twi.h> //enthält z.B. die Bezeichnungen für die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur Behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t
#include "twislave.h"
#include "uart.h" //UART-Lib von P- Fleury
#include <stdlib.h> //nötig für Zahlumwandlung mit itoa
#include <util/delay.h>

#define BAUD 9600 //Baudrate
#define SLAVE_ADRESSE 0x50 //Die Slave-Adresse

//Hilfsfunktion, um Zahlen über das UART auszugeben
void uart_puti( const int val )
{
char buffer[8];
uart_puts( itoa(val, buffer, 10) );

}

int main (void)
{
//TWI als Slave mit Adresse slaveadr starten
init_twi_slave(SLAVE_ADRESSE);

//i2cdatamit Werten füllen, die der Master auslesen und ändern kann
for(uint8_t i=0;i<i2c_buffer_size;i++)
{
i2cdata[i]=10+i;
}

//Serielle Schnittstelle aktivieren
uart_init((UART_BAUD_SELECT((BAUD),F_CPU)));
uart_puts("I2C-Test\r\n");
uart_puts("Teste I2C-Slave mit Adresse "); uart_puti(SLAVE_ADRESSE);
uart_puts("\r\n");
uart_puts("\r\n"); //Leerzeile

//in einer Endlosschleife den Inhalt der Buffer ausgeben
while(1)
{
uart_puts("i2cdata:\r\n");
for(uint8_t i=0;i<i2c_buffer_size;i++)
{
uart_puti(i2cdata[i]);
uart_puts("\r\n");
}
uart_puts("\r\n");//leerzeile
_delay_ms(500);
} //end.while
} //end.main

</pre>

== Slave sourcecode ==
Die twislave.c für den Slave. Stand: 12.4.2010
<pre>
#include <util/twi.h> //enthält z.B. die Bezeichnungen für die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur Behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t
#include "twislave.h"

//%%%%%%%% Globale Variablen, die vom Hauptprogramm genutzt werden %%%%%%%%
/*Der Buffer, in dem die Daten gespeichert werden.
Aus Sicht des Masters läuft der Zugrif auf den Buffer genau wie bei einem I2C-EEPROm ab.
Für den Slave ist es eine globale Variable
*/
volatile uint8_t i2cdata[i2c_buffer_size+1];
volatile uint8_t buffer_adr; //"Adressregister" für den Buffer

/*Initaliserung des TWI-Inteface. Muss zu Beginn aufgerufen werden, sowie bei einem Wechsel der Slave Adresse
Parameter adr: gewünschte Slave-Adresse
*/
void init_twi_slave(uint8_t adr)
{
TWAR= adr; //Adresse setzen
TWCR &= ~(1<<TWSTA)|(1<<TWSTO);
TWCR|= (1<<TWEA) | (1<<TWEN)|(1<<TWIE);
buffer_adr=0xFF;
sei();
}

//Je nach Statuscode in TWSR müssen verschiedene Bitmuster in TWCR geschreiben werden(siehe Tabellen im Datenblatt!).
//Makros für die verwendeten Bitmuster:

//ACK nach empfangenen Daten senden/ ACK nach gesendeten Daten erwarten
#define TWCR_ACK TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);

//NACK nach empfangenen Daten senden/ NACK nach gesendeten Daten erwarten
#define TWCR_NACK TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);

//switch to the non adressed slave mode...
#define TWCR_RESET TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(1<<TWSTO)|(0<<TWWC);

/*ISR, die bei einem Ereignis auf dem Bus ausgelöst wird. Im Register TWSR befindet sich dann
ein Statuscode, anhand dessen die Situation festgestellt werden kann.
*/
ISR (TWI_vect)
{
uint8_t data=0;

switch (TW_STATUS) //TWI-Statusregister prüfen und nötige Aktion bestimmen
{

// Slave Receiver

case TW_SR_SLA_ACK: // 0x60 Slave Receiver, Slave wurde adressiert
TWCR_ACK; // nächstes Datenbyte empfangen, ACK danach senden
buffer_adr=0xFF; //Bufferposition ist undefiniert
break;

case TW_SR_DATA_ACK: // 0x80 Slave Receiver, ein Datenbyte wurde empfangen
data=TWDR; //Empfangene Daten auslesen
if (buffer_adr == 0xFF) //erster Zugriff, Bufferposition setzen
{
//Kontrolle ob gewünschte Adresse im erlaubten bereich
if(data<i2c_buffer_size)
{
buffer_adr= data; //Bufferposition wie adressiert setzen
}
else
{
buffer_adr=0; //Adresse auf Null setzen. Ist das sinnvoll? TO DO!
}
TWCR_ACK; // nächstes Datenbyte empfangen, ACK danach, um nächstes Byte anzufordern
}
else //weiterer Zugriff, nachdem die Position im Buffer gesetzt wurde. NUn die Daten empfangen und speichern
{

if(buffer_adr<i2c_buffer_size)
{
i2cdata[buffer_adr]=data; //Daten in Buffer schreibe
}
buffer_adr++; //Buffer-Adresse weiterzählen für nächsten Schreibzugriff
TWCR_ACK;
}
break;

//Slave transmitter

case TW_ST_SLA_ACK: //0xA8 Slave wurde im Lesemodus adressiert und hat ein ACK zurückgegeben.
//Hier steht kein break! Es wird also der folgende Code ebenfalls ausgeführt!

case TW_ST_DATA_ACK: //0xB8 Slave Transmitter, Daten wurden angefordert

if (buffer_adr == 0xFF) //zuvor keine Leseadresse angegeben!
{
buffer_adr=0;
}

if(buffer_adr<i2c_buffer_size)
{
TWDR = i2cdata[buffer_adr]; //Datenbyte senden
buffer_adr++; //bufferadresse für nächstes Byte weiterzählen
}
else
{
TWDR=0; //Kein Daten mehr im Buffer
}
TWCR_ACK;
break;

case TW_ST_DATA_NACK: // 0xC0 Keine Daten mehr gefordert
case TW_SR_DATA_NACK: // 0x88
case TW_ST_LAST_DATA: // 0xC8 Last data byte in TWDR has been transmitted (TWEA = “0”); ACK has been received
case TW_SR_STOP: // 0xA0 STOP empfangen
default:
TWCR_RESET;
break;

} //end.switch (TW_STATUS)
} //end.ISR(TWI_vect)

////Ende von twislave.c////

</pre>

== Slave header ==
Die zugehörige Headerdatei twislave.h für den Slave. Stand: 19.2.2010
<pre>

#ifndef _TWISLAVE_H
#define _TWISLAVE_H

#include <util/twi.h> //enthaelt z.B. die Bezeichnungen fuer die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t

/**
* @defgroup twislave TWI-Slave
* @code #include "twislave.h" @endcode
*
* @brief Betrieb eines AVRs mit Hardware-TWI-Schnittstelle als Slave.
* Zu Beginn muss init_twi_slave mit der gewuenschten Slave-Adresse als
* Parameter aufgerufen werden.
*
* Der Datenaustausch mit dem Master erfolgt ueber den Buffer i2cdata,
* auf den von Master und Slave zugegriffen werden kann.
* Dies ist fuer den Slave eine globale Variable (Array aus uint8_t).

* Der Zugriff durch den Master erfolgt aehnlich wie bei einem
* normalen I2C-EEPROM.
* Man sendet zunaechst die Bufferposition, an die man schreiben will,
* und dann die Daten.
* Die Bufferposition wird automatisch hochgezaehlt, sodass man mehrere
* Datenbytes hintereinander schreiben kann, ohne jedesmal die
* Bufferadresse zu schreiben.
*
* Um vom Master aus zu lesen, uebertraegt man zunaechst in einem
* Schreibzugriff die gewuenschte Bufferposition und liest dann nach
* einem repeated start die Daten aus. Die Bufferposition wird
* automatisch hochgezaehlt, sodass man mehrere Datenbytes
* hintereinander lesen kann, ohne jedesmal die Bufferposition zu
* schreiben.
*
* Abgefangene Fehlbedienung durch den Master:
* - Lesen ueber die Grenze des txbuffers hinaus
* - Schreiben ueber die Grenzen des rxbuffers hinaus
* - Angabe einer ungueltigen Schreib/Lese-Adresse
* - Lesezugriff, ohne vorher Leseadresse geschrieben zu haben
*
* @author uwegw
*/

/*@{*/

//%%%%%%%% von Benutzer konfigurierbare Einstellungen %%%%%%%%
/**@brief Groesse des Buffers in Byte (2..254) */
#define i2c_buffer_size 10// I2C_REG_ANZAHL 254 Hier kann eingestellt werden wieviele Register ausgegeben werden

//%%%%%%%% Globale Variablen, die vom Hauptprogramm genutzt werden %%%%%%%%
/**@brief Der Buffer, in dem die Daten gespeichert werden.
* Aus Sicht des Masters laeuft der Zugrif auf den Buffer genau wie
* bei einem I2C-EEPROm ab.
* Fuer den Slave ist es eine globale Variable
*/
volatile uint8_t i2cdata[i2c_buffer_size+1];

/**@brief Initaliserung des TWI-Inteface. Muss zu Beginn aufgerufen werden, sowie bei einem Wechsel der Slave Adresse
* @param adr gewuenschte Slave-Adresse */
void init_twi_slave(uint8_t adr);

//%%%%%%%% ab hier sind normalerweise keine weiteren Aenderungen erforderlich! %%%%%%%%//
//____________________________________________________________________________________//

//Bei zu alten AVR-GCC-Versionen werden die Interrupts anders genutzt, daher in diesem Fall mit Fehlermeldung abbrechen
#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304
#error "This library requires AVR-GCC 3.4.5 or later, update to newer AVR-GCC compiler !"
#endif

//Schutz vor unsinnigen Buffergroessen
#if (i2c_buffer_size > 254)
#error Buffer zu gross gewaehlt! Maximal 254 Bytes erlaubt.
#endif

#if (i2c_buffer_size < 2)
#error Buffer muss mindestens zwei Byte gross sein!
#endif

#endif //#ifdef _TWISLAVE_H
////Ende von twislave.h////

</pre>

== Andere Bibliotheken ==

* [http://www.jtronics.de/avr-projekte/library-i2c/twi-slave-avr http://www.jtronics.de/avr-projekte/library-i2c/twi-slave-avr]
* [http://www.ermicro.com/blog/?p=1239 http://www.ermicro.com/blog/?p=1239]

[[Kategorie:Microcontroller]]
[[Kategorie:Quellcode C]]

TWI Slave mit avr-gcc

2011-12-05T15:06:55Z

Chypsylon: Links zu alternativen Libraries hinzugefügt

Programm für einen AVR mit [[TWI]] (Hardware-[[I2C]])-Schnittstelle als Slave.
Manchmal stellt sich die Aufgabe, mehrere AVRs per [[I2C]] zu vernetzen. Ein Beispiel ist die Erweiterung eines bestehenden Systems um einen leistungsstärkeren Controller. Dies ist etwa beim [[Asuro]] oder [[Yeti]] denkbar, um z.B. mehr Ein/Ausgänge oder Speicherplatz zu bekommen.

Man kann aber beim Bau eines Roboters auch von Anfang an auf ein System von mehreren vernetzten Controllern setzen. So kann man verschiedene Aufgabe, die weitgehend unabhängig voneinader gleichzeitg erledigt werden müssen, besser verteilen. Denkbar ist z.B. ein Controller für die Motorsteuerung, einer für die Sensorik, einer für Ein-und Ausgabe (wie LCD und Bedientaster),... , und ein zentraler Controller, der die Richtung vorgibt und alle anderen Controller mit Befehlen versorgt. Ein konkretes Beispiel ist der Roboterbausatz Nibo (siehe: [http://www.nicai-systems.de/nibo.html]) von nicai-systems, der einen Atmel ATmega128 als Hauptcontroller und zwei Atmel ATtiny44 als Controller für die Motorsteuerung und die IR-Sensorik einsetzt. Die Kommunikation läuft mit 400 kHz über den I2C-Bus mit dem ATmega128 als Master.
Schließlich kann ein entsprechend programmierter AVR auch als Ersatz für handelsübliche I2C-Bauteile dienen. Der kleinste AVR mit Hardware-I2C, der ATmega48, ist mit 1,30€ (Reichelt) billiger als viele normale I2C-ICs. Er kann bei entsprechender Programmierung z.B. die Aufgaben von zwei PCF8574 (8bit-Portexpander, 1,25€) und einem PCF8591 (4fach AD-Wandler, 2,35€) übernehmen und außerdem noch als I2C-EEPROM mit 256 Bytes dienen.

Das System ist als eine Art Dualport-RAM konzipiert, Master und Slave teilen sich also einen Speicherbereich und können darüber Daten austauschen. Die Ansteuerung läuft wie bei den bekannten I2C-EEPROMs. Der Master schreibt erst die Adresse, die er lesen bzw- schreiben will. Bei einem Schreibzugriff überträgt er nun die Daten. Bei einem Lesezugriff wird ein repeated start im Lesemodus durchgeführt, dann können die Daten byteweise eingelesen werden. Die Adressen werden dabei automatisch weitergezählt, sodass mehrere Bytes in Folge verarbeitet werden können.

Getestet wurde der Code für zwei Mega32 mit dem AVR Studio. Beachte: im AVR-Studio ist default ein ATmega128 eingestellt, unter Projekt -> Configuration Options kann das Device geändert werden, außerdem ist die Taktfrequenz des Controllers einzustellen. Im Projekt wird für den Master die Dateien twimaster.c und i2cmaster.h hinzugefügt, und für den Slave die twislave.c und twislave.h.
Wenn stattdessen ein makefile verwendet wird, müssen dort unter SRC die c-Dateien eingetragen werden.

Die Verbindung zwischen Master und Slave erfolgt über die Pins SCL und SDA, außerdem muss ein gemeinsamer GND vorhanden sein. Abschlusswiderstände (4,7kOhm) nicht vergessen, am besten beim Master, siehe auch I2C-Definitionen.

Das folgende Programm (twislave.c) steuert das TWI (Hardware-I2C)-Interface eines AVRs als Slave an. Es müsste auf allen AVRs der Mega-Reihe funktionieren, die über eine TWI-Schnittstelle verfügen.

== Master ==
Ein Testprogramm für den Master. Es wird die [http://homepage.hispeed.ch/peterfleury/avr-software.html#libs I2C-Master-Bibliothek von Peter Fleury] verwendet.
Es wird geprüft, ob der Slave bereit ist, dann werden drei Bytes erst in den Slave geschrieben, und anschließend wieder ausgelesen.
<pre>

// I2C-Master-Routinen von Peter Fleury verwenden
// siehe http://homepage.hispeed.ch/peterfleury/avr-software.html#libs
// Hier sind auch die Dateien: i2cmaster.h und twimaster.c zu finden, die benötigt werden
// Letztes Update des Codes 5. April 2010 durch HannoHupmann

#include <avr/io.h>
#include "i2cmaster.h"
#define SLAVE_ADRESSE 0x50

uint8_t byte1 = 42;
uint8_t byte2 = 43;
uint8_t byte3 = 44;

int main(void)
{
i2c_init(); // init I2C interface

if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum schreiben?
{
i2c_write(0x00); // Buffer Startadresse setzen
i2c_write(byte1); // Drei Bytes schreiben...
i2c_write(byte2);
i2c_write(byte3);
i2c_stop(); // Zugriff beenden
}
else
{
/* Hier könnte eine Fehlermeldung ausgegeben werden... */
}

if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum lesen?
{
i2c_write(0x00); //Buffer Startadresse zum Auslesen
i2c_rep_start(SLAVE_ADRESSE+I2C_READ); //Lesen beginnen

byte1= i2c_readAck(); // Bytes lesen...
byte2= i2c_readAck();
byte3= i2c_readNak(); // letztes Byte lesen, darum kein ACK
i2c_stop(); // Zugriff beenden
}
else
{
/* Hier könnte eine Fehlermeldung ausgegeben werden... */
}

if ((byte1 != 42)||(byte2 != 43)||(byte3 != 44))
{
/* Die Bytes wurden nicht korrekt übertragen und wieder gelesen! */
}
for(;;);
}

// Code wurde von HannoHupmann auf einem Mega32 getestet
</pre>

== Slave ==
Hier soll nun der Code behandelt werden der für den Slave-Controller notwendig ist. Der vorgestellte Code schreibt die Register des Slaves an die Serielle Schnittstelle, mit einem Terminal Programm kann man sich die Ausgabe ansehen und überprüfen ob alles korrekt funktioniert.
Der Code ist wieder an den von Peter Fleury angelehnt.

Der Slave sollte ohne Master folgende Ausgabe liefern:
<pre>
i2cdata:
10
11
12
13
usw.
</pre>
Die Register werden der Reihe nach mit ihrem Wert angezeigt. Wird der Master hinzugefügt sollte nun folgende Ausgabe im Terminal erscheinen:
<pre>
i2cdata:
42
43
44
13
usw.
</pre>

== Slave Testprogramm ==
Ein Testprogramm für den Slave. Es verwendet zur Ausgabe die UART-lib von P. Fleury, die auf derselben Homepage wie die TWI-Master-Lib zu finden ist.
<pre>
/*
Testprogramm für den Slave
Der Buffer wird mit Werten gefüllt. Dann wird er fortlaufend über die serielle Schnittstelle ausgegeben.
Nun kann man dort sehen, wenn der Master einen Wert ändert
*/
#include <util/twi.h> //enthält z.B. die Bezeichnungen für die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur Behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t
#include "twislave.h"
#include "uart.h" //UART-Lib von P- Fleury
#include <stdlib.h> //nötig für Zahlumwandlung mit itoa
#include <util/delay.h>

#define BAUD 9600 //Baudrate
#define SLAVE_ADRESSE 0x50 //Die Slave-Adresse

//Hilfsfunktion, um Zahlen über das UART auszugeben
void uart_puti( const int val )
{
char buffer[8];
uart_puts( itoa(val, buffer, 10) );

}

int main (void)
{
//TWI als Slave mit Adresse slaveadr starten
init_twi_slave(SLAVE_ADRESSE);

//i2cdatamit Werten füllen, die der Master auslesen und ändern kann
for(uint8_t i=0;i<i2c_buffer_size;i++)
{
i2cdata[i]=10+i;
}

//Serielle Schnittstelle aktivieren
uart_init((UART_BAUD_SELECT((BAUD),F_CPU)));
uart_puts("I2C-Test\r\n");
uart_puts("Teste I2C-Slave mit Adresse "); uart_puti(SLAVE_ADRESSE);
uart_puts("\r\n");
uart_puts("\r\n"); //Leerzeile

//in einer Endlosschleife den Inhalt der Buffer ausgeben
while(1)
{
uart_puts("i2cdata:\r\n");
for(uint8_t i=0;i<i2c_buffer_size;i++)
{
uart_puti(i2cdata[i]);
uart_puts("\r\n");
}
uart_puts("\r\n");//leerzeile
_delay_ms(500);
} //end.while
} //end.main

</pre>

== Slave sourcecode ==
Die twislave.c für den Slave. Stand: 12.4.2010
<pre>
#include <util/twi.h> //enthält z.B. die Bezeichnungen für die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur Behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t
#include "twislave.h"

//%%%%%%%% Globale Variablen, die vom Hauptprogramm genutzt werden %%%%%%%%
/*Der Buffer, in dem die Daten gespeichert werden.
Aus Sicht des Masters läuft der Zugrif auf den Buffer genau wie bei einem I2C-EEPROm ab.
Für den Slave ist es eine globale Variable
*/
volatile uint8_t i2cdata[i2c_buffer_size+1];
volatile uint8_t buffer_adr; //"Adressregister" für den Buffer

/*Initaliserung des TWI-Inteface. Muss zu Beginn aufgerufen werden, sowie bei einem Wechsel der Slave Adresse
Parameter adr: gewünschte Slave-Adresse
*/
void init_twi_slave(uint8_t adr)
{
TWAR= adr; //Adresse setzen
TWCR &= ~(1<<TWSTA)|(1<<TWSTO);
TWCR|= (1<<TWEA) | (1<<TWEN)|(1<<TWIE);
buffer_adr=0xFF;
sei();
}

//Je nach Statuscode in TWSR müssen verschiedene Bitmuster in TWCR geschreiben werden(siehe Tabellen im Datenblatt!).
//Makros für die verwendeten Bitmuster:

//ACK nach empfangenen Daten senden/ ACK nach gesendeten Daten erwarten
#define TWCR_ACK TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);

//NACK nach empfangenen Daten senden/ NACK nach gesendeten Daten erwarten
#define TWCR_NACK TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);

//switch to the non adressed slave mode...
#define TWCR_RESET TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(1<<TWSTO)|(0<<TWWC);

/*ISR, die bei einem Ereignis auf dem Bus ausgelöst wird. Im Register TWSR befindet sich dann
ein Statuscode, anhand dessen die Situation festgestellt werden kann.
*/
ISR (TWI_vect)
{
uint8_t data=0;

switch (TW_STATUS) //TWI-Statusregister prüfen und nötige Aktion bestimmen
{

// Slave Receiver

case TW_SR_SLA_ACK: // 0x60 Slave Receiver, Slave wurde adressiert
TWCR_ACK; // nächstes Datenbyte empfangen, ACK danach senden
buffer_adr=0xFF; //Bufferposition ist undefiniert
break;

case TW_SR_DATA_ACK: // 0x80 Slave Receiver, ein Datenbyte wurde empfangen
data=TWDR; //Empfangene Daten auslesen
if (buffer_adr == 0xFF) //erster Zugriff, Bufferposition setzen
{
//Kontrolle ob gewünschte Adresse im erlaubten bereich
if(data<i2c_buffer_size)
{
buffer_adr= data; //Bufferposition wie adressiert setzen
}
else
{
buffer_adr=0; //Adresse auf Null setzen. Ist das sinnvoll? TO DO!
}
TWCR_ACK; // nächstes Datenbyte empfangen, ACK danach, um nächstes Byte anzufordern
}
else //weiterer Zugriff, nachdem die Position im Buffer gesetzt wurde. NUn die Daten empfangen und speichern
{

if(buffer_adr<i2c_buffer_size)
{
i2cdata[buffer_adr]=data; //Daten in Buffer schreibe
}
buffer_adr++; //Buffer-Adresse weiterzählen für nächsten Schreibzugriff
TWCR_ACK;
}
break;

//Slave transmitter

case TW_ST_SLA_ACK: //0xA8 Slave wurde im Lesemodus adressiert und hat ein ACK zurückgegeben.
//Hier steht kein break! Es wird also der folgende Code ebenfalls ausgeführt!

case TW_ST_DATA_ACK: //0xB8 Slave Transmitter, Daten wurden angefordert

if (buffer_adr == 0xFF) //zuvor keine Leseadresse angegeben!
{
buffer_adr=0;
}

if(buffer_adr<i2c_buffer_size)
{
TWDR = i2cdata[buffer_adr]; //Datenbyte senden
buffer_adr++; //bufferadresse für nächstes Byte weiterzählen
}
else
{
TWDR=0; //Kein Daten mehr im Buffer
}
TWCR_ACK;
break;

case TW_ST_DATA_NACK: // 0xC0 Keine Daten mehr gefordert
case TW_SR_DATA_NACK: // 0x88
case TW_ST_LAST_DATA: // 0xC8 Last data byte in TWDR has been transmitted (TWEA = “0”); ACK has been received
case TW_SR_STOP: // 0xA0 STOP empfangen
default:
TWCR_RESET;
break;

} //end.switch (TW_STATUS)
} //end.ISR(TWI_vect)

////Ende von twislave.c////

</pre>

== Slave header ==
Die zugehörige Headerdatei twislave.h für den Slave. Stand: 19.2.2010
<pre>

#ifndef _TWISLAVE_H
#define _TWISLAVE_H

#include <util/twi.h> //enthaelt z.B. die Bezeichnungen fuer die Statuscodes in TWSR
#include <avr/interrupt.h> //dient zur behandlung der Interrupts
#include <stdint.h> //definiert den Datentyp uint8_t

/**
* @defgroup twislave TWI-Slave
* @code #include "twislave.h" @endcode
*
* @brief Betrieb eines AVRs mit Hardware-TWI-Schnittstelle als Slave.
* Zu Beginn muss init_twi_slave mit der gewuenschten Slave-Adresse als
* Parameter aufgerufen werden.
*
* Der Datenaustausch mit dem Master erfolgt ueber den Buffer i2cdata,
* auf den von Master und Slave zugegriffen werden kann.
* Dies ist fuer den Slave eine globale Variable (Array aus uint8_t).

* Der Zugriff durch den Master erfolgt aehnlich wie bei einem
* normalen I2C-EEPROM.
* Man sendet zunaechst die Bufferposition, an die man schreiben will,
* und dann die Daten.
* Die Bufferposition wird automatisch hochgezaehlt, sodass man mehrere
* Datenbytes hintereinander schreiben kann, ohne jedesmal die
* Bufferadresse zu schreiben.
*
* Um vom Master aus zu lesen, uebertraegt man zunaechst in einem
* Schreibzugriff die gewuenschte Bufferposition und liest dann nach
* einem repeated start die Daten aus. Die Bufferposition wird
* automatisch hochgezaehlt, sodass man mehrere Datenbytes
* hintereinander lesen kann, ohne jedesmal die Bufferposition zu
* schreiben.
*
* Abgefangene Fehlbedienung durch den Master:
* - Lesen ueber die Grenze des txbuffers hinaus
* - Schreiben ueber die Grenzen des rxbuffers hinaus
* - Angabe einer ungueltigen Schreib/Lese-Adresse
* - Lesezugriff, ohne vorher Leseadresse geschrieben zu haben
*
* @author uwegw
*/

/*@{*/

//%%%%%%%% von Benutzer konfigurierbare Einstellungen %%%%%%%%
/**@brief Groesse des Buffers in Byte (2..254) */
#define i2c_buffer_size 10// I2C_REG_ANZAHL 254 Hier kann eingestellt werden wieviele Register ausgegeben werden

//%%%%%%%% Globale Variablen, die vom Hauptprogramm genutzt werden %%%%%%%%
/**@brief Der Buffer, in dem die Daten gespeichert werden.
* Aus Sicht des Masters laeuft der Zugrif auf den Buffer genau wie
* bei einem I2C-EEPROm ab.
* Fuer den Slave ist es eine globale Variable
*/
volatile uint8_t i2cdata[i2c_buffer_size+1];

/**@brief Initaliserung des TWI-Inteface. Muss zu Beginn aufgerufen werden, sowie bei einem Wechsel der Slave Adresse
* @param adr gewuenschte Slave-Adresse */
void init_twi_slave(uint8_t adr);

//%%%%%%%% ab hier sind normalerweise keine weiteren Aenderungen erforderlich! %%%%%%%%//
//____________________________________________________________________________________//

//Bei zu alten AVR-GCC-Versionen werden die Interrupts anders genutzt, daher in diesem Fall mit Fehlermeldung abbrechen
#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304
#error "This library requires AVR-GCC 3.4.5 or later, update to newer AVR-GCC compiler !"
#endif

//Schutz vor unsinnigen Buffergroessen
#if (i2c_buffer_size > 254)
#error Buffer zu gross gewaehlt! Maximal 254 Bytes erlaubt.
#endif

#if (i2c_buffer_size < 2)
#error Buffer muss mindestens zwei Byte gross sein!
#endif

#endif //#ifdef _TWISLAVE_H
////Ende von twislave.h////

</pre>

== Andere Bibliotheken ==

* [http://www.jtronics.de/avr-projekte/library-i2c/twi-slave-avr]
* [http://www.ermicro.com/blog/?p=1239]

[[Kategorie:Microcontroller]]
[[Kategorie:Quellcode C]]

Terminals

2011-10-24T14:25:18Z

Chypsylon: /* Hyperterm Terminal */

==Allgemeines zu Terminals==
Ein Terminal dient dazu, Daten, die z.B. an einen COM-Port geschickt wurden, zu empfangen, oder Daten zu versenden. Die Daten sind meist in Textform (ASCII). Es gibt Terminals ohne GUI, diese laufen dann z.B. in einer Konsole, oder welche mit GUI. Siehe dazu

Man kann ein Terminal u.a. für folgendes verwenden (neben dem simplen Senden und Empfangen):
* Debugginginformationen protokollieren
* Daten aufzeichnen (loggen)
* Daten auswerten

Es sind einige Terminalprogramme für die unterschiedlichsten Betriebsysteme vorhanden (siehe [[Terminalprogramm|Terminalprogramme]]).

Was hat ein Terminal mit Robotik zu tun? Eigentlich nichts. Aber wer nicht ein LCD-Display und eine Tastatur auf seinem Board eingebaut hat, ist darauf angewiesen, mit einer Terminal-Emulation Kontakt mit seinem Controllerboard aufzunehmen.

Gleich vorweg: Da kaum ein Bastler mit einem richtigen "physischen" Terminal zu tun hat, werde ich den Zusatz "Emulation" in Zukunft streichen. Das verwirrt nur und bringt nichts.
Bei so einem Terminal sind ein paar Dinge einzustellen und auf die sollte man auch achten. Häufig verwendet werden

==Terminalprogramme==
Es gibt einige bekannte Terminals mit einer GUI. Solche Programme für das Betriebssystem Windows sind u.a.:
* [[Terminals#Hyperterm Terminal|Hyperterm Terminal]]
* TTY
* [http://www.der-hammer.info/terminal/ HTerm]

Entwicklungsumgebungen wie z.B. Bascom haben oft bereits ein Terminalprogramm (siehe [[Terminals#BasCom Terminal|BasCom Terminal]]) integriert. Dies erleichtert das Debuggen (Fehlersuche in eigenen Programmen) erheblich. Links sind im [[Terminals#Weblinks|Weblinks]] Bereich.

==BasCom Terminal==
Die Entwicklungsumgebung Bascom bringt ein eigenes, in die Entwicklungsumgebung integriertes, Terminalprogramm mit - Bascom Terminal. Die Möglichkeiten des Programms beschränken sich auf das Wichtigste.

Options » Communications

http://www.roboternetz.de/wiki/uploads/Main/basterm1.jpg

Es ist nicht viel einzustellen, die gezeigten Werte sind der Normalfall.

==Hyperterm Terminal==
Das Hyperterm Terminal wird standardgemäß mit jeder Windowsversion bis Windows XP mitgeliefert. In Vista und Win7 müssen die Dateien "hypertrm.dll" und "hypertrm.exe" von einer XP-Installation kopiert bzw. downgeloadet werden. Es bietet auch nur Grundfunktionen, ist aber als einfaches Terminalprogramm mit GUI gut zu gebrauchen.

Nach dem Programmstart erscheint:

'''Neue Verbindung'''

[[Bild:Hyper1_v2.png]]

Da gibt man irgendeinen Namen für die Verbindung ein, z.B. "Roboternetz".

Es erscheint:
'''Verbinden mit'''

[[Bild:Hyper2_v2.png]]

Wir geben den COM-Port ein (der Port also, über den die Daten gesendet/empfangen werden sollen):

Nun können wir einige COM-Port Einstellungen wählen. Damit es zu einer Verbindung kommt müssen die gewählten Einstellungen mit den Einstellungen des Endgeräts (das über eine COM-Port Schnittstelle am Computer hängt) übereinstimmen. Sonst empfängt man nur Datenmüll oder gar nichts.

'''Anschlusseinstellungen'''

[[Bild:Hyper3_v2.png]]

* Baudrate (Bits pro Sekunde) - Beliebt ist 9600, dass muss aber mit den Einstellungen des Controllers übereinstimmen
* Datenbits - Normalerweise "8"
* Parität - Normalerweise "keine"
* Stoppbits - Normalerweise "1"
* Flusssteuerung - Normalerweise "kein"

Jetzt ist das Hyperterm soweit zufrieden, wir aber nicht.

[[Bild:Hyper4_v2.png]]

Es geht weiter bei:

===Einstellungen===

Datei » Eigenschaften » Einstellungen

[[Bild:Hyper5_v2.png]]

Interessant sind:
* Rücktaste sendet*
** CAN (Ctrl-H) --> Terminalsteuerung
** DEL --> Terminalsteuerung

'''Emulation'''
wird hier Verschiedenes angeboten
* Auto Detect
* TTY
Solange man nur "print" und "input" sagt, ist dies völlig ausreichend.

* VT100 / VT220 und evtl. andere
Diese Typen verstehen die normalen "ANSI-Steuersequenzen" und einige mehr ANSII-Sequenzen.

Das reicht, um mit dem Roboter (oder einem anderen Endgerät) kommunizieren zu können.

===ASCII-Konfiguration===

Um das Interesse zu wecken, einmal ein Bild der Einstellungen. Beim Thema "Terminalsteuerung" gibt es dazu mehr Information.

[[Bild:Hyper6_v2.png]]

==Terminalsteuerung ANSI==

Ein Terminal bietet aber auch einiges mehr als das, was bei der allgemeinen Terminalsteuerung besprochen wurde.

* Volle Kontrolle über den Bildschirm
* Alle Tasten können verwendet werden

Dazu werden ANSI-Sequenzen verwendet (dass sind Zeichenfolgen mit ganz bestimmtem Aufbau). Und auch die werden noch von verschiedenen Herstellern um zusätzliche Funktionen erweitert. Besonders hervorgetan hat sich hier DEC (Digital Equipment Corporation) mit seinen VTxxx-Terminals. Viele Terminal-Emulationen bieten solche Typen an, wobei besonders die VT220 und aufwärts interessant sind. Aber auch schon VT100 ist ganz nett.

Die ganzen Steuersequenzen sind auch im Internet zu finden und Power-User sind gebeten, sich dort über alle Feinheiten zu informieren.

Für Mikrocontroller ist wohl einiges zu aufwendig, aber einige Möglichkeiten möchte ich hier darstellen, da man damit doch von den unleserlich schnell durchlaufenden Einzelzeilen wegkommen kann.

Nicht jeder hat die Möglichkeit, und manchmal zahlt es sich auch gar nicht aus, eigens ein graphikfähiges PC-Programm zu schreiben, um mit seinem Microcontroller Dialog zu führen, oder ein bisschen Balkengraphik zu zeigen.

Den Typ VT100 bieten BasCom und Hyperterm an, wollen wir mal sehen

===VT100===
====Was sendet das Terminal? (Auszug)====
Bei der normalen Schreibmaschinen-Tastatur ändert sich nichts. Aber die anderen Blöcke werden nun lebendig.

Nur das erste Zeichen eine Sequenz ist ein Kontrollzeichen, und zwar:
<ESC>, Code 27, die anderen sind normal lesbare ASCII Zeichen

'''Pfeiltasten'''
* Pfeil oben
<ESC>[A
* Pfeil unten
<ESC>[B
* Pfeil rechts
<ESC>[C
* Pfeil links
<ESC>[D

'''EDIT Keys'''
* Pos 1 (Home)
<ESC>[1~
* Bild rauf
<ESC>[5~
* Bild runter
<ESC>[6~

====Was kann man senden? (Auszug)====
Wie beim Empfangen. Bei den "normalen" Zeichen ändert sich nichts. Ich will auch nur einige Beispiele aufzeigen, die einen auf den Geschmack bringen sollen.

Freie Positionierung des Cursors irgendwo am Schirm:
<ESC>[''nn'';''mm''H
dabei ist
* nn die Zeilennummer 1-24
* mm die Spalternummer 1-80 oder 1-132

BasCom Beispiel, das auch der C-Programmierer versteht:
PRINT chr(27);"[01;40H";
Stellt den Cursor in die oberste Zeile, genau in die Mitte.'- (führende Nullen können sein, müssen aber nicht)-'

'''Zeichen-Attribute:'''
<ESC>[''param''m '-(das ist ein kleines "m" am Schluß)-'
Mögliche "param" sind:
* 0 = Normal
* 1 = Heller (bold)
* 4 = Unterstrichen
* 5 = Blinkend
* 7 = Reverse (dunkel auf hell bzw. umgekehrt)
Dabei können mehrere Attribute angegeben werden, dann aber mit Semikolon getrennt:
<ESC>[''param1'';''param2'';''param3''m

'''Beispiel:'''
will man bei einer Eingabe den Aufforderungstext verkehrt darstellen, sendet man
PRINT chr(27);"[7m"; ' setzt attribut "revers"
PRINT "VORNAME ?>"; ' der Text
PRINT chr(27);"[0m"; ' Attribut wieder normal

http://www.roboternetz.de/wiki/uploads/Main/Ansii_2.jpg

(Das geht natürlich auch in einem Print-Befehl auf einmal.)

'''Lösch-Befehle:'''
* Rechts vom Cursor die Zeile löschen
<ESC>[K
* Links vom Cursor die Zeile löschen
<ESC>[1K
* Vom Cursor abwärts den ganzen Schirm löschen
<ESC>[2J
* Oberhalb des Cursors den ganzen Schirm löschen
<ESC>[J

'''Beispiel:'''
Beim Programmstart als Erstes den gesamten Schirm löschen und eine Überschrift in der Mitte
PRINT chr(27);"[1;1f"; ' Cursor ganz rauf
PRINT chr(27);"[J"; ' den ganzen Schirm löschen
PRINT chr(27);"[1;38f"; ' In die Mitte der ersten Zeile
PRINT chr(27);"[7m"; ' setzt attribut "revers"
PRINT "START"; ' Überschrift
PRINT chr(27);"[0m"; ' setzt attribut normal
PRINT ' (=neue Zeile) Cursor am Anfang der zweiten Zeile

'''Anmerkung:'''
Man kann mit diesen Sequenzen einiges tun. Auch einige [[Terminal_Game_mit_BasCom|Spiele aus der Urzeit]] lassen sich damit programmieren, vor allem aber kann man z.B. Sensorwerte übersichtlich an verschiedenen Stellen des Schirms so platzieren, dass man mehrere im Auge behalten kann.

==Siehe auch==
* [[Terminal_Game_mit_BasCom]]
* [[UART]]

==Weblinks==
* [http://www.der-hammer.info/terminal Terminalprogramm HTherm]
* [http://www.emtec.com/zoc/index.htm ZOC Terminal - Terminalprogramm für Windows und Mac OS]
* [http://www.elektronik-labor.de/RS232/2010Terminal.html einfaches Terminal, unterstützt auch USB-seriell-Adapter]

==Autoren==
''Artikel von [[User:PicNick|PicNick]], bearbeitet von Luma''

[[Kategorie:Software]]
[[Kategorie:Praxis|Terminalsteuerung]]

Timer/Counter (Avr)

2011-09-04T13:33:54Z

Chypsylon: /* Weblinks */

Die Mikrocontroller der AVR-Familie besitzen je nach Typ eine unterschiedliche Anzahl an programmierbaren [[Timer|Timern]]. Bei den aktuellen ATmegas sind das mindestens ein 8-Bit Timer und ein 16-Bit Timer. Die Timer werden immer Timerx benannt, wobei x für die Timernummer steht (also 0, 1, 2, usw.).
Die Konfigurationsmöglichkeiten sind von Timer zu Timer unterschiedlich.

'''Hinweis:''' Die folgenden Code-Beispiele sind in C programmiert und wurden für einen [[ATMega32|ATmega32]] entwickelt. Sie lassen sich also ohne große Änderungen auch auf anderen Mikrocontrollern der AVR-Familie einsetzen.

== Allgemeine Funktionsweise ==
Timer funktionieren nach dem allgemeinen Prinzip, dass sie eine Ganzzahl (im weiteren als Zähler bezeichnet) je nach Betriebsmodus auf- oder abwärtszählen, d.h. inkrementieren bzw. dekrementieren.

Angenommen, der Timer arbeitet im einfachsten Betriebsmodus, dem [[Timer/Counter (Avr)#Normaler Modus (Normal Mode)|Normalen Modus]]. Die Zählrichtung des Timers ist aufsteigend gerichtet. Je nach Auflösung, also 8-Bit oder 16-Bit, folgt auf den maximalen Zählerstand wieder die Null. Wenn z.B. bei einem 8-Bit Timer der Wert 255 inkrementiert wird folgt die Null (siehe Grafik).

[[Bild:AbstrakterZaehlvorgang.png]]

== Der Prescaler ==
Der Prescaler (eng. = Vorteiler) kann der Takt für den Timer herunter geteilt werden. Oft hat man Faktoren von 1, 8, 64 ,256 oder 1024 zur Auswahl. Über das selbe Register kann der Timer auch ganz angehalten werden oder ein externer Takt ausgewählt werden. Ein externer Takt darf dabei höchstens halb so hoch wie der Prozezessortakt sein.
Hier eine Grafik die den Prescaler veranschaulicht:

[[Bild:Prescaler.png]]

Das obere Diagramm zeigt den Betrieb ohne Prescaler, das untere mit Prescaler (:2). Die gestrichelte Linie zeigt, wann der Timer weiterzählt.

Im Teil [[Timer/Counter (Avr)#Die Betriebsmodi|Die Betriebsmodi]] wird weiter auf die praktische Verwendung des Prescalers eingegangen.

== Die Betriebsmodi ==
Die AVR-Timer können in unterschiedlichen Betriebsmodi betrieben werden. Diese sind:
* Normaler Modus
* CTC Modus
* PWM

=== Normaler Modus (Normal Mode) ===
Der einfachste Betriebsmodus ist der normale Modus. Er funktioniert wie im Abschnitt "[[Timer/Counter (Avr)#Allgemeine Funktionsweise|Allgemeine Funktionsweise]]" beschrieben. Die Zählrichtung des Timers ist immer aufsteigend, bis zum Überlauf - da fängt der Zähler wieder bei 0 an. Der Überlauf kann einen Interrupt (Timer-Overflow) auslösen. Im einfachsten Fall kann dieser Modus im folgendem Diagramm dargestellt werden:

[[Bild:NormalerModus_1.png]]

Der Zähler des Timers (im Diagramm oben, die aufsteigende und dann wieder zurückgesetzte Linie) ist in dem Register TCNTx gespeichert, wobei x für eine Zahl steht. Soll z.B. auf den Timer0 (siehe Datenblatt des jeweiligen Controllers) des Controllers zugegriffen werden, so ist an TCNT eine 0 anzuhängen, also TCNT0.
Wie lange es braucht, bis der Zähler einen Overflow auslöst, ist von der Taktfrequenz des Controllers, dem eingestellten Prescaler-Wert und von der Timerauflösung abhängig. Nun wäre es ja sehr unpraktisch, wenn wir den Zähler nicht anpassen könnten. Denn sonst müssten wir unsere Software, die den Timer benutzt, evtl. anpassen und viel rechnen, um z.B. für 1000 ms zu schlafen. Deswegen kann auf den Zähler zugegriffen werden und ihn vorladen, bevor dieser wieder vom eigentlichen Timer hochgezählt wird. Dies veranschaulicht folgendes Diagramm:

[[Bild:NormalerModus_1_Vorladen.png]]

Dadurch kann eingestellt werden, wie lange es dauert, bis ein Overflow auftritt. Um zu berechnen, welchen Wert wir vorladen müssen, kann auch ein Java-Applet genutzt werden, siehe unter [[Timer/Counter (Avr)#Weblinks|Weblinks Java Applet]].

Natürlich kann das auch "von Hand" berechnet werden. Die Berechnung des Preloader- sowie Prescalerwerts bei Verwendung der Overflow-Interrupts, eines Prescalers von 64 (nicht alle Prescaler können verwendet werden) und eines Quarzes mit der Frequenz von 8 MHz sieht folgendermaßen aus (gesuchte Frequenz beträgt 1000 Hz unter der Verwendung des Timer0 eines ATmega32):
# <math>Prescale = Frequenz * 1000000 [Hz] = 8000000</math>
# Wir definieren den maximalen Zählerwert. Dieser ist bei einem 8-Bit Timer 256, bei einem 16-Bit Timer 65536. In unserem Fall ist der maximale Zählerwert 256, weil Timer0 verwendet wird.
# Nun wird die Variable ''Prescale'' (s.o.) durch den verwendeten Prescaler (64) geteilt (<math>8000000 Hz / 64 = 125000</math>).
# Als nächstes wird der im dritten Punkt errechnete Wert durch die gesuchte Frequenz geteilt <math>=125000 / 1000Hz = 125</math>.
# Nun wird mathematisch überprüft, ob der errechnete Wert aus dem vierten Punkt kleiner als der maximale Zählerwert ist. Trifft dies zu, so wird der errechneten Wert vom maximalen Zählerwert subtrahiert(<math>= 256 - 125 = 131</math>).

Damit haben wir den Wert errechnet, der bei jedem Interrupt, den der Timer0 auslöst, in TCNTx (in diesem Fall TCNT0) nachgeladen werden muss, damit die Interrupts in dem gewünschten Zeitabstand von einer Millisekunde ausgelöst werden.

Zwischen dem Timer Overflow und dem tatsächlichen Aufrufen der ISR mit dem Nachladen des Timers ergibt sich eine kleine Verzögerung, die nicht einmal immer gleich ist. Bei einem genügend großen Prescaler (z.B. 64) kommt durch die Verzögerung kein zusätzlicher Timerschritt zustande, und auch die Methode mit dem Nachladen liefert exacte Ergebnisse. Bei kleinen Prescalern kommt es durch die Verzögerung zu längeren und nicht immer gleichen Zeitabständen. Wenn möglich wird für die Erzeugung einer konstanten Interruptrate deshalb besser der CTC Moduls benutzt.

Zusammenfassend ein Beispielprogramm:

<pre>
/* Es wird der Timer2 (8-Bit) eines ATmega32 verwendet, der mit einem Quarz mit 7,3728 MHz
betrieben wird. Im Abstand von etwa 0,1 ms erzeugt der Timer einen Interrupt, also eine
Frequenz von 10000 Hz. Der Timer wird auf einen Prescaler von 64 und
einem Preloader von 244 konfiguriert.*/

volatile uint8_t countTimer2; // Speichert den aktuellen Zählerwert

// ISR zum auffangen der Interrupts:
SIGNAL(SIG_SIG_OVERFLOW2)
{
TCNT2 = 244; // Nachladen
countTimer2++;
}

// Initialisierung:
TCCR2 = (1<<CS22); // Prescaler von 64
TCNT2 = 244; // Vorladen
TIMSK |= (1<<TOIE2); // Interrupts aktivieren und damit Timer starten
sei();

// Funktionen zum benutzen der Timer:
/** Diese Funktion nicht aufrufen. Wird von sleep_millisec aufgerufen.
Bei t=10 schläft die Funktion 1 ms. */
inline void sleep (uint8_t t)
{
// countTimer2 wird in der ISR oben inkrementiert
countTimer2 = 0; // 1 Byte Typ, daher kein cli()... sei() nötig
while (countTimer2 < t);
}

/** Schläft x-Millisekunden. */
inline void sleep_millisec(uint16_t msec)
{
uint16_t i;
for(i=0; i<msec; i++) {
sleep(10);
}
}
</pre>

Viele Timer haben "Output-Compare" Register: OCRx oder OCRAx,OCRBx. Wenn der Zähler den darin eingestellten Wert erreicht hat, kann ein Interrupts ausgelöst werden.

==== Input Capture ====

Die 16 Bit Timer haben eine "Input Capture" Funktion. Dieser Hardwareteil dient zur genauen Zeitmessung. Außer in einigen PWM Betriebsarten, wo das ICP Register als TOP-wert für den Timer benutzt wird, ist die ICP-Funktion immer aktiv. Wenn am ICP Pin die über das Bit "ICESx" eingestellte Flanke auftritt, wird der aktuelle Zählerstand in das ICP Register kopiert. Außerdem kann ein Interrupt ausgelöst werden. Der Interrupt wird, wie die anderen Timer Interrupts, in den Registern TIMSK und TIFR an- oder abgestellt. Man kann zwar die ICP-Funktion selber nicht ohne weiteres abschalten, aber natürlich den dazugehörigen Interrupt. Als eine spezielle Funktion ("Noise Cancler") gibt es die Möglichkeit sehr kurze Pulse (unter 4 Zyklen) zu unterdrücken. In der Regel kann man diese Funktion angestellt lassen, denn so schnell kann man die Daten ohnehin nicht verarbeiten.

Die typische Anwendung ist die Messung von kurze Zeiten, wie z.B. die Zeit für eine Motorumdrehung. Solange die 16 Bit des Timers ausreichen ist die Benutzung ganz einfach: Der Timer wird mit dem gewünschten Vorteiler im normalen Modus gestartet. Im ICP-Interrupt wird die Differenz aus zwei aufeinanderfolgenden Zeiten (Werte in ICP-Register) berechnet. Dazu wird jeweils die vorherige Zeit im RAM zwischengespeichert. Wenn man bei der Rechnung eventuelle Überläufe ignoriert, bekommt man die richtige Zeitdifferenz, auch wenn der Timer während der Messzeit einen Überlauf hatte. Das funktioniert so einfach, denn wenn noch weitere (höherwertige) Bytes vorhanden wären, damit es keinen Überlauf gibt, würde man genau so die unteren Bits berechnen.

Etwas komplizierter wird es, wenn die 16 Bit Auflösung nicht mehr ausreicht. Dann kann der Timer-Überlauf benutzt werden, um auch längere Zeiten mit voller Auflösung zu messen. Die wesentliche Schwierigkeit ist es, den Fall zu berücksichtigen, dass ein Überlauf Interrupt und der ICP Interrupt fast gleichzeitig ausgelöst werden. Es kann passieren, dass der ICP-Interrupt aufgerufen wird, obwohl eigentlich erst der Overflow Interrupt dran gewesen wäre. Dieser seltene Fall läßt sich daran erkennen, dass das Overflow-Interrupt Flag gesetzt ist und der Wert im ICP Register klein ist (high Byte < 128, meistens 0).

Beispielpropgramm (für GCC):
(Bisher nur im Simulator getestet)
<pre>
// Beispielprogramm für Zeitmessung mit ICP-Funktion
// Erweiterung des Timers auf 32 Bit durch Software
// Es wird die Periodendauer am ICP-Eingang gemessen und als ASCII via UART ausgegeben
// Code für Mega48 / Mega88 / Mega 168 / ...
// mit leichten Anpassungen auch für Tiny2313, Mega16, Mega32,...

#include <stdlib.h> // für utoa
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h> // Unterstützung für sleep mode

// #define F_CPU 1000000UL // Definition der Frequenz ist normal in makefile
#define BAUD 19200UL
#define UBRR_BAUD ((F_CPU/(16UL*BAUD))-1)

typedef union { // union erlaubt einen effektiven, seperaten Zugriff auf Teile der Variable
unsigned long i32;
struct {uint8_t i8l; // low
uint8_t i8m; // mid
unsigned int high; // high, soft timer
};
} convert32to8;

volatile unsigned long timestamp; // volatile wegen Zugriff im Interrrupt
volatile unsigned int softtimer;
volatile unsigned long zeitdifferenz;
unsigned long zeit;
char puffer[12]; // puffer für Ausgabe als Ascii

ISR(TIMER1_OVF_vect) // Timer1 Überlauf
{
++softtimer; // zählen der Überläufe
}

ISR(TIMER1_CAPT_vect) // Flanke an ICP pin
{
convert32to8 cap; // Variablendeklaration

cap.i8l = ICR1L; // low Byte zuerst, high Byte wird gepuffert
cap.i8m = ICR1H;
// overflow verpasst, wenn ICR1H klein und wartender Overflow Interrupt
if ((cap.i8m < 128) && (TIFR1 & (1<<TOV1)))
{ // wartenden timer overflow Interrupt vorziehen
++softtimer;
TIFR1 = (1<<TOV1); // timer overflow int. löschen, da schon hier ausgeführt
}
cap.high = softtimer; // obere 16 Bit aus Software Zähler
zeitdifferenz = cap.i32 - timestamp;
timestamp = cap.i32; // Zeit merken
}

void uart_init(void) // USART initialisieren (Mega48 etc.)
{
// Baudrate einstellen (Normaler Modus)
// kann bei älteren AVR Typen etwas anders sein (kein UBRR0H, dafür prescaler)
UBRR0H = (uint8_t) (UBRR_BAUD>>8); // bei Mega32 anders !
UBRR0L = (uint8_t) (UBRR_BAUD & 0x0ff); // bei Mega32 UBRRL
UCSR0B = (1<<TXEN0); // Aktivieren des Senders, bei Mega32 UCSRB
UCSR0C = (1<<UCSZ01)|(1<<UCSZ00)|(1<<USBS0); // bei Mega32 UCSRC
// Einstellen des Datenformats: 8 Datenbits, 2 Stoppbit:
}

void putser(char c) // sende ein Byte via UART
{
while ( !( UCSR0A & (1<<UDRE0)) ) ; // Warten bis der Sendepuffer frei ist
UDR0 = c;
}

void main(void)
{
unsigned char i;
// Datenrichtungen:
DDRB = 0; // Alles Eingänge, PB0 ist ICP
PORTB = 0xFF - (1<<PB0); // Pullups an Eingängen außer ICP
DDRC = 0; // Eingänge
PORTC = 0xFF; // Pullups an Eingängen
DDRD = (1<<PD1); // Eingänge, außer PD1 = Tx (UART)
PORTC = 0xFF- (1<<PD1); // Pullups an alle Eingängen (außer TX)
// Timer1 initialisieren:
TCCR1A = 0; // normal mode, keine PWM Ausgänge
TCCR1B = (1<< ICNC1) + (1<<CS10) // start Timer mit Systemtakt
+ (1 << ICES1); // steigende Flanke auswählen
TIMSK1 = (1<<TOIE1) + (1<<ICIE1); // overflow und Input-capture aktivieren, Mega32: TIMSK
TIFR1 = (1<<TOIE1) + (1<<ICIE1); // Schon aktive Interrrupts löschen, Mega32: TIFR
// UART initialisieren:
uart_init();

zeitdifferenz = 0;
softtimer = 0; // wird für Zeitdifferenzmessung nicht mal gebraucht,
// denn Differenz geht auch über Überlauf bei Softtimer
set_sleep_mode (SLEEP_MODE_IDLE); // idle Mode: timer läuft weiter, int zum aufwachen

sei(); // Interrupts erlauben: Messung startet
while (1)
{
sleep_enable ();
sei();
sleep_cpu(); // wartet auf irgendeinen Interrupt, z.B. ICP, timer_ovr,...
sleep_disable();
cli(); // Interrupt sperren wegen Zugriff auf volatile Variable
zeit = zeitdifferenz;
zeitdifferenz = 0; // als Markierung für ungültigen Wert
sei();
if (zeit > 0)
{
ultoa(zeit,puffer,10); // nach ASCII umwandeln
i = 0;
while (puffer[i])
{
putser(puffer[i++]); // Ausgabe
}
putser(13); // Zeilenumbruch senden
putser(10);
}
} // Ende von While-schleife
}
</pre>

=== CTC Modus (Clear Timer on Compare Match mode) ===
Der CTC Modus ist eine Erweiterung des "Output-Compare"-Funktion. Der CTC Modus eignet sich besonders, um einen mit konstanter Frequenz wiederkehrenden Interrupt zu erzeugen. Wie im normalen Modus zählt der Timer hoch. Wenn der Wert im OCRx Register erreicht wird, wird zusätzlich zum möglichen Interrupt der Zähler wieder auf 0 gesetzt. Es kann also die maximalen Zählergrenze selber definiert werden.
Dieses Diagramm veranschaulicht den CTC Modus.

[[Bild:NormalerModus_CompareMatch.png]]

Beispielprogramm:

<pre>
/* Es wird der Timer2 (8-Bit) eines ATmega32 verwendet, der mit einem Quarz
mit 7,3728 MHz betrieben wird. Im Abstand von 0,01 ms erzeugt der Timer
einen Interrupt, also eine Frequenz von 100000 Hz (oder 100 kHz).
Der Timer wird auf einen Prescaler von 1 und einem OCR2-Wert von 73 konfiguriert. */

volatile uint8_t countTimer2; // Speichert den aktuellen Zählerwert

// ISR zum auffangen der Interrupts:
SIGNAL(SIG_OUTPUT_COMPARE2)
{
countTimer2++;
}

// Initialisierung:
TCCR2 = (1<<CS20) | (1<<WGM21); // Prescaler von 1 | CTC-Modus (siehe unten für Beschreibung)
OCR2 = 73; // Vergleichswert
TIMSK |= (1<<OCIE2); // Interrupts aktivieren und damit Timer starten
sei();

// Funktionen zum benutzen der Timer:
/** Diese Funktion nicht aufrufen. Wird von sleep_millisec aufgerufen.
Bei t=100 schläft die Funktion 1 ms. */
inline void sleep(uint8_t t)
{
// countTimer2 wird in der ISR oben inkrementiert
countTimer2 = 0;
while (countTimer2 < t);
}

/** Schläft x-Millisekunden. */
inline void sleep_millisec(uint16_t msec)
{
uint16_t i;
for(i=0; i<msec; i++) {
sleep(100);
}
}
</pre>

----

=== PWM ===

Eine häufige Aufgabe für Mikrocontroller ist die Erzeugung von [[PWM]]-Signalen, zum Beispiel für Motorsteuerungen. Daher sind in den meisten [[AVR|AVRs]] PWM-Einheiten als Hardware vorhanden. Sie sind direkt mit den Timern verbunden und nutzen diese als Taktquelle. Die Hardware-PWM-Einheiten haben den Vorteil, sehr wenig Rechenzeit in Anspruch zu nehmen. Es muss nur die PWM aktiviert werden und bei Änderungen den gewünschten Wert in ein Register schreiben. Der Rest läuft automatisch und unabhängig vom restlichen Programm, ohne den AVR ständig zu beschäftigen wie bei einer PWM-Lösung in Software. Allerdings stehen meist nur zwei bis drei solcher PWM-Kanäle zur Verfügung, die außerdem an bestimmte Pins gebunden sind. Für die meisten Roboter mit zwei Antriebsmotoren reicht dies aber für gewöhnlich aus.

==== nutzbare Pins am AVR ====
Die Hardware-PWM-Funktion steht nur an bestimmten Pins zur Verfügung. In der Pinbelegungsübersicht im Datenblatt ist erkenntbar, dass als Sonderfunktion in Klammern "OC..." angegeben ist. Beim Mega32 sind dies zb. OC0 an PB3, OC1A an PD5, OC1B an PD4 und OC2 an PD7. Der Mega32 hat also insgesamt vier Hardware-PWM-Kanäle. Die Zahl hinter dem "OC" gibt an, zu welchem der Timer dieser PWM-Kanal gehört. Wenn noch ein Buchstabe dahinter kommt, dann gehören mehrere PWMs zu diesem Timer. Beim Mega32 sind also OC1A und OC1B demselben Timer, nämlich Timer1, zugeordnet.

'''Zu beachten ist, dass die für die PWM benutzten Pins zuvor explizit als Ausgang konfiguriert werden müssen! Ansonsten gelangt das PWM-Signal nicht nach draußen!'''

==== Funktionsprinzip ====
Das "OC" in den Pinbezeichnungen steht für "Output Compare Unit", also frei übersetzt Ausgangs-Vergleicher-Einheit. Dies beschreibt die Funktionsweise der PWM-Kanäle: der Zählerstand des Timers wird fortlaufend mit einen einstellbaren Referenzwert verglichen, und wenn beide Werte übereinstimmen, kann ein Ausgangspin des AVRs automatisch geschaltet werden (und ein Interrupt ausgelöst werden, was allerdings für die PWM-Funktion nicht relevant ist). Dies entspricht dem Verfahren im [[PWM#PWM_per_Software|Beispiel zur Software-PWM]]. Es läuft nun allerdings vollautomatisch im Hintergrund, sodass der Controller nicht damit belastet wird.

==== Die verschiedenen PWM-Modi ====
Es gibt -je nach AVR und Timer- etliche Betriebsarten, in denen die PWM-Einheit betrieben werden kann. Sie unterscheiden sich vor allem darin, wie schnell und mit welchen Nebeneffekten sich Änderungen des Sollwertes auf das Ausgangssignal auswirken. Für den Anfang sind diese Unterschiede erst einmal nebensächlich, und für eine einfache Motorsteuerung meist auch irrelevant. Daher wird hier zunächst der "Fast PWM Mode" ("Schneller PWM Modus", weil hier die größte Ausgangsfrequenz möglich ist) beschreiben, welcher der einfachste von allen ist.

Hierbei zählt der Timer immer von Null an aufwärts, bis er den Maximalwert (teilweise einstellbar) erreicht hat. Dann läuft er über und fängt von vorne an. Wie schnell dies geschieht, wird, wie im normalen Modus, über den Prescaler eingestellt.
Der gewünschte PWM-Ausgangswert wird im "OCRn"-Register abgelegt. Er darf zwischen Null und dem Maximalwert des Timers liegen. Er wird nun mit dem Timer-Wert verglichen. Was dann passiert, regeln die "COM..."-Bits. Sie bestimmen, wie der Ausgang geschaltet wird. Die übliche Konfiguration ist, dass bei Erreichen des Sollwertes die Ausgänge auf high geschaltet werden, und beim Überlauf auf low. Damit ergibt sich ein nichtinvertiertes PWM-Signal. Schließt man (über einem passenden Motortreiber!) einen Motor an, dreht er sich bei einem Sollwert von 0 gar nicht und beim Maximalwert mit voller Geschwindigkeit.

Beispielcode für den Timer1 des Mega16/32 (und vieler anderer AVRs):
<pre>
#include <avr/io.h>
#include <util/delay.h> // Warteschleife für die Demo. Für die eigentliche PWM nicht benötigt!

/* PWM-Beispiel für Mega16/32 (beiden haben den gleichen Timer)
Benutzt wird Timer1 im Fast PWM Mode, 8 Bit Auflösung
Die PWM-Signale liegen auf PD5/OC1A und PD4/OC1B
*/

// 1. Den Prescaler einstellen, der die Frequenz festlegt
TCCR1B |= (1<<CS12); //Prescaler 256

// 2. Den Timer in den Fast PWM Mode, 8 Bit schalten
// ACHTUNG: Die WGM-Bits sind auf beide Konfigurationsregister verteilt!
TCCR1A |= (1<<WGM10);
TCCR1B |= (1<<WGM12);

// 3. Compare Output mode einstellen: Pin geht auf high bei Compare match, auf low bei Überlauf.
// Ergibt nichtinvertierte PWM.
TCCR1A |= (1<<COM1A1) | (1<<COM1B1) ;

// In diesen Registern wird der gwünschte PWM-Wert abgelegt. Erlaubter Bereich: 0 bis 255.
OCR1A = 0;
OCR1B = 0;

// 4. Die Pins als Ausgänge konfigurieren. Erst jetzt liegt das PWM-Signal an den Pins an!
DDRD |= (1<<PD4) | (1<< PD5);

/*Nun ist der PWM-Modus aktiv! Der Ausgangswert kann nun über die Register OCR1A und OCR1B
vorgegeben werden. Man könnte ihnen per define noch einen Zweitnamen verpassen, zb */
#define MotorLinks OCR1A
#define MotorRechts OCR1B
//Und nun kann man per
MotorLinks = 127;
MotorRechts = 127;
//seinen Roboter mit halber Kraft vorwärts fahren lassen.

/*PWM-Demo: Die PWM-Werte werden erst bis zum Maximalwert erhöht und dann wieder verringert.
Ein angeschlossener Motor wird beschleunigen und dann wieder abbremsen. */
uint8_t wert;
while(1)
{
for (wert=0; wert<255; wert++)
{
OCR1A = wert;
OCR1B = wert;
_delay_ms(10);
}

for (wert=255; wert>0; wert--)
{
OCR1A = wert;
OCR1B = wert;
_delay_ms(10);
}
}
</pre>

Es sind also vier Einstellungen zu treffen:
# Takt anlegen per Prescaler
# PWM-Modus wählen
# Ausgangs-Aktion festlegen
# Pins als Ausgänge schalten

Diese Schritte müssen bei jedem AVR-PWM-Kanal ausgeführt werden. Die genauen Registernamen und Werte können sich jedoch je nach Timer-Ausführung etwas unterscheiden.

== Registerübersicht ==
''Hinweis: Diese Registertabellen wurden für den aktuellen [[Atmel Controller Mega16 und Mega32]] erstellt. Wenn Sie ein anderes Modell verwenden kann es sein, dass ein oder mehrere Register nicht existieren, oder sie eine andere Bezeichnung haben.''

{| {{Blaueschmaltabelle}} width=100%
|'''TIMSK'''
|-
|Mit diesem Register, der von allen Timern verwendet wird, lässt sich die Interruptausführung und Art des jeweiligen Timers bestimmen. 

{{Registertabelle8Bit|OCIE2|TOIE2|TICIE1|OCIE1A|OCIE1B|TOIE1|OCIE0|TOIE0}}

|-
|
*'''OCIE2 (Timer/Counter2 Output Compare Match Interrupt Enable)''' Wenn dieses Bit gesetzt wird, wird der Timer/Counter2 Compare Match Interrupt aktiviert (vorrausgesetzt die Interrupts sind global aktiviert).
*'''TOIE2 (Timer/Counter2 Overflow Interrupt Enable)''' Wenn dieses Bit gesetzt wird, wird der Timer/Counter2 Overflow Interrupt aktiviert (vorrausgesetzt die Interrupts sind global aktiviert).
*'''TICIE1 (Timer/Counter1, Input Capture Interrupt Enable)''' Wenn dieses Bit gesetzt wird, wird der Timer/Counter1 Input Capture Interrupt aktiviert (vorrausgesetzt die Interrupts sind global aktiviert).
*'''OCIE1A (Timer/Counter1 Output Compare A Match Interrupt Enable)''' Wenn dieses Bit gesetzt wird, wird der Timer/Counter1 Output Compare A Match Interrupt aktiviert (vorrausgesetzt die Interrupts sind global aktiviert).
*'''OCIE1B (Timer/Counter1 Output Compare B Match Interrupt Enable)''' Wenn dieses Bit gesetzt wird, wird der Timer/Counter1 Output Compare B Match Interrupt aktiviert (vorrausgesetzt die Interrupts sind global aktiviert).
*'''TOIE1 (Timer/Counter1 Overflow Interrupt Enable)''' Wenn dieses Bit gesetzt wird, wird der Timer/Counter1 Overflow Interrupt aktiviert (vorrausgesetzt die Interrupts sind global aktiviert).
*'''OCIE0 (Timer/Counter0 Output Compare Match Interrupt Enable)''' Wenn dieses Bit gesetzt wird, so wird der Timer/Counter0 Compare Match Interrupt aktiviert (vorrausgesetzt die Interrupts sind global aktiviert).
*'''TOIE0 (Timer/Counter0 Overflow Interrupt Enable)''' Wenn dieses Bit gesetzt wird, so wird der Timer/Counter0 Overflow Interrupt aktiviert (vorrausgesetzt die Interrupts sind global aktiviert).
|}

== Siehe auch ==

* [[Atmel]]
* [[HEX Beispiel-Dateien für AVR]]
* [[Bascom_und_Timer]]

== Weblinks ==

* [http://www.atmel.com/dyn/products/devices.asp?family_id=607 Die Datenblätter zu Atmel Controllern]
* [http://frank.circleofcurrent.com/cache/avrtimercalc.htm Javascript-Toll zur Timerberechnung]
* [http://www.roboternetz.de/phpBB2/dload.php?action=file&file_id=169 AvrTimer Windows Berechnungstool (für Bascom, nur nach Anmeldung)]

[[Kategorie:Microcontroller]]
[[Kategorie:Grundlagen]]
[[Kategorie:Elektronik]]
[[Kategorie:Abkürzung|AVR]]
[[Kategorie:Quellcode C]]

Beispiel Drehzahlmessung mit Drehgeber

2011-06-20T17:57:56Z

Chypsylon: /* Quelcode */

[[Kategorie:Sensoren]]
[[Kategorie:Praxis]]
[[Kategorie:Motoren]]

Ermitteln der Drehzahl und Wegstrecke in Abhängigkeit einer Winkeländerung oder Impulsfolge in einer Abgelaufenen Zeit

* Messen der Drehzahl nach jedem Impuls, also in Abhängigkeit einer Winkeländerung.
* Messen der Drehzahl durch Zählen der Impulse nach Ablauf einer bestimmten Zeit.
* Richtung, Geschwindigkeit und Position mit Doppellichtschranke ermitteln
{{Ausbauwunsch|Mehr Grundlagen und vor allem mal praktische Programmbeispiele / Algorithmen etc.}}
= Messen der Drehzahl nach jedem Impuls =

Dieser Teil beschäftigt sich vor allem mit der Optischen Drehzahlmessung mit Hilfe einer Lochscheibe und [[Gabellichtschranke]] berechnet über die Periodendauer ohne Drehrichtungserkennung.
[[Bild:GP1S23 Testaufbau.JPG|thumb| Testaufbau mit einer 32er Lochscheibe ]]
[[Bild:183015_LB_00_FB.EPS_250.jpg|thumb|GP1S23 Gabellichtschranke Bild: Conrad Electronic ]]

== Einführung ==

Am einfachsten ist Impulse direkt an einer Bürste eines Motors zu zählen. Siehe dazu: http://www.roboternetz.de/community/...einem-DC-Motor .

Die [http://de.wikipedia.org/wiki/Winkelgeschwindigkeit Winkelgeschwindigkeit] ist die Winkeländerung pro Zeiteinheit. Mit der Lichtschranke und den geometrischen Daten der Lochscheibe kann man nun relativ einfach die Zeit für eine bestimmte Winkeländerung messen.
Die Lochscheibe gibt uns die Winkeländerung bei einer Periode vor, bei einer 32er Lochscheibe wären das 11,25° pro Periode , wie in den Bildern vom Oszilloskop zu sehen ändert sich natürlich bei Änderung der Drehzahl die Periodendauer, die Winkeländerung pro Periode ist aber konstant da diese durch die Lochscheibe vor gegeben ist.

<gallery>
Bild:GP1S23_signal_langsam.png|Signal der Lichtschranke bei langsamer Drehzahl
Bild:GP1S23_signal_schnell.PNG |Signal der Lichtschranke bei schneller Drehzahl
</gallery>

Um die Periodendauer zu messen verwende ich den ICP1 (Input Capture Pin) eines Atmega8 der bei steigender Flanke den Timer1 ausliest und in das ICR1 Register schreibt. Läuft der Mikrocontroller auf 8Mhz und wir stellen den Vorteiler des Timers auf 8 so bekommen wir die Periodendauer in µs als Wert.

== Auslegen der Lochscheibe ==

In den meisten Fällen definieren der mechanische Aufbau den Durchmesser der Lochscheibe und die Drehzahl die Teilung (Anzahl der Löcher). Der µContoller und die Gabellichtschranke müssen die Impulse auch erfassen und verarbeiten können. Wenn man das Drehzahlband abschätzen kann ist es hilfreich, sich schon Gedanken um die Programmierung zu machen, denn bei hohen Drehzahlen springt der µC jedes mal in die Interrupt Service Routine rein, sofern man es so programmiert wie im Beispiel. Bei hohen Drehzahlen sollte die Teilung somit gröber, bei niedriger Drehzahl die Teilung feiner sein.

[[Bild:Drehscheibe20mm.png|400px|thumb|left|Lochscheibe abgerollt mit idealisiertem Signal ]]

== Berechnungen ==

Hier folgt nun die Berechnung über die Periodendauer, beachten sollte man das im [http://de.wikipedia.org/wiki/Bogenma%C3%9F Bogenmaß] gerechnet wird, ein Winkel mit dem Bogenmaß 1 rad hat ein Gradmaß von ca. 57,3°. 11.25° sind also ca. 0,196 rad, das führt später natürlich zu unschönen Rechenoperationen im µC, Stichwort [http://www.mikrocontroller.net/articles/Festkommaarithmetik Festkommaarithmetik].

Nach dem Umstellen kommt man aber auf eine recht handliche Formel <math>n = \frac{\varphi }{dt \cdot 360}</math>

Es ist auch eine Überlegung wert, ob man die Drehzahl nicht umrechnet sondern mit der Periodendauer arbeitet. Das ist zwar nicht so geläufig aber das stört den µController nicht. Mit einem Kalkulationsprogramm kann man die Umrechnung von Periodendauer in Drehzahl auch extern vornehmen.

Man sollte sich auch klar machen, das zumindest ein 8-Bit Prozessor am besten mit '''Ganzzahlen''' zwischen 0 und 255 oder 0 und 65535 zurechtkommt. Für die Teilung der Lochscheibe bieten sich deshalb Werte wie 90, 72, 45, 36, 30, 24, 20, 18, 15, 12, 10 und 8 an. Verwendet man an Stelle der dargestellten 32er Lochscheibe eine 30er oder 36er Scheibe, kann man zumindest mit ganzzahligen Gradzahlen rechnen. "Krumme Werte" wie [http://de.wikipedia.org/wiki/Kreiszahl Pi = 3,1415...], [http://de.wikipedia.org/wiki/Radiant_%28Einheit%29 Radiant = 57,29577...°] usw. sollten eine seltene Ausnahme in der Programmierung sein.

= Messen der Drehzahl durch zählen der Impulse =

Dieser Teil beschäftigt sich mit der Optischen Drehzahlmessung mit Hilfe einer Lochscheibe und [[Gabellichtschranke]] berechnet über die die Anzahl der Impulse in einer gewissen Zeit.

== Einführung ==

== Berechnung==

= Richtung, Geschwindigkeit und Position mit Doppellichtschranke ermitteln =
Dieser Teil beschäftigt sich mit der Optischen Drehzahl- und Geschwindigkeitsmessung sowie der Erfassung von Drehrichtung und zurückgelegter Position mit Hilfe einer Lochscheibe und 2 Gabellichtschranken. Hierfür werden Quadratursignale in definierten Zeitabständen ausgewertet.

== Einführung ==

Für kontrollierte Bewegungen ist es mitunter wichtig, auch die Drehrichtung/Richtungswechsel und Position auszuwerten. Eine Lochscheibe mit einer Gabellichtschranke liefert lediglich Rechteckimpulse, egal wie rum sich die Lochscheibe bewegt. Bringt man eine zweite Gabellichtschranke an der gleichen Lochscheibe leicht versetzt an, bekommt man auch die Drehrichtung mit. Diese Methode ist altbekannt, simpel und leicht nachzubauen. Wenn man die Drehrichtung kennt, ist auch die Position kein Problem mehr. Ausgehend von einer Kalibrierposition können bei Vorwärtsbewegung Inkremente hochgezählt oder bei Rückwärtsbewegung runtergezählt werden.

Interessierte nehmen dazu mal eine PC-Maus mit Kugelantrieb zur Hand. Darin findet man zwei kleine Lochscheiben, die für die X- und Y-Richtung die Impulse erzeugen. Durch spezielle Gabellichtschranken mit 2 phasenversetzten Ausgängen wird auch die Drehrichtung erkannt.

Das selbe Prinzip ist in linearer Form auch in PC-Druckern zu finden: Entlang des Wagenrücklaufes ist ein transparentes Kunsstoffband gespannt, auf dem winzig kleine Streifenmuster aufgebracht sind. Diese werden von einer Gabellichtschranke mit 2 Ausgängen erkannt und so die Wagenposition gesteuert.

Aber es geht natürlich noch einfacher...

== Zwei Lichtschranken liefern vier Informationen ==

[[Bild:vorwaerts_.jpg|thumb|Zustandsfolge bei Vorwärtsbewegung]]
[[Bild:rueckwaerts_.jpg|thumb|Zustandsfolge bei Rückwärtsbewegung]]
[[Bild:2LSZustand.jpg|thumb|2 Lichtschranken (LSA und LSB) liefern phasenversetzte Rechtecksignale. In Vorwärts- und Rückwärtsrichtung ergeben sich unterschiedliche Zustandsfolgen]]

Man nimmt 2 normale Gabellichtschranken und bringt sie so an, das sie im 1,5 fachen Lochabstand die Lochscheibe durchleuchten. Wenn sich Lichtschranke A in der Mitte des Lichtstreifens befindet, ist Lichtschranke B an der Grenze des Schattenstreifens. Nebenstehende Skizzen zeigen die möglichen Zustände beider Lichtschranken bei Vorwärts- und Rückwärtsbewgung der Lochscheibe. Wichtig ist hierbei, das die Lochscheibe in gleich breite Licht- und Schattensegmente eingeteilt ist und die Lichtschranke(n) einen möglichst haarfeinen Lichtstrahl besitzt. Die Signale der Fototransistoren sollten verstärkt und gegebenenfalls mit TTL-Bausteinen zu korrekten High- und Low-Pegeln aufbereitet werden.

Es ergeben sich nun folgende Kombinationen:

* Zustand 1: LSA = hell und LSB = hell
* Zustand 2: LSA = hell und LSB = dunkel
* Zustand 3: LSA = dunkel und LSB = dunkel
* Zustand 4: LSA = dunkel und LSB = hell

Dreht man die Lochscheibe weiter, wiederholt sich der Vorgang. Die Zustandsfolge ist 1 > 2 > 3 > 4 > 1 > 2 > 3 > 4 > usw.

Bei entgegengesetzter Drehrichtung ändert sich diese Reihenfolge. Betrachtet man wieder vom Zustand 1 ausgehend die Gegenrichtung, ergeben sich nun diese Kombinationen:

* Zustand 1: LSA = hell und LSB = hell
* Zustand 4: LSA = dunkel und LSB = hell
* Zustand 3: LSA = dunkel und LSB = dunkel
* Zustand 2: LSA = hell und LSB = dunkel

Die Zustandsfolge in Gegenrichtung lautet dann: 1 < 4 < 3 < 2 < 1 < 4 < 3 < 2 < usw.

Mit diesem Wissen ist es nun ein Kinderspiel, auch die Änderung der Drehrichtung festzustellen. Dazu muss der letzte Zustand in einer Variable gespeichert und mit dem neu erkannten Zustand verglichen werden. Folgt nach Zustand 1 der Zustand 2, so ist es eine Vorwärtsbewegung. Folgt dem Zustand 1 der Zustand 4, so ist es eine Rückwärtsbewegung. Gleiches Prinzip gilt auch für die restlichen Zustände 2, 3 und 4.

== Positionsüberwachung ==

Von jedem der 4 Zustände gibt es also zwei zu unterscheidende Fälle: Vorwärts und Rückwärts. Insgesamt müssen demzufolge 8 Bedingungen zyklisch abgetastet und ein Positionszähler entsprechend inkrementiert oder dekrementiert werden und schon hat man eine exakte Streckeninformation. In Worte gefasst ergibt sich folgende Logik:

Ausgangszustand: Beide Lichtschranken sind aus (A=0 UND B=0) und Zustand =1

* WENN (Zustand=1 UND A=0 UND B=1) DANN: Setze Zustand=2, Position inkrementieren, Vor
* WENN (Zustand=1 UND A=1 UND B=0) DANN: Setze Zustand=4, Position dekrementieren, Rück
* WENN (Zustand=2 UND A=1 UND B=1) DANN: Setze Zustand=3, Position inkrementieren, Vor
* WENN (Zustand=2 UND A=0 UND B=0) DANN: Setze Zustand=1, Position dekrementieren, Rück
* WENN (Zustand=3 UND A=1 UND B=0) DANN: Setze Zustand=4, Position inkrementieren, Vor
* WENN (Zustand=3 UND A=0 UND B=1) DANN: Setze Zustand=2, Position dekrementieren, Rück
* WENN (Zustand=4 UND A=0 UND B=0) DANN: Setze Zustand=1, Position inkrementieren, Vor
* WENN (Zustand=4 UND A=1 UND B=1) DANN: Setze Zustand=3, Position dekrementieren, Rück
[[Bild:Lochscheibe8.jpg|thumb|Lochscheibe 8 ]]
[[Bild:Lochscheibe10.jpg|thumb|Lochscheibe 10 ]]
[[Bild:Lochscheibe12.jpg|thumb|Lochscheibe 12 ]]
[[Bild:Lochscheibe15.jpg|thumb|Lochscheibe 15 ]]
[[Bild:Lochscheibe18.jpg|thumb|Lochscheibe 18 ]]
[[Bild:Lochscheibe20.jpg|thumb|Lochscheibe 20 ]]

Diese Prüfung muss ständig wiederholt werden, damit alle Pegelwechsel der beiden Lichtschranken erfasst werden. Nur so ist es möglich, die exakte Position zu verfolgen. Dafür bieten sich 2 Möglichkeiten: Entweder die Prüfung wird im Hauptprogramm ständig durchlaufen (Polling) oder ein Timer-Interrupt tastet regelmäßig die Lichtschranken ab. Hier soll nur die zweite, also Interruptvariante betrachtet werden, weil sie mehr Vorteile bringt. Weiter unten im Artikel ist dazu ein Beispiel in Sprache C zu finden.

Zuvor muss aber eine sinnvolle Auslegung von Lochscheibe, Drehzahl und Positionsbereich gefunden und in Einklang mit den Ressourcen des verwendeten µControlles gebracht werden. Dazu folgende Betrachtungen:

Wenn 2 phasenversetzte Lichtschranken je Hell-/ Dunkelzyklus bereits 4 Positionen liefern, benötigt die Lochscheibe nur halb so viel "Löcher" wie eine Lochscheibe bei Verwendung nur einer Lichtschranke. Eine 15er Lochscheibe liefert demzufolge 15x4 = 60 Positionen auf 360°, das sind 6° je erfasster Position. Entscheidend ist, an welchem Antriebsteil die Lochscheibe montiert ist und mit welcher Untersetzung zwischen Motor und Abtriebswelle(Rad) gearbeitet wird. Ist die Lochscheibe an der Motorwelle angebracht, würde bei einer angenommenen Untersetzung von 10:1 eine erfasste Position nur 0,6° an der Abtriebswelle ausmachen.

Man muss sich klar machen, welche '''Positioniergenauigkeit''' nötig ist. Dabei gilt: Auslegung so genau wie nötig, nicht wie möglich. Weiter muss geklärt werden, wo man die Lochscheibe sinnvoll anbringt. Sie darf im Betrieb weder verschmutzt oder beschädigt werden. Fahrmodelle ziehen Staub, Haare etc. gern an, gut beraten ist man mit einer '''verkapselten Optomechanik'''. Ein weiterer Faktor ist die '''Drehzahl''' (im Leerlauf am höchsten) des Motors, weil diese die Frequenz der abzutastenden Signale beeinflusst. Zwischen Drehzahl n [U/min], Frequenz f [Hz] und Teilung T besteht folgender Zusammenhang:

'''f = n * T / 60 s'''

Beispiel: Ein Motor dreht im Leerlauf mit 2370 U/min und hat eine Lochscheibe mit Teilung = 12 an der Motorwelle. Die Frequenz der abzutastenden Signale einer Lichtschranke soll ermittelt werden. (oben im Osszillogramm dargestellt)

'''f = 2370 * 12 / 60 s'''

'''f = 474 Hz'''

Eine Lichtschranke liefert also ein Rechtecksignal mit f = 474 Hz. Jetzt muss noch das Signal der zweiten Lichtschranke um 90° versetzt darübergelegt werden. Bei idealen Pegeln sind in einer Periode 4 Schaltzustände abzutasten, also muss die Abtastfrequenz mindestens 4-fach über der Grundfrequenz liegen. Da es in der Praxis aber keine idealen Pegel gibt, muss die Abtastfrequenz noch höher ausgelegt werden. Betrachten wir noch mal das Osszillogrammm weiter oben:

Es fällt auf, das die Zeiten nicht exakt gleich sind, die Zustandszeiten 1 und 3 sind etwas länger als 2 und 4. Das liegt an der Einstellung des Abstandes beider Lichtschranken zueinander, die Phasenlage ist hier nicht genau 90°. Außerdem sind Lochscheibe und Lichtschranken mit kleinen Unregelmäßikeiten, Streuungen, Anstiegs- und Abfallzeiten behaftet, so dass es in einer Periode auch Zeiten gibt, die nicht eindeutig einem der 4 genannten Zustände entsprechen. Für eine sichere Abtastung ist deshalb von der kürzesten (= ungünstigsten) Schaltzeit auszugehen, hier sind es ca. 0,4 Millisekunden, das entspricht 2,5 kHz. Jeder Zustand sollte vom µController sicherheitshalber schon 3 bis 4 mal abgetastet werden, so das wir für das Beispiel mindestens ca. 10 kHz Abtastfrequenz einplanen müssen. Als Orientierungshilfe gilt:

'''Abtastfrequenz >= 20 * Frequenz Lichtschranke'''

Entsprechend der gewünschten Positioniergenauigkeit und Drehzahl kann nun die Teilung der Lochscheibe so gewählt werden, das die Lichtschrankensignale vom µController abgetastet werden können. Da Kaufteile aus dem Industriebereich oft eine recht hohe Teilung vorgeben, ist es manchmal besser, mit kleineren Teilungen anzufangen. Rechts sind Vorlagen, die man sich auf Folien ausdrucken kann.(Nähere Beschreibung im Praxis-Teil)

Die Abtastung muss sicher sein, auch wenn das Hauptprogramm gerade mit anderen Dingen als der Lochscheibenauswertung beschäftigt ist. Man kann zwar die Lochscheibe vom Hauptprogramm durchaus mit abfragen lassen, aber dann sollten keine anderen zeitraubenden Prozeduren darin enthalten sein. Ist nur ein Zustandswechsel übersehen und ausgelassen wurden, geht es erst an der nachfolgenden gleichen Hell-/Dunkel-Kombination weiter und der Contoller verzählt sich um 4 Inkremente! Deshalb sollte die TimerInterrupt-Variante vorgezogen oder die Abtastung in einen separaten µController ausgelagert werden.

Der Positionsbereich muss schließlich auch in einer Variablen dargestellt werden. Im Beispiel mit Teilung =12 wird der Positionzähler bei einer Motorumdrehung um 48 Inkremente hochgezählt. Bei 2370 U/min wäre eine 16Bit-Variable nach ca. 34 Sekunden übergelaufen. Demzufolge ist auch das Speichervolumen der Positionsvariablen dem tatsächlichen Fahrbereich anzupassen. Man kann auch Ober-/ Untergrenzen definieren, die bei Erreichen den Antrieb anhalten. Somit wird ein mechanisches Überfahren von Endlagen oder ein logisches Überlaufen von Variablen verhindert.

'''Zusammenfassung:'''
{| {{Blauetabelle}}
|
# Welche Positionsgenauigkeit brauch ich?
# Sind Lochscheibe und Optik vor Störeinflüssen geschützt?
# Welche maximale Drehzahl muss noch sicher abgetastet werden?
# Frequenz Lichtschranke anpassen: Hohe Drehzahl mit kleiner Teilung / geringe Drehzahl mit großer Teilung
# Phasenlage richtig eingestellt? Optimal sind 90°
# Positionsvariable mit genügend Speichervolumen?
|}

== Kalibrierung ==

Im einfachsten Fall fährt man seinem Antrieb auf eine Referenzmarke (Nonius, Paßstift o.ä.) und setzt dort den Positionszähler zurück.

Wer es noch genauer will, muß auch noch die Lochscheibe in eine definierte Ausgangsstellung bringen. Dazu kann man die Lichtschrankensignale mit 2 LEDs optisch anzeigen. In der Kalibrierstellung müssen dann der Antrieb auf der Refernzmarke stehen und beide LEDs leuchten. Als Referenzmarke kann natürlich auch eine zusätzliche Lichtschranke dienen, die eine kleine Bohrung am Antrieb erkennt. Wichtig ist, dass die Referenzmarke nur einmal und eindeutig am Antrieb angebracht ist.

== Geschwindigkeit und Beschleunigung ==

Geschwindigkeit wird meist in [m/s], [km/h] oder [mph] ausgedrückt, also der Wegstrecke je Zeiteinheit. Im µController interessieren uns diese Einheiten erst mal nicht, hier werden Inkremente je Zeiteinheit gezählt. Die Zeitintervalle, in denen die Inkremente ausgewertet werden, liefert wieder ein TimerInterrupt. Dieser ist mit deutlich längeren Zyklen auszulegen, damit auch genügend Inkremente je Zyklus gezählt werden können. Im Code-Beispiel unten werden bei 16Mhz CPU-Takt die Vorteiler 1 und 1024 für die TimerInterrupt´s verwendet: Timer 0 mit Prescaler =1024 für die Geschwindigkeitsberechnung mit ca. 61 Hz und Timer 2 mit Prescaler =1 für die Abtastung der Lichtschranken mit 62,5 kHz. Die Geschwindigkeitsmessung wurde mit 12er, 15er und 18er Teilung getestet. In der ISR des Timer_0 Overflow wird die Differenz aus aktueller Position und der Position des vergangenen Zyklus gebildet. Da diese Wegdifferenz in definierten Zeitabständen ermittelt wird, hat man hier bereits die Geschwindigkeit in n Inkremente je 0,01638 Sekunden. Mit dieser etwas abstrakten Geschwindigkeitseinheit wird im Hauptprogramm der Motor gesteuert.

Das gleiche Verfahren ist auch für die Beschleunigung anwendbar. Die Beschleunigung ist die Geschwindigkeitsänderung je Zeiteinheit. In der ISR des Timer_0 Overflow kann die Differenz aus aktueller Geschwindigkeit und der Geschwindigkeit des vergangenen Zyklus gebildet werden, um so die Beschleunigung zu erhalten. Die Einheit ist wieder etwas ungewohnt: Inkremente je 0,01638 Sekunden in 0,01638 Sekunden, also Inkremente/Quadratsekunden. Voraussetzung für eine vernünftige Beschleunigungsermittlung ist, das eine genügend hohe Auflösung der Geschwindigkeit vorliegt(=hohe Teilung der Lochscheibe). Ansonsten sind die ermittelten Werte zu klein und liegen, je nach Trägheit des Motors, fast immer bei 0, 1, 2 oder maximal 3.

Vorteil der Differenzmethode ist, man kann die Geschwindigkeit in einer 8Bit-Variable mit Vorzeichen ausdrücken. Die Werte des Beispieles lagen je nach Teilung zwischen -50 und +50 und sind für die Motorsteuerung ausreichend. Bessere Auflösung erfordert höhere Teilung, höhere Abtastrate, höhere CPU-Frequenz.

== Praxis==

=== Herstellung der Lochscheibe ===
Für eigene Projekte ist es mitunter schwer, Lochscheiben in passender Größe und Teilung zu finden. Oft müssen dann Kompromisse in der Drehzahlsteuerung oder Positionierung gemacht werden, weil die vielleicht günstigere Teilung nicht zu beschaffen ist.

Hier wird deshalb ein Selbstbau von preiswerten Lochscheiben vorgestellt: Man trägt in einer Excel-Tabelle z.B. 18 mal die Zahl 20 ein und markiert diesen Zellbereich. Anschließend erstellt man mit dem Diagramm-Assistent ein Ring-Diagramm. Darin muss man nun jeden Datenpunkt einzeln formatieren und abwechslend die Farbe schwarz und weiß zuordnen. Markiert man die komplette Datenreihe, kann man unter 'Formatieren'>'Optionen' auch die Innenringgröße einstellen. Dieses Ring-Diagramm kann nun beliebig kopiert und vergößert oder verkleinert werden, auch die Datenreihe kann auf z.B. 24x15 oder 30x12 angepasst werden. So lassen sich auf einer A4-Seite einige Dutzend Lochscheiben in allen Größen und Teilungen herstellen. Das fertige Arbeitsblatt muss nun noch mit geeigneter Tinte auf Folie ausgedruckt werden. Den Drucker muss man möglichst auf satte Farbe und kräftgen Kontrast einstellen. Zum Schluß wird die ausgedruckte Folie mit A4- Laminierfolie verstärkt, wer kein Laminiergerät hat, geht in einen Copy-Shop o.ä.

Die so gewonnenen Lochscheiben werden nun ausgeschnitten und bei Bedarf mit einem Heißluftgerät noch etwas "nachgebacken", bevor sie im eigenen Projekt mit Kraftkleber auf ein kleines Rad aufgeklebt werden. Hierbei auf gute Zentrierung achten, damit die Lochscheibe möglichst rund läuft. Sekundenkleber ist deshalb ungeeignet, weil kaum Zeit für Korrektur und Einstellung bleibt.

=== Anpassen der Lichtschranke ===

Baustelle:

Fotos, Anregungen zum Nachbau, Beschaffung, Erfahrungen

weiterführende Informationen:
[http://de.wikipedia.org/wiki/Inkrementalgeber Inkrementalgeber]

=== Quellcode ===

<pre>

//Deklaration global
volatile uint8_t Zust_Li; //Zustandsmerker Position linker Motor
volatile uint16_t Li_Inkr; //aktuelle Position linker Motor
volatile uint16_t old_Li_Inkr; //Position im vorangegangenen Takt
volatile int8_t Speed_Li_Ist; //Wegänderung je Takt, in ISR Timer 0

...

// Interrupt-Service-Routine Timer_0 Overflow
SIGNAL (SIG_OVERFLOW0)
{
// ISR-Code 61,035 Pro Sekunde
Timeout++;
Speed_Li_Ist = Li_Inkr - old_Li_Inkr;
old_Li_Inkr = Li_Inkr;
}

// Interrupt-Service-Routine Timer_2 Overflow
SIGNAL (SIG_OVERFLOW2)
{
// ISR-Code 62.5 kHz
// 4 Zustaende durch jeweils 1 Bit repräsentiert (1,2,4,8)
// Lichtschranke A liegt an Port A.0
// Lichtschranke B liegt an Port A.1

if ( (Zust_Li == 1) && ( !(PINA & (1<<PINA0)) )&& ( PINA & (1<<PINA1) ) ){
Li_Inkr = Li_Inkr + 1;
Zust_Li = 2;
} /* end if */

if ( (Zust_Li == 1) && (PINA & (1<<PINA0) )&& ( !( PINA & (1<<PINA1)) ) ){
Li_Inkr = Li_Inkr - 1;
Zust_Li = 8;
} /* end if */

if ( (Zust_Li == 2) && (PINA & (1<<PINA0) )&& ( PINA & (1<<PINA1) ) ){
Li_Inkr = Li_Inkr + 1;
Zust_Li = 4;
} /* end if */

if ( (Zust_Li == 2) && ( !(PINA & (1<<PINA0)) )&& ( !( PINA & (1<<PINA1)) ) ){
Li_Inkr = Li_Inkr - 1;
Zust_Li = 1;
} /* end if */

if ( (Zust_Li == 4) && (PINA & (1<<PINA0) )&& ( !( PINA & (1<<PINA1)) ) ){
Li_Inkr = Li_Inkr + 1;
Zust_Li = 8;
} /* end if */

if ( (Zust_Li == 4) && ( !(PINA & (1<<PINA0)) )&& ( PINA & (1<<PINA1) ) ){
Li_Inkr = Li_Inkr - 1;
Zust_Li = 2;
} /* end if */

if ( (Zust_Li == 8) && ( !(PINA & (1<<PINA0)) )&& ( !( PINA & (1<<PINA1)) ) ){
Li_Inkr = Li_Inkr + 1;
Zust_Li = 1;
} /* end if */

if ( (Zust_Li == 8) && (PINA & (1<<PINA0) )&& ( PINA & (1<<PINA1) ) ){
Li_Inkr = Li_Inkr - 1;
Zust_Li = 4;
} /* end if */

}

...

int main (void)
{

//Init
TCCR2 |= (1<<CS20); //Prescaler = 1 (16MHz/1 = 16000000) ->
//16000000/256 -> 62500 Interrupts je Sekunde

TCCR0 |= (1<<CS02)|(1<<CS00); //Prescaler = 1024 (16000000 / 1024 = 15625) ->
//15625/256 = 61,035 -> 61 Interrupts je Sekunde

TIMSK |= (1<<TOIE0)|(1<<TOIE2); //Timer Overflow Interrupt Enablae für Timer 0 und 2

Li_Inkr = 32000;Zust_Li = 1; // Kalibrierstellung bei 32000
sei(); // Interrupts aktivieren

while(1)
{

// hier kann Position und Geschwindigkeit ausgewertet werden

}
}

</pre>

= Vor und Nachteile der Messmethoden=

Roboterwettbewerbe

2011-06-20T15:24:13Z

Chypsylon: /* Überblick */

Auf diese Seite werden die bekanntesten nationalen und internationalen Roboterwettbewerbe kurz vorgestellt.

==Überblick==
{| {{Blauetabelle}}
|''' Wettbewerb primär für'''||Schüler ||Studenten || Hobbyrobotiker ||1 Person || bis 5 Personen || mehr als 5 Personen || nächster Termin || Ort
|-
|[[#Robocup_Junior|Robocup Junior]] || X || (X) || || || X || || 5. bis 11.7.2011 , versch. Nationalbewerbe || WM in Istanbul, Nationale Bewerbe
|-
|[[#Eurobot|Eurobot]] || X || X || || || || X || 22. bis 27.06.2011 || Russland
|-
|[[#Carolo_Cup|Carolo Cup]] || || X || || || || X || 07. / 08.02.2011 || Braunschweig
|-
|[[#Field_Robot_Event|Field Robot Event]] || || X || || || || X || 30.6. - 02.07.2011 || Dänemark
|-
|[[#FIRST_Lego_League|FIRST LEGO Leaue]] || X || || || || || X || 4. - 30.11. in 52 Regionen(Zentraleuropa) ||
|-
|[[#RoboCup_Soccer|RoboCup Soccer]] || || X || X || || || X || 04. - 10.07.2011 || Istanbul
|-
|[[#RobotChallenge|RobotChallenge]] || || || X || X || || || 12. / 13.03.2011 || Wien
|-
|[[#SPURT|SPURT]] || X || || || || X || || 20.05.2011 || Rostock
|-
|[[#ELROB|European Land Robot Trial (ELROB)]] || || X || || || || X || 20. - 24.07.2011 || Leuven, Belgien
|-
|[[#ROBOCOM|ROBOCOM]] || X || || || || X || || 15.07.2011 || Gelsenkirchen
|-
|[[#RobotLiga|RobotLiga]] || || || X || X || || || keine nach 2007 bekannt ||
|-
|[[#RoboTest|RoboTest]] || || || X || X || || || keine nach 2008 bekannt ||
|-
|[[#RoboKing|RoboKing]] || X || || || || X || || keine nach 2008 bekannt ||
|-
|[[#GSF_Robot_Contest|GSF Robot Contest]] || || || X ||X || X || || keine nach 2007 bekannt ||
|}

= Aktuelle Wettbewerbe =

==Robocup Junior==
"RoboCupJunior ist eine international organisierte Bildungsinitiative. Sie soll jungen Menschen spielerisch den Umgang mit Robotern näher bringen, soll die Lust auf Naturwissenschaften und Technik wecken und einen spannenden Wissenserwerb im Unterricht ermöglichen. Wichtig bei RoboCupJunior ist die hands-on Komponente. Deshalb bauen und programmieren die Teilnehmerinnen und Teilnehmer kleine Roboter für spezielle Aufgaben und zeigen diese dann in Präsentationen und Wettbewerben.

Damit das Ganze nicht zu theoretisch behandelt wird, werden auch jedes Jahr nationale und internationale Bewerbe veranstaltet, wo sich die unterschiedlichen Teams messen, aber auch andere Schulen, Länder und Kulturen kennen lernen können.(Zitat robocupjunior.at)"

Unterteilt ist das ganze in drei Kategorien:
*Soccer
*Rescue
*Dance

sowie in in zwei Altersgruppen - 10-14 (Primary) sowie unter 19 Jahre (Secondary).

'''Weblinks''':
* Allgemein:
# [http://www.robocupjunior.org www.robocupjunior.org]
# [http://www.rcjrescue.com/ www.rcjrescue.com]
* Weltmeisterschaften:
# [http://www.robocup2009.org www.robocup2009.org]
# [http://www.robocup2010.org www.robocup2010.org]
# [http://www.robocup2011.org www.robocup2011.org]
* Nationale Seiten:
# [http://robocupjunior.at robocupjunior.at]
# [http://www.robocupgermanopen.de www.robocupgermanopen.de]
# [http://www.robocupjunior.it/ www.robocupjunior.it]
# [http://www.robocupjunior.org.au/ www.robocupjunior.org.au]

==Eurobot==
"Seit 1998 ist Eurobot ein internationaler Roboterwettbewerb für Teams von Jugendlichen, Studenten und sonstigen an Robotern interessierten Menschen.
Eurobot findet stets in Europa statt, ist aber für alle Länder aller Kontinente zugänglich. Im Jahre 2004 nahmen insgesamt 250 Teams aus 21 Länder an diesem technisch/wissenschaftlichen Wettbewerb teil." (zitiert von www.eurobot.org)
Aus jedem Land dürfen maximal drei Teams zu den internationalen Finalen fahren. Diese drei Mannschaften müssen sich in nationalen Vorausscheiden qualifizieren. Die Aufgabe wird jedes Jahr neu gestellt. Nur die Rahmenbedingungen bleiben gleich: Ein Match dauert nur 90 Sekunden, es ist also sowohl Schnelligkeit als auch eine intelligente Taktik und Sicherheit gefragt. Die Spielfläche ist etwa 2x3 Meter groß.
Eurobot findet seit 2005 jedes Jahr in einem anderen Land statt. Der Wettbewerb wird von einer großen Rahmenveranstaltung inklusive Vorträgen und vielen Attraktionen für die zahlreichen Zuschauer ergänzt.

'''Weblinks''':
* [http://www.eurobot.org www.eurobot.org]
* [http://www.eurobot-deutschland.de www.eurobot-deutschland.de]

==Carolo Cup==
Dieser Wettbewerb für Studenten findet an der TU Braunschweig statt.
Es treten autonome Modellfahrzeuge im Maßstab 1:10 gegeneinander an. Aufgaben sind das Fahren auf einem Rundkurs (dabei muss die Fahrbahnmarkierung z.B. mit Kameras erkannt werden) und das seitliche Einparken in einer vorgegebenen Parklücke. 

'''Weblinks''':
* [http://www.carolo-cup.de www.carolo-cup.de]

==Field Robot Event==
Dieser Wettbewerb für Studenten findet auf einem Maisfeld statt. Die Roboter müssen den Maisreihen folgen und "Unkraut" erkennen, wobei es mehrere Schwierigkeitsgrade gibt (z.B. können einzelne Pflanzen fehlen, oder es gibt größere Unebenheiten im Boden).
2011 wird der Wettbewerb in Dänemark ausgetragen.

'''Weblinks''':
* [http://www.fre2011.dk/ http://www.fre2011.dk/]

==FIRST Lego League==
Bei der FIRST LEGO League (FLL) handelt es sich um einen internationalen Wettbewerb der von der Firma LEGO und der amerikanischen Stiftung FIRST (For Inspiration and Recognition of Science and Technology) veranstalltet wird. Er findet jährlich auf der ganzen Welt mit regionalen Runden statt und steht jedes Jahr unter einem neuen Motto.

Der Wettbewerb beschäftigt sich immer mit aktuellen naturwissenschaftlichen Problemen, die gesellschaftlich relevant sind. Dabei sollen die Kinder nicht nur einen Roboter programmieren, der Aufgaben auf dem vorgegebenen Spielfeld erfüllt, sondern sich auch tiefgründig mit dem Wettbewerbsthema auseinandersetzen. Die Teilnehmer sollen einen Lösungsansatz für ein aktuelles Probleme erarbeiten, dass mit dem Wettbewerbsthema in Verbindung steht. 2010 heißt das Thema von FLL "Body Forward" und dabei dreht sich alles um Biomedizin.

Bei diesem Wettbewerb dürfen nur Roboter eingesetzt werden, die aus dem LEGO Mindstorms System bestehen. Der Wettbewerb richtet sich vornehmlich an junge Schüler, wie auch das gesamte Mindstorms System. Deshalb dürfen die Teilnehmer maximal 16 Jahre alt sein. Jedes Team wird von einem volljährigen Coach bei der Bewältigung der Aufgaben angeleitet.

Die Wettbewerbsaufgaben werden immer Anfang September veröffentlicht, danach hat jedes Team ca. 8 Wochen Zeit seinen Roboter zu programmieren und den Forschungsauftrag zu erfüllen, um die Ergebnisse dann bei einem der Regionalwettbewerbe zu präsentieren.

'''Weblinks''':
* [http://www.firstlegoleague.org/ www.firstlegoleague.org]
* [http://www.firstlegoleague.de/ www.firstlegoleague.de]

==RoboCup Soccer==
Die Komplexität und Beliebtheit von Fußball (soccer) spielten wesentliche Rollen bei der Motivation der ersten RoboCupspiele Mitte der 90er Jahre. Die Dynamik und die Komplexität von Fußball birgt enorme Herausforderungen für Wissenschaftler, die sich mit der Entwicklung von autonomen Robotern in diesem Bereich beschäftigen:

Individuelle Herausforderungen: jeder Agent/Roboter muss Objekte erkennen, sich selbst lokalisieren, navigieren und den Ball bewegen können. Zu klären sind Fragen wie: was ist in diesem Moment wichtig in meiner Wahrnehmung? Ist meine Position und die der anderen Mitspieler bekannt?
Kooperation von Agenten: in einer dynamischen Echtzeitumgebung kommt es nicht auf einen einzelnen Spieler an, sondern besonders auf das kooperative Spiel, bei dem auch die Kommunikation eine große Rolle spielt.

Dynamische Echtzeitumgebung mit sich bewegenden Objekten, von denen einige intelligente Agenten sind, die gegen einen spielen. Diese Art von Umgebung ist z.B. auch im Straßenverkehr zu beobachten, wobei die anderen Verkehrsteilnehmer zwar keine Gegner sind, die meine Pläne durchkreuzen wollen, wo aber die Situationen beliebig komplex werden können.
RoboCupSoccer besteht aus fünf Ligen: der Simulationsliga, der Small-Size Liga, der Middle-Size Liga, der Sony Legged Liga, und der Humanoidliga.

'''Weblinks:'''
* [http://www.robocup.org www.robocup.org]

==RobotChallenge==
Die RobotChallenge ist ein österreichischer Wettbewerb für selbstgebaute, autonome Roboter, dessen Ziel es ist für den kreativen Umgang mit innovativen Technologien zu begeistern. Experimente und praktische Erfahrungen lassen Teilnehmer und Zuschauer Wissenschaft hautnah erleben. Dieser Wettbewerb soll zeigen, wie man mit einfachen Mitteln, aber offenem Geiste und Phantasie spannende, zukunftstaugliche Lösungen finden kann.
Folgende Disiplienen wurden dort schon ausgetragen:

'''Parallel-Slalom''' 
Möglichst schnell muss einer schwarzen Linie auf weißem Untergrund entlang gefahren werden. Reglement im Wesentlichen wie bei RC'05.

'''Parallel-Slalom Enhanced''' 
Wie Parallel-Slalom, jedoch mit Erschwernissen: ein Tunnel, eine kurze Unterbrechung der Linie und ein Hindernis auf der Linie, das umfahren werden muss.

'''Robot-Sumo''' 
Je zwei Roboter treten gegeneinander an und versuchen den jeweils anderen von einer runden Platte zu schieben. Die Platte ist schwarz, der Rand ist durch einen weissen Streifen markiert. Die Regeln entsprechen der internationalen Norm für autonomes Roboter-Sumo.

'''Hindernislauf''' 
Ein Infrarot-Leuchtturm mit definiertem Signal am Ende des Parcours ist möglichst rasch zu erreichen. Auf dem Weg befindliche Hindernisse müssen umfahren werden. Jedes Team kann alternativ auch einen eigenen Leuchtturm als Orientierungshilfe mitbringen. Reglement im Wesentlichen wie bei RC'05, jedoch sind auch komplexere Hindernisse (z.B. Sackgassen) möglich.

'''Puck Collect''' 
Je zwei Roboter - von denen einem die Farbe rot, dem anderen blau zugeteilt wird - treten gegeneinander an. Auf dem Spielfeld sind kleine rote und blaue Scheiben (Pucks) verteilt. Ziel ist es, möglichst schnell alle Pucks der eigenen Farbe einzusammeln und zur eigenen, farblich gekennzeichneten Homebase zu bringen.

'''Weblinks:'''
* [http://www.robotchallenge.at/ RobotChallenge]

==SPURT==
Der Wettbewerb SPURT (die Abkürzung steht für "Schüler-Projekte um Roboter-Technik") wird jährlich von der Universität Rostock veranstaltet. SPURT richtet sich an technikinteressierte Schüler. Die zu lösende Aufgabe ist eine Linienverfolgung. Wer am schnellsten die herzförmige Linie abfährt, hat gewonnen.

'''Weblinks:'''
* [http://spurt.uni-rostock.de/ Wettbewerb SPURT]

==ELROB==
Die deutsche Bundeswehr läd Firmen und Privatpersonen ein, am European Land-Robot Trial teilzunehmen (findet 2010 zum fünften Mal statt). Die ELROB wird veranstaltet, um einen Überblick über den europäischen State-of-the-art auf dem Gebiet von UGVs (unmanned ground vehicles) mit Fokus auf kurzfristig realisierbare Robotersystemen zu liefern. Hinsichtlich der vorhandenen Fähigkeiten versuchen die Organisatoren, technische Lösungen zu fördern, die den Betrieb unbemannter Fahrzeuge (UGV) verbessern. Repräsentanten aus Militär, Grenzschutz, Spezialkräften, Polizei, Feuerwehr, und Zivilschutzagenturen aus vielen europäischen Ländern werden anwesend sein. Die ELROB wird von einer Ausstellung begleitet, welche eine breite Vielzahl an Robotikaspekten umfasst.

'''Weblinks:'''
* [http://www.elrob.org/ Homepage von ELROB]

==ROBOCOM==
Bei diesem Wettbewerb soll eine vorgegebene Aufgabe mit LEGO MINDSTORMS NXT Robotern autonom, d.h. ohne Eingriffe von außen bewältigt werden. Mit diesem Wettbewerb möchte die Fachhochschule Gelsenkirchen in den Schulen den Einsatz moderner Techniken fördern und Schülerinnen und Schüler für ein naturwissenschaftliches Studium interessieren.

'''Weblinks:'''
* http://www2.fh-gelsenkirchen.de/FH-Sites/FB1/index.php?id=791

= Derzeit nicht regelmäßig stattfindende Wettbewerbe =

==RobotLiga==
Die RobotLiga fand bis 2007 in Kaiserslautern statt, neuere Termine sind nicht bekannt. Teilnehmen konnten alle interessierten Roboterbastler.

'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2cm breit.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 75cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://www.robotliga.de/ RobotLiga]

==RoboTest==
'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2 bis 3cm breit. Es starten immer zwei Roboter gleichzeitig in einem Parallelslalom. Der Wettbewerb läuft in mehreren Runden nach dem KO-System.

'''BLOCKED LINE''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Auf der Strecke stehen Hindernisse, die umfahren werden müssen.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2 bis 5cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, innerhalb von drei Minuten möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MICRO LINE''' 
Linienfolgen für sehr kleine Roboter. Die maximale Größe liegt bei 8x8x8cm und 200g. Je kleiner und leichter der Roboter ist, desto mehr Bonuspunkte gibt es.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''JUST WALK''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 1m zurücklegen, wenden, und die Strecke zurück laufen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://WWW.ROBOTEST.DE/ RoboTest]

==GSF Robot Contest==
Ein neuer Wettbewerb für Hobbyrobotiker. Er findet am 19.5.07 erstmals statt. Austragungsort ist Fröndenberg (Raum Dortmund/Unna).
Die Aufgaben sind teilweise angelehnt an die der RobotLiga.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegenrische Hälfte zu befördern.

'''FIRE FIGHTING''' 
Naqch einem akustischen "Feueralarm" muss eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude gefunden und gelöscht werden.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinader an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 100cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FREESTYLE''' 
In dieser Disziplin hat jeder Teilnehmer die Möglichkeit seinen Roboter vorzustellen und zu zeigen was dieser kann.

'''Weblinks:'''
* http://www.gsf-robot-contest.de/

==RoboKing==
RoboKing ist ein Wettbewerb für technikinteressierte Schüler, der jährlich von der TU Chemnitz organisiert wird. Jedes Team besteht aus 3 bis 5 Schülern und einem erwachsenem Teamleiter. RoboKing richtet sich ausdrücklich auch an Schülergruppen ohne große Vorkenntnisse. Ziel der Initiative ist, Schüler für ein Studium ingenieurwissenschaftlicher Fächer zu begeistern und zu zeigen, dass auch Schulfächer wie Physik und Informatik eine Menge Spaß machen können. Das Durchschnittsalter der Teilnehmer liegt bei etwa 16 Jahren. Die jüngsten Teilnehmer waren 10 Jahre alt.

Besonderes Highlight des Wettberwebs RoboKing ist zweifellos eine Gutschrift, von denen die Teilnehmer alle Materialien die zum Bau des Roboters benötigt werden, bezahlen können. Dadurch unterscheidet sich dieser Wettbewerb von allen vergleichbaren, denn auf die teilnehmenden Schüler kommen keine Kosten für Material zu. Jedes Jahr werden 25 Teams mit dieser Gutschrift finanziell unterstützt. Ab dem Wettbewerb RoboKing 2007 (startet im Frühjahr 2006) können zusätzlich auch alle Teams teilnehmen, die sich selbst finanzieren.

Die Endrunde des Wettbewerbs wurde 2004 und auf der Hannover Messe ausgetragen. 2006 fand das Finale auf der digital living / CeBIT statt.
Eine weitere Besonderheit des Wettbewerbs: Jedes Jahr müssen die Teilnehmer eine andere Aufgabenstellung lösen. Bei den vergangenen Wettbewerben mussten die Roboter sicher durch ein großes Labyrinth navigieren, Tennisbälle einsammeln und in die eigene Basis bringen oder Bauklötzchen durch einen Hindernisparcours mit Graben, Brücke und Schlucht transportieren. Die Teilnehmer haben nach Bekanntgabe der Spielregeln etwa 8 Monate Zeit, die Aufgabe zu lösen.

RoboKing finanziert sich ausschließlich über Spenden von zahlreichen Sponsoren. Verantwortlich für die Organisation sind die Mitarbeiter und Studenten der Professur Prozessautomatisierung der TU Chemnitz.

'''Weblinks:'''
* [http://www.roboking.de www.roboking.de]

[[Kategorie:Praxis]]

Roboterwettbewerbe

2011-06-20T15:24:01Z

Chypsylon: /* Überblick */

Auf diese Seite werden die bekanntesten nationalen und internationalen Roboterwettbewerbe kurz vorgestellt.

==Überblick==
{| {{Blauetabelle}}
|''' Wettbewerb primär für'''||Schüler ||Studenten || Hobbyrobotiker ||1 Person || bis 5 Personen || mehr als 5 Personen || nächster Termin || Ort
|-
|[[#Robocup_Junior|Robocup Junior]] || X || (X) || || || X || || 5. bis 11.7.2011 , versch. Nationalbewerbe || WM in Istanbul, Nationale Bewerbe
|-
|[[#Eurobot|Eurobot]] || X || X || || || || X || 22. bis 27.06.2011 || Russland
|-
|[[#Carolo_Cup|Carolo Cup]] || || X || || || || X || 07. / 08.02.2011 || Braunschweig
|-
|[[#Field_Robot_Event|Field Robot Event]] || || X || || || || X || 30.6. - 02.07.2011 || Dänemark
|-
|[[#FIRST_Lego_League|FIRST LEGO Leaue]] || X || || || || || X || 4. - 30.11. in 52 Regionen(Zentraleuropa) ||
|-
|[[#RoboCup_Soccer|RoboCup Soccer]] || || X || (X) || || || X || 04. - 10.07.2011 || Istanbul
|-
|[[#RobotChallenge|RobotChallenge]] || || || X || X || || || 12. / 13.03.2011 || Wien
|-
|[[#SPURT|SPURT]] || X || || || || X || || 20.05.2011 || Rostock
|-
|[[#ELROB|European Land Robot Trial (ELROB)]] || || X || || || || X || 20. - 24.07.2011 || Leuven, Belgien
|-
|[[#ROBOCOM|ROBOCOM]] || X || || || || X || || 15.07.2011 || Gelsenkirchen
|-
|[[#RobotLiga|RobotLiga]] || || || X || X || || || keine nach 2007 bekannt ||
|-
|[[#RoboTest|RoboTest]] || || || X || X || || || keine nach 2008 bekannt ||
|-
|[[#RoboKing|RoboKing]] || X || || || || X || || keine nach 2008 bekannt ||
|-
|[[#GSF_Robot_Contest|GSF Robot Contest]] || || || X ||X || X || || keine nach 2007 bekannt ||
|}

= Aktuelle Wettbewerbe =

==Robocup Junior==
"RoboCupJunior ist eine international organisierte Bildungsinitiative. Sie soll jungen Menschen spielerisch den Umgang mit Robotern näher bringen, soll die Lust auf Naturwissenschaften und Technik wecken und einen spannenden Wissenserwerb im Unterricht ermöglichen. Wichtig bei RoboCupJunior ist die hands-on Komponente. Deshalb bauen und programmieren die Teilnehmerinnen und Teilnehmer kleine Roboter für spezielle Aufgaben und zeigen diese dann in Präsentationen und Wettbewerben.

Damit das Ganze nicht zu theoretisch behandelt wird, werden auch jedes Jahr nationale und internationale Bewerbe veranstaltet, wo sich die unterschiedlichen Teams messen, aber auch andere Schulen, Länder und Kulturen kennen lernen können.(Zitat robocupjunior.at)"

Unterteilt ist das ganze in drei Kategorien:
*Soccer
*Rescue
*Dance

sowie in in zwei Altersgruppen - 10-14 (Primary) sowie unter 19 Jahre (Secondary).

'''Weblinks''':
* Allgemein:
# [http://www.robocupjunior.org www.robocupjunior.org]
# [http://www.rcjrescue.com/ www.rcjrescue.com]
* Weltmeisterschaften:
# [http://www.robocup2009.org www.robocup2009.org]
# [http://www.robocup2010.org www.robocup2010.org]
# [http://www.robocup2011.org www.robocup2011.org]
* Nationale Seiten:
# [http://robocupjunior.at robocupjunior.at]
# [http://www.robocupgermanopen.de www.robocupgermanopen.de]
# [http://www.robocupjunior.it/ www.robocupjunior.it]
# [http://www.robocupjunior.org.au/ www.robocupjunior.org.au]

==Eurobot==
"Seit 1998 ist Eurobot ein internationaler Roboterwettbewerb für Teams von Jugendlichen, Studenten und sonstigen an Robotern interessierten Menschen.
Eurobot findet stets in Europa statt, ist aber für alle Länder aller Kontinente zugänglich. Im Jahre 2004 nahmen insgesamt 250 Teams aus 21 Länder an diesem technisch/wissenschaftlichen Wettbewerb teil." (zitiert von www.eurobot.org)
Aus jedem Land dürfen maximal drei Teams zu den internationalen Finalen fahren. Diese drei Mannschaften müssen sich in nationalen Vorausscheiden qualifizieren. Die Aufgabe wird jedes Jahr neu gestellt. Nur die Rahmenbedingungen bleiben gleich: Ein Match dauert nur 90 Sekunden, es ist also sowohl Schnelligkeit als auch eine intelligente Taktik und Sicherheit gefragt. Die Spielfläche ist etwa 2x3 Meter groß.
Eurobot findet seit 2005 jedes Jahr in einem anderen Land statt. Der Wettbewerb wird von einer großen Rahmenveranstaltung inklusive Vorträgen und vielen Attraktionen für die zahlreichen Zuschauer ergänzt.

'''Weblinks''':
* [http://www.eurobot.org www.eurobot.org]
* [http://www.eurobot-deutschland.de www.eurobot-deutschland.de]

==Carolo Cup==
Dieser Wettbewerb für Studenten findet an der TU Braunschweig statt.
Es treten autonome Modellfahrzeuge im Maßstab 1:10 gegeneinander an. Aufgaben sind das Fahren auf einem Rundkurs (dabei muss die Fahrbahnmarkierung z.B. mit Kameras erkannt werden) und das seitliche Einparken in einer vorgegebenen Parklücke. 

'''Weblinks''':
* [http://www.carolo-cup.de www.carolo-cup.de]

==Field Robot Event==
Dieser Wettbewerb für Studenten findet auf einem Maisfeld statt. Die Roboter müssen den Maisreihen folgen und "Unkraut" erkennen, wobei es mehrere Schwierigkeitsgrade gibt (z.B. können einzelne Pflanzen fehlen, oder es gibt größere Unebenheiten im Boden).
2011 wird der Wettbewerb in Dänemark ausgetragen.

'''Weblinks''':
* [http://www.fre2011.dk/ http://www.fre2011.dk/]

==FIRST Lego League==
Bei der FIRST LEGO League (FLL) handelt es sich um einen internationalen Wettbewerb der von der Firma LEGO und der amerikanischen Stiftung FIRST (For Inspiration and Recognition of Science and Technology) veranstalltet wird. Er findet jährlich auf der ganzen Welt mit regionalen Runden statt und steht jedes Jahr unter einem neuen Motto.

Der Wettbewerb beschäftigt sich immer mit aktuellen naturwissenschaftlichen Problemen, die gesellschaftlich relevant sind. Dabei sollen die Kinder nicht nur einen Roboter programmieren, der Aufgaben auf dem vorgegebenen Spielfeld erfüllt, sondern sich auch tiefgründig mit dem Wettbewerbsthema auseinandersetzen. Die Teilnehmer sollen einen Lösungsansatz für ein aktuelles Probleme erarbeiten, dass mit dem Wettbewerbsthema in Verbindung steht. 2010 heißt das Thema von FLL "Body Forward" und dabei dreht sich alles um Biomedizin.

Bei diesem Wettbewerb dürfen nur Roboter eingesetzt werden, die aus dem LEGO Mindstorms System bestehen. Der Wettbewerb richtet sich vornehmlich an junge Schüler, wie auch das gesamte Mindstorms System. Deshalb dürfen die Teilnehmer maximal 16 Jahre alt sein. Jedes Team wird von einem volljährigen Coach bei der Bewältigung der Aufgaben angeleitet.

Die Wettbewerbsaufgaben werden immer Anfang September veröffentlicht, danach hat jedes Team ca. 8 Wochen Zeit seinen Roboter zu programmieren und den Forschungsauftrag zu erfüllen, um die Ergebnisse dann bei einem der Regionalwettbewerbe zu präsentieren.

'''Weblinks''':
* [http://www.firstlegoleague.org/ www.firstlegoleague.org]
* [http://www.firstlegoleague.de/ www.firstlegoleague.de]

==RoboCup Soccer==
Die Komplexität und Beliebtheit von Fußball (soccer) spielten wesentliche Rollen bei der Motivation der ersten RoboCupspiele Mitte der 90er Jahre. Die Dynamik und die Komplexität von Fußball birgt enorme Herausforderungen für Wissenschaftler, die sich mit der Entwicklung von autonomen Robotern in diesem Bereich beschäftigen:

Individuelle Herausforderungen: jeder Agent/Roboter muss Objekte erkennen, sich selbst lokalisieren, navigieren und den Ball bewegen können. Zu klären sind Fragen wie: was ist in diesem Moment wichtig in meiner Wahrnehmung? Ist meine Position und die der anderen Mitspieler bekannt?
Kooperation von Agenten: in einer dynamischen Echtzeitumgebung kommt es nicht auf einen einzelnen Spieler an, sondern besonders auf das kooperative Spiel, bei dem auch die Kommunikation eine große Rolle spielt.

Dynamische Echtzeitumgebung mit sich bewegenden Objekten, von denen einige intelligente Agenten sind, die gegen einen spielen. Diese Art von Umgebung ist z.B. auch im Straßenverkehr zu beobachten, wobei die anderen Verkehrsteilnehmer zwar keine Gegner sind, die meine Pläne durchkreuzen wollen, wo aber die Situationen beliebig komplex werden können.
RoboCupSoccer besteht aus fünf Ligen: der Simulationsliga, der Small-Size Liga, der Middle-Size Liga, der Sony Legged Liga, und der Humanoidliga.

'''Weblinks:'''
* [http://www.robocup.org www.robocup.org]

==RobotChallenge==
Die RobotChallenge ist ein österreichischer Wettbewerb für selbstgebaute, autonome Roboter, dessen Ziel es ist für den kreativen Umgang mit innovativen Technologien zu begeistern. Experimente und praktische Erfahrungen lassen Teilnehmer und Zuschauer Wissenschaft hautnah erleben. Dieser Wettbewerb soll zeigen, wie man mit einfachen Mitteln, aber offenem Geiste und Phantasie spannende, zukunftstaugliche Lösungen finden kann.
Folgende Disiplienen wurden dort schon ausgetragen:

'''Parallel-Slalom''' 
Möglichst schnell muss einer schwarzen Linie auf weißem Untergrund entlang gefahren werden. Reglement im Wesentlichen wie bei RC'05.

'''Parallel-Slalom Enhanced''' 
Wie Parallel-Slalom, jedoch mit Erschwernissen: ein Tunnel, eine kurze Unterbrechung der Linie und ein Hindernis auf der Linie, das umfahren werden muss.

'''Robot-Sumo''' 
Je zwei Roboter treten gegeneinander an und versuchen den jeweils anderen von einer runden Platte zu schieben. Die Platte ist schwarz, der Rand ist durch einen weissen Streifen markiert. Die Regeln entsprechen der internationalen Norm für autonomes Roboter-Sumo.

'''Hindernislauf''' 
Ein Infrarot-Leuchtturm mit definiertem Signal am Ende des Parcours ist möglichst rasch zu erreichen. Auf dem Weg befindliche Hindernisse müssen umfahren werden. Jedes Team kann alternativ auch einen eigenen Leuchtturm als Orientierungshilfe mitbringen. Reglement im Wesentlichen wie bei RC'05, jedoch sind auch komplexere Hindernisse (z.B. Sackgassen) möglich.

'''Puck Collect''' 
Je zwei Roboter - von denen einem die Farbe rot, dem anderen blau zugeteilt wird - treten gegeneinander an. Auf dem Spielfeld sind kleine rote und blaue Scheiben (Pucks) verteilt. Ziel ist es, möglichst schnell alle Pucks der eigenen Farbe einzusammeln und zur eigenen, farblich gekennzeichneten Homebase zu bringen.

'''Weblinks:'''
* [http://www.robotchallenge.at/ RobotChallenge]

==SPURT==
Der Wettbewerb SPURT (die Abkürzung steht für "Schüler-Projekte um Roboter-Technik") wird jährlich von der Universität Rostock veranstaltet. SPURT richtet sich an technikinteressierte Schüler. Die zu lösende Aufgabe ist eine Linienverfolgung. Wer am schnellsten die herzförmige Linie abfährt, hat gewonnen.

'''Weblinks:'''
* [http://spurt.uni-rostock.de/ Wettbewerb SPURT]

==ELROB==
Die deutsche Bundeswehr läd Firmen und Privatpersonen ein, am European Land-Robot Trial teilzunehmen (findet 2010 zum fünften Mal statt). Die ELROB wird veranstaltet, um einen Überblick über den europäischen State-of-the-art auf dem Gebiet von UGVs (unmanned ground vehicles) mit Fokus auf kurzfristig realisierbare Robotersystemen zu liefern. Hinsichtlich der vorhandenen Fähigkeiten versuchen die Organisatoren, technische Lösungen zu fördern, die den Betrieb unbemannter Fahrzeuge (UGV) verbessern. Repräsentanten aus Militär, Grenzschutz, Spezialkräften, Polizei, Feuerwehr, und Zivilschutzagenturen aus vielen europäischen Ländern werden anwesend sein. Die ELROB wird von einer Ausstellung begleitet, welche eine breite Vielzahl an Robotikaspekten umfasst.

'''Weblinks:'''
* [http://www.elrob.org/ Homepage von ELROB]

==ROBOCOM==
Bei diesem Wettbewerb soll eine vorgegebene Aufgabe mit LEGO MINDSTORMS NXT Robotern autonom, d.h. ohne Eingriffe von außen bewältigt werden. Mit diesem Wettbewerb möchte die Fachhochschule Gelsenkirchen in den Schulen den Einsatz moderner Techniken fördern und Schülerinnen und Schüler für ein naturwissenschaftliches Studium interessieren.

'''Weblinks:'''
* http://www2.fh-gelsenkirchen.de/FH-Sites/FB1/index.php?id=791

= Derzeit nicht regelmäßig stattfindende Wettbewerbe =

==RobotLiga==
Die RobotLiga fand bis 2007 in Kaiserslautern statt, neuere Termine sind nicht bekannt. Teilnehmen konnten alle interessierten Roboterbastler.

'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2cm breit.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 75cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://www.robotliga.de/ RobotLiga]

==RoboTest==
'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2 bis 3cm breit. Es starten immer zwei Roboter gleichzeitig in einem Parallelslalom. Der Wettbewerb läuft in mehreren Runden nach dem KO-System.

'''BLOCKED LINE''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Auf der Strecke stehen Hindernisse, die umfahren werden müssen.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2 bis 5cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, innerhalb von drei Minuten möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MICRO LINE''' 
Linienfolgen für sehr kleine Roboter. Die maximale Größe liegt bei 8x8x8cm und 200g. Je kleiner und leichter der Roboter ist, desto mehr Bonuspunkte gibt es.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''JUST WALK''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 1m zurücklegen, wenden, und die Strecke zurück laufen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://WWW.ROBOTEST.DE/ RoboTest]

==GSF Robot Contest==
Ein neuer Wettbewerb für Hobbyrobotiker. Er findet am 19.5.07 erstmals statt. Austragungsort ist Fröndenberg (Raum Dortmund/Unna).
Die Aufgaben sind teilweise angelehnt an die der RobotLiga.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegenrische Hälfte zu befördern.

'''FIRE FIGHTING''' 
Naqch einem akustischen "Feueralarm" muss eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude gefunden und gelöscht werden.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinader an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 100cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FREESTYLE''' 
In dieser Disziplin hat jeder Teilnehmer die Möglichkeit seinen Roboter vorzustellen und zu zeigen was dieser kann.

'''Weblinks:'''
* http://www.gsf-robot-contest.de/

==RoboKing==
RoboKing ist ein Wettbewerb für technikinteressierte Schüler, der jährlich von der TU Chemnitz organisiert wird. Jedes Team besteht aus 3 bis 5 Schülern und einem erwachsenem Teamleiter. RoboKing richtet sich ausdrücklich auch an Schülergruppen ohne große Vorkenntnisse. Ziel der Initiative ist, Schüler für ein Studium ingenieurwissenschaftlicher Fächer zu begeistern und zu zeigen, dass auch Schulfächer wie Physik und Informatik eine Menge Spaß machen können. Das Durchschnittsalter der Teilnehmer liegt bei etwa 16 Jahren. Die jüngsten Teilnehmer waren 10 Jahre alt.

Besonderes Highlight des Wettberwebs RoboKing ist zweifellos eine Gutschrift, von denen die Teilnehmer alle Materialien die zum Bau des Roboters benötigt werden, bezahlen können. Dadurch unterscheidet sich dieser Wettbewerb von allen vergleichbaren, denn auf die teilnehmenden Schüler kommen keine Kosten für Material zu. Jedes Jahr werden 25 Teams mit dieser Gutschrift finanziell unterstützt. Ab dem Wettbewerb RoboKing 2007 (startet im Frühjahr 2006) können zusätzlich auch alle Teams teilnehmen, die sich selbst finanzieren.

Die Endrunde des Wettbewerbs wurde 2004 und auf der Hannover Messe ausgetragen. 2006 fand das Finale auf der digital living / CeBIT statt.
Eine weitere Besonderheit des Wettbewerbs: Jedes Jahr müssen die Teilnehmer eine andere Aufgabenstellung lösen. Bei den vergangenen Wettbewerben mussten die Roboter sicher durch ein großes Labyrinth navigieren, Tennisbälle einsammeln und in die eigene Basis bringen oder Bauklötzchen durch einen Hindernisparcours mit Graben, Brücke und Schlucht transportieren. Die Teilnehmer haben nach Bekanntgabe der Spielregeln etwa 8 Monate Zeit, die Aufgabe zu lösen.

RoboKing finanziert sich ausschließlich über Spenden von zahlreichen Sponsoren. Verantwortlich für die Organisation sind die Mitarbeiter und Studenten der Professur Prozessautomatisierung der TU Chemnitz.

'''Weblinks:'''
* [http://www.roboking.de www.roboking.de]

[[Kategorie:Praxis]]

Roboterwettbewerbe

2011-06-20T15:21:50Z

Chypsylon: /* Aktuelle Wettbewerbe */

Auf diese Seite werden die bekanntesten nationalen und internationalen Roboterwettbewerbe kurz vorgestellt.

==Überblick==
{| {{Blauetabelle}}
|''' Wettbewerb primär für'''||Schüler ||Studenten || Hobbyrobotiker ||1 Person || bis 5 Personen || mehr als 5 Personen || nächster Termin || Ort
|-
|[[#Robocup_Junior|Robocup Junior]] || X || (X) || || || X || || 5. bis 11.7.2011 , versch. Nationalbewerbe || WM in Istanbul, Nationale Bewerbe
|-
|[[#Eurobot|Eurobot]] || X || X || || || || X || 22. bis 27.06.2011 || Russland
|-
|[[#Carolo_Cup|Carolo Cup]] || || X || || || || X || 07. / 08.02.2011 || Braunschweig
|-
|[[#Field_Robot_Event|Field Robot Event]] || || X || || || || X || 30.6. - 02.07.2011 || Dänemark
|-
|[[#FIRST_Lego_League|FIRST LEGO Leaue]] || X || || || || || X || 4. - 30.11. in 52 Regionen(Zentraleuropa) ||
|-
|[[#RoboCup_Soccer|RoboCup Soccer]] || || X || || || || X || 04. - 10.07.2011 || Istanbul
|-
|[[#RobotChallenge|RobotChallenge]] || || || X || X || || || 12. / 13.03.2011 || Wien
|-
|[[#SPURT|SPURT]] || X || || || || X || || 20.05.2011 || Rostock
|-
|[[#ELROB|European Land Robot Trial (ELROB)]] || || X || || || || X || 20. - 24.07.2011 || Leuven, Belgien
|-
|[[#ROBOCOM|ROBOCOM]] || X || || || || X || || 15.07.2011 || Gelsenkirchen
|-
|[[#RobotLiga|RobotLiga]] || || || X || X || || || keine nach 2007 bekannt ||
|-
|[[#RoboTest|RoboTest]] || || || X || X || || || keine nach 2008 bekannt ||
|-
|[[#RoboKing|RoboKing]] || X || || || || X || || keine nach 2008 bekannt ||
|-
|[[#GSF_Robot_Contest|GSF Robot Contest]] || || || X ||X || X || || keine nach 2007 bekannt ||
|}

= Aktuelle Wettbewerbe =

==Robocup Junior==
"RoboCupJunior ist eine international organisierte Bildungsinitiative. Sie soll jungen Menschen spielerisch den Umgang mit Robotern näher bringen, soll die Lust auf Naturwissenschaften und Technik wecken und einen spannenden Wissenserwerb im Unterricht ermöglichen. Wichtig bei RoboCupJunior ist die hands-on Komponente. Deshalb bauen und programmieren die Teilnehmerinnen und Teilnehmer kleine Roboter für spezielle Aufgaben und zeigen diese dann in Präsentationen und Wettbewerben.

Damit das Ganze nicht zu theoretisch behandelt wird, werden auch jedes Jahr nationale und internationale Bewerbe veranstaltet, wo sich die unterschiedlichen Teams messen, aber auch andere Schulen, Länder und Kulturen kennen lernen können.(Zitat robocupjunior.at)"

Unterteilt ist das ganze in drei Kategorien:
*Soccer
*Rescue
*Dance

sowie in in zwei Altersgruppen - 10-14 (Primary) sowie unter 19 Jahre (Secondary).

'''Weblinks''':
* Allgemein:
# [http://www.robocupjunior.org www.robocupjunior.org]
# [http://www.rcjrescue.com/ www.rcjrescue.com]
* Weltmeisterschaften:
# [http://www.robocup2009.org www.robocup2009.org]
# [http://www.robocup2010.org www.robocup2010.org]
# [http://www.robocup2011.org www.robocup2011.org]
* Nationale Seiten:
# [http://robocupjunior.at robocupjunior.at]
# [http://www.robocupgermanopen.de www.robocupgermanopen.de]
# [http://www.robocupjunior.it/ www.robocupjunior.it]
# [http://www.robocupjunior.org.au/ www.robocupjunior.org.au]

==Eurobot==
"Seit 1998 ist Eurobot ein internationaler Roboterwettbewerb für Teams von Jugendlichen, Studenten und sonstigen an Robotern interessierten Menschen.
Eurobot findet stets in Europa statt, ist aber für alle Länder aller Kontinente zugänglich. Im Jahre 2004 nahmen insgesamt 250 Teams aus 21 Länder an diesem technisch/wissenschaftlichen Wettbewerb teil." (zitiert von www.eurobot.org)
Aus jedem Land dürfen maximal drei Teams zu den internationalen Finalen fahren. Diese drei Mannschaften müssen sich in nationalen Vorausscheiden qualifizieren. Die Aufgabe wird jedes Jahr neu gestellt. Nur die Rahmenbedingungen bleiben gleich: Ein Match dauert nur 90 Sekunden, es ist also sowohl Schnelligkeit als auch eine intelligente Taktik und Sicherheit gefragt. Die Spielfläche ist etwa 2x3 Meter groß.
Eurobot findet seit 2005 jedes Jahr in einem anderen Land statt. Der Wettbewerb wird von einer großen Rahmenveranstaltung inklusive Vorträgen und vielen Attraktionen für die zahlreichen Zuschauer ergänzt.

'''Weblinks''':
* [http://www.eurobot.org www.eurobot.org]
* [http://www.eurobot-deutschland.de www.eurobot-deutschland.de]

==Carolo Cup==
Dieser Wettbewerb für Studenten findet an der TU Braunschweig statt.
Es treten autonome Modellfahrzeuge im Maßstab 1:10 gegeneinander an. Aufgaben sind das Fahren auf einem Rundkurs (dabei muss die Fahrbahnmarkierung z.B. mit Kameras erkannt werden) und das seitliche Einparken in einer vorgegebenen Parklücke. 

'''Weblinks''':
* [http://www.carolo-cup.de www.carolo-cup.de]

==Field Robot Event==
Dieser Wettbewerb für Studenten findet auf einem Maisfeld statt. Die Roboter müssen den Maisreihen folgen und "Unkraut" erkennen, wobei es mehrere Schwierigkeitsgrade gibt (z.B. können einzelne Pflanzen fehlen, oder es gibt größere Unebenheiten im Boden).
2011 wird der Wettbewerb in Dänemark ausgetragen.

'''Weblinks''':
* [http://www.fre2011.dk/ http://www.fre2011.dk/]

==FIRST Lego League==
Bei der FIRST LEGO League (FLL) handelt es sich um einen internationalen Wettbewerb der von der Firma LEGO und der amerikanischen Stiftung FIRST (For Inspiration and Recognition of Science and Technology) veranstalltet wird. Er findet jährlich auf der ganzen Welt mit regionalen Runden statt und steht jedes Jahr unter einem neuen Motto.

Der Wettbewerb beschäftigt sich immer mit aktuellen naturwissenschaftlichen Problemen, die gesellschaftlich relevant sind. Dabei sollen die Kinder nicht nur einen Roboter programmieren, der Aufgaben auf dem vorgegebenen Spielfeld erfüllt, sondern sich auch tiefgründig mit dem Wettbewerbsthema auseinandersetzen. Die Teilnehmer sollen einen Lösungsansatz für ein aktuelles Probleme erarbeiten, dass mit dem Wettbewerbsthema in Verbindung steht. 2010 heißt das Thema von FLL "Body Forward" und dabei dreht sich alles um Biomedizin.

Bei diesem Wettbewerb dürfen nur Roboter eingesetzt werden, die aus dem LEGO Mindstorms System bestehen. Der Wettbewerb richtet sich vornehmlich an junge Schüler, wie auch das gesamte Mindstorms System. Deshalb dürfen die Teilnehmer maximal 16 Jahre alt sein. Jedes Team wird von einem volljährigen Coach bei der Bewältigung der Aufgaben angeleitet.

Die Wettbewerbsaufgaben werden immer Anfang September veröffentlicht, danach hat jedes Team ca. 8 Wochen Zeit seinen Roboter zu programmieren und den Forschungsauftrag zu erfüllen, um die Ergebnisse dann bei einem der Regionalwettbewerbe zu präsentieren.

'''Weblinks''':
* [http://www.firstlegoleague.org/ www.firstlegoleague.org]
* [http://www.firstlegoleague.de/ www.firstlegoleague.de]

==RoboCup Soccer==
Die Komplexität und Beliebtheit von Fußball (soccer) spielten wesentliche Rollen bei der Motivation der ersten RoboCupspiele Mitte der 90er Jahre. Die Dynamik und die Komplexität von Fußball birgt enorme Herausforderungen für Wissenschaftler, die sich mit der Entwicklung von autonomen Robotern in diesem Bereich beschäftigen:

Individuelle Herausforderungen: jeder Agent/Roboter muss Objekte erkennen, sich selbst lokalisieren, navigieren und den Ball bewegen können. Zu klären sind Fragen wie: was ist in diesem Moment wichtig in meiner Wahrnehmung? Ist meine Position und die der anderen Mitspieler bekannt?
Kooperation von Agenten: in einer dynamischen Echtzeitumgebung kommt es nicht auf einen einzelnen Spieler an, sondern besonders auf das kooperative Spiel, bei dem auch die Kommunikation eine große Rolle spielt.

Dynamische Echtzeitumgebung mit sich bewegenden Objekten, von denen einige intelligente Agenten sind, die gegen einen spielen. Diese Art von Umgebung ist z.B. auch im Straßenverkehr zu beobachten, wobei die anderen Verkehrsteilnehmer zwar keine Gegner sind, die meine Pläne durchkreuzen wollen, wo aber die Situationen beliebig komplex werden können.
RoboCupSoccer besteht aus fünf Ligen: der Simulationsliga, der Small-Size Liga, der Middle-Size Liga, der Sony Legged Liga, und der Humanoidliga.

'''Weblinks:'''
* [http://www.robocup.org www.robocup.org]

==RobotChallenge==
Die RobotChallenge ist ein österreichischer Wettbewerb für selbstgebaute, autonome Roboter, dessen Ziel es ist für den kreativen Umgang mit innovativen Technologien zu begeistern. Experimente und praktische Erfahrungen lassen Teilnehmer und Zuschauer Wissenschaft hautnah erleben. Dieser Wettbewerb soll zeigen, wie man mit einfachen Mitteln, aber offenem Geiste und Phantasie spannende, zukunftstaugliche Lösungen finden kann.
Folgende Disiplienen wurden dort schon ausgetragen:

'''Parallel-Slalom''' 
Möglichst schnell muss einer schwarzen Linie auf weißem Untergrund entlang gefahren werden. Reglement im Wesentlichen wie bei RC'05.

'''Parallel-Slalom Enhanced''' 
Wie Parallel-Slalom, jedoch mit Erschwernissen: ein Tunnel, eine kurze Unterbrechung der Linie und ein Hindernis auf der Linie, das umfahren werden muss.

'''Robot-Sumo''' 
Je zwei Roboter treten gegeneinander an und versuchen den jeweils anderen von einer runden Platte zu schieben. Die Platte ist schwarz, der Rand ist durch einen weissen Streifen markiert. Die Regeln entsprechen der internationalen Norm für autonomes Roboter-Sumo.

'''Hindernislauf''' 
Ein Infrarot-Leuchtturm mit definiertem Signal am Ende des Parcours ist möglichst rasch zu erreichen. Auf dem Weg befindliche Hindernisse müssen umfahren werden. Jedes Team kann alternativ auch einen eigenen Leuchtturm als Orientierungshilfe mitbringen. Reglement im Wesentlichen wie bei RC'05, jedoch sind auch komplexere Hindernisse (z.B. Sackgassen) möglich.

'''Puck Collect''' 
Je zwei Roboter - von denen einem die Farbe rot, dem anderen blau zugeteilt wird - treten gegeneinander an. Auf dem Spielfeld sind kleine rote und blaue Scheiben (Pucks) verteilt. Ziel ist es, möglichst schnell alle Pucks der eigenen Farbe einzusammeln und zur eigenen, farblich gekennzeichneten Homebase zu bringen.

'''Weblinks:'''
* [http://www.robotchallenge.at/ RobotChallenge]

==SPURT==
Der Wettbewerb SPURT (die Abkürzung steht für "Schüler-Projekte um Roboter-Technik") wird jährlich von der Universität Rostock veranstaltet. SPURT richtet sich an technikinteressierte Schüler. Die zu lösende Aufgabe ist eine Linienverfolgung. Wer am schnellsten die herzförmige Linie abfährt, hat gewonnen.

'''Weblinks:'''
* [http://spurt.uni-rostock.de/ Wettbewerb SPURT]

==ELROB==
Die deutsche Bundeswehr läd Firmen und Privatpersonen ein, am European Land-Robot Trial teilzunehmen (findet 2010 zum fünften Mal statt). Die ELROB wird veranstaltet, um einen Überblick über den europäischen State-of-the-art auf dem Gebiet von UGVs (unmanned ground vehicles) mit Fokus auf kurzfristig realisierbare Robotersystemen zu liefern. Hinsichtlich der vorhandenen Fähigkeiten versuchen die Organisatoren, technische Lösungen zu fördern, die den Betrieb unbemannter Fahrzeuge (UGV) verbessern. Repräsentanten aus Militär, Grenzschutz, Spezialkräften, Polizei, Feuerwehr, und Zivilschutzagenturen aus vielen europäischen Ländern werden anwesend sein. Die ELROB wird von einer Ausstellung begleitet, welche eine breite Vielzahl an Robotikaspekten umfasst.

'''Weblinks:'''
* [http://www.elrob.org/ Homepage von ELROB]

==ROBOCOM==
Bei diesem Wettbewerb soll eine vorgegebene Aufgabe mit LEGO MINDSTORMS NXT Robotern autonom, d.h. ohne Eingriffe von außen bewältigt werden. Mit diesem Wettbewerb möchte die Fachhochschule Gelsenkirchen in den Schulen den Einsatz moderner Techniken fördern und Schülerinnen und Schüler für ein naturwissenschaftliches Studium interessieren.

'''Weblinks:'''
* http://www2.fh-gelsenkirchen.de/FH-Sites/FB1/index.php?id=791

= Derzeit nicht regelmäßig stattfindende Wettbewerbe =

==RobotLiga==
Die RobotLiga fand bis 2007 in Kaiserslautern statt, neuere Termine sind nicht bekannt. Teilnehmen konnten alle interessierten Roboterbastler.

'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2cm breit.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 75cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://www.robotliga.de/ RobotLiga]

==RoboTest==
'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2 bis 3cm breit. Es starten immer zwei Roboter gleichzeitig in einem Parallelslalom. Der Wettbewerb läuft in mehreren Runden nach dem KO-System.

'''BLOCKED LINE''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Auf der Strecke stehen Hindernisse, die umfahren werden müssen.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2 bis 5cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, innerhalb von drei Minuten möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MICRO LINE''' 
Linienfolgen für sehr kleine Roboter. Die maximale Größe liegt bei 8x8x8cm und 200g. Je kleiner und leichter der Roboter ist, desto mehr Bonuspunkte gibt es.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''JUST WALK''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 1m zurücklegen, wenden, und die Strecke zurück laufen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://WWW.ROBOTEST.DE/ RoboTest]

==GSF Robot Contest==
Ein neuer Wettbewerb für Hobbyrobotiker. Er findet am 19.5.07 erstmals statt. Austragungsort ist Fröndenberg (Raum Dortmund/Unna).
Die Aufgaben sind teilweise angelehnt an die der RobotLiga.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegenrische Hälfte zu befördern.

'''FIRE FIGHTING''' 
Naqch einem akustischen "Feueralarm" muss eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude gefunden und gelöscht werden.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinader an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 100cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FREESTYLE''' 
In dieser Disziplin hat jeder Teilnehmer die Möglichkeit seinen Roboter vorzustellen und zu zeigen was dieser kann.

'''Weblinks:'''
* http://www.gsf-robot-contest.de/

==RoboKing==
RoboKing ist ein Wettbewerb für technikinteressierte Schüler, der jährlich von der TU Chemnitz organisiert wird. Jedes Team besteht aus 3 bis 5 Schülern und einem erwachsenem Teamleiter. RoboKing richtet sich ausdrücklich auch an Schülergruppen ohne große Vorkenntnisse. Ziel der Initiative ist, Schüler für ein Studium ingenieurwissenschaftlicher Fächer zu begeistern und zu zeigen, dass auch Schulfächer wie Physik und Informatik eine Menge Spaß machen können. Das Durchschnittsalter der Teilnehmer liegt bei etwa 16 Jahren. Die jüngsten Teilnehmer waren 10 Jahre alt.

Besonderes Highlight des Wettberwebs RoboKing ist zweifellos eine Gutschrift, von denen die Teilnehmer alle Materialien die zum Bau des Roboters benötigt werden, bezahlen können. Dadurch unterscheidet sich dieser Wettbewerb von allen vergleichbaren, denn auf die teilnehmenden Schüler kommen keine Kosten für Material zu. Jedes Jahr werden 25 Teams mit dieser Gutschrift finanziell unterstützt. Ab dem Wettbewerb RoboKing 2007 (startet im Frühjahr 2006) können zusätzlich auch alle Teams teilnehmen, die sich selbst finanzieren.

Die Endrunde des Wettbewerbs wurde 2004 und auf der Hannover Messe ausgetragen. 2006 fand das Finale auf der digital living / CeBIT statt.
Eine weitere Besonderheit des Wettbewerbs: Jedes Jahr müssen die Teilnehmer eine andere Aufgabenstellung lösen. Bei den vergangenen Wettbewerben mussten die Roboter sicher durch ein großes Labyrinth navigieren, Tennisbälle einsammeln und in die eigene Basis bringen oder Bauklötzchen durch einen Hindernisparcours mit Graben, Brücke und Schlucht transportieren. Die Teilnehmer haben nach Bekanntgabe der Spielregeln etwa 8 Monate Zeit, die Aufgabe zu lösen.

RoboKing finanziert sich ausschließlich über Spenden von zahlreichen Sponsoren. Verantwortlich für die Organisation sind die Mitarbeiter und Studenten der Professur Prozessautomatisierung der TU Chemnitz.

'''Weblinks:'''
* [http://www.roboking.de www.roboking.de]

[[Kategorie:Praxis]]

Roboterwettbewerbe

2011-06-20T15:08:04Z

Chypsylon: /* Überblick */

Auf diese Seite werden die bekanntesten nationalen und internationalen Roboterwettbewerbe kurz vorgestellt.

==Überblick==
{| {{Blauetabelle}}
|''' Wettbewerb primär für'''||Schüler ||Studenten || Hobbyrobotiker ||1 Person || bis 5 Personen || mehr als 5 Personen || nächster Termin || Ort
|-
|[[#Robocup_Junior|Robocup Junior]] || X || (X) || || || X || || 5. bis 11.7.2011 , versch. Nationalbewerbe || WM in Istanbul, Nationale Bewerbe
|-
|[[#Eurobot|Eurobot]] || X || X || || || || X || 22. bis 27.06.2011 || Russland
|-
|[[#Carolo_Cup|Carolo Cup]] || || X || || || || X || 07. / 08.02.2011 || Braunschweig
|-
|[[#Field_Robot_Event|Field Robot Event]] || || X || || || || X || 30.6. - 02.07.2011 || Dänemark
|-
|[[#FIRST_Lego_League|FIRST LEGO Leaue]] || X || || || || || X || 4. - 30.11. in 52 Regionen(Zentraleuropa) ||
|-
|[[#RoboCup_Soccer|RoboCup Soccer]] || || X || || || || X || 04. - 10.07.2011 || Istanbul
|-
|[[#RobotChallenge|RobotChallenge]] || || || X || X || || || 12. / 13.03.2011 || Wien
|-
|[[#SPURT|SPURT]] || X || || || || X || || 20.05.2011 || Rostock
|-
|[[#ELROB|European Land Robot Trial (ELROB)]] || || X || || || || X || 20. - 24.07.2011 || Leuven, Belgien
|-
|[[#ROBOCOM|ROBOCOM]] || X || || || || X || || 15.07.2011 || Gelsenkirchen
|-
|[[#RobotLiga|RobotLiga]] || || || X || X || || || keine nach 2007 bekannt ||
|-
|[[#RoboTest|RoboTest]] || || || X || X || || || keine nach 2008 bekannt ||
|-
|[[#RoboKing|RoboKing]] || X || || || || X || || keine nach 2008 bekannt ||
|-
|[[#GSF_Robot_Contest|GSF Robot Contest]] || || || X ||X || X || || keine nach 2007 bekannt ||
|}

= Aktuelle Wettbewerbe =

==Robocup Junior==
"RoboCupJunior ist eine international organisierte Bildungsinitiative. Sie soll jungen Menschen spielerisch den Umgang mit Robotern näher bringen, soll die Lust auf Naturwissenschaften und Technik wecken und einen spannenden Wissenserwerb im Unterricht ermöglichen. Wichtig bei RoboCupJunior ist die hands-on Komponente. Deshalb bauen und programmieren die Teilnehmerinnen und Teilnehmer kleine Roboter für spezielle Aufgaben und zeigen diese dann in Präsentationen und Wettbewerben.

Damit das Ganze nicht zu theoretisch behandelt wird, werden auch jedes Jahr nationale und internationale Bewerbe veranstaltet, wo sich die unterschiedlichen Teams messen, aber auch andere Schulen, Länder und Kulturen kennen lernen können.(Zitat robocupjunior.at)"

Unterteilt ist das ganze in drei Kategorien:
*Soccer
*Rescue
*Dance

sowie in in zwei Altersgruppen - 10-14 (Primary) sowie unter 19 Jahre (Secondary).

==Eurobot==
"Seit 1998 ist Eurobot ein internationaler Roboterwettbewerb für Teams von Jugendlichen, Studenten und sonstigen an Robotern interessierten Menschen.
Eurobot findet stets in Europa statt, ist aber für alle Länder aller Kontinente zugänglich. Im Jahre 2004 nahmen insgesamt 250 Teams aus 21 Länder an diesem technisch/wissenschaftlichen Wettbewerb teil." (zitiert von www.eurobot.org)
Aus jedem Land dürfen maximal drei Teams zu den internationalen Finalen fahren. Diese drei Mannschaften müssen sich in nationalen Vorausscheiden qualifizieren. Die Aufgabe wird jedes Jahr neu gestellt. Nur die Rahmenbedingungen bleiben gleich: Ein Match dauert nur 90 Sekunden, es ist also sowohl Schnelligkeit als auch eine intelligente Taktik und Sicherheit gefragt. Die Spielfläche ist etwa 2x3 Meter groß.
Eurobot findet seit 2005 jedes Jahr in einem anderen Land statt. Der Wettbewerb wird von einer großen Rahmenveranstaltung inklusive Vorträgen und vielen Attraktionen für die zahlreichen Zuschauer ergänzt.

'''Weblinks''':
* [http://www.eurobot.org www.eurobot.org]
* [http://www.eurobot-deutschland.de www.eurobot-deutschland.de]

==Carolo Cup==
Dieser Wettbewerb für Studenten findet an der TU Braunschweig statt.
Es treten autonome Modellfahrzeuge im Maßstab 1:10 gegeneinander an. Aufgaben sind das Fahren auf einem Rundkurs (dabei muss die Fahrbahnmarkierung z.B. mit Kameras erkannt werden) und das seitliche Einparken in einer vorgegebenen Parklücke. 

'''Weblinks''':
* [http://www.carolo-cup.de www.carolo-cup.de]

==Field Robot Event==
Dieser Wettbewerb für Studenten findet auf einem Maisfeld statt. Die Roboter müssen den Maisreihen folgen und "Unkraut" erkennen, wobei es mehrere Schwierigkeitsgrade gibt (z.B. können einzelne Pflanzen fehlen, oder es gibt größere Unebenheiten im Boden).
2011 wird der Wettbewerb in Dänemark ausgetragen.

'''Weblinks''':
* [http://www.fre2011.dk/ http://www.fre2011.dk/]

==FIRST Lego League==
Bei der FIRST LEGO League (FLL) handelt es sich um einen internationalen Wettbewerb der von der Firma LEGO und der amerikanischen Stiftung FIRST (For Inspiration and Recognition of Science and Technology) veranstalltet wird. Er findet jährlich auf der ganzen Welt mit regionalen Runden statt und steht jedes Jahr unter einem neuen Motto.

Der Wettbewerb beschäftigt sich immer mit aktuellen naturwissenschaftlichen Problemen, die gesellschaftlich relevant sind. Dabei sollen die Kinder nicht nur einen Roboter programmieren, der Aufgaben auf dem vorgegebenen Spielfeld erfüllt, sondern sich auch tiefgründig mit dem Wettbewerbsthema auseinandersetzen. Die Teilnehmer sollen einen Lösungsansatz für ein aktuelles Probleme erarbeiten, dass mit dem Wettbewerbsthema in Verbindung steht. 2010 heißt das Thema von FLL "Body Forward" und dabei dreht sich alles um Biomedizin.

Bei diesem Wettbewerb dürfen nur Roboter eingesetzt werden, die aus dem LEGO Mindstorms System bestehen. Der Wettbewerb richtet sich vornehmlich an junge Schüler, wie auch das gesamte Mindstorms System. Deshalb dürfen die Teilnehmer maximal 16 Jahre alt sein. Jedes Team wird von einem volljährigen Coach bei der Bewältigung der Aufgaben angeleitet.

Die Wettbewerbsaufgaben werden immer Anfang September veröffentlicht, danach hat jedes Team ca. 8 Wochen Zeit seinen Roboter zu programmieren und den Forschungsauftrag zu erfüllen, um die Ergebnisse dann bei einem der Regionalwettbewerbe zu präsentieren.

'''Weblinks''':
* [http://www.firstlegoleague.org/ www.firstlegoleague.org]
* [http://www.firstlegoleague.de/ www.firstlegoleague.de]

==RoboCup Soccer==
Die Komplexität und Beliebtheit von Fußball (soccer) spielten wesentliche Rollen bei der Motivation der ersten RoboCupspiele Mitte der 90er Jahre. Die Dynamik und die Komplexität von Fußball birgt enorme Herausforderungen für Wissenschaftler, die sich mit der Entwicklung von autonomen Robotern in diesem Bereich beschäftigen:

Individuelle Herausforderungen: jeder Agent/Roboter muss Objekte erkennen, sich selbst lokalisieren, navigieren und den Ball bewegen können. Zu klären sind Fragen wie: was ist in diesem Moment wichtig in meiner Wahrnehmung? Ist meine Position und die der anderen Mitspieler bekannt?
Kooperation von Agenten: in einer dynamischen Echtzeitumgebung kommt es nicht auf einen einzelnen Spieler an, sondern besonders auf das kooperative Spiel, bei dem auch die Kommunikation eine große Rolle spielt.

Dynamische Echtzeitumgebung mit sich bewegenden Objekten, von denen einige intelligente Agenten sind, die gegen einen spielen. Diese Art von Umgebung ist z.B. auch im Straßenverkehr zu beobachten, wobei die anderen Verkehrsteilnehmer zwar keine Gegner sind, die meine Pläne durchkreuzen wollen, wo aber die Situationen beliebig komplex werden können.
RoboCupSoccer besteht aus fünf Ligen: der Simulationsliga, der Small-Size Liga, der Middle-Size Liga, der Sony Legged Liga, und der Humanoidliga.

'''Weblinks:'''
* [http://www.robocup.org www.robocup.org]

==RobotChallenge==
Die RobotChallenge ist ein österreichischer Wettbewerb für selbstgebaute, autonome Roboter, dessen Ziel es ist für den kreativen Umgang mit innovativen Technologien zu begeistern. Experimente und praktische Erfahrungen lassen Teilnehmer und Zuschauer Wissenschaft hautnah erleben. Dieser Wettbewerb soll zeigen, wie man mit einfachen Mitteln, aber offenem Geiste und Phantasie spannende, zukunftstaugliche Lösungen finden kann.
Folgende Disiplienen wurden dort schon ausgetragen:

'''Parallel-Slalom''' 
Möglichst schnell muss einer schwarzen Linie auf weißem Untergrund entlang gefahren werden. Reglement im Wesentlichen wie bei RC'05.

'''Parallel-Slalom Enhanced''' 
Wie Parallel-Slalom, jedoch mit Erschwernissen: ein Tunnel, eine kurze Unterbrechung der Linie und ein Hindernis auf der Linie, das umfahren werden muss.

'''Robot-Sumo''' 
Je zwei Roboter treten gegeneinander an und versuchen den jeweils anderen von einer runden Platte zu schieben. Die Platte ist schwarz, der Rand ist durch einen weissen Streifen markiert. Die Regeln entsprechen der internationalen Norm für autonomes Roboter-Sumo.

'''Hindernislauf''' 
Ein Infrarot-Leuchtturm mit definiertem Signal am Ende des Parcours ist möglichst rasch zu erreichen. Auf dem Weg befindliche Hindernisse müssen umfahren werden. Jedes Team kann alternativ auch einen eigenen Leuchtturm als Orientierungshilfe mitbringen. Reglement im Wesentlichen wie bei RC'05, jedoch sind auch komplexere Hindernisse (z.B. Sackgassen) möglich.

'''Puck Collect''' 
Je zwei Roboter - von denen einem die Farbe rot, dem anderen blau zugeteilt wird - treten gegeneinander an. Auf dem Spielfeld sind kleine rote und blaue Scheiben (Pucks) verteilt. Ziel ist es, möglichst schnell alle Pucks der eigenen Farbe einzusammeln und zur eigenen, farblich gekennzeichneten Homebase zu bringen.

'''Weblinks:'''
* [http://www.robotchallenge.at/ RobotChallenge]

==SPURT==
Der Wettbewerb SPURT (die Abkürzung steht für "Schüler-Projekte um Roboter-Technik") wird jährlich von der Universität Rostock veranstaltet. SPURT richtet sich an technikinteressierte Schüler. Die zu lösende Aufgabe ist eine Linienverfolgung. Wer am schnellsten die herzförmige Linie abfährt, hat gewonnen.

'''Weblinks:'''
* [http://spurt.uni-rostock.de/ Wettbewerb SPURT]

==ELROB==
Die deutsche Bundeswehr läd Firmen und Privatpersonen ein, am European Land-Robot Trial teilzunehmen (findet 2010 zum fünften Mal statt). Die ELROB wird veranstaltet, um einen Überblick über den europäischen State-of-the-art auf dem Gebiet von UGVs (unmanned ground vehicles) mit Fokus auf kurzfristig realisierbare Robotersystemen zu liefern. Hinsichtlich der vorhandenen Fähigkeiten versuchen die Organisatoren, technische Lösungen zu fördern, die den Betrieb unbemannter Fahrzeuge (UGV) verbessern. Repräsentanten aus Militär, Grenzschutz, Spezialkräften, Polizei, Feuerwehr, und Zivilschutzagenturen aus vielen europäischen Ländern werden anwesend sein. Die ELROB wird von einer Ausstellung begleitet, welche eine breite Vielzahl an Robotikaspekten umfasst.

'''Weblinks:'''
* [http://www.elrob.org/ Homepage von ELROB]

==ROBOCOM==
Bei diesem Wettbewerb soll eine vorgegebene Aufgabe mit LEGO MINDSTORMS NXT Robotern autonom, d.h. ohne Eingriffe von außen bewältigt werden. Mit diesem Wettbewerb möchte die Fachhochschule Gelsenkirchen in den Schulen den Einsatz moderner Techniken fördern und Schülerinnen und Schüler für ein naturwissenschaftliches Studium interessieren.

'''Weblinks:'''
* http://www2.fh-gelsenkirchen.de/FH-Sites/FB1/index.php?id=791

= Derzeit nicht regelmäßig stattfindende Wettbewerbe =

==RobotLiga==
Die RobotLiga fand bis 2007 in Kaiserslautern statt, neuere Termine sind nicht bekannt. Teilnehmen konnten alle interessierten Roboterbastler.

'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2cm breit.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 75cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://www.robotliga.de/ RobotLiga]

==RoboTest==
'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2 bis 3cm breit. Es starten immer zwei Roboter gleichzeitig in einem Parallelslalom. Der Wettbewerb läuft in mehreren Runden nach dem KO-System.

'''BLOCKED LINE''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Auf der Strecke stehen Hindernisse, die umfahren werden müssen.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2 bis 5cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, innerhalb von drei Minuten möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MICRO LINE''' 
Linienfolgen für sehr kleine Roboter. Die maximale Größe liegt bei 8x8x8cm und 200g. Je kleiner und leichter der Roboter ist, desto mehr Bonuspunkte gibt es.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''JUST WALK''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 1m zurücklegen, wenden, und die Strecke zurück laufen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://WWW.ROBOTEST.DE/ RoboTest]

==GSF Robot Contest==
Ein neuer Wettbewerb für Hobbyrobotiker. Er findet am 19.5.07 erstmals statt. Austragungsort ist Fröndenberg (Raum Dortmund/Unna).
Die Aufgaben sind teilweise angelehnt an die der RobotLiga.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegenrische Hälfte zu befördern.

'''FIRE FIGHTING''' 
Naqch einem akustischen "Feueralarm" muss eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude gefunden und gelöscht werden.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinader an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 100cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FREESTYLE''' 
In dieser Disziplin hat jeder Teilnehmer die Möglichkeit seinen Roboter vorzustellen und zu zeigen was dieser kann.

'''Weblinks:'''
* http://www.gsf-robot-contest.de/

==RoboKing==
RoboKing ist ein Wettbewerb für technikinteressierte Schüler, der jährlich von der TU Chemnitz organisiert wird. Jedes Team besteht aus 3 bis 5 Schülern und einem erwachsenem Teamleiter. RoboKing richtet sich ausdrücklich auch an Schülergruppen ohne große Vorkenntnisse. Ziel der Initiative ist, Schüler für ein Studium ingenieurwissenschaftlicher Fächer zu begeistern und zu zeigen, dass auch Schulfächer wie Physik und Informatik eine Menge Spaß machen können. Das Durchschnittsalter der Teilnehmer liegt bei etwa 16 Jahren. Die jüngsten Teilnehmer waren 10 Jahre alt.

Besonderes Highlight des Wettberwebs RoboKing ist zweifellos eine Gutschrift, von denen die Teilnehmer alle Materialien die zum Bau des Roboters benötigt werden, bezahlen können. Dadurch unterscheidet sich dieser Wettbewerb von allen vergleichbaren, denn auf die teilnehmenden Schüler kommen keine Kosten für Material zu. Jedes Jahr werden 25 Teams mit dieser Gutschrift finanziell unterstützt. Ab dem Wettbewerb RoboKing 2007 (startet im Frühjahr 2006) können zusätzlich auch alle Teams teilnehmen, die sich selbst finanzieren.

Die Endrunde des Wettbewerbs wurde 2004 und auf der Hannover Messe ausgetragen. 2006 fand das Finale auf der digital living / CeBIT statt.
Eine weitere Besonderheit des Wettbewerbs: Jedes Jahr müssen die Teilnehmer eine andere Aufgabenstellung lösen. Bei den vergangenen Wettbewerben mussten die Roboter sicher durch ein großes Labyrinth navigieren, Tennisbälle einsammeln und in die eigene Basis bringen oder Bauklötzchen durch einen Hindernisparcours mit Graben, Brücke und Schlucht transportieren. Die Teilnehmer haben nach Bekanntgabe der Spielregeln etwa 8 Monate Zeit, die Aufgabe zu lösen.

RoboKing finanziert sich ausschließlich über Spenden von zahlreichen Sponsoren. Verantwortlich für die Organisation sind die Mitarbeiter und Studenten der Professur Prozessautomatisierung der TU Chemnitz.

'''Weblinks:'''
* [http://www.roboking.de www.roboking.de]

[[Kategorie:Praxis]]

Roboterwettbewerbe

2011-06-20T15:06:19Z

Chypsylon: /* Robocup Junior */

Auf diese Seite werden die bekanntesten nationalen und internationalen Roboterwettbewerbe kurz vorgestellt.

==Überblick==
{| {{Blauetabelle}}
|''' Wettbewerb primär für'''||Schüler ||Studenten || Hobbyrobotiker ||1 Person || bis 5 Personen || mehr als 5 Personen || nächster Termin || Ort
|-
|[[#Robocup_Junior|Robocup Junior]] || X || || || || X || || 5. bis 11.7.2011 , versch. Nationalbewerbe || WM in Istanbul, Nationale Bewerbe
|-
|[[#Eurobot|Eurobot]] || X || X || || || || X || 22. bis 27.06.2011 || Russland
|-
|[[#Carolo_Cup|Carolo Cup]] || || X || || || || X || 07. / 08.02.2011 || Braunschweig
|-
|[[#Field_Robot_Event|Field Robot Event]] || || X || || || || X || 30.6. - 02.07.2011 || Dänemark
|-
|[[#FIRST_Lego_League|FIRST LEGO Leaue]] || X || || || || || X || 4. - 30.11. in 52 Regionen(Zentraleuropa) ||
|-
|[[#RoboCup_Soccer|RoboCup Soccer]] || || X || || || || X || 04. - 10.07.2011 || Istanbul
|-
|[[#RobotChallenge|RobotChallenge]] || || || X || X || || || 12. / 13.03.2011 || Wien
|-
|[[#SPURT|SPURT]] || X || || || || X || || 20.05.2011 || Rostock
|-
|[[#ELROB|European Land Robot Trial (ELROB)]] || || X || || || || X || 20. - 24.07.2011 || Leuven, Belgien
|-
|[[#ROBOCOM|ROBOCOM]] || X || || || || X || || 15.07.2011 || Gelsenkirchen
|-
|[[#RobotLiga|RobotLiga]] || || || X || X || || || keine nach 2007 bekannt ||
|-
|[[#RoboTest|RoboTest]] || || || X || X || || || keine nach 2008 bekannt ||
|-
|[[#RoboKing|RoboKing]] || X || || || || X || || keine nach 2008 bekannt ||
|-
|[[#GSF_Robot_Contest|GSF Robot Contest]] || || || X ||X || X || || keine nach 2007 bekannt ||
|}

= Aktuelle Wettbewerbe =

==Robocup Junior==
"RoboCupJunior ist eine international organisierte Bildungsinitiative. Sie soll jungen Menschen spielerisch den Umgang mit Robotern näher bringen, soll die Lust auf Naturwissenschaften und Technik wecken und einen spannenden Wissenserwerb im Unterricht ermöglichen. Wichtig bei RoboCupJunior ist die hands-on Komponente. Deshalb bauen und programmieren die Teilnehmerinnen und Teilnehmer kleine Roboter für spezielle Aufgaben und zeigen diese dann in Präsentationen und Wettbewerben.

Damit das Ganze nicht zu theoretisch behandelt wird, werden auch jedes Jahr nationale und internationale Bewerbe veranstaltet, wo sich die unterschiedlichen Teams messen, aber auch andere Schulen, Länder und Kulturen kennen lernen können.(Zitat robocupjunior.at)"

Unterteilt ist das ganze in drei Kategorien:
*Soccer
*Rescue
*Dance

sowie in in zwei Altersgruppen - 10-14 (Primary) sowie unter 19 Jahre (Secondary).

==Eurobot==
"Seit 1998 ist Eurobot ein internationaler Roboterwettbewerb für Teams von Jugendlichen, Studenten und sonstigen an Robotern interessierten Menschen.
Eurobot findet stets in Europa statt, ist aber für alle Länder aller Kontinente zugänglich. Im Jahre 2004 nahmen insgesamt 250 Teams aus 21 Länder an diesem technisch/wissenschaftlichen Wettbewerb teil." (zitiert von www.eurobot.org)
Aus jedem Land dürfen maximal drei Teams zu den internationalen Finalen fahren. Diese drei Mannschaften müssen sich in nationalen Vorausscheiden qualifizieren. Die Aufgabe wird jedes Jahr neu gestellt. Nur die Rahmenbedingungen bleiben gleich: Ein Match dauert nur 90 Sekunden, es ist also sowohl Schnelligkeit als auch eine intelligente Taktik und Sicherheit gefragt. Die Spielfläche ist etwa 2x3 Meter groß.
Eurobot findet seit 2005 jedes Jahr in einem anderen Land statt. Der Wettbewerb wird von einer großen Rahmenveranstaltung inklusive Vorträgen und vielen Attraktionen für die zahlreichen Zuschauer ergänzt.

'''Weblinks''':
* [http://www.eurobot.org www.eurobot.org]
* [http://www.eurobot-deutschland.de www.eurobot-deutschland.de]

==Carolo Cup==
Dieser Wettbewerb für Studenten findet an der TU Braunschweig statt.
Es treten autonome Modellfahrzeuge im Maßstab 1:10 gegeneinander an. Aufgaben sind das Fahren auf einem Rundkurs (dabei muss die Fahrbahnmarkierung z.B. mit Kameras erkannt werden) und das seitliche Einparken in einer vorgegebenen Parklücke. 

'''Weblinks''':
* [http://www.carolo-cup.de www.carolo-cup.de]

==Field Robot Event==
Dieser Wettbewerb für Studenten findet auf einem Maisfeld statt. Die Roboter müssen den Maisreihen folgen und "Unkraut" erkennen, wobei es mehrere Schwierigkeitsgrade gibt (z.B. können einzelne Pflanzen fehlen, oder es gibt größere Unebenheiten im Boden).
2011 wird der Wettbewerb in Dänemark ausgetragen.

'''Weblinks''':
* [http://www.fre2011.dk/ http://www.fre2011.dk/]

==FIRST Lego League==
Bei der FIRST LEGO League (FLL) handelt es sich um einen internationalen Wettbewerb der von der Firma LEGO und der amerikanischen Stiftung FIRST (For Inspiration and Recognition of Science and Technology) veranstalltet wird. Er findet jährlich auf der ganzen Welt mit regionalen Runden statt und steht jedes Jahr unter einem neuen Motto.

Der Wettbewerb beschäftigt sich immer mit aktuellen naturwissenschaftlichen Problemen, die gesellschaftlich relevant sind. Dabei sollen die Kinder nicht nur einen Roboter programmieren, der Aufgaben auf dem vorgegebenen Spielfeld erfüllt, sondern sich auch tiefgründig mit dem Wettbewerbsthema auseinandersetzen. Die Teilnehmer sollen einen Lösungsansatz für ein aktuelles Probleme erarbeiten, dass mit dem Wettbewerbsthema in Verbindung steht. 2010 heißt das Thema von FLL "Body Forward" und dabei dreht sich alles um Biomedizin.

Bei diesem Wettbewerb dürfen nur Roboter eingesetzt werden, die aus dem LEGO Mindstorms System bestehen. Der Wettbewerb richtet sich vornehmlich an junge Schüler, wie auch das gesamte Mindstorms System. Deshalb dürfen die Teilnehmer maximal 16 Jahre alt sein. Jedes Team wird von einem volljährigen Coach bei der Bewältigung der Aufgaben angeleitet.

Die Wettbewerbsaufgaben werden immer Anfang September veröffentlicht, danach hat jedes Team ca. 8 Wochen Zeit seinen Roboter zu programmieren und den Forschungsauftrag zu erfüllen, um die Ergebnisse dann bei einem der Regionalwettbewerbe zu präsentieren.

'''Weblinks''':
* [http://www.firstlegoleague.org/ www.firstlegoleague.org]
* [http://www.firstlegoleague.de/ www.firstlegoleague.de]

==RoboCup Soccer==
Die Komplexität und Beliebtheit von Fußball (soccer) spielten wesentliche Rollen bei der Motivation der ersten RoboCupspiele Mitte der 90er Jahre. Die Dynamik und die Komplexität von Fußball birgt enorme Herausforderungen für Wissenschaftler, die sich mit der Entwicklung von autonomen Robotern in diesem Bereich beschäftigen:

Individuelle Herausforderungen: jeder Agent/Roboter muss Objekte erkennen, sich selbst lokalisieren, navigieren und den Ball bewegen können. Zu klären sind Fragen wie: was ist in diesem Moment wichtig in meiner Wahrnehmung? Ist meine Position und die der anderen Mitspieler bekannt?
Kooperation von Agenten: in einer dynamischen Echtzeitumgebung kommt es nicht auf einen einzelnen Spieler an, sondern besonders auf das kooperative Spiel, bei dem auch die Kommunikation eine große Rolle spielt.

Dynamische Echtzeitumgebung mit sich bewegenden Objekten, von denen einige intelligente Agenten sind, die gegen einen spielen. Diese Art von Umgebung ist z.B. auch im Straßenverkehr zu beobachten, wobei die anderen Verkehrsteilnehmer zwar keine Gegner sind, die meine Pläne durchkreuzen wollen, wo aber die Situationen beliebig komplex werden können.
RoboCupSoccer besteht aus fünf Ligen: der Simulationsliga, der Small-Size Liga, der Middle-Size Liga, der Sony Legged Liga, und der Humanoidliga.

'''Weblinks:'''
* [http://www.robocup.org www.robocup.org]

==RobotChallenge==
Die RobotChallenge ist ein österreichischer Wettbewerb für selbstgebaute, autonome Roboter, dessen Ziel es ist für den kreativen Umgang mit innovativen Technologien zu begeistern. Experimente und praktische Erfahrungen lassen Teilnehmer und Zuschauer Wissenschaft hautnah erleben. Dieser Wettbewerb soll zeigen, wie man mit einfachen Mitteln, aber offenem Geiste und Phantasie spannende, zukunftstaugliche Lösungen finden kann.
Folgende Disiplienen wurden dort schon ausgetragen:

'''Parallel-Slalom''' 
Möglichst schnell muss einer schwarzen Linie auf weißem Untergrund entlang gefahren werden. Reglement im Wesentlichen wie bei RC'05.

'''Parallel-Slalom Enhanced''' 
Wie Parallel-Slalom, jedoch mit Erschwernissen: ein Tunnel, eine kurze Unterbrechung der Linie und ein Hindernis auf der Linie, das umfahren werden muss.

'''Robot-Sumo''' 
Je zwei Roboter treten gegeneinander an und versuchen den jeweils anderen von einer runden Platte zu schieben. Die Platte ist schwarz, der Rand ist durch einen weissen Streifen markiert. Die Regeln entsprechen der internationalen Norm für autonomes Roboter-Sumo.

'''Hindernislauf''' 
Ein Infrarot-Leuchtturm mit definiertem Signal am Ende des Parcours ist möglichst rasch zu erreichen. Auf dem Weg befindliche Hindernisse müssen umfahren werden. Jedes Team kann alternativ auch einen eigenen Leuchtturm als Orientierungshilfe mitbringen. Reglement im Wesentlichen wie bei RC'05, jedoch sind auch komplexere Hindernisse (z.B. Sackgassen) möglich.

'''Puck Collect''' 
Je zwei Roboter - von denen einem die Farbe rot, dem anderen blau zugeteilt wird - treten gegeneinander an. Auf dem Spielfeld sind kleine rote und blaue Scheiben (Pucks) verteilt. Ziel ist es, möglichst schnell alle Pucks der eigenen Farbe einzusammeln und zur eigenen, farblich gekennzeichneten Homebase zu bringen.

'''Weblinks:'''
* [http://www.robotchallenge.at/ RobotChallenge]

==SPURT==
Der Wettbewerb SPURT (die Abkürzung steht für "Schüler-Projekte um Roboter-Technik") wird jährlich von der Universität Rostock veranstaltet. SPURT richtet sich an technikinteressierte Schüler. Die zu lösende Aufgabe ist eine Linienverfolgung. Wer am schnellsten die herzförmige Linie abfährt, hat gewonnen.

'''Weblinks:'''
* [http://spurt.uni-rostock.de/ Wettbewerb SPURT]

==ELROB==
Die deutsche Bundeswehr läd Firmen und Privatpersonen ein, am European Land-Robot Trial teilzunehmen (findet 2010 zum fünften Mal statt). Die ELROB wird veranstaltet, um einen Überblick über den europäischen State-of-the-art auf dem Gebiet von UGVs (unmanned ground vehicles) mit Fokus auf kurzfristig realisierbare Robotersystemen zu liefern. Hinsichtlich der vorhandenen Fähigkeiten versuchen die Organisatoren, technische Lösungen zu fördern, die den Betrieb unbemannter Fahrzeuge (UGV) verbessern. Repräsentanten aus Militär, Grenzschutz, Spezialkräften, Polizei, Feuerwehr, und Zivilschutzagenturen aus vielen europäischen Ländern werden anwesend sein. Die ELROB wird von einer Ausstellung begleitet, welche eine breite Vielzahl an Robotikaspekten umfasst.

'''Weblinks:'''
* [http://www.elrob.org/ Homepage von ELROB]

==ROBOCOM==
Bei diesem Wettbewerb soll eine vorgegebene Aufgabe mit LEGO MINDSTORMS NXT Robotern autonom, d.h. ohne Eingriffe von außen bewältigt werden. Mit diesem Wettbewerb möchte die Fachhochschule Gelsenkirchen in den Schulen den Einsatz moderner Techniken fördern und Schülerinnen und Schüler für ein naturwissenschaftliches Studium interessieren.

'''Weblinks:'''
* http://www2.fh-gelsenkirchen.de/FH-Sites/FB1/index.php?id=791

= Derzeit nicht regelmäßig stattfindende Wettbewerbe =

==RobotLiga==
Die RobotLiga fand bis 2007 in Kaiserslautern statt, neuere Termine sind nicht bekannt. Teilnehmen konnten alle interessierten Roboterbastler.

'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2cm breit.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 75cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://www.robotliga.de/ RobotLiga]

==RoboTest==
'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2 bis 3cm breit. Es starten immer zwei Roboter gleichzeitig in einem Parallelslalom. Der Wettbewerb läuft in mehreren Runden nach dem KO-System.

'''BLOCKED LINE''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Auf der Strecke stehen Hindernisse, die umfahren werden müssen.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2 bis 5cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, innerhalb von drei Minuten möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MICRO LINE''' 
Linienfolgen für sehr kleine Roboter. Die maximale Größe liegt bei 8x8x8cm und 200g. Je kleiner und leichter der Roboter ist, desto mehr Bonuspunkte gibt es.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''JUST WALK''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 1m zurücklegen, wenden, und die Strecke zurück laufen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://WWW.ROBOTEST.DE/ RoboTest]

==GSF Robot Contest==
Ein neuer Wettbewerb für Hobbyrobotiker. Er findet am 19.5.07 erstmals statt. Austragungsort ist Fröndenberg (Raum Dortmund/Unna).
Die Aufgaben sind teilweise angelehnt an die der RobotLiga.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegenrische Hälfte zu befördern.

'''FIRE FIGHTING''' 
Naqch einem akustischen "Feueralarm" muss eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude gefunden und gelöscht werden.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinader an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 100cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FREESTYLE''' 
In dieser Disziplin hat jeder Teilnehmer die Möglichkeit seinen Roboter vorzustellen und zu zeigen was dieser kann.

'''Weblinks:'''
* http://www.gsf-robot-contest.de/

==RoboKing==
RoboKing ist ein Wettbewerb für technikinteressierte Schüler, der jährlich von der TU Chemnitz organisiert wird. Jedes Team besteht aus 3 bis 5 Schülern und einem erwachsenem Teamleiter. RoboKing richtet sich ausdrücklich auch an Schülergruppen ohne große Vorkenntnisse. Ziel der Initiative ist, Schüler für ein Studium ingenieurwissenschaftlicher Fächer zu begeistern und zu zeigen, dass auch Schulfächer wie Physik und Informatik eine Menge Spaß machen können. Das Durchschnittsalter der Teilnehmer liegt bei etwa 16 Jahren. Die jüngsten Teilnehmer waren 10 Jahre alt.

Besonderes Highlight des Wettberwebs RoboKing ist zweifellos eine Gutschrift, von denen die Teilnehmer alle Materialien die zum Bau des Roboters benötigt werden, bezahlen können. Dadurch unterscheidet sich dieser Wettbewerb von allen vergleichbaren, denn auf die teilnehmenden Schüler kommen keine Kosten für Material zu. Jedes Jahr werden 25 Teams mit dieser Gutschrift finanziell unterstützt. Ab dem Wettbewerb RoboKing 2007 (startet im Frühjahr 2006) können zusätzlich auch alle Teams teilnehmen, die sich selbst finanzieren.

Die Endrunde des Wettbewerbs wurde 2004 und auf der Hannover Messe ausgetragen. 2006 fand das Finale auf der digital living / CeBIT statt.
Eine weitere Besonderheit des Wettbewerbs: Jedes Jahr müssen die Teilnehmer eine andere Aufgabenstellung lösen. Bei den vergangenen Wettbewerben mussten die Roboter sicher durch ein großes Labyrinth navigieren, Tennisbälle einsammeln und in die eigene Basis bringen oder Bauklötzchen durch einen Hindernisparcours mit Graben, Brücke und Schlucht transportieren. Die Teilnehmer haben nach Bekanntgabe der Spielregeln etwa 8 Monate Zeit, die Aufgabe zu lösen.

RoboKing finanziert sich ausschließlich über Spenden von zahlreichen Sponsoren. Verantwortlich für die Organisation sind die Mitarbeiter und Studenten der Professur Prozessautomatisierung der TU Chemnitz.

'''Weblinks:'''
* [http://www.roboking.de www.roboking.de]

[[Kategorie:Praxis]]

Roboterwettbewerbe

2011-06-20T15:03:36Z

Chypsylon: /* Aktuelle Wettbewerbe */

Auf diese Seite werden die bekanntesten nationalen und internationalen Roboterwettbewerbe kurz vorgestellt.

==Überblick==
{| {{Blauetabelle}}
|''' Wettbewerb primär für'''||Schüler ||Studenten || Hobbyrobotiker ||1 Person || bis 5 Personen || mehr als 5 Personen || nächster Termin || Ort
|-
|[[#Robocup_Junior|Robocup Junior]] || X || || || || X || || 5. bis 11.7.2011 , versch. Nationalbewerbe || WM in Istanbul, Nationale Bewerbe
|-
|[[#Eurobot|Eurobot]] || X || X || || || || X || 22. bis 27.06.2011 || Russland
|-
|[[#Carolo_Cup|Carolo Cup]] || || X || || || || X || 07. / 08.02.2011 || Braunschweig
|-
|[[#Field_Robot_Event|Field Robot Event]] || || X || || || || X || 30.6. - 02.07.2011 || Dänemark
|-
|[[#FIRST_Lego_League|FIRST LEGO Leaue]] || X || || || || || X || 4. - 30.11. in 52 Regionen(Zentraleuropa) ||
|-
|[[#RoboCup_Soccer|RoboCup Soccer]] || || X || || || || X || 04. - 10.07.2011 || Istanbul
|-
|[[#RobotChallenge|RobotChallenge]] || || || X || X || || || 12. / 13.03.2011 || Wien
|-
|[[#SPURT|SPURT]] || X || || || || X || || 20.05.2011 || Rostock
|-
|[[#ELROB|European Land Robot Trial (ELROB)]] || || X || || || || X || 20. - 24.07.2011 || Leuven, Belgien
|-
|[[#ROBOCOM|ROBOCOM]] || X || || || || X || || 15.07.2011 || Gelsenkirchen
|-
|[[#RobotLiga|RobotLiga]] || || || X || X || || || keine nach 2007 bekannt ||
|-
|[[#RoboTest|RoboTest]] || || || X || X || || || keine nach 2008 bekannt ||
|-
|[[#RoboKing|RoboKing]] || X || || || || X || || keine nach 2008 bekannt ||
|-
|[[#GSF_Robot_Contest|GSF Robot Contest]] || || || X ||X || X || || keine nach 2007 bekannt ||
|}

= Aktuelle Wettbewerbe =

==Robocup Junior==
"RoboCupJunior ist eine international organisierte Bildungsinitiative. Sie soll jungen Menschen spielerisch den Umgang mit Robotern näher bringen, soll die Lust auf Naturwissenschaften und Technik wecken und einen spannenden Wissenserwerb im Unterricht ermöglichen. Wichtig bei RoboCupJunior ist die hands-on Komponente. Deshalb bauen und programmieren die Teilnehmerinnen und Teilnehmer kleine Roboter für spezielle Aufgaben und zeigen diese dann in Präsentationen und Wettbewerben.

Damit das Ganze nicht zu theoretisch behandelt wird, werden auch jedes Jahr nationale und internationale Bewerbe veranstaltet, wo sich die unterschiedlichen Teams messen, aber auch andere Schulen, Länder und Kulturen kennen lernen können.(Zitat robocupjunior.at)"

Unterteilt ist das ganze in drei Kategorien:
*Soccer
*Rescue
*Dance

sowie in in zwei Altersgruppen.

==Eurobot==
"Seit 1998 ist Eurobot ein internationaler Roboterwettbewerb für Teams von Jugendlichen, Studenten und sonstigen an Robotern interessierten Menschen.
Eurobot findet stets in Europa statt, ist aber für alle Länder aller Kontinente zugänglich. Im Jahre 2004 nahmen insgesamt 250 Teams aus 21 Länder an diesem technisch/wissenschaftlichen Wettbewerb teil." (zitiert von www.eurobot.org)
Aus jedem Land dürfen maximal drei Teams zu den internationalen Finalen fahren. Diese drei Mannschaften müssen sich in nationalen Vorausscheiden qualifizieren. Die Aufgabe wird jedes Jahr neu gestellt. Nur die Rahmenbedingungen bleiben gleich: Ein Match dauert nur 90 Sekunden, es ist also sowohl Schnelligkeit als auch eine intelligente Taktik und Sicherheit gefragt. Die Spielfläche ist etwa 2x3 Meter groß.
Eurobot findet seit 2005 jedes Jahr in einem anderen Land statt. Der Wettbewerb wird von einer großen Rahmenveranstaltung inklusive Vorträgen und vielen Attraktionen für die zahlreichen Zuschauer ergänzt.

'''Weblinks''':
* [http://www.eurobot.org www.eurobot.org]
* [http://www.eurobot-deutschland.de www.eurobot-deutschland.de]

==Carolo Cup==
Dieser Wettbewerb für Studenten findet an der TU Braunschweig statt.
Es treten autonome Modellfahrzeuge im Maßstab 1:10 gegeneinander an. Aufgaben sind das Fahren auf einem Rundkurs (dabei muss die Fahrbahnmarkierung z.B. mit Kameras erkannt werden) und das seitliche Einparken in einer vorgegebenen Parklücke. 

'''Weblinks''':
* [http://www.carolo-cup.de www.carolo-cup.de]

==Field Robot Event==
Dieser Wettbewerb für Studenten findet auf einem Maisfeld statt. Die Roboter müssen den Maisreihen folgen und "Unkraut" erkennen, wobei es mehrere Schwierigkeitsgrade gibt (z.B. können einzelne Pflanzen fehlen, oder es gibt größere Unebenheiten im Boden).
2011 wird der Wettbewerb in Dänemark ausgetragen.

'''Weblinks''':
* [http://www.fre2011.dk/ http://www.fre2011.dk/]

==FIRST Lego League==
Bei der FIRST LEGO League (FLL) handelt es sich um einen internationalen Wettbewerb der von der Firma LEGO und der amerikanischen Stiftung FIRST (For Inspiration and Recognition of Science and Technology) veranstalltet wird. Er findet jährlich auf der ganzen Welt mit regionalen Runden statt und steht jedes Jahr unter einem neuen Motto.

Der Wettbewerb beschäftigt sich immer mit aktuellen naturwissenschaftlichen Problemen, die gesellschaftlich relevant sind. Dabei sollen die Kinder nicht nur einen Roboter programmieren, der Aufgaben auf dem vorgegebenen Spielfeld erfüllt, sondern sich auch tiefgründig mit dem Wettbewerbsthema auseinandersetzen. Die Teilnehmer sollen einen Lösungsansatz für ein aktuelles Probleme erarbeiten, dass mit dem Wettbewerbsthema in Verbindung steht. 2010 heißt das Thema von FLL "Body Forward" und dabei dreht sich alles um Biomedizin.

Bei diesem Wettbewerb dürfen nur Roboter eingesetzt werden, die aus dem LEGO Mindstorms System bestehen. Der Wettbewerb richtet sich vornehmlich an junge Schüler, wie auch das gesamte Mindstorms System. Deshalb dürfen die Teilnehmer maximal 16 Jahre alt sein. Jedes Team wird von einem volljährigen Coach bei der Bewältigung der Aufgaben angeleitet.

Die Wettbewerbsaufgaben werden immer Anfang September veröffentlicht, danach hat jedes Team ca. 8 Wochen Zeit seinen Roboter zu programmieren und den Forschungsauftrag zu erfüllen, um die Ergebnisse dann bei einem der Regionalwettbewerbe zu präsentieren.

'''Weblinks''':
* [http://www.firstlegoleague.org/ www.firstlegoleague.org]
* [http://www.firstlegoleague.de/ www.firstlegoleague.de]

==RoboCup Soccer==
Die Komplexität und Beliebtheit von Fußball (soccer) spielten wesentliche Rollen bei der Motivation der ersten RoboCupspiele Mitte der 90er Jahre. Die Dynamik und die Komplexität von Fußball birgt enorme Herausforderungen für Wissenschaftler, die sich mit der Entwicklung von autonomen Robotern in diesem Bereich beschäftigen:

Individuelle Herausforderungen: jeder Agent/Roboter muss Objekte erkennen, sich selbst lokalisieren, navigieren und den Ball bewegen können. Zu klären sind Fragen wie: was ist in diesem Moment wichtig in meiner Wahrnehmung? Ist meine Position und die der anderen Mitspieler bekannt?
Kooperation von Agenten: in einer dynamischen Echtzeitumgebung kommt es nicht auf einen einzelnen Spieler an, sondern besonders auf das kooperative Spiel, bei dem auch die Kommunikation eine große Rolle spielt.

Dynamische Echtzeitumgebung mit sich bewegenden Objekten, von denen einige intelligente Agenten sind, die gegen einen spielen. Diese Art von Umgebung ist z.B. auch im Straßenverkehr zu beobachten, wobei die anderen Verkehrsteilnehmer zwar keine Gegner sind, die meine Pläne durchkreuzen wollen, wo aber die Situationen beliebig komplex werden können.
RoboCupSoccer besteht aus fünf Ligen: der Simulationsliga, der Small-Size Liga, der Middle-Size Liga, der Sony Legged Liga, und der Humanoidliga.

'''Weblinks:'''
* [http://www.robocup.org www.robocup.org]

==RobotChallenge==
Die RobotChallenge ist ein österreichischer Wettbewerb für selbstgebaute, autonome Roboter, dessen Ziel es ist für den kreativen Umgang mit innovativen Technologien zu begeistern. Experimente und praktische Erfahrungen lassen Teilnehmer und Zuschauer Wissenschaft hautnah erleben. Dieser Wettbewerb soll zeigen, wie man mit einfachen Mitteln, aber offenem Geiste und Phantasie spannende, zukunftstaugliche Lösungen finden kann.
Folgende Disiplienen wurden dort schon ausgetragen:

'''Parallel-Slalom''' 
Möglichst schnell muss einer schwarzen Linie auf weißem Untergrund entlang gefahren werden. Reglement im Wesentlichen wie bei RC'05.

'''Parallel-Slalom Enhanced''' 
Wie Parallel-Slalom, jedoch mit Erschwernissen: ein Tunnel, eine kurze Unterbrechung der Linie und ein Hindernis auf der Linie, das umfahren werden muss.

'''Robot-Sumo''' 
Je zwei Roboter treten gegeneinander an und versuchen den jeweils anderen von einer runden Platte zu schieben. Die Platte ist schwarz, der Rand ist durch einen weissen Streifen markiert. Die Regeln entsprechen der internationalen Norm für autonomes Roboter-Sumo.

'''Hindernislauf''' 
Ein Infrarot-Leuchtturm mit definiertem Signal am Ende des Parcours ist möglichst rasch zu erreichen. Auf dem Weg befindliche Hindernisse müssen umfahren werden. Jedes Team kann alternativ auch einen eigenen Leuchtturm als Orientierungshilfe mitbringen. Reglement im Wesentlichen wie bei RC'05, jedoch sind auch komplexere Hindernisse (z.B. Sackgassen) möglich.

'''Puck Collect''' 
Je zwei Roboter - von denen einem die Farbe rot, dem anderen blau zugeteilt wird - treten gegeneinander an. Auf dem Spielfeld sind kleine rote und blaue Scheiben (Pucks) verteilt. Ziel ist es, möglichst schnell alle Pucks der eigenen Farbe einzusammeln und zur eigenen, farblich gekennzeichneten Homebase zu bringen.

'''Weblinks:'''
* [http://www.robotchallenge.at/ RobotChallenge]

==SPURT==
Der Wettbewerb SPURT (die Abkürzung steht für "Schüler-Projekte um Roboter-Technik") wird jährlich von der Universität Rostock veranstaltet. SPURT richtet sich an technikinteressierte Schüler. Die zu lösende Aufgabe ist eine Linienverfolgung. Wer am schnellsten die herzförmige Linie abfährt, hat gewonnen.

'''Weblinks:'''
* [http://spurt.uni-rostock.de/ Wettbewerb SPURT]

==ELROB==
Die deutsche Bundeswehr läd Firmen und Privatpersonen ein, am European Land-Robot Trial teilzunehmen (findet 2010 zum fünften Mal statt). Die ELROB wird veranstaltet, um einen Überblick über den europäischen State-of-the-art auf dem Gebiet von UGVs (unmanned ground vehicles) mit Fokus auf kurzfristig realisierbare Robotersystemen zu liefern. Hinsichtlich der vorhandenen Fähigkeiten versuchen die Organisatoren, technische Lösungen zu fördern, die den Betrieb unbemannter Fahrzeuge (UGV) verbessern. Repräsentanten aus Militär, Grenzschutz, Spezialkräften, Polizei, Feuerwehr, und Zivilschutzagenturen aus vielen europäischen Ländern werden anwesend sein. Die ELROB wird von einer Ausstellung begleitet, welche eine breite Vielzahl an Robotikaspekten umfasst.

'''Weblinks:'''
* [http://www.elrob.org/ Homepage von ELROB]

==ROBOCOM==
Bei diesem Wettbewerb soll eine vorgegebene Aufgabe mit LEGO MINDSTORMS NXT Robotern autonom, d.h. ohne Eingriffe von außen bewältigt werden. Mit diesem Wettbewerb möchte die Fachhochschule Gelsenkirchen in den Schulen den Einsatz moderner Techniken fördern und Schülerinnen und Schüler für ein naturwissenschaftliches Studium interessieren.

'''Weblinks:'''
* http://www2.fh-gelsenkirchen.de/FH-Sites/FB1/index.php?id=791

= Derzeit nicht regelmäßig stattfindende Wettbewerbe =

==RobotLiga==
Die RobotLiga fand bis 2007 in Kaiserslautern statt, neuere Termine sind nicht bekannt. Teilnehmen konnten alle interessierten Roboterbastler.

'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2cm breit.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 75cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://www.robotliga.de/ RobotLiga]

==RoboTest==
'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2 bis 3cm breit. Es starten immer zwei Roboter gleichzeitig in einem Parallelslalom. Der Wettbewerb läuft in mehreren Runden nach dem KO-System.

'''BLOCKED LINE''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Auf der Strecke stehen Hindernisse, die umfahren werden müssen.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2 bis 5cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, innerhalb von drei Minuten möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MICRO LINE''' 
Linienfolgen für sehr kleine Roboter. Die maximale Größe liegt bei 8x8x8cm und 200g. Je kleiner und leichter der Roboter ist, desto mehr Bonuspunkte gibt es.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''JUST WALK''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 1m zurücklegen, wenden, und die Strecke zurück laufen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://WWW.ROBOTEST.DE/ RoboTest]

==GSF Robot Contest==
Ein neuer Wettbewerb für Hobbyrobotiker. Er findet am 19.5.07 erstmals statt. Austragungsort ist Fröndenberg (Raum Dortmund/Unna).
Die Aufgaben sind teilweise angelehnt an die der RobotLiga.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegenrische Hälfte zu befördern.

'''FIRE FIGHTING''' 
Naqch einem akustischen "Feueralarm" muss eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude gefunden und gelöscht werden.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinader an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 100cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FREESTYLE''' 
In dieser Disziplin hat jeder Teilnehmer die Möglichkeit seinen Roboter vorzustellen und zu zeigen was dieser kann.

'''Weblinks:'''
* http://www.gsf-robot-contest.de/

==RoboKing==
RoboKing ist ein Wettbewerb für technikinteressierte Schüler, der jährlich von der TU Chemnitz organisiert wird. Jedes Team besteht aus 3 bis 5 Schülern und einem erwachsenem Teamleiter. RoboKing richtet sich ausdrücklich auch an Schülergruppen ohne große Vorkenntnisse. Ziel der Initiative ist, Schüler für ein Studium ingenieurwissenschaftlicher Fächer zu begeistern und zu zeigen, dass auch Schulfächer wie Physik und Informatik eine Menge Spaß machen können. Das Durchschnittsalter der Teilnehmer liegt bei etwa 16 Jahren. Die jüngsten Teilnehmer waren 10 Jahre alt.

Besonderes Highlight des Wettberwebs RoboKing ist zweifellos eine Gutschrift, von denen die Teilnehmer alle Materialien die zum Bau des Roboters benötigt werden, bezahlen können. Dadurch unterscheidet sich dieser Wettbewerb von allen vergleichbaren, denn auf die teilnehmenden Schüler kommen keine Kosten für Material zu. Jedes Jahr werden 25 Teams mit dieser Gutschrift finanziell unterstützt. Ab dem Wettbewerb RoboKing 2007 (startet im Frühjahr 2006) können zusätzlich auch alle Teams teilnehmen, die sich selbst finanzieren.

Die Endrunde des Wettbewerbs wurde 2004 und auf der Hannover Messe ausgetragen. 2006 fand das Finale auf der digital living / CeBIT statt.
Eine weitere Besonderheit des Wettbewerbs: Jedes Jahr müssen die Teilnehmer eine andere Aufgabenstellung lösen. Bei den vergangenen Wettbewerben mussten die Roboter sicher durch ein großes Labyrinth navigieren, Tennisbälle einsammeln und in die eigene Basis bringen oder Bauklötzchen durch einen Hindernisparcours mit Graben, Brücke und Schlucht transportieren. Die Teilnehmer haben nach Bekanntgabe der Spielregeln etwa 8 Monate Zeit, die Aufgabe zu lösen.

RoboKing finanziert sich ausschließlich über Spenden von zahlreichen Sponsoren. Verantwortlich für die Organisation sind die Mitarbeiter und Studenten der Professur Prozessautomatisierung der TU Chemnitz.

'''Weblinks:'''
* [http://www.roboking.de www.roboking.de]

[[Kategorie:Praxis]]

Roboterwettbewerbe

2011-06-20T14:52:31Z

Chypsylon: /* Überblick */

Auf diese Seite werden die bekanntesten nationalen und internationalen Roboterwettbewerbe kurz vorgestellt.

==Überblick==
{| {{Blauetabelle}}
|''' Wettbewerb primär für'''||Schüler ||Studenten || Hobbyrobotiker ||1 Person || bis 5 Personen || mehr als 5 Personen || nächster Termin || Ort
|-
|[[#Robocup_Junior|Robocup Junior]] || X || || || || X || || 5. bis 11.7.2011 , versch. Nationalbewerbe || WM in Istanbul, Nationale Bewerbe
|-
|[[#Eurobot|Eurobot]] || X || X || || || || X || 22. bis 27.06.2011 || Russland
|-
|[[#Carolo_Cup|Carolo Cup]] || || X || || || || X || 07. / 08.02.2011 || Braunschweig
|-
|[[#Field_Robot_Event|Field Robot Event]] || || X || || || || X || 30.6. - 02.07.2011 || Dänemark
|-
|[[#FIRST_Lego_League|FIRST LEGO Leaue]] || X || || || || || X || 4. - 30.11. in 52 Regionen(Zentraleuropa) ||
|-
|[[#RoboCup_Soccer|RoboCup Soccer]] || || X || || || || X || 04. - 10.07.2011 || Istanbul
|-
|[[#RobotChallenge|RobotChallenge]] || || || X || X || || || 12. / 13.03.2011 || Wien
|-
|[[#SPURT|SPURT]] || X || || || || X || || 20.05.2011 || Rostock
|-
|[[#ELROB|European Land Robot Trial (ELROB)]] || || X || || || || X || 20. - 24.07.2011 || Leuven, Belgien
|-
|[[#ROBOCOM|ROBOCOM]] || X || || || || X || || 15.07.2011 || Gelsenkirchen
|-
|[[#RobotLiga|RobotLiga]] || || || X || X || || || keine nach 2007 bekannt ||
|-
|[[#RoboTest|RoboTest]] || || || X || X || || || keine nach 2008 bekannt ||
|-
|[[#RoboKing|RoboKing]] || X || || || || X || || keine nach 2008 bekannt ||
|-
|[[#GSF_Robot_Contest|GSF Robot Contest]] || || || X ||X || X || || keine nach 2007 bekannt ||
|}

= Aktuelle Wettbewerbe =

==Eurobot==
"Seit 1998 ist Eurobot ein internationaler Roboterwettbewerb für Teams von Jugendlichen, Studenten und sonstigen an Robotern interessierten Menschen.
Eurobot findet stets in Europa statt, ist aber für alle Länder aller Kontinente zugänglich. Im Jahre 2004 nahmen insgesamt 250 Teams aus 21 Länder an diesem technisch/wissenschaftlichen Wettbewerb teil." (zitiert von www.eurobot.org)
Aus jedem Land dürfen maximal drei Teams zu den internationalen Finalen fahren. Diese drei Mannschaften müssen sich in nationalen Vorausscheiden qualifizieren. Die Aufgabe wird jedes Jahr neu gestellt. Nur die Rahmenbedingungen bleiben gleich: Ein Match dauert nur 90 Sekunden, es ist also sowohl Schnelligkeit als auch eine intelligente Taktik und Sicherheit gefragt. Die Spielfläche ist etwa 2x3 Meter groß.
Eurobot findet seit 2005 jedes Jahr in einem anderen Land statt. Der Wettbewerb wird von einer großen Rahmenveranstaltung inklusive Vorträgen und vielen Attraktionen für die zahlreichen Zuschauer ergänzt.

'''Weblinks''':
* [http://www.eurobot.org www.eurobot.org]
* [http://www.eurobot-deutschland.de www.eurobot-deutschland.de]

==Carolo Cup==
Dieser Wettbewerb für Studenten findet an der TU Braunschweig statt.
Es treten autonome Modellfahrzeuge im Maßstab 1:10 gegeneinander an. Aufgaben sind das Fahren auf einem Rundkurs (dabei muss die Fahrbahnmarkierung z.B. mit Kameras erkannt werden) und das seitliche Einparken in einer vorgegebenen Parklücke. 

'''Weblinks''':
* [http://www.carolo-cup.de www.carolo-cup.de]

==Field Robot Event==
Dieser Wettbewerb für Studenten findet auf einem Maisfeld statt. Die Roboter müssen den Maisreihen folgen und "Unkraut" erkennen, wobei es mehrere Schwierigkeitsgrade gibt (z.B. können einzelne Pflanzen fehlen, oder es gibt größere Unebenheiten im Boden).
2011 wird der Wettbewerb in Dänemark ausgetragen.

'''Weblinks''':
* [http://www.fre2011.dk/ http://www.fre2011.dk/]

==FIRST Lego League==
Bei der FIRST LEGO League (FLL) handelt es sich um einen internationalen Wettbewerb der von der Firma LEGO und der amerikanischen Stiftung FIRST (For Inspiration and Recognition of Science and Technology) veranstalltet wird. Er findet jährlich auf der ganzen Welt mit regionalen Runden statt und steht jedes Jahr unter einem neuen Motto.

Der Wettbewerb beschäftigt sich immer mit aktuellen naturwissenschaftlichen Problemen, die gesellschaftlich relevant sind. Dabei sollen die Kinder nicht nur einen Roboter programmieren, der Aufgaben auf dem vorgegebenen Spielfeld erfüllt, sondern sich auch tiefgründig mit dem Wettbewerbsthema auseinandersetzen. Die Teilnehmer sollen einen Lösungsansatz für ein aktuelles Probleme erarbeiten, dass mit dem Wettbewerbsthema in Verbindung steht. 2010 heißt das Thema von FLL "Body Forward" und dabei dreht sich alles um Biomedizin.

Bei diesem Wettbewerb dürfen nur Roboter eingesetzt werden, die aus dem LEGO Mindstorms System bestehen. Der Wettbewerb richtet sich vornehmlich an junge Schüler, wie auch das gesamte Mindstorms System. Deshalb dürfen die Teilnehmer maximal 16 Jahre alt sein. Jedes Team wird von einem volljährigen Coach bei der Bewältigung der Aufgaben angeleitet.

Die Wettbewerbsaufgaben werden immer Anfang September veröffentlicht, danach hat jedes Team ca. 8 Wochen Zeit seinen Roboter zu programmieren und den Forschungsauftrag zu erfüllen, um die Ergebnisse dann bei einem der Regionalwettbewerbe zu präsentieren.

'''Weblinks''':
* [http://www.firstlegoleague.org/ www.firstlegoleague.org]
* [http://www.firstlegoleague.de/ www.firstlegoleague.de]

==RoboCup Soccer==
Die Komplexität und Beliebtheit von Fußball (soccer) spielten wesentliche Rollen bei der Motivation der ersten RoboCupspiele Mitte der 90er Jahre. Die Dynamik und die Komplexität von Fußball birgt enorme Herausforderungen für Wissenschaftler, die sich mit der Entwicklung von autonomen Robotern in diesem Bereich beschäftigen:

Individuelle Herausforderungen: jeder Agent/Roboter muss Objekte erkennen, sich selbst lokalisieren, navigieren und den Ball bewegen können. Zu klären sind Fragen wie: was ist in diesem Moment wichtig in meiner Wahrnehmung? Ist meine Position und die der anderen Mitspieler bekannt?
Kooperation von Agenten: in einer dynamischen Echtzeitumgebung kommt es nicht auf einen einzelnen Spieler an, sondern besonders auf das kooperative Spiel, bei dem auch die Kommunikation eine große Rolle spielt.

Dynamische Echtzeitumgebung mit sich bewegenden Objekten, von denen einige intelligente Agenten sind, die gegen einen spielen. Diese Art von Umgebung ist z.B. auch im Straßenverkehr zu beobachten, wobei die anderen Verkehrsteilnehmer zwar keine Gegner sind, die meine Pläne durchkreuzen wollen, wo aber die Situationen beliebig komplex werden können.
RoboCupSoccer besteht aus fünf Ligen: der Simulationsliga, der Small-Size Liga, der Middle-Size Liga, der Sony Legged Liga, und der Humanoidliga.

'''Weblinks:'''
* [http://www.robocup.org www.robocup.org]

==RobotChallenge==
Die RobotChallenge ist ein österreichischer Wettbewerb für selbstgebaute, autonome Roboter, dessen Ziel es ist für den kreativen Umgang mit innovativen Technologien zu begeistern. Experimente und praktische Erfahrungen lassen Teilnehmer und Zuschauer Wissenschaft hautnah erleben. Dieser Wettbewerb soll zeigen, wie man mit einfachen Mitteln, aber offenem Geiste und Phantasie spannende, zukunftstaugliche Lösungen finden kann.
Folgende Disiplienen wurden dort schon ausgetragen:

'''Parallel-Slalom''' 
Möglichst schnell muss einer schwarzen Linie auf weißem Untergrund entlang gefahren werden. Reglement im Wesentlichen wie bei RC'05.

'''Parallel-Slalom Enhanced''' 
Wie Parallel-Slalom, jedoch mit Erschwernissen: ein Tunnel, eine kurze Unterbrechung der Linie und ein Hindernis auf der Linie, das umfahren werden muss.

'''Robot-Sumo''' 
Je zwei Roboter treten gegeneinander an und versuchen den jeweils anderen von einer runden Platte zu schieben. Die Platte ist schwarz, der Rand ist durch einen weissen Streifen markiert. Die Regeln entsprechen der internationalen Norm für autonomes Roboter-Sumo.

'''Hindernislauf''' 
Ein Infrarot-Leuchtturm mit definiertem Signal am Ende des Parcours ist möglichst rasch zu erreichen. Auf dem Weg befindliche Hindernisse müssen umfahren werden. Jedes Team kann alternativ auch einen eigenen Leuchtturm als Orientierungshilfe mitbringen. Reglement im Wesentlichen wie bei RC'05, jedoch sind auch komplexere Hindernisse (z.B. Sackgassen) möglich.

'''Puck Collect''' 
Je zwei Roboter - von denen einem die Farbe rot, dem anderen blau zugeteilt wird - treten gegeneinander an. Auf dem Spielfeld sind kleine rote und blaue Scheiben (Pucks) verteilt. Ziel ist es, möglichst schnell alle Pucks der eigenen Farbe einzusammeln und zur eigenen, farblich gekennzeichneten Homebase zu bringen.

'''Weblinks:'''
* [http://www.robotchallenge.at/ RobotChallenge]

==SPURT==
Der Wettbewerb SPURT (die Abkürzung steht für "Schüler-Projekte um Roboter-Technik") wird jährlich von der Universität Rostock veranstaltet. SPURT richtet sich an technikinteressierte Schüler. Die zu lösende Aufgabe ist eine Linienverfolgung. Wer am schnellsten die herzförmige Linie abfährt, hat gewonnen.

'''Weblinks:'''
* [http://spurt.uni-rostock.de/ Wettbewerb SPURT]

==ELROB==
Die deutsche Bundeswehr läd Firmen und Privatpersonen ein, am European Land-Robot Trial teilzunehmen (findet 2010 zum fünften Mal statt). Die ELROB wird veranstaltet, um einen Überblick über den europäischen State-of-the-art auf dem Gebiet von UGVs (unmanned ground vehicles) mit Fokus auf kurzfristig realisierbare Robotersystemen zu liefern. Hinsichtlich der vorhandenen Fähigkeiten versuchen die Organisatoren, technische Lösungen zu fördern, die den Betrieb unbemannter Fahrzeuge (UGV) verbessern. Repräsentanten aus Militär, Grenzschutz, Spezialkräften, Polizei, Feuerwehr, und Zivilschutzagenturen aus vielen europäischen Ländern werden anwesend sein. Die ELROB wird von einer Ausstellung begleitet, welche eine breite Vielzahl an Robotikaspekten umfasst.

'''Weblinks:'''
* [http://www.elrob.org/ Homepage von ELROB]

==ROBOCOM==
Bei diesem Wettbewerb soll eine vorgegebene Aufgabe mit LEGO MINDSTORMS NXT Robotern autonom, d.h. ohne Eingriffe von außen bewältigt werden. Mit diesem Wettbewerb möchte die Fachhochschule Gelsenkirchen in den Schulen den Einsatz moderner Techniken fördern und Schülerinnen und Schüler für ein naturwissenschaftliches Studium interessieren.

'''Weblinks:'''
* http://www2.fh-gelsenkirchen.de/FH-Sites/FB1/index.php?id=791

= Derzeit nicht regelmäßig stattfindende Wettbewerbe =

==RobotLiga==
Die RobotLiga fand bis 2007 in Kaiserslautern statt, neuere Termine sind nicht bekannt. Teilnehmen konnten alle interessierten Roboterbastler.

'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2cm breit.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 75cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://www.robotliga.de/ RobotLiga]

==RoboTest==
'''LINE SEARCH''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Die Linie ist 2 bis 3cm breit. Es starten immer zwei Roboter gleichzeitig in einem Parallelslalom. Der Wettbewerb läuft in mehreren Runden nach dem KO-System.

'''BLOCKED LINE''' 
Linienfolgen auf einer Strecke ohne Abzweigungen. Auf der Strecke stehen Hindernisse, die umfahren werden müssen.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2 bis 5cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, innerhalb von drei Minuten möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegnerische Hälfte zu befördern.

'''MICRO LINE''' 
Linienfolgen für sehr kleine Roboter. Die maximale Größe liegt bei 8x8x8cm und 200g. Je kleiner und leichter der Roboter ist, desto mehr Bonuspunkte gibt es.

'''FIRE FIGHTING''' 
Es geht darum, eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude zu finden und zu löschen.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinander an und versuchen, sich aus dem Ring zu schieben.

'''JUST WALK''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 1m zurücklegen, wenden, und die Strecke zurück laufen.

'''FREE ROBOTS''' 
Hier können eigene Roboter dem Publikum vorgestellt werden.

'''Weblinks:'''
* [http://WWW.ROBOTEST.DE/ RoboTest]

==GSF Robot Contest==
Ein neuer Wettbewerb für Hobbyrobotiker. Er findet am 19.5.07 erstmals statt. Austragungsort ist Fröndenberg (Raum Dortmund/Unna).
Die Aufgaben sind teilweise angelehnt an die der RobotLiga.

'''LABYRINTH''' 
Linienfolgen auf einer Strecke mit Abzweigungen und Kreuzungen. Die Linie ist 2cm breit.

'''ROBOT COLLECT''' 
Auf einem Spielfeld von 3x3m sind 30 Objekte in der Größe von Teelichtern verteilt. Zwei Roboter treten gegeneinander an und versuchen, möglichst viele der Objekte in ihre eigene Heimatecke des Spielfeldes zu bringen.

''' ROBOT VOLLEY''' 
Das Spielfeld ist 2x4m groß und wird durch eine Wand (als "Netz") in zwei Hälfte geteilt, in denen je ein Roboter positioniert wird. In jeder Hälfte befinden sich am Anfang zehn Bälle. Die Roboter müssen nun innerhalb von fünf Minuten versuchen, möglichst viele der Bälle einzusammeln und in die gegenrische Hälfte zu befördern.

'''FIRE FIGHTING''' 
Naqch einem akustischen "Feueralarm" muss eine brennende Kerze in einem durch mehrere Wände angedeuteten Gebäude gefunden und gelöscht werden.

'''MINI SUMO''' 
Zwei Roboter treten gegeneinader an und versuchen, sich aus dem Ring zu schieben.

'''WALKING''' 
Eine Disziplin nur für Laufroboter. Der Roboter muss schnellstmöglich eine Strecke von 100cm zurücklegen, wenden, und die Strecke zurück laufen.

'''FREESTYLE''' 
In dieser Disziplin hat jeder Teilnehmer die Möglichkeit seinen Roboter vorzustellen und zu zeigen was dieser kann.

'''Weblinks:'''
* http://www.gsf-robot-contest.de/

==RoboKing==
RoboKing ist ein Wettbewerb für technikinteressierte Schüler, der jährlich von der TU Chemnitz organisiert wird. Jedes Team besteht aus 3 bis 5 Schülern und einem erwachsenem Teamleiter. RoboKing richtet sich ausdrücklich auch an Schülergruppen ohne große Vorkenntnisse. Ziel der Initiative ist, Schüler für ein Studium ingenieurwissenschaftlicher Fächer zu begeistern und zu zeigen, dass auch Schulfächer wie Physik und Informatik eine Menge Spaß machen können. Das Durchschnittsalter der Teilnehmer liegt bei etwa 16 Jahren. Die jüngsten Teilnehmer waren 10 Jahre alt.

Besonderes Highlight des Wettberwebs RoboKing ist zweifellos eine Gutschrift, von denen die Teilnehmer alle Materialien die zum Bau des Roboters benötigt werden, bezahlen können. Dadurch unterscheidet sich dieser Wettbewerb von allen vergleichbaren, denn auf die teilnehmenden Schüler kommen keine Kosten für Material zu. Jedes Jahr werden 25 Teams mit dieser Gutschrift finanziell unterstützt. Ab dem Wettbewerb RoboKing 2007 (startet im Frühjahr 2006) können zusätzlich auch alle Teams teilnehmen, die sich selbst finanzieren.

Die Endrunde des Wettbewerbs wurde 2004 und auf der Hannover Messe ausgetragen. 2006 fand das Finale auf der digital living / CeBIT statt.
Eine weitere Besonderheit des Wettbewerbs: Jedes Jahr müssen die Teilnehmer eine andere Aufgabenstellung lösen. Bei den vergangenen Wettbewerben mussten die Roboter sicher durch ein großes Labyrinth navigieren, Tennisbälle einsammeln und in die eigene Basis bringen oder Bauklötzchen durch einen Hindernisparcours mit Graben, Brücke und Schlucht transportieren. Die Teilnehmer haben nach Bekanntgabe der Spielregeln etwa 8 Monate Zeit, die Aufgabe zu lösen.

RoboKing finanziert sich ausschließlich über Spenden von zahlreichen Sponsoren. Verantwortlich für die Organisation sind die Mitarbeiter und Studenten der Professur Prozessautomatisierung der TU Chemnitz.

'''Weblinks:'''
* [http://www.roboking.de www.roboking.de]

[[Kategorie:Praxis]]