[Tic-Tac-Toe Reloaded]

News zum Workshop

An dieser Stelle zunächst ein Dankeschön an alle Teilnehmer, der Workshop mit euch hat uns sehr viel Freude gemacht. Wir hoffen natürlich, euch auch.

Hier sind die Links zu den Archiven:

tic_tac_toe_reloaded-1.0.zip - Dokumentation und Quelltext zum Workshop
uracoli-src-0.2.0.zip - µracoli-Source-Paket Version 0.2.0
addon_slides.pdf - zusätzliche Folien zum Workshop

Probleme unter MAC-OS

Das Problem, das sich während des Worshops zeigte, tritt (plattformunabhängig) auf, wenn ein GCC >=4.6.x verwendet wird. Die Lösung gibt es hier.

Wie sind die Platinen entstanden?

Wie versprochen, gibt es hier noch eine bebilderte Dokumentation, die die Herstellung der Platinen auf dem heimischen Basteltisch zeigt.

Überblick

Das Spiel Tic-Tac-Toe wird in einer Hardwareversion neu implementiert, wobei die entwickelte Schaltung bewußt minimalistisch gehalten wurde.

Zur Steuerung des Spiels kommt ein Mikrocontroller ATmega128RFA1 zum Einsatz, über dessen Funkschnittstelle die beiden Spielgegner kommunizieren. Die Eingabe erfolgt jeweils über ein kapazitives oder resistives Touchfeld, und zur Anzeige des Spielstandes werden zweifarbigen LEDs eingesetzt.

Die wichtigsten Fragen zum Workshop

Kann ich am Workshop teilnehmen, auch wenn ich kompletter AVR-Neuling bin?

Ja, wenn dich das Thema interessiert und du bereits selbst etwas in C programmiert hast, dann melde dich auf alle Fälle an. Wir beginnen im Workshop bei den Grundlagen und enden mit einer einfachen Implementierung des Spiels.
Was kostet der Workhop?

Die Kosten belaufen sich auf insgesamt 30,-EUR, weitere Details findest du hier.
Was muss ich zum Workshop mitbringen?

Einen Laptop, möglichst mit vorinstallierter AVR-Software, weitere Details findest du hier.
Kann ich meinen AVR-ISP im Workshop benutzen?

Nein, die Platinen haben nur ein JTAG-Interface. Wir bringen aber genügend AVR-Dragons für alle Workshop-Teilnehmer mit.

Die Hardware

Bilder zum Vergößern anklicken.

Das Hardware-Set besteht aus zwei Platinen, die mit einem ATmega128RFA1 bestückt sind. Dieser 8-Bit-Controller der Firma Atmel besitzt neben 128 KiByte FLASH-Programmspeicher, 16 KiByte RAM und 4 KiByte EEPROM noch eine Funkschnittstelle nach dem IEEE-802.15.4-Standard, die zur Kommunikation zwischen den beiden Spielern benutzt wird. An die digitalen IOs des Controllers sind die LED-Matrix und die Berührungssensoren angeschlossen. Auf jedem Board ist der JTAG-, UART- und I2C-Port herausgeführt, so dass im Anschluss an den Workshop eigene Hardware-Erweiterungen vorgenommen werden können. Jedes Board wird über 2xLR03-Batterien mit der notwendigen Betriebsspannung versorgt.

Die Kosten

Da es Platinen und Bauelemente nicht kostenlos gibt, müssen wir die Materialkosten auf euch umlegen. Für 25,- EUR bekommt ihr ein Tic-Tac-Toe-Set bestehend aus je einer kapazitiven und einer resistiven Platine, einem JTAG-Adapter, Batterien und einer CD mit der Software.

Zu erwähnen bleibt noch, dass dieser für eine Kleinserie sehr günstige Preis zustande kommt, da uns folgende Firmen unterstützten:

Firma Atmel sponsorte die ATmega128RFA1-Mikrocntroller.
Jakob Kleinen von http://www.platinensammler.de machte uns einen sehr guten Platinenpreis.

