Mikrocontroller.net - Benutzerbeiträge [de]

MP2103-Stick: Ein Mini-Mikrocontroller-Board mit USB und bis zu 4MB Datenspeicher

2011-04-15T15:22:45Z

Chrisu: /* Elektrische Inbetriebnahme */

''von Mario Pieschel''

== Einleitung ==

Der MP2103-Stick ist ein kleines Arm7-Mikrocontroller-Board, welches sehr einfach und damit sehr billig gehalten wurde. Jeglicher Schnickschnack wurde weggelassen und möglichst viele Pins des Mikrocontrollers zu den beiden Steckverbindern geführt. Als Mikrocontroller kommt der LPC2103 von NXP zum Einsatz. Viele Mikrocontroller-Anwendungen sind als Stand-Alone-Anwendungen konzipiert – der MP2103-Stick nicht!!! Er soll mehr als Interface-Baustein für den PC gesehen werden.
Anwendungsbereiche sehe ich überall dort, wo irgendetwas mit dem PC elektrisch verbunden werden soll, was sich sonst nicht mit diesem über die herkömmlichen PC-Schnittstellen verbinden lässt. Da der LPC2103 über eine mannigfaltige Peripherie verfügt (digitale Ein/Ausgänge, ADC, Timer, I2C, SPI/SSP, PWM, RTC), sehe ich fast keine Grenzen in seinem Einsatzspektrum. Überall wo der PC steuern, regeln und/oder messen soll, könnte der MP2103-Stick zum Einsatz kommen. Die Daten feuern vom und zum PC mit einer Datenübertragungsgeschwindigkeit von fast bis zu 1 Megabit pro Sekunde! Für eventuelle Kalibrierdaten oder andere individuelle Daten für das zu betreibende Gerät steht ein bis zu 4 Megabyte großer Datenspeicher zur Verfügung. Für den MP2103-Stick wird kein spezielles Programmiergerät benötigt – er wird einfach an einen USB-Anschluss eines PCs angeschlossen und das war’s. An ein bestimmtes Betriebssystem des Ziel-PCs ist man ebenfalls nicht gebunden, da für den eingesetzten USB-Baustein (FT232) Treiber für alle gängigen Betriebssysteme vom Hersteller FTDI-Chip angeboten werden.

[http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher LINK: MP-Stick mit ARM Cortex-M3 (STM32F103CBT6)]

[[Bild:MP2103Stick.jpg]]

== Funktionsmodell des MP2103-Stick ==

[[Bild:MP2103 Model.PNG]]

