DVA Versuche
Inhalt
1 Versuche mit 8-Bit AVR Controllern
1.1 V1: AVR Grundlagen
Foto
Beschreibung
Bei diesem Versuch lernen Sie den elementaren Umgang mit einem Atmel AVR Mikrocontroller. Sie werden selber eine Schaltung aus einzelnen Bauelementen auf einem Steckbrett aufbauen und in Betrieb nehmen. Wir werden dazu einen der Controller AVR Mega8, Mega88 oder Mega32 verwenden. Auf Ihrem Notebook werden Sie unter Linux die GCC Toolchain installieren und ein kleines Demo-Programm in der Sprache C schreiben, das nach dem Kompilieren mit Hilfe eines Download-Werkzeuges auf den Atmel Controller übertragen ("geflasht") wird.
Ziele
- Grundlegende Hardware-Kenntnisse zum Betrieb eines Mikrocontrollers erwerben.
- Kennenlernen aller notwendigen Schritte um einen AVR zu programmieren.
- ISP/JTAG Adapter kennenlernen (Atmel ISP mkII, Atmel Dragon, USBprog, JTAGICE mkII, JTAGICE3).
- Verschiedene Compiler und IDEs kennenlernen
- Atmel AVR Studio 6 (Windows, kommerziell)
- WinAVR (Windows, frei unter GPL Lizenz)
- avr-gcc (Linux, frei unter GPL Lizenz)
Material
- AVR Mikrocontroller
- Drähte
- ISP Wannenstecker
- ISP Programmieradapter
- Steckbrett
Links
Homepage des Herstellers Atmel
AVR Tutorial
AVR GCC Tutorial
AVR Freaks Community
AVR im Labor
http://elk.informatik.hs-augsburg.de/hhweb/labor/avr/index.html
B. Liehr, Einführung in die Programmierung des AVR-Controllers (Creative Commons Lizenz)
Download Bereich für AtmelStudio-6 (login/pwd nötig)
WinAVR
1.2 V2: Das Arduino Projekt
Foto
Beschreibung
Im Versuch V1 haben wir die Verwendung des Atmel AVR auf der untersten technischen Ebene gelernt. Das Arduino Projekt verwendet auch den Atmel AVR Controller, jedoch wird die Programmierung durch eine eigene IDE und einer eigenen Programmiersprache, die stark an C++ angelehnt ist, vereinfacht. Die Kehrseite dieser vereinfachten Verwendung ist, dass die zugrunde liegende Funktionweise verschleiert wird.
Ziele
- Unterschiede zwischen low-level Programmierung und Arduino-Programmierung erkennen.
- "Physical Computing" Plattformen studieren.
Links
Homepage des Arduino Projektes
Verwandte Projekte
- Pinguino (PIC32): https://www.olimex.com/Products/Duino/PIC32/
- Maple (STM32): http://wiki.leaflabs.com
Material
- Arduino UNO
1.4 V4: Octopus
Foto
Beschreibung
Octopus ist ein kleines Hardware-Modul, das man über USB an den PC steckt. Man kann man es als Erweiterung für den PC verstehen, um mit allen in der Mikrocomputertechnik üblichen Schnittstellen zu kommunizieren: GPIO, UART, SPI, I2C, A/D, D/A (PWM) und CAN. Das sind die wesentlichen Schnittstellen des Atmel AVR AT90CAN128, der auf dem Octopus verwendet wird. Fast das komplette USB Protokoll wird in der Firmware des AVR erledigt.
Um mit Octopus zu kommunizieren, verwendet man auf dem PC auf unterster Ebene die Bibliothek liboctopus, die in der Sprache C geschrieben wurde. Es gibt auch eine höhere Ebene, die man von high-level Sprachen wie z.B. Python verwenden kann.
Ziele
- Kennenlernen der USB Kommunikation
- Kennenlernen der verschiedenen Mikrocontroller-Schnittstellen.
- Kennenlernen der Organisation eines freien Projektes.
Links
http://shop.embedded-projects.net/Open-Source_Projekte/Octopus
Buch von Benedikt Sauter: "Messen, Steuern und Regeln mit USB", Franzis Verlag 2009.
http://www.franzis.de/elektronik/messtechnik/messen-steuern-und-regeln-mit-usb-screenshots
Material
- 1 x Octopus
- 1 x USB Kabel
- 1 x Lochraster Basisplatine
2 Versuche mit 32-Bit ARM Controllern
2.1 A1: Make Controller Kit
ACHTUNG: DIESEN VERSUCH GIBT ES NICHT MEHR, DA DAS PRODUKT EINGESTELLT WURDE.
Foto
Beschreibung
Bei diesem Versuch nehmen Sie das "Make Controller Kit" der kanadischen Firma MakingThings in Betrieb. Die Hardware besteht aus einem Aufsteckboard, das einen Atmel "Smart ARM" Controller AT91SAM7X enthält und aus einer Basisplatine, umd die Verbindungen zur Aussenwelt einfach über Schraubanschlüsse herzustellen. Der SAM7X hat einen ARM7TDMI CPU Kern und viele Peripheriemodule, unter anderem sogar CAN, USB und Ethernet. Der Programmspeicher (Flash) ist 256K gross, der Speicher für flüchtige Daten (RAM) ist 64K gross.
Ziele
- Board anschliessen an den Entwicklungsrechner.
- Installation der Werkzeugkette.
- "Flashen" des Boards mit einer Anwendung.
- Einblicke in den Atmel SAM7X256 sammeln: CPU und Peripheriemodule studieren (GPIO, UART, SPI, PWM, A/D, I2C, USB, Ethernet, CAN).
- Überblick über das Firmware API bekommen.
- Programmieren/nachvollziehen einer einfachen Demo-Applikation.
- Ihr Bericht soll Neulingen helfen, den Einstieg in das Make Kit zu schaffen.
Links
MakingThings
Atmel SAM7 Produkte
Material
- Make Controller Kit
- USB Kabel
- Ethernet Kabel
- Stromversorgung (?)
2.2 A2: FreeRTOS auf SAM7X
Foto
Beschreibung
Mit dem freien Echtzeitbetriebsssytem FreeRTOS (RTOS = Real Time Operating System) kann man komplexe Programmieraufgaben anschaulich durch quasi-parallele Tasks beschreiben. Dieses RTOS gibt es mittlerweile für eine grosse Zahl an unterschiedlichen Mikrocontrollern, unter anderem für den Atmel SAM7X, einem Controller mit ARM7TDMI Kern. Auf dem Board "SAM7-EX256" von Olimex befindet sich ein AT91SAM7X256 Mikrocontroller, der alle wichtigen Schnittstellen und auch den Programm- (256K) und Datenspeicher (64K) integriert hat.
Da dieser Mikrocontroller einen "ARM Kern" hat, kann man damit den freien JTAG Debugger "OpenOCD" verwenden.
Ziele
- Das Olimex "SAM7-EX256" kennenlernen
- Den AT91SAM7X256 Controller kennenlernen (ARM7TDMI Kern)
- FreeRTOS kennenlernen
- OpenOCD kennenlernen zum Flashen der Programme und zum Debuggen.
Links
Info zum Board: https://www.olimex.com/Products/ARM/Atmel/SAM7-EX256
FreeRTOS: http://www.freertos.org
Hubert Högl, "GNU Software und der SAM7X", 2012
http://elk.informatik.hs-augsburg.de/hhweb/labor/arm/sam7x/sam7x-gnu.html
ARM im Labor
Advanced Risc Machines (ARM): http://www.arm.com
Material
- 1 x Olimex SAM7-EX256, komplett aufgebaut mit OpenOCD JTAG Adapter von www.eproo.net (inkl. RS-232), USB-zu-Ethernet Adapter, USB Hub, Netzteil für USB Hub.
2.3 A3: mbed Mikrocontroller
Foto
Beschreibung
Der "mbed" Mikrocontroller ist eigentlich nur eine der üblichen kleinen Platine, die einen NXP LPC1768 Controller mit Cortex-M3 Kern enthält. Sie wird über USB an einen PC angeschlossen. Einige der auf dem Modul gespeicherten Daten erscheinen anschliessend im Dateimanager des PC. Zur sonst üblichen "schweren" Entwicklungsumgebung (IDE) gelangt man hier aber federleicht durch Anklicken eines Links im Web-Browser. Die IDE läuft nämlich auf einem Server von NXP als Web-Applikation. Sie editieren und kompilieren Ihre Programmtexte also über das Web. Zum Flashen der Software wird das Kompilat über das Web zu Ihrem PC geholt und per USB in den Controller geschoben.
Ziele
- Kennenlernen des LPC1768.
- Kennenlernen der Web-IDE.
- Anfertigen eines Beispielprogrammes.
Links
- http://www.mbed.org
- http://www.nxp.com (dann Suche nach LPC1768)
- http://www.nxp.com/documents/data_sheet/LPC1768_66_65_64.pdf
Material
- 1 x mbed Modul mit LPC1768 Mikrocontroller (bestellt bei http://www.farnell.de)
- 1 x USB Kabel
2.4 A4: STM32 Discovery (Cortex M3)
Der Cortex M3 (CM3) Controller etabliert sich an der Hochschule Augsburg in den Fachbereichen Elektrotechnik und Informatik gerade als "Standard Controller", der die Nachfolge des nun schon deutlich veralteten MC68000 antritt. Ein mit unter 10 Euro sehr preiswertes CM3 Board ist das STM32 Discovery:
http://www.st.com/internet/evalboard/product/250863.jsp
Schön daran ist, dass der JTAG (SWD) Adapter direkt auf dem Board enthalten ist, so dass man OpenOCD ohne separate Hardware nutzen kann. Die Programmierung kann vollständig mit freier Software unter Linux erfolgen.
Hier ist ein Artikel, der die Programmierung des STM32 Discovery mit GNU Tools beschreibt:
http://elk.informatik.hs-augsburg.de/es2-doc/stm32vldiscovery
2.5 A5: LM3S811 Kit (Cortex M3)
Hier gilt der gleiche Text, den ich schon vorher beim STM32 Discovery geschrieben habe. Die "Stellaris" Controller von "Luminary Micro" (jetzt Texas Instruments) eignen sich auch hervorragend für ein modernes Mikrocontroller Praktikum. Dieses Kit ist allerdings mit 30 bis 40 Euro etwas teurer als das Discovery:
http://www.ti.com/lit/ml/spmt196b/spmt196b.pdf
Die Programmierung kann auch hier vollständig mit freier Software unter Linux erfolgen. Der JTAG/SWD Adapter ist auch auf dem Board enthalten.
Links
Crosscompiler für ARM
https://launchpad.net/gcc-arm-embedded (bitte diesen hier verwenden!)
Weitere Informationen sind im Wiki
2.6 A6: Pinguino mit PIC32 MX220
Der "Pinguino" ist ein Duino Klon, hinter dem zwar die gleiche Idee wie beim Arduino steckt, allerdings ist sowohl die Hardware als auch die IDE verschieden vom Original. Auf dem Pinguino ist ein 32-Bit Controller von Arizona Microchip mit MIPS Kern. Dieser Kern ist ähnlich wie der ARM Kern, aber vom Konkurrenten MIPS Technologies (http://www.mips.com). Das komplette Pinguino Board kostet weniger als 10 Euro!
Die IDE beim Pinguino Projekt imitiert zwar die originale Arduino IDE, ist aber in der Sprache Python geschrieben.
Link zum Hersteller Olimex
https://www.olimex.com/Products/Duino/PIC32/PIC32-PINGUINO-MX220/
3 Versuche mit Feldbussen
3.1 F1: RS-485 Bussystem
Wir werden einen einfachen Versuch mit dem Schnittstellen-Standard RS/EIA-485 machen, der zur preiswerten Vernetzung in der Fabrik und im Gebäudebereich verwendet wird. Zum Beispiel ist die berührungslose Türöffnungsanlage der Hochschule Augsburg mit diesem Bus realisiert.
Literatur
3.2 F2: Controller Area Network (CAN)
Foto
Beschreibung
Bei diesem Versuch werden Sie den CAN Feldbus kennenlernen. Mit Hilfe von zwei USB-zu-CAN Adaptern der Firma MHS-Elektronik stellen Sie eine CAN Verbindung zwischen zwei PCs her (oder zwischen zwei USB Schnittstellen eines PC).
Ziele
Kennenlernen des CAN Übertragungsprinzips.
Anwenden des can_view Programmes, das in der TinyCAN Software von http://www.mhs-elektronik.de enthalten ist. Man kann alles frei herunterladen. Das Programm kann sowohl unter Linux als auch unter Windows kompiliert werden, da das zugrunde liegende Gtk2 Toolkit für grafische Oberflächen auf beiden Plattformen vorhanden ist. Unter Windows nimmt man den MinGW Compiler. Den Quelltext von can_view findet man in tiny_can/can_view/src/.
Zugreifen auf den CAN Bus durch ein Programm in C, das gegen die TinyCAN Bibliothek gelinkt wurde ("CAN API"). Auch hier kann man wieder unter Linux als auch unter Windows arbeiten.
Beispielprogramme findet man unter tiny_can/can_api/sample/.
Ausblick auf die höhere CAN Schicht CANopen.
Informationen speziell für Linux
socketcan ist das Standard-API für die CAN Schnittstelle
Leider unterstützt TinyCAN zur Zeit noch nicht socketcan.
can4linux ist ein weiterer Treiber für CAN Controller unter Linux
In seltenen Fällen könnte es nötig sein, auf eine neuere Version der Firmware in den CAN Adaptern zu wechseln. Die Firmware ist das Programm, das im CAN Adapter auf einem Mikrocontroller läuft. Auf der Website von MHS Elektronik findet man ein Firmware-Update Programm als auch die neueste Firmware.
Links
Kommerzielle Produkte, die mit TinyCAN zusammenarbeiten
Alternative kommerzielle Hersteller von CAN-Bus Adaptern:
Literatur
Wolfhard Lawrenz (Hrsg.): CAN - Controller Area Network. Grundlagen und Praxis. Hüthig Verlag 1994 (liegt dem Versuch bei).
Renesas, Introduction to CAN, 44 Seiten, 2006
http://elk.informatik.hs-augsburg.de/cdrom-es/CAN/rej05b0804_m16cap.pdf
CAN Spezifikation
Boterenbrood, CANopen, 23 Seiten, 2000.
http://elk.informatik.hs-augsburg.de/cdrom-es/CAN/CANopen30.pdf
Material
- 2 x TinyCAN USB-zu-CAN Module
- 1 x CAN Verbindungskabel Sub-D 9-polig.
- Die Software ist frei von http://www.mhs-elektronik.de erhältlich.
4 Versuche mit Embedded Linux
4.1 L1: Das Gnublin Board
Das Gnublin Projekt wurde in einer Kooperation zwischen der Hochschule Augsburg (Prof. Högl) und der Embedded Projects GmbH entwickelt. Das Ziel war es, eine Lernumgebung für Embedded Linux zu schaffen.
Homepage: http://www.gnublin.org
4.2 L2: Das Network Gateway NGW100
Foto
Beschreibung
Das "Network Gateway 100" (NGW100) von Atmel ist eine preiswerte Mikrocontroller-Platine zum Einstieg in die Welt des "Embedded Linux".
Ziele
- Die Entwicklungsumgebung für das Board aufbauen: Stromversorgung, RS-232, Netzwerkkabel.
- Den U-Boot Bootloader kennenlernen.
- Die "Buildroot" Umgebung kompilieren. Das Ergebnis ist ein Kernel und ein Root-Filesystem.
- Das Root-Filesystem über NFS auf dem Target (NGW100) mounten. Das eigentliche Root-Filesystem bleibt auf dem Entwicklungsrechner liegen.
- Eine kleine Demo-Anwendung schreiben. Das Root-Filesystem auf das NGW100 in den Flash-Speicher übertragen. Es gibt dazu mehrere Möglichkeiten: (a) NOR Flash, (b) Dataflash, (c) SD/MMC Karte. Am Schluss soll eine von sich aus startende simple Applikation entstehen.
Links/Literatur
Anleitung zum DVA-Praktikum:
http://elk.informatik.hs-augsburg.de/hhweb/elinux/ngw100/dva-anleitung/ngw100-dva.txt
Atmel Homepage
Atmel Produktseite zum NGW100
http://www.atmel.com/tools/maturengw100networkgatewaykit.aspx
Meine Bücherliste zum Wahlfach "Embedded Linux"
http://elk.informatik.hs-augsburg.de/hhweb/elinux/Buecher/index.html
Sie können die meisten dieser Bücher auf "Safari" lesen. Dazu müssen Sie von einem Rechner der Hochschule aus arbeiten.
NGW100 Archiv
http://elk.informatik.hs-augsburg.de/elinux/ngw100
Beispielprogramme http://elk.informatik.hs-augsburg.de/elinux/ngw100/beispiele
Material
- 1 x NGW100 mit Netzteil
- 1 x USB Kabel
- 1 x RS-232 Kabel (USB)
- 1 x Netzwerkkabel
Sie benötigen auf Ihrem Rechner einen freien Ethernet-Anschluss.