Zuzüglich zu den Hardwarekosten ist noch eine Workshopgebühr von 5,-EUR an die Organisatoren des Linuxtages zu bezahlen, so dass euch der ganze Spass insgesamt 30,- EUR kostet.

Der Workshop Inhalt

Im Workshop wird die Software in einzelnen Teilmodulen (Tastaturscan, LED-Ansteuerung, Funkkomunikation und Spiellogik) auf dem Mikrocontoller entwickelt und debuggt. Dabei kommt die AVR GNU-Toolchain und ein JTAG-Debugger vom Typ AVR Dragon zum Einsatz.

Hauptaugenmerk liegt dabei vor allem auf direkter Bedienung der Hardware sowie auf dem Kennenlernen entsprechender Konzepte wie Zeitmulitplex-Ansteuerung, resistive und kapazitive Sensortechnik ("touch"). Für die Funkkommunikation kommt die µracoli-Bibliothek zum Einsatz, da eine "from scratch"-Implementierung den zeitlichen Rahmen sprengen würde.

Vorbereitung

Hardware

Um erfolgreich auf dem Workshop Embedded Software zu übersetzen und debuggen, solltet ihr folgendes mitbringen:

einen Laptop oder PC mit installiertem Linux oder FreeBSD. Der Rechner sollte einen freien USB-Port haben und vorzugsweise auch ein CD-ROM Laufwerk. Wir werden zwar auch ein paar USB-Sticks mit der Software dabeihaben, aber das Herumreichen kostet Zeit, die dann bei der eigentlichen Arbeit fehlt.
Falls bereits vorhanden, könnt ihr einen AVR Dragon oder ein JTAGICEmkII mitbringen. Wir bringen zwar ausreichend AVR-Dragon-Leihgeräte mit, aber vielleicht möchtet ihr ja lieber mit eurer eigenen Technik arbeiten. Das Board hat keinen ISP Anschluss, d.h. Geräte wie den AVR-ISP braucht ihr nicht mitbringen, die nutzen beim Workshop nichts.

Software

Zunächst einmal ist es notwenig, Administrationsrechte auf dem Laptop zu haben, um auf den Programmer zugreifen zu können (oder fehlende Software nachinstallieren zu können). Unter Ubuntu ist die sudo-Fähigkeit bereits eingebaut. Unter Fedora beispielsweise ist diese leicht nachzurüsten. Um die beiden Tools avrdude und avarice als root ausführen zu können, editiert man die Datei /etc/sudoers mit dem Kommando visudo -f /etc/sudoers und hängt folgende beiden Zeilen an:

mylogin ALL=(root) NOPASSWD: /usr/bin/avrdude
mylogin ALL=(root) NOPASSWD: /usr/bin/avarice

mylogin ist hierbei der persönliche Nutzername; die Pfadangabebn der beiden Programme avrdude und avarice müssen bei Bedarf angepasst werden.

Die Installation der nötigen Pakete kann auf verschiedene Weise erfolgen. Bei Verwendung einer relativ aktuellen Linux-Distribution kann der Paketmanager bemüht werden:

Unter Debian und Ubuntu sollte dies mit dem folgenden Kommando erfolgen:

sudo apt-get install avr-libc binutils-avr gcc-avr avrdude avarice gdb-avr

Unter Fedora heisst das entsprechende Kommando:

yum install avr-gcc avr-binutils avrdude avarice avr-libc avr-gdb

Über Hinweise, wie Nutzer anderer Distributionen zum gewünschten Ergebnis kommen, wären wir dankbar.

Schließlich ist es auch möglich, die AVR-Toolchain selbst zu kompilieren. Wie das geschehen kann, ist auf einer separaten Seite nachzulesen.

Erste Softwaretests

Erste Tests der installierten Toolchain sind von Vorteil.

avrdude

Der verwendete Controller ATmega128RFA1 muss unterstützt werden. Das Kommando avrdude -p? gibt eine Liste aller unterstützten Devices aus. Oder kurz:

avrdude -p? |& grep -i RFA1 sollte eine Zeile wie