[http://www.nxp.com/acrobat_download/datasheets/LPC2101_02_03_2.pdf LINK: Datasheet vom LPC2103]

[http://www.nxp.com/acrobat/usermanuals/UM10161_2.pdf LINK: Usermanual vom LPC2103]

[http://www.nxp.com/acrobat/erratasheets/ES_LPC2103_4.pdf LINK: Erratasheet vom LPC2103]

[http://atmel.com/dyn/products/devices.asp?family_id=616#1802 LINK: Datasheet und Anwendung vom AT45DBxxx]

== Schaltungsbeschreibung ==

Die Schaltung des MP2103-Sticks gliedert sich in fünf Funktionsgruppen.

1. Dem Mikrocontroller LPC2103 von NXP (IC3) mit seiner Grundbeschaltung (dem so genannten Hühnerfutter), den beiden Quarzen (Q2: 14,7456MHz und Q1: 32,768kHz), dem Anschluss für eine Real-Time-Clock-Batterie und den beiden Anschlussleisten CON1 und CON2 für externe Elektronik.

2. Dem USB-IC FT232RL (IC4) mit Hühnerfutter und der USB-Buchse.

3. Dem 4 Megabyte großen Datenspeicher AT45DB321 von Atmel (IC2) mit Hühnerfutter.
Es sind auch die kleineren Varianten z. B. AT45DB161 (2MB) und AT45DB081 (1MB) möglich. Der AT45DB642 (8MB) hat leider ein anderes Gehäuse - Das Löten geht dann nur mit etwas Geschick.

4. Der Reset-Automatik für Normalbetrieb und Programmiermodus mit Signal-LED (die Schaltung oben rechts).

5. And last but not least die Mikrocontroller-Core-Spannungsversorgungsschaltung von 1,8 Volt mit LM317D oben links.

== Schaltplan ==

[[Media:MP2103stick_schematic.GIF|LINK: Schaltplan gesamt]]

[[Bild:MP2103stick_schematic_LPC2103.GIF]]

[[Bild:MP2103stick_schematic_USB.GIF]]

[[Bild:MP2103stick_schematic_AT45DBxxx.GIF]]

[[Bild:MP2103stick_schematic_RESET.GIF]]

[[Bild:MP2103stick_schematic_LM317.GIF]]

Der Mikrocontroller benötigt vier Betriebsspannungen:

– VDD1.8, für den Core an Pin 5 (1,8 Volt)

– VDD3.3, für dessen Peripherie an Pin 17 und 40 (3,3 Volt)

– VDDA, für die analogen Komponenten an Pin 42 (3,3 Volt)

– VBAT, für die Real Time Clock an Pin 4 (3,3 Volt)

Die Core-Spannung wird mit dem LM317 erzeugt und mit den Widerständen R1 und R2 fest eingestellt. Die 3,3 Volt werden im FT232RL erzeugt. VDDA wird über den Widerstand R10 von VDD3.3 bezogen. VBAT wird über die Diode D2 von VDD3.3 oder von einer externen Backup-Batterie versorgt. Die Kondensatoren an den Versorgungsspannungen dienen der Entkopplung von Störsignalen und damit dem sicheren Betrieb des LPC2103. R1! und R2! mit je Null Ohm in den beiden Spannungsversorgungsleitungen VDD1.8 und VDD3.3 dienen dem Schutz des Mikrocontrollers bei Inbetriebnahme des MP2103-Sticks. Sie sollten erst ganz zum Schluss eingelötet werden – erst wenn alle Spannungen überprüft und OK sind.
Dem Mikrocontroller wird mit dem Quarz Q2 (14,7456 MHz Grundton) sozusagen das Leben eingehaucht. Er erzeugt den Takt für den LPC2103. Durch den Multiplier in diesem kann das System mit bis zu 4 x 14,7456MHz = 58,9824MHz betrieben werden. Der krumme Wert von 14,7456MHz ist einzig und allein für die Kommunikation zum PC über die UART0 und USB von Nöten. Q1 ist ein normaler Uhren-Quarz mit 32KHz für die interne Echtzeituhr.
An CON1 und CON2 gehen fast alle Pins des Mikrocontrollers. CON1 und CON2 sind im Raster 2,54mm auf der Leiterplatte angeordnet, so dass eine Lochraster-Leiterplatte auf den Stick gesteckt werden kann.
Die Kommunikation mit einem PC/Labtop erfolgt mit dem seriellen Port UART0 des LPC2103 (Pin 13 und 14) über den USB-zu-seriell-Umsetzer FT232RL (IC4). Dort gehen die beiden Signale (Leitungen) RXD und TXD gekreuzt an die Pins 1 und 5. Die beiden Handshake-Signale RTS und DTR sind über den Dip-Schalter S2 mit der Reset-Automatik oben rechts verbunden. Die beiden Datenleitungen USBDM (Pin 16) und USBDP (Pin 15) sind direkt mit der USB-B-Buchse (Pin 2 und 3) verbunden. VDD (5 Volt) kommt von Pin 1 der USB-B-Buchse über L1 (Entstörung) und geht an Pin 20 von IC4 und an Pin 16 von CON2 zur Außenwelt. Aus Sicherheitsgründen sind die 3.3 Volt nicht nach außen geführt. Wenn man auf seiner externen Schaltung 3,3 Volt benötigt, kann man dieses sehr einfach mit einem weiteren LM317 mit angepassten Widerständen bewerkstelligen.
Die Reset-Automatik oben rechts im Schaltplan sorgt bei geöffnetem Dip-Schalter S2 und nicht gestecktem Jumper auf BSL_HAND (BSL = Bootstrap Loader: Urlader) für ein ordnungsgemäßes Starten des Mikrocontrollers im Normalbetrieb. LED1 kann dann in einem Programm als Signallampe benutzt werden. Wird der Jumper BSL_HAND gesteckt geht der Mikrocontroller sofort nach einem Reset-Impuls an Pin 6 in den Bootloader-Modus. Es kann sofort eine Firmware (das Anwenderprogramm) mit einer Programmer-Software hochgeladen werden. Damit man nicht immer bei der Softwareentwicklung diesen Jumper ständig stecken und abziehen muss, gibt es noch die Programmier-Automatik mittels der beiden Handshake-Leitungen RTS und DTR. Eine Programmer-Software kann diese beiden Leitungen der RS232-Schnittstelle schalten und damit den Mikrocontroller gezielt in den Bootloader-Modus bringen, die Firmware übertragen und anschließend das Programm starten. Der MP2103-Stick muss bei der Softwareentwicklung nicht angefasst werden. Alles geschieht vom PC aus. Im endgültigen Normalbetrieb müssen S2 offen und BSL_HAND nicht gesteckt sein. In welchen Modus der Mikrocontroller geschaltet werden soll entscheidet der Signalpegel an Pin 44 des LPC2103 bei einem Reset-Impuls. High = Normalbetrieb, Low = Bootloader.
Sehr einfach gestaltet sich die Beschaltung des externen seriellen Flash-Speichers IC2.
Es können die ICs AT45DB321D-SU (4MB), AT45DB161D-SU (2MB) oder AT45DB081D-SU (1MB) eingelötet werden. Dieser ist mit der SPI des LPC2103 verbunden. Wichtig ist R3! Er wird nur bestückt wenn der Speicher schreibgeschützt sein soll.

== Eagle-Files ==

[[Media:MP2103Stick_v1.0.zip‎|LINK: MP2103Stick_v1.0.zip‎]]

== Mechanische Realisierung ==

Die Leiterplatte sollte von einem Leiterplattenhersteller gefertigt werden. Ich habe die Erfahrung gemacht, dass Anbieter mit Preis-Berechnungen auf Quadratdezimeter-Basis egal mit welchem Inhalt die günstigsten sind. Wichtig ist, dass die Leiterplatten mit Durchkontaktierungen gefertigt werden. Aus Erfahrung rate ich die Leiterplatten mit Lötstopplack fertigen zu lassen. Einfach die Datei „MP03Stick_v1.0.brd“ dem Hersteller schicken.

Board top:

[[Bild:MP03Stick_board_top_klein.GIF]]

Board bottom:

[[Bild:MP03Stick_board_bottom_klein.GIF]]

Stueckliste:

[[Bild:MP2103Stick_Stueckliste.PNG]]

== Bestückung der Leiterplatte ==

Elektronische Bauteile sind durch elektrostatische Ladungen gefährdet. Deshalb ab jetzt mit ESD-Armband und ESD-Unterlage arbeiten!!!
Beim Arbeiten mit den kleinen Bauteilen hilft auf jeden Fall ein Briefmarken-Lupen-Headset oder ein Stereo-Mikroskop mit Verstärkungsfaktor 10 (bei ebey ca. 200,- €).
Zuerst die beiden großen ICs, IC3 (LPC2103) und IC4 (FT232RL), bestücken. Da es sich um ziemlich kleine und mit hoher Pin-Anzahl versehene elektronische Bauteile handelt, empfehle ich folgende Vorgehensweise: Die Lötpads auf der Leiterplatte für das entsprechende IC reichlich mit dem Lötkolben und Lötzinn (<= 0,5 mm Durchmesser) verzinnen. Die Lötpads sollten glänzen und um ca. 0,1 bis 0,2 mm erhaben sein. Nun die Leiterplatte mit handelsüblichem Brennspiritus reinigen. Jetzt das IC mit ein wenig Klebstoff auf der Leiterplatte fixieren. Ich nehme dafür handelsüblichen Klebestift (Pr…-Stift). Eine kleine Messerspitze voll vom Klebestift auf die Mitte der IC-Position auf die Leiterplatte auftragen, das IC auf die Leiterplatte aufsetzen und positionieren. Es darf auf keinen Fall Klebstoff bis zu den Lötanschlüssen des ICs quellen. Erst mit dem Festlöten beginnen, wenn das IC korrekt auf den Lötpads sitzt und etwas angetrocknet ist. Ab jetzt wird nicht mehr mit Lötzinn gearbeitet – dieses am besten so weit wie möglich weglegen. Die Kapillarwirkung der IC-Anschlüsse ist viel zu groß, diese würden eine weitere Zugabe von Lötzinn sofort dieses zwischen die Lötpins ziehen und damit für reichlich Kurzschlüsse sorgen. Ab jetzt wird nur noch mit Flussmittel gearbeitet, entweder handelsübliches Flux oder Kolofonium (in Brennspiritus aufgelöst) nehmen. Ist das IC korrekt positioniert und fixiert mit dem Festlöten beginnen. Jeden einzelnen IC-Anschluss mit dem heißen Lötkolben und wenig Druck in Richtung Leiterplatte anlöten. Wichtig ist wirklich, sich damit Zeit zu lassen und darauf zu achten, dass das Lötzinn richtig fließt. Sollte bei einem der hier beschriebenen Arbeitsschritte etwas schief gehen, unbedingt die Arbeiten abbrechen, alles reinigen und von Anfang beginnen. Sind IC3 und IC4 erfolgreich auf die Leiterplatte gelötet können alle anderen Bauteile bestückt und gelötet werden. Wichtig: „R1!“, „R2!“ und „R3!“ nicht bestücken!!! Die voll bestückte Leiterplatte gründlich mit Brennspiritus und einem kleinen Pinsel reinigen. Die Leiterplatte wegen der Buchsen und Schalter/Taster nicht im Reinigungsmittel baden. Das Reinigungsmittel nicht abtrocknen lassen sondern mit Druckluft entfernen. Es werden so unschöne Flecken vermieden. Sollte der Stick in rauer Umgebung betrieben werden ist das Lackieren mit farblosem Leiterplattenlack sinnvoll.

== Optische Prüfung ==

Jetzt sollte eine ausgiebige Fehlersuche auf Kurzschlüsse, kalte Lötstellen, Verpolung von Bauteilen und richtiger Bestückung erfolgen. Entweder mit einer großen Lupe oder einem Stereo-Mikroskop mit Vergrößerungsfaktor 10.

Alle weiteren Arbeitsschritt erst nach vollständiger Trocknung des Stick durchführen.

== Elektrische Inbetriebnahme ==

Für erste Tests ist es am Besten den Stick mit einem Strom geregelten Netzteil über die USB-Buchse (Pin1 +5V, Pin4 Masse) zu verbinden; den Strom auf 50 mA begrenzen und 5 Volt einstellen. Nach Einschalten sollte ein Strom von ca. 10 bis 20 mA fließen und die anliegende Spannung weiterhin 5 Volt betragen. Bricht die Spannung zusammen auf keinen Fall die Strombegrenzung erhöhen sondern auf Kurzschlusssuche gehen. Fließt zu wenig Strom oder keiner kalte Lötstellen suchen. Ist kein Netzteil vorhanden, einfach drei kleine billige Knopfzellen á 1,5 Volt in Reihe schalten und den Strom mit einem Multimeter messen. Stimmt der Strom und liegen die 5 Volt an, die Spannungen an den Testpunkten TP1 bis TP4 überprüfen. Bezugspunkt ist TPM (Masse). Folgende Spannungen sollten gemessen werden:

TP1 = 1,8 Volt

TP2 = 3,3 Volt

TP3 = 5 Volt (oder 4,5V bei der Variante mit den drei 1,5V Knopfzellen)

TP4 = 3,3 Volt

Wenn diese Spannungen OK sind kann der Stick an den PC/Notebook über ein USB-Kabel angeschlossen werden. Nun sollte das Betriebssystem (Windows, für WinCE, Linux und Mac weiß ich es nicht) melden, dass neue Hardware erkannt wurde. Jetzt kann der Treiber für den FT232RL installiert werden. Den Treiber (Virtual COM Port, VCP) von der [http://ftdichip.com Herstellerseite] downloaden – die Vorgehensweise ist dort ausführlich beschrieben. Nach erfolgreicher Installation des Treibers sollte im Hardwaremanager ein neuer COMx-Port zu sehen sein. Die COM-Nummer sollte man sich merken. Windows registriert für jede USB-Schnittstelle eine andere COM-Port-Nummer, was zu Verwirrung beim Umstecken führen kann. Damit sind aber auch mehrere Sticks anschließbar.

[http://ftdichip.com/Drivers/VCP.htm LINK: die Treiber für den FT232RL]

[http://ftdichip.com/Documents/InstallGuides.htm LINK: Driver Installation Guides]

Sind alle Tests und Arbeitsschritte bis hier OK können die beiden Widerstände „R1!“ und „R2!“ eingelötet werden um den Mikrocontroller mit Strom zu versorgen. Es sollte ein Strom zwischen 20 und 40 mA fließen, wenn nicht: Fehlersuche nach Kurzschlüssen, kalten Lötstellen, verpolten Bauteilen und falscher Bestückung. Sind die beiden Dip-Schalter von S2 offen (nicht auf ON) und der Jumper BSL_Hand gezogen sollte die LED leuchten.

== Firmware Upload ==

Zum Hochladen der Firmware benötigt man das Programm Flash-Magic-Tool.

[http://www.flashmagictool.com/ LINK: Flash Magig Tool]

Die Einstellungen sind folgende:

Unter „Step 1 - Communications“:

Com Port: der COMx-Port, an dem der MP2103-Stick angeschlossen ist. Im Hardwaremanager nachsehen!

Baud Rate: 115200

Device: LPC2103

Interface: None (ISP)

Oscillator Freq. (MHz): 14.7456

Unter „Step 2 - Erase“:

Ein Hägchen hinter: „Erase all Flash+Code Rd Prot“

Ùnter „Step 3 – Hex File“:

Das Hex-File, welches hochgeladen werden soll.

Unter „Step 4 – Options“:

Hinter „Verify after programming“

Unter Adanced Options im Formular „Hardware Options“ ein Häckchen hinter „Use DTR and RTS to control RTS and P0.14“

[[Bild:FlashMagicFlashen.GIF]]

[[Bild:FlashMagicAdvanstOption.GIF]]

Jetzt am Besten erst einmal testen, ob sich der Mikrocontroller meldet. Die beiden Dip-Schalter von S2 müssen auf „ON“ stehen und Jumper „BSL_HAND“ muss gezogen sein. Flash Magic starten, die Einstellungen wie oben und in der Menüleiste „ISP“ den Menüpunk „Read Device Signatur“ anwählen. Der Mikrocontroller muss in dem sich öffnenden Fenster die Divice-ID und die Bootloaderversion liefern. Meldet Magic Flash einen Fehler: Fehlersuche. :O(

[[Bild:FlashMagicReadDeviceSegnature.GIF]]

[[Bild:FlashMagicDeviceSignature.GIF]]

Den Firmware-Upload startet man mit dem Button "Start" unter "Step 5 - Start!" im Falsh Magic.

Ein weiteres Flash-Tool ist das „LPC2000 Flash Utility“ von Philips, welches leider nicht mehr weiterentwickelt wird. Es ist aber in der Auswahl der COM-Ports begrenzt (COM1 bis COM5). Im Geräte-Manager von Windows müssen bei Bedarf Änderungen an der COM-Port-Nummerierung vorgenommen werden. Bis auf diesen Makel ist dieses Tool schnell und unkompliziert.

[http://www.lpctools.com/downloads/LPC2000%20Flash%20ISP%20Utility%20v2.2.3.zip LINK: LPC2000 Flash Utility]

[[Bild:MP2103Stick_LPC2000Flasher.PNG]]

== Testprojekt ==

Hier ein kleines Testprogramm als Basis für eigene Projekte.
Es lässt die LED blinken und kommuniziert über die serielle Schnittstelle.

[[Media:MP2103-Stick_Test.zip‎|LINK: MP2103-Stick_Test.zip‎]]

Einstellungen im Hyperterminal:

Baud Rate (Bits pro Sekunde): 921600

Einstellungen/Emulation: ANSI

Die genauen Einstellungen befinden sich im Projekt unter MP2103-Stick_921600_baud.ht.

[[Bild:MP2103_Terminal.GIF]]

Compiliert wird das Projekt mit WinARM oder Yagarto.

[http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/ LINK: WinARM]

[http://www.yagarto.de/ LINK: Yagarto]

== Compiler und IDE (neu) ==

Die Integrierte Entwicklungsumgebung von Raisonance, Ride7 und RKit-ARM, umfasst einen voll funktionsfähigen und Code unbegrenzten GNU C/C++-Compiler und das Raisonance Integrated Development Environment (RIDE). Über eine grafische Benutzeroberfläche wird die Bedienung der Softwareentwicklungs-Tools (Compiler, Assembler, Linker und Simulator) ermöglicht. Für die Softwareentwicklung und Kompilierung vom C-Source-Code bis hin zum endgültigen HEX-File besteht keine Codegrößenbegrenzung, lediglich das Debugging ist bis 32kByte begrenzt. Das ist aber hier nicht von Belang, da mit dem Bootloader des Mikrocontrollers geflasht wird.

[[Bild:MP2103Stick_Ripe7.PNG]]

Auf der Page von Raisonance.com anmelden und die Files "RKit-ARM" (GCC) und "Ride7" (IDE) downloaden und installieren. Zuerst RKit-ARM dann Ride7. Der Umgang mit diesen Programmen ist super einfach - keine Rumquälerei mit Makefiles und solcherlei Teufelszeug - alles ist bereits Mundgerecht von Raisonance zugeschneidert. Sehr empfehlenswert! Ride7 ist eigentlich nicht für den LPC2103 ausgelegt, aber mit ein wenig Überredungskunst geht dieses auch.

[http://www.mcu-raisonance.com/mcu_downloads.html LINK: Compiler und IDE Ride7 von Raisonance.com]

[http://www.mcu-raisonance.com/tzr/scripts/downloader2.php?filename=T020/file/d8/cd/4datj7g5d1wr&mime=application/pdf&originalname=GettingStartedARM_Ride7.pdf LINK: Getting Started with ARM & Ride7 User manual]

Und wie einfach alles ist zeigt dieses Beipiel-Projekt:

[[Media:MP2103Stick_Hello_World.zip|LINK: Hello-World-Projekt mit Ride7]]

Da in Ride7 kein serielles Upload-Tool für den MP2103-Stick integriert ist, kann zum Hochladen der Firmware (Hello_World.hex) „LPC2000 Flash Utility“ von Philips oder Flash-Magic genommen werden.

== Fazit ==

Es wurde ein kleines Arm7-Mikrocontroller-Board mit beachtlichen Leistungsmerkmalen und sehr geringen Herstellungskosten vorgestellt.

32-Bit-Mikrocontroller 14,7456 bis 58,9824 MHz

32 kByte Flash-ROM

8 kByte RAM

bis zu 4MByte Flash-Datenspeicher

jeder Menge Peripherie

Es kann als Standard-Interface-Modul für den PC eingesetzt werden. Es ist so konzipiert, dass es in ein Gehäuse eingebaut und mit vier M2-Schrauben befestigt werden kann. Auf den beiden Wannensteckerleisten CON1 und CON2 kann ein Tochterboard über zwei 16-polige Pfostenbuchsenleisten mit individueller Elektronik aufgesteckt werden (conrad.de Artikel-Nr.: 738501-62).

Ich stelle mir folgende Einsatzbeispiele vor:

Interface für einen Roboter

Logik-Analysator

Datenlogger für analoge Signale

Oszilloskop

Einsatz in Computer gesteuerten Messgeräten

CNC-Maschinen

usw.

Überall, wo ein Interface für den PC benötigt wird, kann der MP2103-Stick eingesetzt werden. Im Stick laufen nur die Treiber für die Peripherie und eine Transport-Routine für die Rohdaten vom und zum PC - die eigentliche Software läuft auf dem PC.

Übrigens:

Der Board-Computer der Mondlandefähre von Apollo 11, der [http://www.ibiblio.org/apollo/ "Apollo Guidance Computer"], hatte einen 16-Bit-Computer mit 2,048 MHz, 72 kByte ROM und 4 kByte RAM.

[[Category:ARM-Boards]]
[[Category:USB]]

STM32

2011-03-13T19:39:38Z

Chrisu: /* Evaluation Boards */

== Allgemeine Infos ==

Der STM32 ist ein Mikrocontroller von [http://www.st.com/mcu/inchtml-pages-stm32.html ST] mit einer 32-Bit [http://www.arm.com/products/processors/cortex-m/index.php ARM Cortex-M3] CPU. Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt, und löst damit die bisherigen ARM7 basierten Controller weitestgehend ab. Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrössen und -formen. Durch die geringe Chipfläche des Cores ist es ST möglich, eine 32 Bit-CPU für weniger als 1 EUR anzubieten.

Bisher gibt es drei STM32-Familien, wobei sich die Größte (STM32F) in weitere Unterfamilien (Linien) aufteilt:
* [http://www.st.com/internet/mcu/subclass/1169.jsp STM32F1]
** Connectivity line
** Performance line
** USB Access line
** Access Line
** Value line (teilweise verfügbar)
* Demnächst: [http://www.st.com/internet/mcu/product/250173.jsp STM32F2]
** Wie die STM32F1 Serie, jedoch 120MHz, Camera-Interface, 32-Bit Timer, ...
* [http://www.st.com/mcu/inchtml-pages-stm32l.html STM32L] (LowPower) (auf ST-Webseite gelistet, noch in Entwicklung)
** mit LCD Treiber
* STM32T (Touch)
* [http://www.st.com/mcu/inchtml-pages-stm32w.html STM32W] (RF-MCU)

'''Features'''
* Cortex-M3 Kern
* 16KB ... 1MB [[Flash-ROM]] und bis zu 96KB [[Speicher#SRAM|SRAM]] und bis zu 4KB [[Speicher#EEPROM|EEPROM]] (STM32L)
* [[IC-Gehäuseformen | Gehäuse]] 36 ... 144 Pins als QFN, LQFP und BGA
* Derzeit sind über '''110''' STM32 Derivate/Varianten verfügbar
* Derzeit bis 72MHz CPU-Takt, Modelle bis 120MHz (mit 0 Wait-States) sind angekündigt; der CPU-Takt wird über einen Multiplikator aus dem internen RC-Takt oder einem externen Quarz-Takt abgeleitet.
* Externes Businterface (nur bei Gehäusen ab 100 Pin und nicht bei alle Serien)
* LCD Treiber für 8x40 Punkte
* Spannungsbereich 1,65 ... 3,6V, nur eine Betriebsspannung nötig
* Temperaturbereich bis 125 °C
* Bis zu 112 IOs, viele davon [[Pegelwandler|5V-tolerant]]
* Interner, kalibrierter RC-Oszillator mit 8MHz
* Externer Quarz
* Real Time Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 14 [[Timer]], je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer (bei STM32F103xF/G)
* Systick Counter
* Bis zu 3 12-Bit [[AD-Wandler]] mit insgesamt 21 AD-Eingängen, integrierter [[Temperatursensor]]
* Bis zu 2 12-Bit [[DA-Wandler]]
* Bis zu 2 [[DMA]] Controller mit bis zu 12 Kanälen
* Bis zu 2x [[I2C|I²C]]
* Bis zu 5x [[UART|USART]] mit LIN, IrDA und Modem Control
* Bis zu 3x [[SPI]]
* Bis zu 2x [[I2S|I²S]]
* Bis zu 2x [[CAN]]
* [[USB]] 2.0 Full Speed / OTG
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich [[Ultra low power|Strom sparen]] lässt
* [[JTAG]] und SWD (Serial Wire Debug) Interface
* Bis zu 6 Hardware-Breakpoints für Debuggen
* und vieles mehr . . .

[[bild:stm32F103xc.png]]

== Struktur der Dokumentation: ==

Als Beispiel der Dokumentation soll stellvertretend der [http://www.st.com/mcu/devicedocs-STM32F103RC-110.html STM32F103RC] genannt werden. Die Seite von ST beinhaltet alle nötigen Informationen passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* [http://www.st.com/stonline/products/literature/ds/14611.pdf Datasheet STM32F103xC/D/E]
* [http://www.st.com/stonline/products/literature/rm/13902.pdf Reference Manual]
* [http://www.st.com/stonline/products/literature/pm/15491.pdf Cortex-M3 Programming Manual]
* [http://www.st.com/stonline/products/literature/pm/13259.pdf Flash Programming Reference]

Im Datasheet sind die speziellen Eigenschaften einer bestimmten Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für alle STM32 Controller. Details zum Prozessorkern selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich die Flash Programming Reference für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates. Hinzu kommen optionale Dokumente von ARM, die den [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0337-/ Cortex-M3 Kern] beschreiben. Hier gibt es den Opcode wenn man ihn in [http://infocenter.arm.com/help/topic/com.arm.doc.ddi0403-/ Assembler] programmieren möchte. Zusätzlich sollten auch die [http://www.st.com/stonline/products/literature/es/14732.pdf Errata Sheets] beachtet werden. Empfohlen sei auch die Appnote "[http://www.st.com/stonline/products/literature/an/13675.pdf STM32F10xxx hardware development: getting started]".

== ‎STM32F10x Standard Peripherals Library ==

ST bietet eine umfangreiche Firmwarebibliothek, eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST (gibt es beispielsweise auf den Cortex-M3 Controllern von TI auch, ist teilweise in einem separaten ROM untergebracht). Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern. Diese Library und ihre Dokumentation setzen das grundlegende Verständnis der Funktion des jeweiligen Peripheriemoduls voraus, wie es die o.A. Referenz und diverse Appnotes vermitteln.

Details siehe: [[‎STM32F10x Standard Peripherals Library]].

Mit [https://sourceforge.net/projects/libopenstm32/ libopenstm32] ist derzeit auch eine Open-Source Alternative (GPL, Version 3 oder höher) zur ST Library in Entwicklung.

== CMSIS ==

Parallel zur Firmware-Library gibt es für die "Selbermacher" die CMSIS, die einen Teil der HW und den Core Support abdeckt.
Im Rahmen des CMSIS Standard ([http://www.onARM.com www.onARM.com]) wurden die Headerfiles standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, als auch eine SystemInit - Funktion, welche sich um die PLL kümmert.
Die CMSIS ist im Download der FW-Lib enthalten.

Der Sys-Tick Counter ist ebenfalls in der CMSIS enthalten da er Bestandteil des Cortex-M3 ist.

== Debug-Interface ==

Als Debug Interface stehen zwei Varianten zur Auswahl:
* [[JTAG]]
* SWD (Serial Wire Debug)

Für JTAG sind 6 Steuerleitungen nötig, für SWD 2 (zzgl GND/3,3V).
Die SWD Schnittstelle verfügt außerdem über eine weitere Leitung, SWO. Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht werden, sowie "printf-ähnlich" Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.

Die Coresight-Debug-Architektur ermöglicht ein non-invasive debugging, d.h. es können während des Betriebes ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

Standard-JTAG Steckerbelegungen: http://www.keil.com/support/man/docs/ulink2/ulink2_hw_connectors.htm

=== Der 10polige JTAG-Stecker von mmvisual ===
mmvisual hat mit dieser Steckerbelegung die Standard JTAG Schnittstelle erweitert:

Ich habe diesen Part in den Artikel [http://www.mikrocontroller.net/articles/JTAG#Der_10-Polige_JTAG_Stecker_von_mmvisual JTAG] verschoben.
Hinzu gekommen ist die Adapterplatine 10-Polig auf Standard JTAG 20 Polig mit TTL/V24 Wandler. [http://www.mikrocontroller.net/articles/JTAG#Die_Adapterplatine Siehe hier.]

=== STM32 Programmiertool ===

Details sind hier im Forum: [http://www.mikrocontroller.net/topic/141711 STM32 Programmiertool]

== Vorteile ==

'''Vorteile gegenüber ARM7:'''

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vektortabelle, keine Sprungleiste wie bei ARM7). Durch Automatismen zwischen Core und NVIC (auto register save r0..r3, lr, sp, pc) bei Interrupt Entry wird eine deutlich schnellere Ausführungszeit bei Interrupts erreicht. Der Interrupt Code muss sich nicht mehr selbst um die Sicherung der o.g. Register kümmern und eine besondere Konfiguration der Handler im Compiler entfällt. Sind vor Beendigung einer ISR (d.h. Rücksprung zum User Code) weitere Interrupts pending, so werden diese ausgeführt, ohne dass eine komplette pop-push-sequenz der Register notwendig ist. Schön beschrieben ist es hier im [http://www.st.com/mcu/files/mcu/1221142709.pdf Insider's Guide] unter 2.4.5 / Seite 20.
* Thumb-2 Befehlssatz, deutlich schneller als Thumb-1 und ebenso kompakt
* Weniger Pins für Debugging benötigt durch SWD
* Mehr Hardware Breakpoints machen debuggen einfacher
* Software ist einfacher weil die Umschaltung zwischen ARM Mode und Thumb Mode wegfällt

'''Vorteile gegenüber LPC1700 und LPC1300:'''

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* FW-Lib für alle STM32 gleich, alle AppNotes/Demos beziehen sich auf diese eine FW-Lib was die Entwicklung der eigenen Applikation sehr beschleunigt.
* Genauerer und flexiblerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010) Allerdings gibts den LPC1100 mit Cortex-M0 schon ab 0,65 $!
'''Nachteil gegenüber LPC1700:'''
* Nur 72 MHz statt 100 MHz (LPC1759: 120 MHz) Taktfrequenz (120 MHz Versionen sind von ST angekündigt)
* Der LPC1700 besitzt deutlich mehr Mechanismen, um die Auswirkung der Waitstates des Flash-ROMs auf Code- und Datenzugriffe zu reduzieren und das bedeutet mehr Performance bei gleicher Taktfrequenz.
* Alle LPC1xxx haben 32 Bit Timer.
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hobby-Anwender'''

* Nicht direkt "Steckbrettauglich", da kein DIL Gehäuse verfügbar. Der ebay-Shop dipmicro führt jedoch sehr günstige Lötadapter für Umsetzung von LQFP48 auf DIP48.

'''

== Programmierung ==

Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden. Es ist für den Einsteiger schwierig herauszufinden welche Open-Source Programme man braucht damit es funktioniert, daher hier eine Zusammenstellung:

* Eclipse
* Yagarto Tools
* Codesourcery Light
* OpenOCD
* Eclipse Plugin "GDB Hardware Debugging"

Folgende kommerzielle Umgebungen sind verfügbar:

* [http://www.keil.com Keil µVision] (Demo max. 32KB Code)
* [http://www.iar.com IAR] (Demo max. 32KB Code)
* [http://www.raisonance.com Raisonance Ride7] (GCC Compiler, kostenlose Version auf Debugging von max. 32KB Code limitiert, keine Limitierung beim Complilieren)
* [http://www.atollic.com Atollic] (Lite Version ohne Code-Limit, auf GCC basierend)
* [http://www.rowley.co.uk/arm/ Rowley Crossworks] (Demo 30 Tage unbeschränkt, 150$ für nichtkommerzielle Nutzung, auf GCC basierend)

Programmieradapter
* [http://www.segger.com J-Link / J-Trace] Cortex-M3, als [http://www.segger.com/cms/j-link-edu.html NonComercial] J-Link für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* [http://olimex.com/dev/index.html Olimex] ARM-USB-OCD (ca. 60.-)
* Keil [http://www.keil.com/arm/ulink2/ ULINK2], [http://www.keil.com/arm/ulinkpro/ ULINK pro]
* [http://www.st.com/mcu/contentid-126-110-ST_LINK.html ST-Link]
* [http://www.raisonance.com/~rlink-debugger-programmer__microcontrollers__tool~tool__T018:4cn9ziz4bnx6.html Raisonance RLink]
* [http://www.amontec.com Amontec]
* [http://www.hjtag.com H-JTAG] Personal Edition für ca. 60,- zu haben, läuft mit ADS, SDT, IAR, Vision und RVDS

Programmieradapter Open-Source
* [http://www.oocdlink.com/ OOCDLink]
* [http://www.openpilot.org/Floss-JTAG Floss-JTAG]
* [http://capitanio.org/mlink/ Linux Demo Code für die Discovery's ST-Link Programmierung]

Der Controller hat auch einen fest eingebauten Boot-Lader. Damit läßt er sich auch über eine gewöhnliche serielle Schnittstelle programmieren, ohne daß man einen JTAG-Adapter benötigt.

=== Installation für STM32 ===

* Eclipse "Helios" installieren mit GNU ARM Eclipse Plug-in
Eclipse IDE for C/C++ Developers downloaden und installieren
http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/heliosr

GNU ARM Eclipse Plug-in runterladen und installieren
Download: http://sourceforge.net/projects/gnuarmeclipse/
Infos: http://sourceforge.net/apps/mediawiki/gnuarmeclipse/index.php?title=Main_Page

Wird CodeSourcery G++ Lite verwendet so muss die PATH Variable angepasst
werden damit das Plugin die CodeSourcery exe Files findet (für Discovery notwendig).
Alternativ das eclipse von einem script aus starten und zuerst den PATH erweitern.

Soll das ST-LINK verwendet werden so kann der Atollic ST-LINK
GDBSERVER aus der Atollic free version genutzt werden.
Mit dem gdbserver im eclipse kann damit problemlos geflasht und
gedebuggt werden (JTAG und SWD).

Die Startup und Linkerscripts der Atollic free version können für
ein Projekt in dieser Konstallation genutzt werden.

* Eclipse "Galileo" installation:
http://www.eclipse.org/ >> Downloads >> "Eclipse IDE for C/C++ Developers (79 MB)"
Und das Servicepack 1: [http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo/SR1/eclipse-cpp-galileo-SR1-win32.zip Eclipse SR1]
Entpacken der Datei eclipse-cpp-galileo-SR1-win32.zip nach "C:\WinARM\" (Ordner neu erstellen)

* Eclipse PlugIn hinzufügen:
Help >> Install New Software... >> http://download.eclipse.org/tools/cdt/releases/galileo
"Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

* Yagarto Tools:
http://www.yagarto.de/ >> "Download (for Windows)" >> "YAGARTO Tools"
http://www.yagarto.de/download/yagarto/yagarto-tools-20091223-setup.exe
Installieren, Auswahl Verzeichnis "C:\WinARM\yagarto-tools"

* CodeSourcery:
Achtung! Die Memustruktur ändert sich durchaus mal, dann suchen gehen.
http://www.codesourcery.com/ >> Products>Sourcery G++ >> Editions>Lite Edition >> ARM >> Downloads
Direkter Download: [http://www.codesourcery.com/sgpp/lite/arm/portal/package6496/public/arm-none-eabi/arm-2010q1-188-arm-none-eabi.exe hier]
Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD:
Kompilierte Version für Windows:
http://www.freddiechopin.info/ >> Download >> Software >> OpenOCD
installieren nach "C:\WinARM\OpenOCD_0_4_0"
ist auch auf der Seite [http://yagarto.de/#ocd Yagarto.de] beschrieben.
PS: Sollte der Olimex ARM-USB-OCD verwendet werden, dann darf nicht der Treiber von Olimex verwendet werden,
sondern der vom OpenOCD Download. [http://www.mikrocontroller.net/topic/173753#1668913 Siehe hier.]

* ST Firmware:
http://www.st.com >> Auswahl CPU STM32F103xxx >> "Firmware" "STM32F10x_StdPeriph_Lib"
http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.4.0\

=== Installation für STM32 auf einem zweiten Rechner===

* Kopieren des Verzeichnisses C:\WinARM\ (Zuvor wurden aus diesem Grund alle Setup-Pakete nach C:\WinARM\... installiert)
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM\.... Verzeichnissen nachführen
* Fertig.

=== Installation für STM32 mit AtollicTrueStudio===
* Installation + Demo: [[STM32 LEDBlinken AtollicTrueStudio]]

== Demo-Projekte ==

* [[prog_bsp_timer_1_timer2|Programmbeispiel für die Verwendung von Timer2 zusammen mit dem Interrupt]]
* [[Cortex_M3_OCM3U]]
* Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:
** [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html "ChaN's FAT-Module with STM32 SPI"]
* [[STM32 USB-FS-Device Lib]]

== Errata, Tipps und Tricks ==

* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 8.3.3. Alle Infos von RM0008 8.3.x sind interssant
* CAN und USB sind nur bei der "◦Connectivity-Line" gleichzeitig nutzbar. Siehe Datenblätter.
* Mit internem RC-Oszillator kann die CPU mit maximal 64MHz betrieben werden. Mit einem externen Quarz sind dann 72MHz möglich.
* Für USB Betrieb muss die CPU mit 48MHz oder 72MHz betrieben werden.

=== Tipps für Umsteiger von Atmel/PIC/8051 ===
* Prozessortakt hat unterschiedliche Taktquellen und eine PLL.
* Alle Peripheriemodule haben einen extra Clock, den man aktivieren muss.
* Wenn man z.B. einen UART benutzen möchte, so muss man den Clock vom UART, Alternate Function IO (AFIO) und dem GPIO-Port aktivieren.
* Ansonsten hat man nahezu doppelt so viele Möglichkeiten in den Peripheriemodulen.
* Forum zu [http://www.mikrocontroller.net/topic/175888 Interrupts vs. Events]

== Bezugsquellen ==

=== Controller ===

Versandhäuser für Privatpersonen

* [http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html Darisus]
* [http://www.hbe-shop.de HBE (Farnell Programm für Private)]
* [http://www.sander-electronic.de/be00069.html Sander]
* [http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+ TME]
* [https://www.distrelec.de/ishopWebFront/catalog/product.do/para/keywords/is/STM32_ARM-Microcontroller/and/language/is/de/and/shop/is/DE/and/series/is/1/and/id/is/01/and/node/is/34910.html Distrelec]

Gewerblich liefern natürlich viele wie Farnell, Digikey usw..

=== Evaluation Boards ===

* [http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14 Im Shop von Embedded Projects]
* [http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3 Cortex M3 bei Watterott]
* [http://www.raisonance.com/~primer-starter-kits__microcontrollers__tool~tool__T018:4enfvamuxbtp.html Primer und Primer2 von Raisonance]
* [http://www.sander-electronic.de/es0028.html Sander Electronic]
* [http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher Artikel im Wiki, ARM mit USB und 4MB Speicher]
* [http://www.futurlec.com/STM32_Development_Board.shtml Futurlec Evalboard, ebenso Header-Board]
* [http://www.propox.com/products/t_174.html Propox, Header-Boards für 103R und 103V sowie Trägerplatine dafür]
* [http://www.mikrocontroller.net/articles/Cortex_M3_OCM3U Cortex M3 Artikel im Wiki]
* [http://olimex.com/dev/index.html STM32 bei Olimex]
* [http://de.farnell.com/jsp/displayProduct.jsp?sku=1824325&action=view&CMP=GRHS-1000962 STM32Discovery bei Farnell] Mikrocontroller Board (STM32F100RBT6B) mit onboard USB-Programming Interface für ca. 12,50€
* [http://www.steitec.net/ARM-Boards/ Steitec, STM32F103 Cortex M3 Board 34,80€]
* [http://www.mcu-raisonance.com/~open4-development-platform__microcontrollers__tool~tool__T018:g65gu6ghg2n.html/ Open 4 oder auch genannt Evo-Primer]

== Weblinks, Foren, Communities ==

* [http://www.mikrocontroller.net/topic/173753 Diskussion zum Artikel]
* [http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex* Suche im Forum]
* [https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx Forum auf der ST Homepage]
* [http://www.stm32circle.com/hom/index.php STM32 Community]

[[Kategorie:ARM]]
[[Kategorie:STM32| ]]

Benutzer Diskussion:Chrisu

2011-03-13T16:48:39Z

Chrisu: Die Seite wurde geleert.

RS-485

2011-01-09T15:26:41Z

Chrisu: /* Einleitung */

== Einleitung ==

RS485 ist die physikalische Spezifikation einer bidirektionalen Verbindung über ein differentiales Leitungspaar. Die Leitung ist idealerweise ein twisted Pair mit 120 Ohm [[Wellenwiderstand]]. Es können zwei oder mehrere Teilnehmer angeschlossen sein. Der Leitungsaufbau ist immer eine Linie, kein Stern und ohne Stichleitungen. Die Leitung ist idealerweise an beiden Enden terminiert. Idealerweise bedeutet hier für höhere Geschwindigkeiten und Distanzen zwingend, bei kurzen Leitungen und niedrigen Geschwindigkeiten nicht, siehe Artikel [[Wellenwiderstand]]. Das Interface ist ein RS485 Transceiver, der beinhaltet einen Sender und einen Empfaenger. 
[[Datei:RS485.png | Transceiver ]] 
Links ist CMOS/TTL Logik, rechts die RS485 Leitung. 
Da nicht mehrere Sender gleichzeitig auf die Leitung aufgeschaltet sein dürfen, muss der jeweilige Sender nach Bedarf eingeschaltet werden ([http://de.wikipedia.org/wiki/Duplex_%28Nachrichtentechnik%29 Halbduplex]). Dies wird auf Protokollebene definiert. Der Sender steuert das differentielle Leitungspaar voll aus, d.h. geht unbelastet auf 0V/Vcc, wobei es 3.3V, sowie 5V Bausteine gibt. Unter Last nimmt die Amplitude dann ab. Der Empfaenger braucht minimal 70mV Differenzspannung in einem Gleichtaktbereich von -7...+12V. Es gibt auch Bausteine mit höheren Gleichtaktspannungen. Während der Standard von bis zu 32 Bausteinen pro Leitung ausgeht, sind Viertel- und Achtelpower Bausteine erhältlich, wovon dann 128 bzw. 256 Stück an eine Leitung angeschlossen werden können. Die Geschwindigkeit und die Reichweite sind nicht im Standard definiert. Bisher sind alle Transceiver pinkomptibel.

== Meist genutzte RS485-Bausteine ==
* SN75176, günstig und leicht zu beschaffen, aber ein Stromfresser (28-50mA!)
* LTC485
* MAX485 Moderne CMOS-Variante mit weniger als 1mA Eigenverbrauch
* ADM485
* ADM483 von Analog Devics, 250kBit, supply 350uA plus load, SO8, 1.14$@100

== Speziellere Ausführungen ==

* SN65HVD23D von TI, extended common mode -20 to +25V, 25MBit @160m, 64nodes, supply 7mA plus load, SO8, 4.05$@1
* SN65HVD24D von TI, extended common mode -20 to +25V, 3MBit @500m, 256 nodes, supply 10mA plus load, SO8, 4.05$ @1

== Weitere Hinweise ==

[[bild:rs485_term.png | framed | RS485 Terminierung mit Pull-Up/Down Widerständen]]

* Failsafe - was passier auf dem Bus, wenn kein Sender aktiv ist? Dann muss man mittles Pull Up und Pull Down Widerstand für definierte Pegel sorgen. Das ist vor allem dann nötig, wenn man mittles [[UART]] Daten überträgt, was bei 90% der RS485 Anwendungen der Fall ist. Arbeitet man mit Terminierung, so werden klassisch die Werte wie im nebenstehenden Bild verwendet. Ohne Terminierung entfällt R2 und R1=R3=1kΩ. Diese Terminierung gibt es nur einmal auf dem Bus, nicht an jedem Teilnehmer!
* Verlustleistung - die Terminierung (100..120 Ohm) verbraucht einiges an Strom, den man mit einem 1uF in Serie unterdrücken kann (AC-Terminierung, siehe Artikel [[Wellenwiderstand]]).
* [[Galvanische Trennung]] - speziell bei ausgedehnten Systemen können die -7...+12V Gleichtaktbereich nicht genügen, speziell in einem industriellen Umfeld nicht. Dann sollte man eine galvanische Trennung einführen.
* Die Masse als Referenz sollte man IMMER im Kabel mitführen, auch wenn es scheinbar oft auch ohne funktioniert.

{{Clear}}

== Weblinks ==

* [http://de.wikipedia.org/wiki/RS485 RS485 auf Wikipedia]
* Slla036b (TI) Interface Circuits for TIA/EIA-485 (RS-485)
* Slla70c (TI) 422 and 485 Standards Overview and System Configurations
* Slla169 (TI) Use receiver equalization to extend RS485 data communication
* AN-1057 (National) Ten Ways to Bulletproof RS-485 Interfaces
* [http://focus.ti.com/lit/an/slyt324/slyt324.pdf RS-485: Passive failsafe for an idle bus], Application Note slyt324 von TI
* [http://pdfserv.maxim-ic.com/en/an/AN1090.pdf Methods for Trimming the Power Required in RS-485 Systems], Application Note 1090 von Maxim

[[Category:Datenübertragung]]

AVR Arithmetik/Saturierung

2010-11-13T23:24:37Z

Chrisu: /* Umsetzung */

''von [[Benutzer:gjlayde|gjlayde]]''

Unter '''Saturierung''' (von engl. ''to saturate'', wörtlich ''Sättigen'') versteht man die Eigenschaft bestimmter Operatoren, bei Überschreitung der Bereichs-Grenzen den Maximal- bzw. Minimalwert zu liefern, anstatt überzulaufen und einen Wert zu liefen, der sehr weit vom erwarteten Ergebnis entfernt liegt.

== Einleitung ==

Bei vielen Anwendungen wie der digitalen Signalverarbeitung ist es wichtig, daß ein Wert an den Rändern seines Wertebereiches nicht überläuft. Ist eine Größe ''x'' zum Beispiel als 8-Bit Wert mit Vorzeichen gespeichert, so führt die Operation
<c>
char x = 127; // x = 127
char y = x+1; // y = -128
</c>
zum Ergebnis ''y''=−128. Solch ein riesiger Sprung ist in vielen Anwendungen fatal. Anstatt an den Bereichsgrenzen überzulaufen ist dann erforderlich daß der Wert an der Maximalgrenze stehen bleibt, d.h. daß das Ergebnis in dem Falle ''y''=127 ist anstatt −128. Die Variable kann ab dieser Grenze nichts mehr aufnehmen: sie hat ihre "Sättigung" erreicht.

Um saturierte Addition von der üblichen Addition zu unterscheiden, wird hier das Symbol <math>\oplus</math> verwendet.

Eine saturierte Addition hat eine sehr wichtige Eigenschaft der gewohnten Addition, nämlich die ''Monotonie'':
:<math>
a \geqslant 0 \;\Rightarrow\; x + a \geqslant x \quad\text{sowie}\quad
a \leqslant 0 \;\Rightarrow\; x + a \leqslant x
</math>
Analoge Zusammenhänge gibt es für die Monotonie der (saturierten) Subtraktion
:<math>
a \geqslant 0 \;\Rightarrow\; x - a \leqslant x \quad\text{sowie}\quad
a \leqslant 0 \;\Rightarrow\; x - a \geqslant x
</math>
sowie für andere saturierte Operatoren wie Negation, Betragsbildung, Multiplikation und Division, welche die gleichen Monotonie-Eigenschaften haben wie die "nativen" mathematischen Operatoren.

Durch Zugewinn der Monotonie verliert man allerdings die ''Assoziativität'', so daß die Reihenfolge, in der saturierte Operatoren anwandt werden, wie im folgenden Beispiel einen Einfluß auf das Ergebnis haben kann:
:<math>
126 = (127 \oplus 1) \ominus 1 \;\neq\; 127 \oplus (1 \ominus 1) = 127
</math>
Das ist bei Verwendung von saturierten Operatoren immer zu bedenken!

Neber der Saturierung, welche bei den Werte an den Bereichsgrenzen – also dort, wo ein Überlauf stattfinden würde – stehen bleibt, gibt es auch Saturierungen, die zB auf den Wertebereich −100...100 begrenzen. Letztere lässt sich zusammensetzen aus einer "normalen" Saturierung, wie sie hier im weiteren besprochen wird, und einer Maximum- bzw. Minimum-Bildung gegen den gewünschten Wertebereich.

== Umsetzung ==

Zur konkreten Umsetzung der Saturierung gibt es mehrere Möglichkeiten:

;A priori: Bereits bevor das Ergebnis berechnet wurde wird anhand der Eingabe entschieden, ob der Wertebereich verlassen und ein Über- oder Unterlauf entstehen wird.
;A posteriori: Erst nach der Berechnung wird anhand des Ergebnisses entschieden, ob ein Über- oder Unterlauf auftrat.

Sind vorzeichenbehaftete Operanden beteiligt, so fällt die Entscheidung strenggenommen automatisch zugunsten der a priori-Variante aus: In C führt der Überlauf von vorzeichenbehafteten Zahlen explizit zu undefiniertem Verhalten; es steht dem Compiler frei, in einem solchen Fall Instruktionen zu generieren, die beispielsweise den Prozessor anhalten oder neustarten.

Am gebräuchlichsten und effizientesten für kleine Typen sind (wenn möglich) A-posteriori-Methoden, da hier das Ergebnis als Entscheidungsgrundlage mit einbezogen werden kann. Das Ergebnis wird unbedingt berechnet und im Fall eines Überlaufs wieder verworfen. Dieser Mehraufwand muss bei aufwändigen Operatoren mit dem Aufwand von a-priori-Methoden abgewogen werden.

Die A-posteriori-Verfahren lassen sich wiederum untergliedern in unterschiedliche Strategien, die je nach Einsatzfeld mehr oder minder effizient oder garnicht anwendbar sind:

;Erweiterter Zahlenbereich: Die Operation wird in einem erweiterten Zahlenbereich ausgeführt in dem kein Überlauf auftreten kann. Das Ergebnis wird dann gegen die Grenzen getestet und ggf. beschnitten. Die Saturierung eines 32-Bit Wertes wird damit sehr aufwändig, weil der nächstgrößere Typ in Hochsprachen 64 Bits breit ist. Irgendwo ist eine Grenze erreicht, ab der es keinen nächstgrößeren Typ mehr gibt. Eine 8-Bit signed Saturierung könnte in C so aussehen:
<c>
char add_signed_sat8 (char x, char y)
{
short x_y = (short) x + y;

return MAX (MIN (x_y, 127), -128);
}
</c>

;Auswertung von Flags: Viele Rechenwerke produzieren Flags, die Auskunft über Eigenschaften des Ergebnisses enthalten. Dazu gehören Carry-, Overflow-, Negative-, Zero-Flag etc. Von einer Hochsprache aus hat man auf diese Flags keinen Zugriff, man muss also Assembler zu ihrer Auswertung heranziehen.

;Test auf Ergebnis-Überlauf ohne Flags: Hier wird die Monotonie ausgenutzt: Falls eine positive Zahle addiert wird, so muß das Ergebnis größer werden. Falls nicht, muß ein Überlauf aufgetreten sein. Eine Formulierung in C:

<c>
char add_signed_sat8 (char x, char y)
{
char x_y = x + y;

if (y > 0 && x_y < x)
return 127;

if (y < 0 && x_y > x)
return -128;

return x_y;
}
</c>

=== Auf AVR ===

Saturierung ist eine Eigenschaft eines Operators und ''nicht'' die einer Zahl, wie bei unsigned/signed, welche nur von der Interpretation des Ergebnisses abhängt. Während für signed/unsigned-Addition die gleichen Befehle verwendet werden, ist dies bei Saturierung nicht der Fall, und wir müssen unterscheiden zwischen verschiedenen Ausprägungen der Saturierung, was in unterschiedlichen Implementierungen resultiert.

Wie im vorhergehenden Abschitt zu sehen, kann Saturierung im Vergleich zu einer gewohnten Addition, die in einem Maschinenbefehl umsetzbar ist, sehr aufwändig sein. Daher versuchen wir nach Möglichkeit Status-Flags des AVR zu verwenden, um einen Überlauf zu erkennen. Dies ist von einer Hochsprache aus leider nicht möglich, so daß wir auf (Inline-)Assembler zurückgreifen müssen, um eine effiziente Implementierung zu erhalten.

Angemerkt sei noch, daß in einer Hochsprache wie C auch bei Verwendung von Assembler die Portabilität erhalten bleibt, wenn maschinenabhängige Sequenzen z. B. per <tt>#ifdef</tt> parametrisiert werden.

==== Unsigned ====

;Addition:

Das ist der einfachste Fall. Die Addition zweier vorzeichenloser Zahlen liefert immer ein nicht-kleineres Ergebnis. Ein Überlauf ist am Carry erkennbar:
<avrasm>
;; unsigned R16
;; unsigned R0
;; R16 := R16 + R0 mit Saturierung
add R16, R0
brcc 0f
; Falls es einen signed Überlauf gab (C=1) Maximalwert laden
ldi R16, 0xff
0:
</avrasm>

Als Inline-Assembler-Schnippel für avr-gcc, der in eine Inline-Funktion gefasst ist, sieht das so aus:
<c>
#include <stdint.h>

// x += y mit Saturierung
static inline uint8_t add_usat8 (uint8_t x, uint8_t y)
{
asm ("add %[x], %[y]" "\n\t"
"brcc 0f" "\n\t"
"ldi %[x], 0xff" "\n\t"
"0:"
: [x] "+d" (x)
: [y] "r" (y));

return x;
}
</c>

Zu beachten ist, daß x wegen dem LDI in Registerklasse <tt>"d"</tt> (R16–R31) liegen muss, während für y jedes Register erlaubt ist, es also in Klasse <tt>"r"</tt> (R0–R31) liegen kann.

Ein <tt>volatile</tt> ist hier übrigens nicht notwendig: der Schnippel hat den Compiler nämlich bereits über ''alle'' Nebeneffekte informiert. Der Compiler darf den Schnippel (bzw. die Inline-Funktion) also wegoptmieren, wenn das Ergebnis nicht verwendet wird – was hier vollkommen in Ordnung ist.

;Subtraktion:

Ganz analog verläuft die Subtraktion:

<avrasm>
;; unsigned R1
;; unsigned R0
;; R1 := R1 - R0 mit Saturierung
sub R1, R0
brcc 0f
; Falls es einen unsigned Unterlauf gab (C=1) Minimalwert laden
clr R1
0:
</avrasm>

==== Signed ====
Mehr Aufwand erfordern die signed-Operatoren, weil diese in zwei Richtungen überlaufen können.

;Addition:

<avrasm>
;; signed R16
;; signed R0
;; R16 := R16 + R0 mit Saturierung
add R16, R0
brvc 0f
; Falls es einen signed Überlauf gab (V=1) Maximalwert laden
ldi R16, 0x7f
sbrc R0, 7
; R0 ist negativ, daher muss der Minimalwert geladen werden
ldi R16, 0x80
0:
</avrasm>

;Subtraktion:

<avrasm>
;; signed R16
;; signed R0
;; R16 := R16 - R0 mit Saturierung
sub R16, R0
brvc 0f
; Falls es einen signed Überlauf gab (V=1) Minimalwert laden
ldi R16, 0x80
sbrc R0, 7
; R0 ist negativ, daher muss der Maximalwert geladen werden
ldi R16, 0x7f
0:
</avrasm>

; Negation

Vorsicht ist geboten beim Negieren einer Zahl und bei Betragsbildung, weil der Wert <tt>0x80</tt>=−128 kein positives Pendant hat:

<avrasm>
;; signed R0
;; R0 := -R0 mit Saturierung
neg R0
brvc 0f
; Signed Überlauf (V=1): Das Ergebnis ist 0x80 und wird verändert zu 0x7f
dec R0
0:
</avrasm>

; Betrag

<avrasm>
;; signed R0
;; R0 := Abs (R0) mit Saturierung
sbrc R0, 7
neg R0 ; R0 < 0: negieren
sbrc R0, 7
dec R0 ; R0 ist immer noch < 0 (also 0x80): lade 0x7f
</avrasm>

==== Unsigned + Signed ====

Diese Kombination ist am aufwändigsten in der Behandlung und geschieht am einfachsten durch Umskalierung auf zwei signed-Werte, signed-saturierter Operation und nachfolgender Rückskalierung. Zu beachten ist, daß dieser Operator nicht kommutativ ist, d.h. a+b liefert i.A. ein anderes Ergebnis als b+a.

;Addition:

<avrasm>
;; unsigned R16
;; signed R0
;; R16 := R16 + R0 mit Saturierung
; Transformation [0x00, 0xff] -> [0x80, 0x7f]
subi R16, 0x80
add R16, R0
brvc 0f
; Falls es einen signed Überlauf gab (V=1) Maximalwert laden
ldi R16, 0x7f
sbrc R0, 7
; R0 ist negativ, daher muss der Minimalwert geladen werden
ldi R16, 0x80
0:
; Rücktransformation [0x80, 0x7f] -> [0x00, 0xff]
subi R16, 0x80
</avrasm>

;Subtraktion:

<avrasm>
;; unsigned R16
;; signed R0
;; R16 := R16 - R0 mit Saturierung
; Transformation [0x00, 0xff] -> [0x80, 0x7f]
subi R16, 0x80
sub R16, R0
brvc 0f
; Falls es einen signed Überlauf gab (V=1) Minimalwert laden
ldi R16, 0x80
sbrc R0, 7
; R0 ist negativ, daher muss der Maximalwert geladen werden
ldi R16, 0x7f
0:
; Rücktransformation [0x80, 0x7f] -> [0x00, 0xff]
subi R16, 0x80
</avrasm>

== Siehe auch ==
Im [[AVR-Tutorial]]:
* [[AVR-Tutorial: Arithmetik8|8-Bit Arithmetik]]
* [[AVR-Tutorial: Vergleiche|Vergleiche]]

[[Kategorie:AVR-Arithmetik|S]]

FAQ

2010-05-25T09:05:14Z

Chrisu: /* Datentypen in Operationen */

Ein Verzeichnis von im Forum oft gestellten und immer wieder beantworteten Fragen und den zugehörigen Antworten:

=Wie kann ich Zahlen auf [[LCD]]/[[UART]] ausgeben?=

Aber die Bibliothek, die du benutzt, stellt nur eine Funktion zur Verfügung, mit der man einen String ausgeben kann... Was tun?

In den folgenden Beispielen wird eine selbstgeschriebene Funktion zur Stringausgabe auf LCD - die Funktion lcd_string() - aus dem [[AVR-GCC-Tutorial/LCD-Ansteuerung|LCD-Teil des AVR-GCC-Tutorials]] verwendet:

<c>
lcd_string( "Hallo Welt" ); // ggf. auch lcd_out() o.ä. in anderen Libraries
</c>

Um also eine Zahl (numerische Konstante oder Variableninhalt) auszugeben, muss von dieser Zahl zunächst ihre String-Repräsentation ermittelt werden. Hier geht es aber nur darum, zu zeigen wie man diese String Repräsenation erzeugen kann. Was man dann mit diesem String weiter macht, ob das dann eine LCD-Ausgabe oder eine UART-Übertragung oder das Abspeichern auf SD-Karte oder ... ist, spielt eine untergeordnete Rolle.

Es gibt mehrere Möglichkeiten, sich die Stringrepräsentation zu erzeugen:

===itoa()===

itoa() ist keine C-Standardfunktion (wohl aber ihre Umkehrung atoi() ). Auf manchen Compilern heisst diese Funktion dann folgerichtig _itoa(), wobei der führende _ eben anzeigt, dass es sich um eine Erweiterung des C-Standards handelt. Bei [[WinAVR]] ist itoa() Bestandteil der mitgelieferten Library avr-libc, in der Libary [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html''stdlib.h''].

<c>
#include <stdlib.h>
char Buffer[20];
int i = 25;

itoa( i, Buffer, 10 );
lcd_string( Buffer ); // ggf. auch lcd_out() o.ä. in anderen Libraries
</c>

itoa( i, Buffer, 10 ); - Die Zahl i wird nach ASCII gewandelt und die String Repräsentierung davon wird in Buffer abgelegt. Die Basis, in der diese Wandlung erfolgt, ist das 10-er System. Wird das dritte Argument von 10 in zb. 2 oder auch 16 abgewandelt, erhält man die binäre oder eben eine hexadezimale Repräsentierung des Wertes. Auch wenn 10, 2 und 16 die häufigsten Angaben an dieser Stelle sind, kann itoa aber grundsätzlich in jedes beliebige Zahlensystem wandlen.

Wichtig ist, darauf zu achten, dass das Array Buffer groß genug dimensioniert wird, um alle Zeichen der Textrepräsentation der Zahl aufzunehmen - inklusive der 0, die den String abschließt, sowie ein mögliches Vorzeichen.

Anzumerken bleibt weiter, dass es normalerweise für alle Datentypen entsprechende Umwandlungsfunktionen gibt, wenn es sie für einen Datentyp gibt. Die Namensgebung lehnt sich an das Schema an: ''Kürzel_für_den_Datentyp to a''. Eine Funktion die einen unsigned int wandelt, heißt dann utoa (oder _utoa), Floating Point heißt dann ftoa (oder _ftoa), etc.

===sprintf()===

<c>
char Buffer[20];
int i = 25;

sprintf( Buffer, "%d", i );
lcd_string( Buffer ); // ggf. auch lcd_out() o.ä. in anderen Libraries
</c>

Diese Methode funktioniert auch bei long oder float Werten. Unbedingt beachtet werden muss allerdings, dass die Typkennzeichnungen im sog. Format-String (hier "%d") mit den tatsächlichen Typen der auszugebenden Werten übereinstimmt. Und dass der Buffer, der den Text aufnimmt, auch groß genug dimensioniert wird. Dabei sollte die 0, die den String terminiert, nicht vergessen werden.

Mit sprintf() hat man dieselben Möglichkeiten zur Formatierung wie bei printf() (siehe unten). Insbesondere gibt es natürlich die Möglichkeit die Zahl gleich in einen umgebenden Text einzubetten bzw. Formatierungen anzugeben:

<c>
char Buffer[20];
int i = 25;

sprintf( Buffer, "Anzahl: %d Stueck", i );
lcd_out( Buffer );
</c>

Der "Haken" an der mächtigen Funktion sprintf() ist, daß sie auch bei minimalisierter Konfiguration verhältnismäßig viel Programmspeicher (Flash-ROM) belegt und relativ viel Prozesszeit benötigt. Daher sollte man sprintf() nur verwenden, wenn kein Speicher- und Prozesszeitmangel besteht. Sonst sollte itoa() oder eine eigene, auf die Bedürfnisse optimierte Implementierung auf jeden Fall vorgezogen werden.

====Formatierungen mit printf====

Für jedes auszugebende Argument muss es im Formatstring einen entsprechenden Formatbezeichner geben. Der Aufbau eines Formatbezeichners ist immer

%[Modifizierer][Feldbreite][.Präzision]Typ

Typ ist dabei eine Kennung, der mit dem Datentyp des jeweiligen auszugebenden Argumentes übereinstimmen muss. Einige oft benutzte Kennungen, ohne Anspruch auf Vollständigkeit, sind:
c char
d int
f float, double
ld long
u unsigned int
lu unsigned long
p pointer
s string
x ein int wird ausgegeben, die Ausgabe erfolgt aber als Hexadezimalzahl
X ein int wird ausgegeben, die Ausgabe erfolgt aber als Hexadezimalzahl, wobei Grossbuchstaben verwendet werden.

Die Feldbreite gibt die Breite des Ausgabefeldes an, in die die Ausgabe durchgeführt werden soll. Reicht die angegebene Feldbreite nicht aus, so vergrößert printf diese Breite eigenmächtig. Die Feldbreite muß nicht angegeben werden. In diesem Fall bestimmt printf selbst die Feldbreite, so dass die Ausgabe darin Platz findet. Mit der Feldbreite hat man eine simple Möglichkeit dafür zu sorgen, dass der erzeugte String immer eine konstante Länge hat, selbst wenn die auszugebende Zahl diese Länge gar nicht benötigen würde (wichtig zb. bei Tabellen).

Der Modifizierer bestimmt, wie und womit nicht benutzte Felder des Ausgabefeldes gefüllt werden sollen, wie die Ausrichtung innerhalb des Feldes erfolgen soll und ob ein Vorzeichen auch dann ausgegeben werden soll wenn die auszugebende Zahl positiv ist. Wird kein Modifizierer angegeben, so werden nicht benutzte Felder mit einem Leerzeichen gefüllt, positive Vorzeichen unterdrückt und die Ausgabe im Feld rechts ausgerichtet.

+ Vorzeichen wird immer ausgegeben
- Die Ausgabe wird im Ausgabefeld linksbündig ausgerichtet
0 anstelle von Leerzeichen werden führende 0-en ausgegeben

Die Präzision kommt nur bei float oder double Zahlen zum Einsatz. Sie legt fest, wieviele Positionen der kompletten Feldbreite für die Ausgabe von Nachkommastellen reserviert werden sollen. Auch sie muss wiederrum nicht angegeben werden und printf benutzt in so einem Fall Standardvorgaben.

===== Beispiele =====
* "%d" Ausgabe eines Integer
* "%5d" Ausgabe eines Integer in einem Feld mit 5 Zeichen Breite
* "%05d" Ausgabe eines Integer in einem Feld mit 5 Zeichen Breite, wobei das Feld links mit führenden Nullen auf 5 Zeichen aufgefüllt wird
* "%-5d" Ausgabe eines Integer in einem Feld mit 5 Zeichen Breite. Die Zahl wird linksbündig in das Feld gestellt.
* "%6.3f" Ausgabe eines float (oder double). DIe Ausgabe erfolgt in einem Feld mit 6 Zeichen Breite, wobei 3 Nachkommastellen ausgegeben werden. Achtung: In der Feldbreite ist auch ein eventuelles Vorzeichen sowie der Dezimalpunkt enthalten. Bei einer Feldbreite von 6 Zeichen und 3 Nachkommastellen, bleiben bei einer positiven Zahl daher nur 2 Positionen für den Vorkommaanteil, bei negativen sogar nur 1 Stelle ( 6 - 3 Nachkommastellen - 1 Dezimalpunkt - 1 Vorzeichen == 1 )

===Eigene Umwandlungsfunktionen===

Möchte man itoa() nicht benutzen oder hat es gar auf seinem System nicht zur Verfügung, dann ist es auch nicht schwer, sich selbst eine Funktion dafür zu schreiben:

<c>
void ItoA( int z, char* Buffer )
{
int i = 0;
int j;
char tmp;
unsigned u; // In u bearbeiten wir den Absolutbetrag von z.

// ist die Zahl negativ?
// gleich mal ein - hinterlassen und die Zahl positiv machen
if( z < 0 ) {
Buffer[0] = '-';
Buffer++;
// -INT_MIN ist idR. größer als INT_MAX und nicht mehr
// als int darstellbar! Man muss daher bei der Bildung
// des Absolutbetrages aufpassen.
u = ( (unsigned)-(z+1) ) + 1;
}
else {
u = (unsigned)z;
}
// die einzelnen Stellen der Zahl berechnen
do {
Buffer[i++] = '0' + u % 10;
u /= 10;
} while( u > 0 );

// den String in sich spiegeln
for( j = 0; j 

Das Grundprinzip ist einfach: 
Die Ermittlung der einzelnen Stellen erfolgt in der zentralen Schleife

<c>
do {
Buffer[i++] = '0' + u % 10;
u /= 10;
} while( u > 0 );
</c>

durch fortgesetzte Division durch 10 und Restbildung.

8392

8392 % 10 -> 2
8392 / 10 -> 839

839 % 10 -> 9
839 / 10 -> 83

83 % 10 -> 3
83 / 10 -> 8

8 % 10 -> 8
8 / 10 -> 0

Nur leider erhält man dadurch die einzelnen Ziffern der Zahl in umgekehrter Reihenfolge im String ('2' '9' '3' '8' anstelle von '8' '3' '9' '2'). Dies ist aber kein Problem, die nachfolgende Schleife

<c>
for( j = 0; j 

spiegelt den String in sich, sodass danach der String eine korrekte Repräsentation der ursprünglichen Zahl darstellt. Der Funktionsteil vor der 'Zerlegeschleife' behandelt den Sonderfall daß die Zahl negativ ist. Negative Zahlen werden behandelt indem im Endergebnis ein '-' vermerkt wird und danach die Zahl positiv gemacht wird.

Siehe auch:
* Forenbeitrag [http://www.mikrocontroller.net/topic/67405#541885 Integer-Zahl in String mit bestimmter Zeichenlänge]
* Forenbeitrag [http://www.mikrocontroller.net/topic/84005#704736 (Resourcenschonend) Wert einer Variable am LCD ausgeben] von Niels Hüsken
* [[Festkommaarithmetik]]

=Datentypen in Operationen=
Ein häufiges Problem betrifft die Auswertung von Ausdrücken. Konkret die Frage nach den beteiligten Datentypen.
zb
<c>
double i;
int j, k;

i = j / k;
</c>
Die Frage lautet dann: Warum erhalte ich keine Kommastellen, ich weise doch das Ergebnis einem double zu?

Dazu ist zu sagen, dass C nicht so funktioniert. Die Tatsache dass i eine double Variable ist, ist für die Auswahl der Operation, welche die Division durchführt, völlig irrelevant. C orientiert sich ausschliesslich an den
Datentypen der beteiligten Operanden, um zu entscheiden ob die Division als Integer- oder als Gleitkommadivision durchzuführen ist. Und da sowohl j als auch k ein Integer sind, wird die Division als Integerdivision durchgeführt
unabhängig davon, was mit dem Ergebnis weiter passiert. Erst nach der Division wird das Ergebnis in einen double überführt, um es an i zuweisen zu können. Zu diesem Zeitpunkt gibt es aber keine Kommastellen mehr, eine Integerdivision erzeugt keine. Und damit tauchen klarerweise auch im Ergebnis keine auf.

Aus genau diesem Grund ist zb das Ergebnis von
<c>
double i;
i = 5 / 8;
</c>
eine glatte 0 und nicht 0.625. Die Division 5 / 8 wird als Integer Division gemacht und liefert als solche keine Nachkommastellen.

Will man den Compiler dazu zwingen, die Division als Gleitkommadivision durchzuführen, so muss man daher dafür sorgen, dass mindestens einer der beteiligten Operanden ein double Wert ist. Dann bleibt dem Compiler nichts anderes übrig, als auch den zweiten Operanden, so er nicht sowieso schon ein double Wert ist, ebenfalls zu einem double zu machen und die Operation als Gleitkommaoperation durchzuführen.

Generell implementiert der Compiler eine Operation immer im 'höchsten' Datentyp, der in einer Operation vorkommt. Operanden in einem 'niedrigeren' Datentyp werden automatisch immer in diesen 'höchsten' Datentyp umgewandelt, zumindest aber int. Die Reihung orientiert sich dabei an der Regel: Ein 'höherer' Datentyp kann alle Werte eines 'niedrigeren' Datentyps aufnehmen.

int
unsigned int
long
unsigned long
long long
unsigned long long
double

float kommt in dieser Tabelle gar nicht vor, da Gleitkommaoperationen grundsätzlich immer als double-Operationen durchgeführt werden. Wohl kann es aber sein, dass double und float dieselbe Anzahl an Bits benutzen. Damit reduziert sich eine double Operation effektiv auf eine float Operation.

Hat man also in einer Operation 2 Operanden der Datentypen int und long, so wird der int implizit zu einem long gemacht und die Operation als long Operation durchgeführt. Das Ergebnis hat dann den Datentyp long.

==Welche Datentypen haben Konstante?==

Auch Zahlenkonstante besitzen einen Datentyp, der selbstverständlich vom Compiler bei der Auswahl der Operation berücksichtigt wird. Hier gilt die Regel: Benutzt wird der Datentyp, der die Zahl gerade noch aufnehmen kann. Eine Zahlenkonstante 5 hat daher den Datentyp int. Die Zahl 32767 passt gerade noch in einen int, und hat daher den Datentyp int. 32768 ist für einen int bereits zu groß und hat daher den Datentyp long. 5.0 ist hingegem immer eine double-Konstante. Der Dezimalpunkt erzwingt dieses.

Eine kleine Feinheit gibt es noch zu beachten. Konstanten in dezimaler Schreibweise haben immer einen signed Datentyp, während Konstante in hexadezimaler bzw. oktaler Schreibweise immer einen unsigned Datentyp haben.

Möchte man einer Konstanten einen bestimmten Datentyp aufzwingen, so gibt es dazu 2 (ein halb) Möglichkeiten:
* Entweder man castet die Konstante in den gewünschten Datentyp
<c>
(long)5
</c>
* oder man benutzt die in C dafür vorgesehene Schreibweise, indem man der Konstanten einen Suffix anhängt, der den gewünschten Datentyp beschreibt
<c>
5L
</c>
Beides ergibt eine dezimale 5, die vom Datentyp long ist.

* eine Zahl in mit einem Dezimalkomma
<c>
5.0
</c>
ist immer eine double Zahl. Es sei denn sie hat explizit eien Suffix
<c>
5.0F
</c>
dann hat man es mit einer float Zahl zu tun.

Die gültigen Suffixe für Zahlen sind U, L und F:

* U wie unsigned; dabei wird zuerst int angenommen. Es erfolgt eine automatische Ausweitung auf long, wenn die Zahl den Wertebereich eines unsigned int überschreitet.
* L wie long; die Zahl selbst kann int oder double sein.
* F wie float.

=Aktivieren der Floating Point Version von sprintf beim WinAVR mit AVR-Studio=
Beim WinAVR/AVR-Studio wird standardmässig eine Version der printf-Bibliothek verwendet, die keine Floating Point Verarbeitung unterstützt. Die meisten Programme benötigen keine Floating Point Unterstützung, sodass hier wertvoller Programmspeicherplatz gespart werden kann.

Benutzt man dann allerdings eine printf Variante für die Ausgabe von Floating Point Zahlen, so erscheint an Stelle der korrekt formatierten Zahl lediglich ein '?'. Dies ist ein Indiz, dass die Floating Point Verarbeitung im Projekt aktiviert werden muss.

Um die Floating Point Verarbeitung zu aktivieren, geht man im AVR-Studio wie folgt vor:
Menüpunkt: "Project"/"Configuration Options"

Im sich öffnenden Dialog wird in der linken Navigationsleiste der Eintrag "Libraries" ausgewählt.
Unter 'Available Link Objects' werden alle möglichen Bibliotheken angeboten. Für die Aktivierung der Floating Point Unterstützung sind 2 interessant:
* libprintf_flt.a
* libm.a
Beide Bibliotheken werden durch aktivieren und einen Druck auf "Add Library -->" in die rechte Spalte übernommen.

libc.a sollte übrigens nicht zu den Bibliotheken hinzugefügt werden da sie automatisch eingebunden wird. Etwas Hintergrundinformationen gibt es in [http://www.mikrocontroller.net/topic/173630 diesem Thread.]

[[Bild:AVR_Studio_float1.gif]]

Danach wählt man in der Navigationsleiste den Eintrag "Custom Options". Unter 'Custom Compilation Options' wird '[Linker Options]' ausgewählt und in das Textfeld rechts/unten wird der Text
-Wl,-u,vfprintf
eingegeben. Ein Druck auf "Add" befördert die Zeile in das Listenfeld darüber, welches die Kommandos an den Linker enthält.

[[Bild:AVR_Studio_float2.gif]]

Damit ist die Konfiguration abgeschlossen, "OK"

=Wie funktioniert String-Verarbeitung in C?=

In C gibt es, anders als in anderen Programmiersprachen, keinen eigenen String-Datentyp. Als Ersatz dafür werden Character-Arrays benutzt, in denen die einzelnen Character (=Zeichen) gespeichert werden. Allerdings gibt es noch einen Zusatz: Das letzte Zeichen eines Strings ist immer ein '\0'-Zeichen, dass das Ende des Strings markiert. Schlieslich kann ja das Array wesentlich größer sein, als der in ihm gespeicherte String und irgendwie müssen ja diverse Funktionen das tatsächliche Ende eines Strings erkennen können.

Möchte man also die Zeichenkette "Hello World" in einem String speichern, so wird dafür ein Array mit mindestens der Länge 12 benötigt. 11 für die Zeichen die "Hello World" bilden, plus eine zusätzliche Position für das abschliesende '\0'-Zeichen.

Da Strings in char-Arrays gespeichert werden, können selbstverständlich normale Array Operationen dafür benutzt werden:

<c>
char Test[12];

Test[0] = 'H';
Test[1] = 'e';
Test[2] = 'l';
Test[3] = 'l';
Test[4] = 'o';
Test[5] = ' ';
Test[6] = 'W';
Test[7] = 'o';
Test[8] = 'r';
Test[9] = 'l';
Test[10] = 'd';
Test[11] = '\0'; // das abschliessende \0 nicht vergessen! Sonst ist
// das kein String!

char Temp[6];

for( i = 0; i < 6; ++i )
Temp[i] = Test[ i + 6 ];
</c>

'''Hinweis:''' Das ''''\0'''' ist nichts anderes als eine binäre Null. Diese spezielle Schreibweise soll explizit die Verwendung dieser ''0'' als Stringende - Character ''(char)0'' hervorheben.

Wird im C-Quelltext ein String in der Form "Hello World" geschrieben, also nicht als einzelne Zeichen, so muss man sich um das abschliessende '\0' Zeichen nicht kümmern. Der Compiler ergänzt das stillschweigend von selbst.

== Einige Stringfunktionen ==
Arrays sind in C keine vollwertigen Datentypen, z. B. ist es nicht möglich einem Array in einem Rutsch ein anderes Array zuzuweisen oder 2 Arrays miteinander zu vergleichen. Genau das möchte man aber in der Stringverarbeitung häufig, sodass es dafür Standardfunktionen gibt, die allesamt im Headerfile "string.h" zusammengefasst sind und deren Namen alle mit str... beginnen. Allen diesen Funktionen gemeinsam ist, dass sie sich nicht um die korrekte Bereitstellung von Arrays kümmern, sondern davon ausgehen, dass dies vom Programmierer korrekt erledigt wird.

=== strcpy( char* dest, const char* src ) ===
Kopieren eines Strings von der Speicherfläche auf die src zeigt, zur Speicherfläche, auf die dest zeigt.
<c>
char Ziel1[20];
char Ziel2[20];

strcpy( Ziel1, "Hallo Welt" );
strcpy( Ziel2, Ziel1 );
</c>

=== strcat( char* dest, const char* src ) ===
Anhängen eines Strings an einen bestehenden String.
<c>
char Ziel[20];
char Temp[20];

strcpy( Ziel, "Hallo " ); // Ziel enthält jetzt den String "Hallo "
strcat( Ziel, "Welt" ); // Ziel enthält jetzt den String "Hallo Welt"

strcpy( Temp, " !" );
strcat( Ziel, Temp ); // Ziel enthält jetzt den String "Hallo Welt !"
</c>

=== strcmp( const char* str1, const char* str2 ) ===
Vergleichen 2-er Strings. Das Ergebnis ist 0, wenn die beiden Strings identisch sind.

<c>
char Ziel[20];

strcpy( Ziel, "Hallo Welt" ); // Ziel enthält jetzt den String "Hallo Welt"

if( strcmp( Ziel, "Hallo Welt" ) == 0 )
printf( "Ziel war 'Hallo Welt'\n" );

if( strcmp( Ziel, "test" ) != 0 )
printf( "Ziel war NICHT 'test'\n" );
</c>

=== strlen( const char* str ) ===
Die Länge eines Strings feststellen. Die Länge beinhaltet nicht das abschliessende '\0' Zeichen.

Unter 'Länge' wird hier die tatsächliche Länge des Strings (also die Anzahl der im String gespeicherten Zeichen) verstanden und nicht die 'Länge' des Arrays in dem der String gespeichert ist. Wird der Text "test" in einem char-Array der Größe 20 gespeichert, so lautet das Ergebnis von strlen() 4 und nicht etwa 20

<C>
char string[20];
strcpy( string, "test" );
i = strlen( string ); // i bekommt hier den Wert 4
</C>

== Beispiele ==

<c>
#include "string.h"

int main()
{
char Meldung[14];
strcpy( Meldung, "Hello World" );
}
</c>
Mittels der Definition
<c>
char Meldung[14];
</c>
wird ein Array bereitgestellt, welches maximal 14 Zeichen aufnehmen kann. Hello World verbraucht für die lesbaren Zeichen 11 Array-Positionen, dazu noch das obligatorische abschliessende '\0' Zeichen, macht in Summe 12 Positionen. Eine Definition von 14 Zeichen ist also mehr als minimal notwendig
wäre. Das macht aber nichts, da durch das abschliessende '\0' Zeichen immer feststellbar ist, an welcher Stelle der tatsächliche String zu Ende ist. Die restlichen 2 Array-Positionen sind zur Zeit halt einfach unbenutzt.
strcpy() kopiert den 2.ten angegebenen String an die Position auf die sein erstes Argument zeigt. Im obigen Beispiel zeigt das 1.te Argument auf den Beginn von Meldung, also auf das Array. Folgerichtig wird der String "Hello World" in das Array Meldung umkopiert. Man beachte auch, dass der Compiler den direkt angegebenen String "Hello World" automatisch mit einem '\0' Zeichen ergänzt hat.
Nach Ausführung der strcpy() Funktion enthält also Meldung den Inhalt:

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| H | e | l | l | o | | W | o | r | l | d | \0| | |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Möchte man an diesen Text jetzt noch etwas anfügen, z. B. ein "?", so würde das so aussehen:

<c>
#include "string.h"

int main()
{
char Meldung[14];
strcpy( Meldung, "Hello World" );
strcat( Meldung, "?" );
}
</c>


Man beachte: auch wenn hier scheinbar nur ein einzelnes Zeichen angehängt wird, so handelt es sich doch um einen String. Strings werden in C immer mit einem " eingeleitet und abgeschlossen. Im Gegensatz zu einzelnen Zeichen, die in einfache ' eingefasst werden. "?" ist also nicht dasselbe wie '?'! Das
erste ist ein String (der mit dem obligatorischen '\0' Zeichen insgesamt aus 2 Zeichen besteht), während letzteres ein einzelnes Zeichen darstellt! Die meisten str... Funktionen arbeiten nur mit Strings!


Da Meldung maximal 14 Zeichen umfassen kann, der Text "Hello World?" aber nur aus 13 Zeichen besteht, funktioniert Obiges auch ohne Probleme. Der Array-Inhalt sieht dann wie folgt aus:

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| H | e | l | l | o | | W | o | r | l | d | ? | \0| |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Ein schwerwiegender Fehler wäre es, wenn der komplette String nach dem strcat() aus mehr als 14 Zeichen (das '\0'-Zeichen nicht vergessen!) bestehen würde.

<c>
#include "string.h"

int main()
{
char Meldung[14];
strcpy( Meldung, "Hello World" );
strcat( Meldung, " von mir" );
}
</c>

würde also das Array überlaufen lassen.

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| H | e | l | l | o | | W | o | r | l | d | | v | o | n m i r \0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Man sieht sehr schön, daß in diesem Fall die weiteren Zeichen einfach an die Folgepositionen im Speicher geschrieben werden und dadurch ungewollt Speicher verändern, der nicht zu Meldung gehört. Abhängig von den Details des Programmes können aber an dieser Stelle im Speicher z. B. ganz andere Variablen liegen, die dann verändert werden. strcpy(), strcat() oder alle anderen String-Funktionen können den Programmierer gegen diesen Fall nicht schützen! Dazu müssten sie die Größe des Speicherbereichs kennen, was sie nicht tun. Es obliegt einzig und alleine der Sorgfalt des Programmierers, das Programm gegen solche Fälle abzusichern!

Seit einiger Zeit wurde das Sammelsurium der str... Funktionen durch Varianten ergänzt, die sich anschicken dieses Manko zu entschärfen. Diesen Funktionen wird die maximale Anzahl der zu bearbeitenden Zeichen mitgegeben. Mit der Kenntnis der Größe des Zielbereichs und der Länge des bereits darin enthaltenen Strings ist es damit möglich eine Obergrenze auszurechnen, wieviele Zeichen von einer Funktion gefahrlos bearbeitet werden dürfen, ehe der Zielbereich überlaufen würde.

Diese Funktionen heißen grundsätzlich gleich wie die str... Funktionen, nur befindet sich ein kleines 'n' im Funktionsnamen. Aus strcpy wird so strncpy, aus strcat wird strncat usw. Für Details dazu sei auf Literatur oder Web-Recherche verwiesen. Auch wenn einen diese Funktionen gegen die gefürchteten Array-Overflows schützen können, so muß man sich trotzem klarmachen, daß dieser Schutz nur die halbe Miete ist. Denn was soll strncpy denn tun, wenn der zu kopierende String nicht in das Zielarray passt? strncpy kopiert soviel wie es kann und gibt dann auf. Aber: Dadurch ist der String aber nicht zur Gänze in den Zielbereich kopiert worden. Programmteile die darauf angewiesen sind, daß der String vollständig kopiert wurde, werden dann nicht mehr oder nicht richtig funktionieren usw. Auch wenn die strn... Funktionen eine gewisse Abhilfe bringen und zumindest den Absturz eines Programmes verhindern können, stellen sie dennoch keine Allheilmittel dar. Um die korrekte Abschätzung der benötigten Arraygrößen kommt man nicht umhin.

strlen() liefert die Länge eines Strings. Die Längenangabe beinhaltet dabei nicht das abschliessende '\0' Zeichen:

<c>
#include "string.h"

int main()
{
char Meldung[14];
int Len;

strcpy( Meldung, "Hello World" );
Len = strlen( Meldung );

/* Hier enthaelt Len den Wert 11 */

Len = strlen( "Hallo Welt" );

/* Hier enthält Len den Wert 10 */
}
</c>

strcmp() schlussendlich vergleicht 2 Strings auf Gleichheit. Der Rückgabewert spiegelt dabei die Position des ersten Unterschiedes in den beiden Strings wieder. Folgerichtig sagt ein Wert von 0 daher aus, dass die beiden Strings identisch sind:

<c>

#include "string.h"

int main()
{
char Meldung1[14];
char Meldung2[14];

strcpy( Meldung1, "Hello World" );
strcpy( Meldung2, "Hallo Welt" );

if( strcmp( Meldung1, Meldung2 ) == 0 ) {
/* die Strings sind identisch */
}
else {
/* die Strings sind nicht identisch */
}

if( strcmp( Meldung2, "Hallo Welt" ) == 0 ) {
/* Meldung2 war "Hallo Welt" */
}
}

</c>

Es gibt noch weitere String-Funktionen, dafür sei aber auf die Verwendung der zum Compiler gehörenden Dokumentation bzw. auf einführende Literatur zum Thema 'Programmieren in C' verwiesen.

=Funktionszeiger=
Um Menüs oder ähnliche Dinge aufzubauen ist es oft praktisch ein Array von Funktionszeigern zu definieren. Der Aufruf einer Funktion kann dann indirekt über eine Variable erfolgen, wobei die Variable die Adresse der aufzurufenden Funktion enthält.

Um mit Funktionszeigern zu arbeiten ist es in der Praxis sinnvoll sich einen typedef für den Typ des Funktionszeigers zu definieren. Ein typedef definiert einen neuen (kürzeren) Namen für einen Datentyp. Und wie wir sehen werden, ist der Datentyp eines Funktionszeigers in der Schreibweise ganz schön umfangreich.

==typedef==
Einen typedef zu definieren ist eigentlich ganz einfach: Man schreibt die Deklaration so, als ob man eine Variable definieren würde. Vor das ganze Konstrukt kommt das Schlüsselwort typedef. Es bewirkt, dass der Name an der Position des Variablennamens zum Namen für den neuen Datentyp wird, der dann in weiterer Folge wie jeder andere Datentyp benutzt werden kann.

Wir wollen einen Funktionszeiger auf eine Funktion definieren, die keine Argumente entgegen nimmt und auch nichts liefert. Also Funktionen nach
dem Muster:

<c>
void foo( void )
{
}
</c>

Ein entsprechender typedef würde zB so aussehen:

<c>
typedef void (*VoidFnct)( void );
</c>

Das vereinbart einen neuen Datentyp VoidFnct. Dieser ist ein Funktionszeiger auf Funktionen, die keine Argumente nehmen und auch nichts zurückliefern.

<c>
typedef int (*IntFnct)( void );
typedef int (*IntFnct2)( int );
</c>

IntFnct ist ein Zeiger auf eine Funktion, die keine Argumente nimmt aber einen int zurückliefert. IntFnct2 hingegen ist ein Zeiger auf eine Funktion, die einen int als Argument nimmt und einen int zurückliefert. Andere Argumenttypen bzw. Rückgabetypen folgen dem gleichen Muster. Wichtig ist, dass sowohl Argumenttypen als auch Rückgabetypen Teil der Signatur eines Funktionszeigers ist. Es ist also nicht möglich einen Funktionszeigertyp zu vereinbaren, der auf beliebige Funktionen mit beliebigen Argumenttypen bzw. Rückgabetypen verweist. Hier muss man ev. auf einen cast ausweichen. Generell ist das aber meist keine gute Idee.

Die Bildung des Datentyps ist im Grunde eigentlich sehr einfach: Man nimmt in Gedanken den Funktionskopf her.
<c>
double CelsiusToFahrenheit( double Celsius )
{
...
</c>
Dann werden in der Argumentliste alle Argumentnamen entfernt
<c>
double CelsiusToFahrenheit( double )
</c>
Der Funktionsname durch den Namen des Datentyps getauscht
<c>
double CallbackFnct( double )
</c>
Vor den Datentypnamen kommt ein * (wie bei allen Zeigerdefinitionen) und rund um dieses Gebilde kommen Klammern (die den * an den Datentypnamen binden und nicht an den Datentyp des Returnwertes)

<c>
double (*CallbackFnct)( double )
</c>

und fertig ist der Datentyp einer Funktion die einen double als Argument annimmt und einen double als Returnwert liefert. Davor noch der typedef und das abschliessende ; und wir haben einen neuen Datentyp namens CallbackFnct, der einen Funktionszeiger auf Funktionen mit genau dieser Signatur darstellt.

<c>
typedef double (*CallbackFnct)( double );
</c>

==Funktionszeigertabellen==
Mit einem typedef ist es nun ein leichtes ein Array von Funktionszeigern zu vereinbaren:

<c>
typedef void (*VoidFnct)( void );

VoidFnct MeineFunktionen[5];
</c>

Dies vereinbart MeineFunktionen als ein Array von Funktionszeigern, wobei jeder Funktionszeiger auf eine Funktion vom Typ void-void zeigt.

<c>
typedef void (*VoidFnct)( void );

void Funct1()
{
printf( "Dies ist Funktion 1\n" );
}

void Funct2()
{
printf( "Dies ist Funktion 2\n" );
}

VoidFnct MeineFunktionen[] = { Funct1, Funct2 };

int main()
{
//
// ruft die Funktion auf, deren Adresse in MeineFunktionen[0]
// steht. In diesem Fall wäre das Funct1()
//
MeineFunktionen[0]();

//
// und jetzt die MeineFunktionen[1]
//
MeineFunktionen[1]();

//
// jetzt wird MeineFunktionen[0] umgeleitet auf Funct2()
// Achtung: Auf der rechten Seite wird kein () angegeben.
// Ansonsten würde ja die Funktione Funct2 aufgerufen. Wir
// wollen aber nur ihre Speicheradresse haben! Daher unterbleibt
// das ()
//
MeineFunktionen[0] = Funct2;

//
// welche Funktion wird jetzt aufgerufen?
//
MeineFunktionen[0]();
// Richtig: Die Funktion, deren Adresse in MeineFunktionen[0]
// steht. Und das ist jetzt Funct2.
}
</c>

==Menüs mit Funktionszeigern==
Besonders bei Menüs ist es oft hilfreich, sich eine Struktur bestehend
aus dem Menütext und der aufzurufenden Funktion zu definieren. Dazu kann man sich dann auch gleich noch irgendwelche Argumente mit in die Struktur mit aufnehmen, die beim Funktionsaufruf an die Funktion übergeben werden.

<c>
typedef void (*MenuFnct)( int);

struct MenuEntry {
char Text[20];
MenuFnct Function;
int ArgumentToFunction;
};
</c>

Ein Menü ist dann einfach ein Array aus derartigen Strukturelementen

<c>

void HandleEdit( int arg )
{
}

void HandleCopy( int arg )
{
}

void HandlePaste( int arg )
{
}

struct MenuEntry MainMenu[] = {
{ "Edit", HandleEdit, 23 }, // Der Funktion HandleEdit soll beim Aufruf 23 mitgegeben werden
{ "Copy", HandleCopy, 0 },
{ "Paste", HandlePaste, 0 }
};

#define ARRAY_SIZE(X) ( sizeof(X) / sizeof(*(X)) )

void DoMenu( int NrEntries, struct MenuEntry Menu[] )
{
int i;
int Auswahl;

do {
//
// Das Menue anzeigen. Für jeden Menuepunkt noch eine Zahl
// davor stellen, damit der Benutzer auch was zum Eingeben hat
//
for( i = 0; i < NrEntries; ++i )
printf( "%d) %s\n", i + 1, Menu[i].Text );

printf( "9) Exit\n\n" );

//
// Jetzt die Benutzereingabe abwarten ...
//
printf( "Ihre Eingabe: " );
scanf( "%d", &Auswahl );

//
// ... und auswerten
//
if( Auswahl == 9 )
return;

Auswahl = Auswahl - 1;
if( Auswahl < 0 || Auswahl > NrEntries )
printf( "Ungültige Eingabe\n" );

else
//
// Die Eingabe war gültig. Zugehörige Funktion aufrufen und der Funktion
// den in der Menüdefinition vermerkten Wert mitgeben
//
Menu[Auswahl].Function( Menu[Auswahl].ArgumentToFunction );
}
}

int main()
{
// Das Menü arbeiten lassen.
// Die Funktion DoMenu ruft selbsttätig die zu den jeweiligen
// Menüpunkten gehörenden Funktionen auf. DoMenu kommt erst
// dann wieder zurück, wenn der Benutzer den Menüpunkt
// 9) Exit
// ausgewählt hat.

DoMenu( ARRAY_SIZE( MainMenu ), MainMenu );

while( 1 )
;
}
</c>

Auf einem Mikrocontroller wird man natürlich die Ein/Ausgabe nicht über printf/scanf abwickeln. Hier geht es aber um das Prinzip der Funktionszeiger und wie man mit ihnen arbeitet, daher wurde die allereinfachste Art der Benutzerinteraktion gewählt. Gegebenenfalls muss printf und scanf durch die Möglichkeiten auf dem konkreten System ersetzt werden. Auch ist die Art und Weise wie das Menü präsentiert bzw. die Benutzereingabe ausgewertet wird, nicht der Weisheit letzter Schluss. Anstatt den Benutzer Zahlen eingeben zu lassen, könnte man auch einen Auswahl-Balken vom Benutzer mit 2 Tasten über die Menüeinträge bewegen lassen. Oder einen Drehencoder nehmen, ...

=Ich hab da mehrere *.c und *.h Dateien. Was mache ich damit?=
Zunächst ist es wichtig, sich zu vergegenwärtigen wie denn der C Compiler/Linker überhaupt arbeitet. Ein komplettes Programmier-Projekt kann und wird im Normalfall aus mehreren Source Code Dateien bestehen die alle zusammengenommen das komplette Programm bilden.

Der Prozess des Erstellens des Programmes geschieht in mehrerern Schritten:
* zunächst werden alle Einzelteile (jede *.c Datei) für sich ''compiliert''. Dabei ensteht für jede *.c Datei eine sog. Object-Datei in der bereits der Maschinencode für die im *.c programmierten Funktionen enthalten ist
* danach werden die einzelnen Object-Dateien zusammen mit zusätzlichen Bibliotheken zum fertigen Programm ''gelinkt''.

Angenommen das komplette Projekt besteht aus 2 Dateien

Datei: main.c
<c>
int twice(int i);

int main()
{
twice( 5 );
}
</c>

Datei: func.c
<c>
int twice( int number )
{
return 2 * number;
}
</c>

dann werden main.c und func.c unabhängig voneinander compiliert. Als Ergebnis erhält man die Dateien main.o und func.o die den besagten Object-Code enthalten. Erst diese beiden Zwischenergebnisse werden dann zusammen mit eventuellen Bibliotheken zum fertigen Programm gebunden (gelinkt), das dann ausgeführt werden kann.

+---------+ +----------+
| main.c | | func.c |
+---------+ +----------+
| |
| |
v v
Compiler Compiler
| |
| |
v v
+---------+ +----------+
| main.o | | func.o |
+---------+ +----------+
| |
+-----------+ +-------------------+
| |
v v
Linker <------ zus. Bibliotheken
|
v
+----------+
| fertiges |
| Programm |
+----------+

Bekommt man also von irgendwo bereits fertige *.c (und zugehörige *.h) Dateien, so genügt es, die *.c Dateien ganz einfach in das Projekt mit aufzunehmen. Daduch wird das entsprechende *.c File compiliert und das Ergebnis davon, das Object-file, wird dann in das fertige Programm mit eingelinkt.

Wie eine *.c Datei in das Projekt mit aufgenommen wird, hängt im wesentlichen von der benutzten Entwicklungsumgebung ab.

==Makefile==
Die zusätzliche *.c Datei wird in die SRC Zeile im makefile eingetragen.
==AVR-Studio==
Hier ist es besonders einfach eine Datei in das Projekt mit aufzunehmen. Dazu wird im Projektbaum einfach der Knoten "Source Files" aktiviert und mit der rechten Maustaste das Kontextmenü geöffnet. Im Menü wird der Punkt "Add existing Source File(s)" ausgewählt und anschliessend zeigt man AVR-Studio das zusätzliche *.c File. AVR-Studio berücksicht dann dieses File bei der Projekterzeugung, compiliert es und sorgt dafür, daß es zum fertigen Programm dazugelinkt wird.

=Globale Variablen über mehrere Dateien=
Ein häufige Problemkreis in der C Programmierung sind auch globale Variablen, die von mehreren *.c Dateien aus benutzt werden sollen. Was hat es damit auf sich?

Zunächst mal muß man bei der Vereinbarung von Variablen zwischen Definition und Deklaration unterscheiden. Worin besteht der Unterschied?
* Definition: Mit einer Definition wird der Compiler angewiesen eine Variable tatsächlich zu erzeugen. Damit er das kann, muß ihm selbstverständlich der exakte Datentyp und auch der Name der Variablen zur Verfügung stehen. Eine Definition sorgt also dafür, daß im späteren Programm Speicherplatz für diese Variable reserviert wird
* Deklaration: Mit einer Deklaration teilt man dem Compiler lediglich mit, dass eine Variable existiert. An dieser Stelle soll der Compiler also keinen Speicherplatz reservieren (das muß an anderer Stelle geschehen sein), sondern der Compiler soll einfach nur zur Kenntniss nehmen, daß es eine Variable mit einem bestimmten Namen gibt und von welchem Datentyp sie ist.

Aus obigem folgt sofort, dass eine Definition auch immer eine Deklaration ist. Denn dadurch daß der Compiler angewiesen wird eine Variable auch tatsächlich zu erzeugen folgt, dass er dazu auch dieselben Informationen benötigt, die auch in einer Deklaration angegeben werden müssen. Der einzige Unterschied: Bei einer Deklaration trägt der Compiler nur in seinen internen Tabellen ein, dass es diese Variable tatsächlich gibt, während er bei einer Definition zusätzlich auch noch dafür sorgt, dass im fertigen Programm auch noch Speicher für diese Variable bereitgestellt wird.

Warum ist diese Unterscheidung jetzt wichtig?

Weil es in C die sog. One Definition Rule oder kurz ODR gibt. Sie besagt, dass in einem vollständigem Programm, also über alle *.c Dateien gesehen, es für eine Variable nur eine Definition geben darf. Es darf allerdings beliebig viele Deklarationen geben, solange diese Deklarationen alle im Datentyp übereinstimmen. Kurz gesagt: Man darf den Compiler nur einmal auffordern eine Variable zu erzeugen (Definition), kann sich aber beliebig oft auf diese eine Variable beziehen (Deklarationen). Aber Vorsicht! Da der Compiler jede einzelne *.c Datei für sich alleine übersetzt und dabei kein Wissen von ausserhalb benutzt, obliegt es der Verantwortung des Programmierers dafür zu sorgen, dass alle Deklarationen im Datentyp übereinstimmen. Der Compiler kann diese Einhaltung prinzipbedingt nicht überwachen!

Woran erkennt man eine Definition bzw. Deklaration?

Eine Definition einer globalen Variable steht immer ausserhalb eines Funktionsblocks. Zb.
<C>
int MyData; // Globale Variable namens MyData. Sie ist vom Typ int
char Name[30]; // Globales Array
long NrElements = 5; // Globale Variable, die auch noch initialisiert wird
</C>

Eine Deklaration unterscheidet sich von einer Definition in 2 Punkten
* Es wird das Schlüsselwort extern vorangestellt.
* Es kann keine Initialisierung geben. Sobald eine Initialisierung vorhanden ist, wird das Schlüsselwort extern ignoriert und aus der Deklaration wird eine Definition.

Beispiele für Deklarationen
<C>
extern int MyData;
extern char Name[30];
extern long NrElements;
extern long NrElements = 5; // Achtung: Dies ist keine Deklaration!
</C>

Besitzt man also 2 *.c Dateien, main.c und helpers.c, und sollen sich diese beiden Dateien eine globale Variable teilen, so muss in eine Datei eine Definition hinein, während in die andere Datei eine Deklaration derselben Variablen erfolgen muß. Traditionell werden die Definitionen in der Datei gemacht, die auch die main() Funktion enthält. Das muss nicht so sein, ist aber eine Konvention, die oft Sinn macht. Alternativ wird auch gerne oft eine eigene *.c Datei (zb. globals.c) gemacht, die einzig und alleine die Defintionen der globalen Variablen enthält.

main.c
<C>
int AnzahlElemente; // Dies ist die Definition. Hier wird die globale
// Variable AnzahlElemente tatsächlich erzeugt.

int main()
{
AnzahlElemente = 8;
...
}
</C>

helpers.c
<C>
extern int AnzahlElemente; // Dies ist die Deklaration die auf die globale
// Variable AnzahlElemente in main.c verweist.
// Wichtig: Der Datentyp muss mit dem in main.c
// angegebenen übereinstimmen

void foo()
{
...
j = AnzahlElemente;
AnzahlElemente = 9;
}
</C>

==Praktische Durchführung==
Besteht ein vollständiges Programm aus mehreren *.c Dateien, dann kann man sich vorstellen, daß es mühsam ist, alle Deklarationen immer auf gleich zu halten. Hier bietet sich der Einsatz eines Header Files an, in der die Deklarationen stehen und welches in die jeweiligen *.c Dateien inkludiert wird

Bsp:

Global.h
<C>
extern int Anzahl;
</C>

main.c
<C>
#include "Global.h"

int Anzahl; // auch wenn Global.h inkludiert wurde, so muss es eine
// Definition der Variablen geben. In Global.h sind ja nur
// Deklarationen.

int main()
{
...
Anzahl = 5;
}
</C>

foo.c
<C>
#include "Global.h"

void foo()
{
...
Anzahl = 8;
...
}
</C>

bar.c
<C>
#include "Global.h"

void bar()
{
...
j = Anzahl;
}
</C>

Auf diese Art kann man erreichen, dass zumindest alle Deklarationen ein und derselben Variablen in einem Programm übereinstimmen. Die Datei Global.h wird auch in main.c inkludiert, obwohl man das eigentlich nicht müsste, denn dort wird die Variable ja definiert. Durch die Inclusion ermöglicht man aber dem Compiler die Überprüfung ob die Deklaration auch tatsächlich mit der Definition übereinstimmt.

Solange kein Initialisierungen der globalen Variablen notwendig sind, gibt es noch einen weiteren Trick, um sich selbst das Leben und die Verwaltung der globalen Variablen zu erleichtern.
Worin besteht das Problem?
Das Problem besteht darin, dass man bei Einführung einer neuen globalen Variablen an 2 Stellen erweitern muss: Zum einen in der Header-Datei, die die 'extern'-Deklaration der Variablen enthält, zum anderen muss in einer C-Datei die Definition der Variablen erfolgen. Das kann man sich mit etwas Präprozessorarbeit auch einfacher machen:

Global.h
<C>
#ifndef EXTERN
#define EXTERN extern
#endif

EXTERN int Anzahl;
</C>

main.c
<C>
#define EXTERN
#include "Global.h"

int main()
{
...
Anzahl = 5;
}
</C>

foo.c
<C>
#include "Global.h"

void foo()
{
...
Anzahl = 8;
...
}
</C>

Wie funktioniert das Ganze? Im Grunde muss man nur dafür sorgen, dass der Compiler an ''einer'' Stelle das Schlüsselwort '''extern''' ignoriert (hier in main.c) und bei allen anderen Inclusionen beibehält. Dadurch das ein Präprozessor-ifndef benutzt wird, kann dieses erreicht werden. Wird das Header File includiert und ist zu diesem Zeitpunkt das Makro '''EXTERN''' noch nicht definiert, so wird innerhalb des Header Files '''EXTERN''' zu '''extern''' definiert und damit in weiterer Folge im Quelltext '''EXTERN''' durch '''extern''' ersetzt. Wenn daher foo.c das Header File inkludiert, wird die Zeile
<C>
EXTERN int Anzahl;
</C>
vom Präprozessor zu
<C>
extern int Anzahl;
</C>
umgewandelt.

In main.c hingegen sieht die Include-Sequenz so aus
<C>
#define EXTERN
#include "Global.h"
</C>
Wenn Global.h bearbeitet wird, existiert bereits ein Makro '''EXTERN''', das auf einen leeren Text expandiert. Dadurch wird verhindert, dass innerhalb von Global.h das Makro '''EXTERN''' mit dem Text '''extern''' belegt wird und
<C>
EXTERN int Anzahl;
</C>
wird daher vom Präprozessor zu
<C>
int Anzahl;
</C>
erweitert, genau wie es benötigt wird.

= Konstanten an fester Flash-Adresse =

Wie kann man eine Konstante an entsprechender Adresse im Flash ablegen?

Mehmet Kendi hat eine Lösung für [[AVR Studio]] & [[WinAVR]] in
[http://www.mikrocontroller.net/topic/142704#1453079] angegeben.

[[Kategorie:Grundlagen]]
[[Kategorie:C]]

LPC2000

2010-05-13T10:42:10Z

Chrisu: /* Verwendung des Bootloaders */

Die LPC2000 von NXP (ehemals Philips) waren die ersten wegen ihrer einfachen Handhabung hobbytauglichen [[ARM]]-basierten Mikrocontroller. Entsprechend sind auch zum LPC2000 mehr Informationen verfügbar als z. B. zum [[AT91SAM]]7, und man findet leichter Hilfe bei Problemen. Ein weiterer Vorteil des LPC2000 ist der einfach zu benutzende serielle Bootloader, mit dem sich der Controller auch ohne JTAG-Interface einfach programmieren lässt. Ansonsten ist die Hardwareausstattung recht ähnlich im Vergleich zum AT91SAM7. Hervorzuhebende Unterschiede sind das schnellere Flash-ROM des LPC2000, die etwas höhere Taktfrequenz, beim gleichen Gehäuse mehr I/O-Pins und die größere Auswahl von Modellen im Low-End-Bereich (LPC2103).

* 2-96 kB [[RAM|SRAM]].
* bis zu 512 kB [[Flash-ROM]]-Programmspeicher (LPC2138/2148/2368/2378/LPC2387/LPC2388/2468/2478)
* vorinstallierter serieller [[Bootloader]] mit automatischer [[Baud]]rate-Erkennung
* [[JTAG]]-Interface
* ETM Trace-Interface
* 2-4 [[UART]]-Schnittstellen (bei einigen Modellen auch mit allen "Modem"-Leitungen (Handshake, Ring, DTR etc.)
* 1-2 [[SPI]]-Schnittstelle(n), bei einigen Modellen auch SSP-Schnittstelle(n) (erweiterte Konfigurationsmöglichkeiten und Funktionen)
* Hardware-[[I2C]](I²C)-Schnittstelle(n)
* teilw. mit CAN-Schnittstellen
* Mit Ausnahme der ersten Chips LPC2104/5/6 haben alle Typen einen integrierten A/D-Wandler
* teilw. mit D/A-Wandler (LPC2132/34/36/38, LPC2142/44/46/48)
* 2 32 Bit [[Timer]], zusätzlicher 32-bit [[Timer]] mit 6 [[Pulsweitenmodulation|PWM]]-Ausgängen, RTC, [[Watchdog]]
* bis 75 MHz Taktfrequenz
* [[IC-Gehäuseformen|LQFP48]]-Gehäuse (LPC210x) bis LQFP208 (LPC24xx)
* LPC213x und LPC214x benötigen zum Betrieb 3V
* Für die anderen Typen werden Core-Spannung 1,65-1,95V und IO-Spannung 3,0-3,6V benötigt (d.h. zum Betrieb sind 2 Versorgungsspannungen erforderlich)
* geringe Leistungsaufnahme (ca. 60 mW bei 60 MHz und Endlosschleife)
* 5V-tolerante IOs
* USB 2.0 Full-Speed (LPC214x und LPC23xx/24xx)
* Ethernet MAC (LPC23xx/24xx)
* Jeweils eigene DMA und eigener AHB-Bus für Ethernet, USB und sonstige schnelle Schnittstellen (LPC23xx und LPC24xx)
* RTC (teilweise mit eigenem Oszillator)

== Verwendung des Bootloaders ==

Benötigte Software gibt es unter http://sourceforge.net/projects/lpc21isp/ zum Download.

# BSL-Jumper setzen
# Reset-Knopf drücken
# lpc21isp starten
#* Linux: lpc21isp programm.hex /dev/ttyS0 115200 14746
#* Windows: lpc21isp programm.hex com1 115200 14746

Die Übertragung des Programms zum Controller sollte jetzt beginnen. Um das Programm zu starten den '''BSL-Jumper entfernen''' und Reset drücken.

Alternativ kann unter MS-Windows das von Philips bereitgestellte "Flash-Tool" oder Flash Magic von Embedded Systems Academy genutzt werden. Diese Programmiersoftware bieten eine grafische Benutzeroberfläche.

Sowohl lpc21isp also auch das Philips-Tool und Flash Magic können Reset und BSL per DTR/RTS-Signal steuern, bei entsprechender Beschaltung auf dem Board muss man somit keine Jumper setzen (vgl. z. B. Schaltpläne der Evaluation-Boards von [http://www.keil.com Keil]).

Eine weitere Alternative ist [http://home.arcor.de/bernhard.michelis/LPC/index.html LPCProg 0.3], welches speziel für auf die Verwendung eines FTDI-232 Chips hin optimiert wurde. Auf der Website gibt es auch ein Layout für einen USB-zu-Seriel-Adapter. Die Software/Hardware ist zu den obigen Programmen Pinkompatibel und kann beliebig damit gemixt werden.

== Allgemeine Hinweise ==
* Der Softwareschutz bei den LPC2104/5/6 ist nicht implementiert (Stand 4/2005). Dies wird Anfang 2007 geändert. Ein Schutz des geistigen Eigentums ist also bei diesen 3 Controllern derzeit nicht gewährleistet. Andere Controller aus der LPC2000-Serie sind davon nicht betroffen.
* Auf vielen (Stand 4/2005) LPC2000 existiert ein Fehler bei der Verwaltung der Interrupt-Flags ("race condition", "timer issue"). Der Fehler und mögliche Abhilfen sind in den Errata von NXP erläutert.
* Die CAN Controller in den LPC2100,2200 sind so gründlich mit Bugs und Designfehlern gespickt, dass letztlich nur ein kleiner Bruchteil der dokumentierten Funktionen nutzbar ist. Die Bugs finden sich im Errata Sheet, die Konstruktionsfehler darf man selber finden.
* Bei Nutzung des SPI-Interfaces im "Master-Mode" ist bei einigen LPC2000-Typen auf die richtige Beschaltung des "Chip-Select"-Pins zu achten (vgl. Manuals und Erratas).
* Viele Fehler in der "ersten Generation" der ICs wurden bei neueren Versionen behoben. Vgl. Datenblätter/Errata zu LPC2xxx/01.
* Bei neueren LPCs (LPC213x/4x) sollte die aktuelle Fassung der NXP ISP-Software genutzt werden (Stand 3/2006: V2.2.2, erhältlich auf der NXP Web-Site). Ältere Versionen funktionieren nicht zuverlässig oder garnicht.
* LPC23xx/24xx werden von der Philips ISP-Software nicht unterstützt. Alternativen: Flashmagic oder lpc21isp.
* Bei Problemen immer auch das Archiv der LPC2000 yahoo-Gruppe absuchen. Dort finden sich, leider oft etwas zerstreut, sehr nützliche Hinweise. Die Anmeldung bei der Gruppe (yahoo-Account erforderlich) gewährt Zugang zum Download-Bereich der Gruppe. Dort finden sich sehr nützliche Beispielprogramme, Libraries und Dokumente.
* Bei Entwicklungen mit der GNU-Toolchain erweisen sich Beispiele von kommerziellen Compiler/IDE-Anbietern, die ebenfalls den GNU-Compiler nutzen, oft als gute Informationsquelle vor allem bei Einstellungen zum Startup-Code oder im Linker-Script. (vgl. u.a. Rowley, Keil, Anglia-Designs)
* siehe auch: [http://www.open-research.org.uk/ARMuC/index.cgi?LPC2100Tips LPC2100-Tips] im ARMuC Wiki (englisch)

== Siehe auch ==

* [[ARM-elf-GCC-Tutorial]]
* [[Linksammlung#ARM|Linksammlung Abschnitt ARM]]
* [[LPC2000-Boards von Olimex]]
* [[MP2103-Stick: Ein Mini-Mikrocontroller-Board mit USB und bis zu 4MB Datenspeicher]]

== Weblinks ==
* [http://www.standardics.nxp.com/products/lpc2000/all/ Philips / NXP LPC2000]
* [http://groups.yahoo.com/group/lpc2000/ LPC2000 Yahoo Group]
* [http://www.dreamislife.com/arm/ LPC210x ARM7 Microcontroller Tutorial]
* [http://www.dontronics-shop.com/tutorials.html Dontronics Tutorials] u.a. "ARM Cross Development with Eclipse Version 3" von James P. Lynch
* [http://www.hitex.co.uk/arm/lpc2000book/free_downloadpage.html The Insider's Guide To The Philips ARM7-Based Microcontrollers (LPC21xx)] bei http://www.hitex.co.uk
* [http://groups.yahoo.com/group/lpc21isp lpc21isp] - Kommandozeilen-ISP-Tool für Linux und MS-Windows
* [http://www.esacademy.com/software/flashmagic/ Flash Magic] ISP-Tool
* [http://www.pjrc.com/arm/lpc2k_pgm/ LPC2K_PGM] - ISP-Tool mit GUI für Linux/GTK
* [http://www.sandring-systems.de/index.php5?lang=en&p=lf4l lpcflash4linux] - ISP-Tool für Linux (Kommandozeile)
* [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/ ARM projects] - LPC2000-Projekte und -Beispiele von Martin Thomas
* [http://www.jandspromotions.com/philips2005/DE-list.htm LPC2138 Design Contest] - Viele Beispiele mit Hard- and Software
* [http://www.ixbat.de/index.php?page_id=94 LPC2103 unter Linux entwickeln] - LED blink mit gcc unter Linux
* [http://www.thegnar.org/nav/LPCgettingstarted.html Bringing up the LPC-P212x] - Bauen einer Toolchain mit Newlib, ISP, JTAG
* [http://home.arcor.de/bernhard.michelis/LPC/index.html LPCProg 0.3] - Geschwindigkeitsoptimierte Version für USB-zu-Seriell-Wandler, Kommandozeilen-ISP-Tool für MS-Windows; Einfaches Demo-Board verfügbar

[[Category:ARM]] [[Category:Mikrocontroller]]
__NOTOC__

Benutzer:Chrisu

2010-04-29T11:14:02Z

Chrisu: Die Seite wurde geleert.

AVR-ISP-Stick

2010-01-23T00:24:32Z

Chrisu: /* Software */

[[Bild:AVR-ISP-Stick-UTIS.JPG|miniatur|rechts|350px]]

Der AVR-ISP-Stick ist ein [[ISP]]-Programmer für Atmels [[AVR]]-Reihe. Seinen Namen hat er wegen Form und Größe, die einem USB-Sticks gleichen. Er stellt die konsequente Optimierung des bekannten USBtinyISP in Hinsicht auf kompakte Baugröße und Kosten dar. Zu letzterem Zwecke wird er als Bausatz ausgeliefert.

Alle Informationen, die für das USBtinyISP(v1) gelten (außer natürlich der physische Aufbau), gelten auch für den AVR-ISP-Stick. Der USBtinyISP ist die Erfindung von Lady Ada, ihre [http://www.ladyada.net/make/usbtinyisp/index.html <Seite>] ist ein nützlicher Anlaufpunkt bei Fragen.

== Hardware ==
[[Bild:AVR-ISP-Stick-bottom.png|miniatur|rechts|280px|Layout Bottom]]
Der Programmer ist auf das wesentliche reduziert, d.h. er besteht im wesentlichen aus einem Attiny2313, einem USB-Stecker und dem ISP-Anschluss. Für USB braucht man einen genauen Takt, der aus einem 12MHz Quarz gewonnen wird. Außerdem kann man mit dem Jumper das Target mit Strom versorgen. Der Stick selbst bezieht seinen Strom aus dem USB-Port.

== Software ==
Der Controller des AVR-ISP-Sticks ist bei der Auslieferung bereits fertig programmiert und muss nicht weiter bearbeitet werden.

Für den Betrieb des Sticks wird ein Treiber benötigt. Auffindbar unter "Drivers"
[http://www.ladyada.net/make/usbtinyisp/download.html Treiberdownload]

Ein kleines Schmankerl des Sticks besteht darin, dass er sich mit ein bisschen Zusatzsoftware nicht nur unter AVRdude, sondern auch unter dem AVR Studio benutzen lässt. Dazu sind zwei Programme notwendig. Eine gute Anleitung findet sich hier: [http://www.ladyada.net/make/usbtinyisp/stk500compat.html Externer Link]
[[Bild:AVR-ISP-Stick-top.png|miniatur|rechts|410px|Layout Top]]

== FAQ ==
Einige Antworten auf häufig gestellte Fragen:
- Die LED2 leuchtet ständig im Betrieb. LED1 ist nur während dem Programmieren an
- Betriebssysteme: Windows XP (32Bit), Windows ??? BITTE ERGÄNZEN!!!
- Mögliche Programmierumgebungen: AVR Studio 4, AVRdude, BITTE ERGÄNZEN!!!
- NEIN, ES GIBT KEIN GEHÄUSE!!!

== Downloads ==
* Schaltplan: Eagle-Files: [[Datei:Stick.zip]]
* Schaltplan als PNG Bild: [[Datei:StickPNG.zip]]
* [http://www.ladyada.net/make/usbtinyisp/download.html Treiber]
* [http://www.ladyada.net/media/usbtinyisp/usbtinyisp%20v1.0%20firm.zip Quellcode und Hex-File von LadyAda]

== Siehe auch ==
* Diskussion: [http://www.mikrocontroller.net/topic/160107 Bausatz AVR-ISP-Stick]
* Diskussion: [http://www.mikrocontroller.net/topic/160025 Projektidee: Der Volks-Programmer]

[[Kategorie:AVR-Projekte|AVR-Projekte]]
[[Kategorie:AVR-Programmer_und_-Bootloader]]

AVR-ISP-Stick

2010-01-21T22:51:37Z

Chrisu: /* FAQ */

[[Bild:AVR-ISP-Stick-UTIS.JPG|miniatur|rechts|350px]]

Der AVR-ISP-Stick ist ein [[ISP]]-Programmer für Atmels [[AVR]]-Reihe. Seinen Namen hat er wegen Form und Größe, die einem USB-Sticks gleichen. Er stellt die konsequente Optimierung des bekannten USBtinyISP in Hinsicht auf kompakte Baugröße und Kosten dar. Zu letzterem Zwecke wird er als Bausatz ausgeliefert.

Alle Informationen, die für das USBtinyISP(V1) gelten (außer natürlich der physische Aufbau), gelten auch für den AVR-ISP-Stick. Die [http://www.ladyada.net/make/usbtinyisp/index.html Herstellerseite] ist ein nützlicher Anlaufpunkt bei Fragen.

== Hardware ==
[[Bild:AVR-ISP-Stick-bottom.png|miniatur|rechts|280px|Layout Bottom]]
[[Bild:AVR-ISP-Stick-top.png|miniatur|rechts|410px|Layout Top]]
Der Programmer ist auf das wesentliche reduziert, d.h. er besteht im wesentlichen aus einem Attiny2313, einem USB-Stecker und dem ISP-Anschluss. Für USB braucht man einen genauen Takt, der aus einem 12MHz Quarz gewonnen wird. Außerdem kann man mit dem Jumper das Target mit Strom versorgen. Der Stick selbst bezieht seinen Strom aus dem USB-Port.

== Software ==
Der Controller des AVR-ISP-Sticks ist bei der Auslieferung bereits fertig programmiert und muss nicht weiter bearbeitet werden.

Für den Betrieb des Sticks wird ein Treiber benötigt. Auffindbar unter "Drivers"
[http://www.ladyada.net/make/usbtinyisp/download.html Treiberdownload]

Ein kleines Schmankerl des Sticks besteht darain, dass er sich mit ein bisschen Zusatzsoftware nicht nur unter AVRdude, sondern auch unter dem AVR Studio benutzen lässt. Dazu sind zwei Programme notwendig. Eine gute Anleitung findet sich hier: [http://www.ladyada.net/make/usbtinyisp/stk500compat.html Externer Link]

== FAQ ==
Einige Antworten auf häufig gestellte Fragen:
- Die LED2 leuchtet ständig im Betrieb. LED1 ist nur während dem Programmieren an
- Betriebssysteme: Windows XP (32Bit), Windows ??? BITTE ERGÄNZEN!!!
- Mögliche Programmierumgebungen: AVR Studio 4, AVRdude, BITTE ERGÄNZEN!!!
- NEIN, ES GIBT KEIN GEHÄUSE!!!

== Downloads ==
* Schaltplan: Eagle-Files: [[Datei:Stick.zip]]
* Schaltplan als PNG Bild: [[Datei:StickPNG.zip]]


== Siehe auch ==
* Diskussion: [http://www.mikrocontroller.net/topic/160107 Bausatz AVR-ISP-Stick]
* Diskussion: [http://www.mikrocontroller.net/topic/160025 Projektidee: Der Volks-Programmer]

[[Kategorie:AVR-Projekte|AVR-Projekte]]
[[Kategorie:AVR-Programmer_und_-Bootloader]]

Diskussion:Linux Webradio

2010-01-14T14:13:28Z

Chrisu: Die Seite wurde neu angelegt: „Ein paar Bilder wären interessant.“

Ein paar Bilder wären interessant.

Benutzer:Chrisu

2009-10-24T22:22:26Z

Chrisu: Die Seite wurde neu angelegt: „Bin noch Anfänger...“

Bin noch Anfänger...

Benutzer Diskussion:Chrisu

2009-10-24T22:21:40Z

Chrisu: Die Seite wurde neu angelegt: „Bin noch Anfänger...“

Bin noch Anfänger...

Olimex AT91SAM7X256-Board SAM7-EX256

2009-10-24T21:05:09Z

Chrisu: ihrgendein russischer spam scheiß, habe ich gelöscht.

[http://shop.mikrocontroller.net/csc_article_details.php?saArticle%5BID%5D=80 Olimex AT91SAM7X256-Board (SAM7-EX256)]

[http://shop.mikrocontroller.net/csc_article_details.php?saArticle%5BID%5D=80 http://shop.mikrocontroller.net/images/sam7-ex256-small.jpg]

== Softwarevoraussetzungen ==

Die folgenden Anleitungen setzen das Vorhandensein einer [[ARM#Compiler|ARM-GCC-Toolchain]] voraus.

== Minimalbeispiel ==

Dieses einfache Beispielprojekt mit Makefile basiert auf dem GCC-Tutorial von Atmel. Enthalten ist kein OS, nur ein paar Funktionen für UART-Kommunikation.

Download: http://www.mikrocontroller.net/attachment/25724/Olimex_SAM7_EX256_StartupMinimal_2007.08.17.zip

== Installation von FreeRTOS ==

Merkmale von FreeRTOS:
* präemptives Multitasking
* Unterstützung für viele Prozessoren und Controller
* Demos für viele verschiedene Boards enthalten
* Beispiele für die Anbindung verschiedener IP-Stacks enthalten (lwIP, uIP)
* Codequalität der Demos durchwachsen

Funktionsumfang des Beispielprojekts:
* TCP/IP-Stack lwIP
* Webserver
* virtueller serieller Port über USB realisiert (CDC, Windows-Treiber enthalten)

Als Ausgangspunkt dient das Beispiel "lwIP_Demo_Rowley_ARM7" aus [http://www.freertos.org FreeRTOS] 4.4.0. Die für das Olimex-Board angepasste (und ein bisschen aufgeräumte) Version kann man [http://www.mikrocontroller.net/attachment/25551/lwIP_Demo_olimex.zip hier] herunterladen. Die Datei muss in den Demo-Ordner von FreeRTOS entpackt werden. Die Änderungen gegenüber der Originalversion sind in der Datei changes.txt dokumentiert.

Die IP-Adresse ist standardmäßig auf 192.168.0.111 gesetzt und lässt sich in der Datei BasicWEB.c ändern.

Kompiliert wird das Projekt wie üblich durch Eingabe von <code>make</code>.

== Installation von Ethernut ==

Ethernut bzw. Nut/OS ist ein Betriebssystem mit TCP/IP-Stack, das ursprünglich für AVR-Controller entwickelt wurde, später aber u.a. auf ARM portiert wurde.

Merkmale von Nut/OS:
* sehr sauberer und gut kommentierter Code
* Buildsystem mit Konfigurations-GUI; Vorteil: einfacher Einstieg, Nachteil: Gesamtsystem manchmal etwas undurchsichtig
* nur kooperatives Multitasking
* zielt hauptsächlich auf AVR ab, ARM-Unterstützung noch nicht weit fortgeschritten
* im Vergleich zu lwIP spartanischer IP-Stack

Funktionsumfang des Beispielprojekts:
* verschiedene Netzwerk-Beispielanwendungen (HTTP, FTP, DHCP)
* serieller Port

Getestet wurde diese Anleitung mit der Ethernut-Version 4.2.1.

Als Ausgangspunkt dient die Konfiguration at91sam7x-ek.conf. Für das Olimex-Board sind ein paar kleine Änderungen nötig.

=== PHY-Konfiguration ändern ===

Unter Architecture/ARM/AT91 EMAC Driver: [[Bild:olimex-sam7x-ethernut-phy-conf.png]]

=== PHY-Initialisierung patchen ===

In der Funktion EmacReset in der Datei at91_emac.c den Block mit dem Kommentar <code>/* For some unknown reason...</code> durch folgenden Code ersetzen:

<c>
/* PHY ID */
#define MII_DM9161_ID_H 0x0181
#define MII_DM9161_ID_L 0xb8a0

#define MII_AM79C875_ID_H 0x0022
#define MII_AM79C875_ID_L 0x5540

#define MII_MICREL_ID_H 0x0022
#define MII_MICREL_ID_L 0x1610

/* For some unknown reason it seems to be required to read the ID registers first. */
// Check for DM PHY (as used on the ATMEL EK)
if (phy_inw(NIC_PHY_ID1) != MII_DM9161_ID_H ||
(phy_inw(NIC_PHY_ID2) & 0xFFF0) != MII_DM9161_ID_L) {
// Check for MICREL PHY (as used on the Olimex SAM7-EX256)
if (phy_inw(NIC_PHY_ID1) != MII_MICREL_ID_H ||
(phy_inw(NIC_PHY_ID2) & 0xFFF0) != MII_MICREL_ID_L) {
outr(EMAC_NCR, inr(EMAC_NCR) & ~EMAC_MPE);
return -1;
}
}
</c>

=== Fehlende Definition ergänzen ===
Falls eine Fehlermeldung auftritt dass EMAC_PIO_SODR nicht definiert ist, folgenden Code in der Datei at91_emac.c vor <code>#ifdef PHY_PWRDN_BIT\n /* Disable PHY power down. */</code> einfügen:

<c>
#ifndef EMAC_PIO_SODR
#define EMAC_PIO_SODR PIOB_SODR
#endif
</c>

=== Ausprobieren ===

Wenn man das Beispielprogramm httpserv kompiliert (<code>make</code> eingeben) und in den Controller geladen hat sollte man über das UART (115.2 kBaud) die erfolgreiche Initialisierung bestätigt bekommen:
Nut/OS 4.2.1 HTTP Daemon...Configure eth0...OK
192.168.0.21 ready

Jetzt kann man die angezeigte IP-Adresse im Browser eingeben und sollte die Testseite zu sehen bekommen.

== Forum ==
* [http://www.mikrocontroller.net/topic/75721#new Diskussion zum Thema]

== Weblinks ==
* http://www.sparkfun.com/tutorial/Nokia%206100%20LCD%20Display%20Driver.pdf

[[Category:ARM-Boards]]

AVR und Linux

2009-10-10T18:09:56Z

Chrisu: Änderung 39821 von 69.120.79.115 (Diskussion) wurde rückgängig gemacht.da war SPAM!!!

Was ist zu beachten, wenn man mit einer Linux-Distribution AVRs programmieren möchte? Hier ist eine offene Liste von verschiedenen Tipps dazu...

==Toolchain beschaffen==

Evtl. sind die benötigten Pakete schon in der Distribution enthalten. Es sollte unbedingt geprüft werden, ob sie aktuell sind, es hat sich einiges geändert.

Alternativ:
* AVR Cross Development Kit - http://cdk4avr.sourceforge.net/
* Selbst kompilieren -
** http://www.nongnu.org/avr-libc/user-manual/install_tools.html
** http://www.roboternetz.de/wissen/index.php/Avr-gcc_und_avrdude_installieren
** http://www.linuxfocus.org/Deutsch/November2004/article352.shtml#352lf
** http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=42631
** http://www.mikrocontroller.net/topic/130972 (2009)

==Editor==

Der Editor sollte das Bearbeiten vom Programm einfach machen. Evtl. nützlich sind Features, um z.B. per Knopfdruck zu kompilieren und das Programm auf den AVR zu übertragen. Ansonsten: Editoren sind Geschmackssache, d.h. ausprobieren.

: [http://www.gnome.org/projects/gedit/ gedit] [gnome]
: [http://kate-editor.org/ kate] [kde]
: [[AVR_Eclipse|Eclipse]] [http://www.eclipse.org/] [Java]
: [http://www.gnu.org/software/emacs/ Emacs] bzw. [http://www.xemacs.org/ XEmacs] [Textterminal oder X]
: [http://www.vim.org/ Vim bzw. GVim] [Textterminal oder X]
: [http://www.codeblocks.org/ Codeblocks] [gtk]
: [http://www.cadmaniac.org/projectMain.php?projectName=kontrollerlab Kontrollerlab] [KDE]

Es lassen sich aber Programme auch in 'fremden' Desktopumgebungen ausführen.

==C-Compiler: avr-gcc==

Macht aus dem C-Code den vom AVR ausführbaren binären Programmcode.

Siehe auch:
* [[AVR-GCC]]
* [[AVR-GCC-Tutorial]]

==Laufzeitbibliothek: avr-libc==

Enthält Makros und Hardwaredefinitionen wie Registernamen für (die meisten) AVRs. Man muss sich deswegen um die echten Adressen in der Prozessor-Logik nicht mehr selbst kümmern, sondern kann direkt die Namen und Werte aus dem Datenblatt benutzen.

http://www.nongnu.org/avr-libc/user-manual/index.html

==Makefile==

Enthält Informationen zum Kompilieren. Das Programm make startet damit den angegeben Compiler. Im einfachsten Fall muss man also nur '''make all''' im entsprechenden Projektverzeichnis aufrufen, der Rest läuft automatisch. Die Datei heisst einfach nur Makefile.

Hier ein Skript, mit dem man die Einstellungen zusammenklicken kann (benötigt aber auch wieder anderes, z.B. TCL/TK, ..): http://www.sax.de/~joerg/mfile/ Dessen Aufruf erfolgt dann z.B. mit

<pre>
$ wish mfile.tcl
</pre>

Über ein Menü kann man dann die Einstellungen zusammenklicken. Das Editieren des Makefiles für Spezialanpassungen lässt sich aktivieren.

Wer sie von Windows kennt und sucht: Die Definition F_CPU der Taktfrequenz ist in der aktuellen Linux-Version nicht vorgesehen. Macht nichts, siehe dazu http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Taktfrequenz

==Programmierprogramm==

Schreibt mit entsprechender Hardware auf den Controller bzw. liest ihn aus.

Mit mfile lässt sich auch im Makefile gleich das Programmierprogramm zur Übertragung auf den Controller festlegen ([[AVRDUDE]], [[uisp]]): http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmierger.C3.A4t_einstellen

Eine Grafische Benutzerschnittstelle (GUI) für AVRDUDE steht mit [http://avr8-burn-o-mat.aaabbb.de/ avr8-burn-o-mat] zur Verfügung.

===Fuses, Lockbits===

Wer bislang Atmels AVR Studio unter Windows zum Programmieren der [[AVR_Fuses]] benutzt hat, kann das z.B. mit [[AVRDUDE]] machen, allerdings über die Shell.
Wer die Dokumentation sucht, findet sie mit Sicherheit im [http://download.savannah.gnu.org/releases/avrdude/ gepackten Programmpaket]. Ein aktuelles PDF

Z.B. bekommt man als Resultat folgenden Aufrufes den Hexwert der lfuse eines Tiny13 über einen [http://www.mikrocontroller.net/articles/AVR_In_System_Programmer AVR-ISP] mit aktueller Firmware, der an einem USB-Seriell-Wandler angeschlossen ist.

Durch die Option -v ([http://en.wiktionary.org/wiki/verbose verbose]) wird aber noch viel mehr [http://www.mikrocontroller.net/forum/read-1-399733.html?#399834 angezeigt].

<pre>
avrdude -p t13 -c avrispv2 -P /dev/ttyUSB0 -v -U lfuse:r:-:i
</pre>

Das - anstelle von FILENAME leitet die Ausgabe auf <stdout> (Bildschirm) um.

Frontend?
Shellbefehl, um die Werte binär anzuzeigen?

Eine Anleitung zum Umgang:
http://www.mikrocontroller.net/forum/read-1-152502.html

Eine 0 steht für eine gesetzte Fuse.

Die Bedeutung der Bits findet sich im Datenblatt unter "Memory Programming -> Fuse Bytes" (tiny13).

===Program/Burn Flash===

Der Mikrocontroller wird wie beim Kompilieren mithilfe von make und der eingestellten Programmiersoftware mit dem Befehl '''make program''' geflasht

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Anwendung

==Konfiguration, Probleme, Erfahrungen==

===Debian===

* Toolchain-Build: http://blog.coldtobi.de/index.php?op=ViewArticle&articleId=21&blogId=1

==== Etch (Netinst) ====
* Installation: gcc-avr, libc-avr, avrdude aus Standardquellen
* Emacs21 als Editor
* Makefile
... läuft problemlos.

===Gentoo===
Gentoo bietet mit dem Shellscript "crossdev" eine einfache automatisierte Möglichkeit die Toolchain zu erstellen. Genauere Versionen von binutils/gcc/libc können via parameter übergeben werden.
<pre>
emerge crossdev
crossdev --target avr
</pre>
Falls 'crossdev --target avr' nicht fehlerfrei durchlaufen sollte mit 'crossdev -t avr --without-headers' versuchen (2009-01-28).

===Mandrake===

* Toolchain-Build: http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=42631
* 2007: benötigt "texinfo" Package

===openSUSE===

* Seit Version 10.0 sind die Pakete avr-libc, cross-avr-gcc, cross-avr-binutils und avrdude in der Download-Version von openSUSE enthalten und können einfach über YaST bzw. zypper installiert werden.

===Ubuntu 6.06===

* Pakete veraltet; ist bereits als bug gemeldet
* Toolchain selbst kompilieren:
** default system path steht in /etc/environment
** Toolchain-Build: http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=42631

===Ubuntu 7.04===

* Toolchain-Build: http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=42631

===Ubuntu 8.04===
* einfach eine universe-Paketquelle von Ubuntu 8.10 (Intrepid Ibex) hinzufügen. Dort gibt es dann aktuelle AVR-Pakete (gcc 4.3, libc 1.6.2 usw.). Anleitung hier: http://packages.ubuntu.com/de/intrepid/i386/gcc-avr/download

===AVR-SLax===
* Einfach zu benutzende AVR-Live-CD
* Keine installation notwendig
* ISO brennen und von CD booten
Zu finden unter: http://www.lost-byte.de/avrslax.php

[[Category:AVR]]

Diskussion:Spule

2009-08-21T21:26:04Z

Chrisu: Die Seite wurde neu angelegt: Ein Anwendungsbeispiel wäre noch interessant. Vorallendingen wenn man am Anfang liest das man viele Sachen mit Coolness Faktor machen kann. mfg Christian

Ein Anwendungsbeispiel wäre noch interessant. Vorallendingen wenn man am Anfang liest das man viele Sachen mit Coolness Faktor machen kann.
mfg Christian