m128rfa1 = ATMEGA128RFA1 [/etc/avrdude.conf:11145] ausgeben.

avr-libc

Die AVR-libc sollte in der Version ab 1.7.1 vorliegen. Das kann beispielsweise folgendermaßen abgefragt werden:

Ubuntu: dpkg-query --show avr-libc
Fedora: rpm -q avr-libc

Wenn das Kompilieren des kleinen Testprogramms (unten) fehlerfrei durchläuft, ist die installierte Version der AVR-libc ausreichend.

Ein einfaches Programm kompilieren

Nun sollte es möglich sein, testweise ein kleines C-Programm zu kompilieren, um die Toolchain zu testen. Hierfür eignet sich das kleine Programm avrtest.c

Nach Ausführen der folgenden Kommandos sollte ein File avrtest.hex entstanden sein, welches auf einen ATmega128RFA1 Mikrocontroller geladen werden könnte.

avr-gcc -Wall -mmcu=atmega128rfa1 -Os -o avrtest.elf avrtest.c
avr-objcopy -O ihex avrtest.elf avrtest.hex

Bei der Ausführung der beiden Kommandos sollten keine Fehlermeldungen oder Warnungen ausgegeben werden. Alternativ kann über die zusätzliche Option -Wa,-adhlns=avrtest.lst im Compile-Schritt (erste Zeile) noch ein Assembler-Listing File avrtest.lst erzeugt werden. Das im zweiten Schritt entstandene File avrtest.hex sollte in etwa so aussehen:

:100000000C9490000C949A000C949A000C949A0012
:100010000C949A000C949A000C949A000C949A00F8
:100020000C949A000C949A000C949A000C949A00E8
:100030000C949A000C949A000C949A000C949A00D8
:100040000C949A000C949A000C949A000C949A00C8
:100050000C949A000C949A000C949A000C949A00B8
:100060000C949A000C949A000C949A000C949A00A8
:100070000C949A000C949A000C949A000C949A0098
:100080000C949A000C949A000C949A000C949A0088
:100090000C949A000C949A000C949A000C949A0078
:1000A0000C949A000C949A000C949A000C949A0068
:1000B0000C949A000C949A000C949A000C949A0058
:1000C0000C949A000C949A000C949A000C949A0048
:1000D0000C949A000C949A000C949A000C949A0038
:1000E0000C949A000C949A000C949A000C949A0028
:1000F0000C949A000C949A000C949A000C949A0018
:100100000C949A000C949A000C949A000C949A0007
:100110000C949A000C949A000C949A000C949A00F7
:1001200011241FBECFEFD1E4DEBFCDBF0E949C00E3
:100130000C94AD000C9400008FE384B987E085B97E
:1001400085B1809585B98FE996E8A1E0815090400E
:0E015000A040E1F700C00000F3CFF894FFCF0D
:00000001FF

Für Fragen oder Hinweise wendet Euch bitte an unsere auf der Workshopseite angegebenen E-Mail-Adressen.

GCC Problem

Das Problem beim Übersetzen von µracoli unter MAC-OS konnten wir leider erst nach dem Workshop lösen.

Die Fehlermeldung war:

libradio/trx_datarate_str.c:115:7: error: variable 'rate_strtable' must be \
    const in order to be put into read-only section by means of \
    '__attribute__((progmem))'
make[1]: *** [obj/xxo_trx_datarate_str.o] Fehler 1
make[1]: Verlasse Verzeichnis '..../uracoli-src-0.2.0/src'
make: *** [xxo] Fehler 2
make: Verlasse Verzeichnis '..../uracoli-src-0.2.0/src'

Der Fehler trat im Zusammenhang mit PGM_P auf und wie sich herausstellte, waren einige fehlende "const" Statements die Ursache. Der Patch uracoli-src-0.2.0-gcc_4.6.x.patch beseitigt das Problem. Er ist wie folgt zu anzuwenden:

cd uracoli-src-0.2.0
patch -p1 -i uracoli-src-0.2.0-gcc_4.6.x.patch
make -C src xxo

Tic-Tac-Toe Reloaded