Mikrocontroller.net - Benutzerbeiträge [de]

Entfernungsmessung mit Ultraschall

2013-09-06T09:53:49Z

Stefanfrings de: Schaltplan vom Spannungsfolger ausgetauscht, war fehlerhaft.

''von Alexander Starke''

Ziel dieses Projektes ist die Realisierung einer Entfernungsmessung mit Ultraschall. Auf das Erläutern eventuell auftauchender Probleme sowie allgemeine Erklärungen wird hier verzichtet, diese Betrachtungen haben bereits [http://www.mikrocontroller.net/mc-project/Pages/Robotik/Sensoren/sensoren.html hier] statt gefunden.

Als Baugruppen werden Standardbauteile verwendet. Als Sender bzw. Empfänger dienen die Module UST-40T bzw. UST-40R, welche man über gängige Elektronik-Versender erhalten kann. Die Frequenzerzeugung für den Sender erfolgt mittels PWM durch einen Mikrocontroller. Die Auswertung des Empfangssignals erfolgt beispielsweise über den AD-Wandler desselben Mikrocontrollers.

== Variante 1 ==

=== Sender ===

Somit ist der Senderteil an sich einfach, da nur per PWM ein 40kHz-Signal erzeugt werden muss, welches dann auf den Sender gegeben werden kann. Die Signalerzeugung sieht bei mir codetechnisch folgendermaßen aus:

<syntaxhighlight lang="c">
void _40khz_init (void) {
TCCR1A = (1<<COM1A1) | (1<<COM1A0) | (1<<WGM11);
TCCR1B = (1<<WGM12) | (1<<WGM13) | (1<<CS10);
OCR1A = 100;
ICR1 = 200;
}
</syntaxhighlight>

Das Funktionsprinzip der obigen Funktion ist im Prinzip identisch mit dem der Funktion zur 36kHz Träger-Erzeugung, welches bereits [http://www.mikrocontroller.net/mc-project/Pages/Robotik/Sensoren/sensoren.html hier] erklärt wurde. Durch "toggeln" (also An- bzw. Ausschalten) des Datenrichtungsregister-Bits für PB1 kann man nun kurze Ultraschall-Impulse senden.

Es gilt jedoch zu experimentieren, wie man die Sendereichweite auf ein ordentliches Maß bringen könnte. Hierzu ergeben sich theoretisch verschiedene Möglichkeiten.

* Man gibt das PWM-Signal direkt auf den Sender, dessen zweiter Pin liegt auf Masse. Er wird nun ständig zwischen 0 und 5V hin und her geschalten. Dies ist die von der Senderstärke her schwächste Variante.
* Man legt das PWM-Signal an die Basis eines Transistors, welcher kollektorseitig an 12V (Batterie- oder Netzteilspannung) angeschlossen ist. An den Transistor ist mit dem Emitter in Reihe der Sender angeschlossen. Das Prinzip bleibt das selbe wie bei der obigen Variante, nur die Leistungsstärke hat zugenommen.
* Man versucht ein Wechselsignal zu erzeugen. Hierzu muss auf irgendeine Art und Weise das PWM-Signal des MC invertiert werden. Nun wird an den einen Pin des Senders das normale PWM-Signal gegeben, an den anderen das invertierte Signal. Man erhält so eine Wechselspannung am Sender mit einer Spitze-Spitze-Spannung von etwa 10V. Diese Variante sollte die obigen beiden leistungsmäßig übersteigen.
* Dasselbe wie im vorigen Beispiel, nur dass zusätzlich noch zwei Treibertransistoren eingefügt werden. Es ergibt sich eine Spitze-Spitze-Spannung von 24V. Ob der Sender diese Spannungen unbeschädigt übersteht gilt es auszutesten :-)
* Man verwendet einfach zwei Ausgänge des Mikrocontrollers und gibt auf einem Pin das normale Signal aus und auf dem anderen das invertierte Signal. Der Sender sieht so ein Umpolen der Spannung von +5V zu -5V usw.

Die Erzeugung des invertierten Signals kann entweder in Software oder über ein Logik-Gatter erfolgen. Geeignet wären beispielsweise NAND oder NOR. Da ich zufällig noch den Schaltkreis MOS4001 herumliegen habe, werde ich diesen verwenden. Hierbei handelt es sich um einen IC, welcher 4 NOR-Gatter mit je zwei Eingängen beinhaltet. Legt man bei einem NOR an beide Eingänge eine '1', so ergibt sich am Ausgang eine '0' und umgekehrt. Schematisch sähe der Anschluss des Senders dann so aus:

http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic_nor.GIF

=== Empfänger ===

Nun zum nicht ganz so einfachen Empfängerteil. Wird ein Signal detektiert, so erhält man an den Klemmen des Empfängers ein relativ schwaches Wechselsignal. Dieses direkt auszuwerten ist nahezu unmöglich, da der AD-Wandler nicht für Wechselwerte geeignet ist sowie das Signal reichlich schwach ist. Es muss also gleichgerichtet werden. Bevor man dies machen kann, muss es verstärkt werden, da über der Gleichrichterdiode sofort wieder etwa 0,7V Flussspannung verloren gehen. Hierfür eignet sich der Schaltkreis TL084. Dieser stellt intern 4 OPVs zur Verfügung.

Nun immer der Reihe nach:

'''1. Signalverstärkung und Herausfiltern von Störungen'''

Die Signalverstärkung wird über die beiden angeschlossenen Widerstände vorgenommen und ergibt sich zu V = R2/R1. Der Kondensator C2 über R2 bildet einen Tiefpass, der Kondensator vor R1 einen Hochpass. Somit wurde insgesamt ein Bandpass realisiert, welcher mehr oder weniger selektiv das Nutzsignal (mit 40kHz) verstärkt.

http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic_opv1.GIF

An den nicht invertierenden Eingang wird Vcc/2 gelegt, da ein Wechselsignal verstärkt werden soll und keine +/- 5V zur Verfügung stehen. Das Signal ist nun etwa um den Faktor 14 verstärkt.

'''2. Erneute Signalverstärkung und Filterung'''

Selbes Funktionsprinzip wie oben. Verstärkung des Signals um den Faktor 21.

http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic_opv2.GIF

'''3. Gleichrichtung und Glättung'''

Das nun ausreichend verstärkte Wechselsignal muss zur Auswertung noch gleichgerichtet und geglättet werden. Die Gleichrichtung wird durch eine Diode vorgenommen, die Glättung durch einen Tiefpass.

http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic_gleichrichter.GIF

'''4. Last but not least...'''

Zuletzt wird das Signal noch auf einen OPV gegeben, welcher als Spannungsfolger geschalten ist. Diese Maßnahme dient lediglich dem Abkoppeln des Signal-Out-Pins von der restlichen Schaltung. Das Signal wird um den Faktor -1 verstärkt.

http://www.mikrocontroller.net/wikifiles/1/10/Op-spannungsfolger2.png

Eine experimenteller Versuchsaufbau hat nun folgende Daten zutage gefördert. Mit ausgeschaltetem Sender liegt am Ausgang der Empfängerschaltung immer eine Spannung von 1,850V an. Diese ist als Offset zu betrachten. Bewegt man nun den Sender über dem Empfänger, so erhält man einen Minimalwert von 1,35V. Dieser ist aufgrund der Richtungswirkung des Senders (Ultraschallkeule) stark positionsabhängig. Typische Werte am Empfängerausgang sind etwa 1,5-1,7V. Alle gemessenen Werte beziehen auf den ersten Punkt zum Thema Senderaufbau, welcher oben bereits dokumentiert wurde. Eine Zuführung des invertierten Signals brachte leider keine wesentliche Verbesserung.

Nachdem der Aufbau soweit geklärt ist, kann sich jetzt an die Programmierung gemacht werden.

=== Programmierung ===

Nachdem Sender und Empfänger nebeneinander auf einer oder mehrerer Platinen angeordnet wurden, kann man sich nun an die Ultraschalldistanzmessung begeben. Zu beachten ist lediglich, dass sich die beiden Gehäuse nicht berühren. Man kann zusätzlich noch etwas Plaste, Metall, o.ä. zwischen ihnen befestigen, um ein direktes Übersprechen möglichst zu verhindern.

Wie die Erzeugung des 40kHz-Signals erfolgt wurde oben bereits angegeben. Nun muss ein kurzer Schallimpuls erzeugt werden. Dieser sollte in etwa 2-3ms lang sein und kann mittels Timer oder delay-Schleife gesteuert werden. Das Prinzip ist trivial, da man einfach den entsprechenden Pin als Ausgang deklariert, kurz wartet und ihn dann wieder als Eingang definiert.
Da alle Operationen von einem MC ausgeführt werden sollen und der Empfänger die Laufzeit des Signals soundso exakt bestimmen muss, wird ein Timerinterrupt verwendet. Es wird Timer0 verwendet.
Die Schallgeschwindigkeit beträgt bei Raumtemperatur etwa 344 m/s. Bei einer Pulslänge von 2ms hat die Spitze der Schallwelle bei Beendigung des Impulses bereits 0,68m zurück gelegt. Somit ist der Sensor nur für Distanzen größer 35-40cm geeignet. Sollen geringere Distanzen ausgewertet werden, muss der Schallimpuls entsprechend kürzer gestaltet werden. Je kürzer dieser allerdings gemacht wird, desto größer sollte die Sendeleistung sein, wenn man noch etwas zum Auswerten haben möchte.

Ich habe das ganze mal testweise implementiert und es stellte sich die gewünschte Funktionalität ein. Allerdings sind die Messwerte mit einem gewissen Rauschen unterlegt, so dass sich eine Mehrfachmessung und/oder Mittelwertbildung empfiehlt. Hier nun der [http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic_usart.c Sourcecode].

Das Programm macht im wesentlichen folgendes:

* Bei Tasterdruck wird Schallpuls ausgesendet. (mittels Timer0)
* Mit Ende des Schallimpulses wird Timer0-Interrupt deaktiviert und Timer2-Interrupt aktiviert.
* Nun wird mit einer Frequenz von 8MHz/256=31,25kHz abgetastet, also alle 32μs ein neuer AD-Wert aufgenommen.
* Alle Werte werden in ein Array geschrieben.
* Nach 400 Werten, also 12,8ms (entspricht einer Distanz von etwa 2,20m) wird Timer2-Interrupt wieder deaktiviert.
* Nun werden die Daten über den USART ausgegeben und können beispielsweise im Excel visualisiert werden.

Bei auf dem Schreibtisch liegendem Sensor ergab sich für einen Schallimpuls Richtung Decke das folgende Bild:

http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic.GIF

Nimmt man Datenpunkt 250 als Mitte des Echos an, so ergibt sich eine Signallaufzeit von 250*(1/(8MHz/256))= 8ms. Dies entspricht einer Distanz von s = 0,5*v*t = 0,5*340*0,008 = 1,36m. Addiert man nun noch die 2ms des Impulses dazu (es wird ja erst nach dessen Aussenden mit der Abtastung begonnen), so ergibt sich eine Distanz von 1,7m, welches im Prinzip der exakte Wert ist.

Für einen Impuls von 1ms Länge ergibt sich das folgende Bild:

http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic2.GIF

Man sieht, dass das Echo nun nur noch 1ms lang ist, eine Auswertung kann aber noch vorgenommen werden.

Als Mögliche Verbesserungen fallen mir diverse Punkte ein. Beispielsweise könnte man eine feinere Abtastung des empfangenen Signals vornehmen. Dann muss angefangen werden, zwischen Echos und dem real reflektierten Signal zu unterscheiden. Auch kann man sicherlich an der Schaltung (Verstärkungen) und dem allgemeinen Layout noch Optimierungen vornehmen.
Sobald ich entsprechende Fortschritte gemacht habe, werden diese natürlich hier veröffentlicht.

== Variante 2 ==

Alternativ habe ich noch eine zweite Variante zur Distanzmessung anzubieten. Diese basiert nicht auf einer dauernden AD-Wandlung des empfangenen Signals sondern ähnelt mehr einem Schwellwert-Schalter.

Das Signal wird zunächst mit Hilfe von zwei Verstärkerstufen (OPVs) verstärkt. Danach folgt ein dritter OPV, dessen Widerstand am Eingang als Poti realisiert ist(50K). Der Widerstand im Rückkopplungszweig hat einen Wert von 50k. Es lässt sich somit eine Verstärkung zwischen 1 und 50 einstellen. Der Ausgang des 3. OPV geht direkt auf die Basis eines npn-Transistors. Zusätzlich wird noch mittels eines weiteren Potentiometers eine Offsetspannung auf die Basis gegeben, um das Umschalten zu unterstützen. Kommen als zu der Offsetspannung noch die Signalspitzen, so schaltet dieser durch. Diesen Vorgang kann man mittels eines angeschlossenen Mikrocontrollers detektieren.
Wiederum ergibt sich die Distanz aus der Zeit zwischen dem Senden des Impulses und dem Schalten des Transistors.

http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic_var2.GIF

Die Senderoutine kann im Prinzip komplett von Variante 1 übernommen werden.

Mit dem Start der Senderoutine wird gleichzeitig ein Timer gestartet, in welchem eine Zählvariable inkrementiert wird. Trifft der Impuls ein (Erkennung bspw. durch externen Interrupt), so kann der Timer gestoppt werden und die Zählvariable ausgewertet werden. Ihre Größe ist ein direktes Maß für die Distanz. Überschreitet sie einen bestimmten Wert, so kann die Messung als gescheitert betrachtet werden und der Zähler muss zurück gesetzt werden.
Natürlich können mehrere Interrupts auftreten, für deren Auswertung es wieder einen geeigneten Algorithmus zu finden gilt.

Eine simple Implementierung ohne weitere Auswertealgorithmen kann man [http://www.mikrocontroller.net/mc-project/Pages/Projekte/Ultraschall/ultrasonic2.c hier] bekommen.

__NOTOC__
[[Category:Mc-project.de]][[Category:Sensorik]]

* http://www.mikrocontroller.net/articles/AVR_Softwarepool#Entfernungsmesser

Miniwebserver

2013-06-19T07:49:16Z

Stefanfrings de: /* Rechtschreibfehler korrigiert und überflüssige Details entfernt */

= Winzig kleine Webserver =
In diesem Artikel möchte ich Informationen über alle Geräte sammeln, die folgende Eigenschaften besitzen:
*Ethernetanschluss (Buchse oder Anschlusspins für eine Buchse)
*Webseiten ausliefern
*Sehr kleine Abmessungen

Keine Voraussetzung ist:
*Programme ausführen
*Weitere Anschlussmöglichkeiten
*Mailserver

== Kandidaten ==

===VIPAR (ab 12 Euro)===

Produkt noch nicht am Markt, erst angekündigt
Samples und EVAL ab August 2011

* Internet Chip based on Cortex-M3 core and Sevenstax TCP/IP technology
* Integrated Ethernet MAC/PHY
* License: Commercial (royalties included in chip cost)
* Runs custom Web Application from SPI Flash or microSD-Card
* Configuration using a single XML file
* Web Server, ZeroConf, Auto-IP, Messenger, IPv4/IPv6, …

Questions: http://www.vipar.eu

===XPort (ab 45 Euro)===

*Ethernetbuchse eingebaut
*Herstellerspezifisches SDK oder Linux
*GPIOs
*1-3 UARTS

===Picotux (ab 100 Euro)===

*Ethernetbuchse eingebaut

===Etherrape (Bausatz 59 Euro)===

* Kleinster Miniwebserver ohne SMD Teile, leider nicht ganz so winzig (100x80mm)

*[http://www.lochraster.org/etherrape Link zur Projektseite]

* Bausatz mit Platine
* Gehäuse als Zubehör erhältlich
* Atmega 644, ENC28J60, 2MByte DataFlash
* ENC28J60 als Ethernet Controller
* Weitere Anwendungen auf der Platine
** RS232
** RS485
** Dallas OneWire(TM) Bus
** Webcam Anschluss
** Senden und empfangen von IR Fenbedienungssignalen
** Integration des ELV FS20 Systems in der Firmware vorbereitet
** Alle Signale des Atmel auf Wannenstecker herausgeführt
* Firmware ist komplett OpenSource GPL Lizenz

===AVR-Board mit Ethernet (ca. 30 Euro)===

*[https://berlin.ccc.de/wiki/AVR-Board_mit_Ethernet Link zur Projektseite]

* Miniwebserver ohne SMD Teile
* ENC28J60 als Ethernet Controller
* Atmega 32, ENC28J60
* RS232
* Alle freien Ports sind nach außen gelegt
* Firmware ist komplett OpenSource GPL Lizenz

===FOX Board (139 Euro)===

*[http://elmicro.com/de/foxboard.html Elektronikladen.de]
*[http://www.acmesystems.it Hersteller]

*Ethernetbuchse eingebaut
*Axis ETRAX LX100 Multi Chip Module
*32 Bit RISC CPU, 100MHz Takt, MMU, 8KB Cache
*4 MB Flash, 16 MB SDRAM
*10/100 Mbps Ethernet Port (RJ45-Buchse)
*2x USB-Port (Full-Speed Host)
*RS232-Port (TTL-Pegel) und I2C
*IDE, SCSI oder Wide-SCSI
*zwei Stiftleisten mit je 2x20 Pins
*3,3V-IOs, 5V-tolerant
*Versorgung: 5V=, ca. 280mA
*Abmessungen: 66mm x 72mm
*Ready-to-run Embedded Linux System (Kernel 2.6)
*Standardanwendungen: HTTP (Web-Server), FTP, Telnet, DHCP, SSH, PPP...
*Firmwareupdates jederzeit einfach via LAN-SDK, FTP-Client oder Web-Browser!

=== ADDS-BF533-STAMP Blackfin Eval-Board (136.50 Euro excl. z.b bei Farnell) ===

*ADSP-BF533 500 MHz Blackfin®-Prozessor
*128 MB SDRAM (64M x 16)
*4 MB FLASH-Speicher
*Ethernet-Controller SMSC 91C111
*serielle RS232-Schnittstelle
*E/A-Erweiterungsanschlüsse für Blackfin-Peripherie
**PPI
**SPORT0 & SPORT1
**SPI
**Timer
**IrDA
**2-Leiter-Schnittstelle
*JTAG-Schnittstelle für Fehlersuche und FLASH-Programmierung
*LEDs (3) und Taster (3)
*Netzteil
*fertiger ucLinux-Port :)

=== ezTCP-Module (ab ca. 40 Euro)===

*[http://www.eztcp.com/en/index_en.html Hersteller-Seite]
*[http://elmicro.com/de/eztcp.html Elektronikladen.de]

*kleine Platine
*AVR ATmega* ist drauf
*RTL Netzwerkchip is drauf
*verschiedene Ausführungen: ezl-50 ist die kleinste / billigste

=== AVR Net-IO Bausatz von Pollin (19,95 Euro) ===

* [[AVR Net-IO Bausatz von Pollin]]
* Mitgelieferte Software muss durch eine andere Software ersetzt werden (diverse freie Software funktioniert)

[http://www.pollin.de/shop/dt/MTQ5OTgxOTk-/Bausaetze_Module/Bausaetze/Bausatz_AVR_NET_IO.html Shop bei pollin.de]

=== myAVR / myEthernet Embedded Webserver (ca. 60 Euro) ===

*[http://shop.myavr.de/index.php?sp=article.sp.php&artID=100065 Shop des Herstellers]

*sehr kleine Platine
*ATmega644P fest auf der Platine
*MicroSD-Slot gleich auf der Platine

=== CrumbX1-NET (ca 45 Euro) ===

* [http://go.chip45.com/crumbx1-net-1.2 Shop des Herstellers]

* Xmega 128 (8bit, 128kB Programmspeicher, 8kB Ram)
* CP2201 Ethernetcontroller mit MAC und Phy
* Ethernetübertrager onboard
* RJ45 Buchse
* Mini USB
* Micro SD/MMC Slot
* kann optional mit Bootloader bestellt werden
* Nur minimal größer als eine Streichholz-Schachtel
* kostenlose Software mit TCPIP Stack, Webserver, DHCP, Emailversand, etc.
* Steckplatz für optionales Power-Over-Ethernet (PoE) Addon Board

=== [http://www.raspberrypi.org/ Raspberry PI] (ca. 30 EUR) ===
* Broadcom SoC, 700 MHz
* Modell A: 256, B: 512 MB RAM on Chip
* 1 x Fast Ethernet
* 2 x USB
* 1 x HDMI-Ausgang
* 1 x S-Video-Ausgang
* 1 x 3,5 mm Audio-Ausgang
* SD-Kartenslot für Betriebssystem
* 26 Pins (2 x 13 @ 2,54 mm):
** 2 x 5 V
** 2 x 3,3 V
** 5 x GND
** 17 GPIO-Pins mit Alternativfunktionen:
*** UART
*** I2C
*** SPI
*** 1 x PWM
* etwa Kreditkartengröße
* Versorgung über Micro-USB mit 1000 mA
* div. Gehäuse erhältlich

=== Weitere Webserver ===

* [[Avr Webserver mit Wiznet WIZ810MJ]]
* [[Einfacher und billiger Webserver mit AtMega32]]
* Arduino Uno (ca. 24 EUR) mit Ethernet Shield (ca. 35 EUR) oder Arduino Ethernet (ca. 48 EUR)

== private Projekte ==
===avrETH1===
*winzige Maße: 32mm x 47.8mm x ~20mm (BxLxH)
*Microchip ENC28J60 Ethernetcontroller
*Atmel Atmega32 uC
*4MBit Atmel SPI Flash
*Webcam Support
*Temperaturlogger mit Ausgabe als Graph
*Stromversorgung über die freien Leitungen im Ethernet Kabel oder extern

http://avr.auctionant.de/avrETH1/

===ENC28J60 IO-Webserver===
*Platine: 74.9mm x 74.9mm
*Microchip [[ENC28J60]] Ethernetcontroller
*Atmel Atmega32 oder Atmega644 uC
*Software kompatibel zum AVR Net-IO von Pollin
*Div. Erweiterungsboards

http://mikrocontroller.heldt.eu/index.php?page=enc28j60-io-webserver

===mega-eth===
*Platine 100mm x 80mm
*Microchip ENC28J60
*SD/MMC-Slot
*FTDI USB/RS232-Wandler
*ATmega128 mit 64kBytes SRAM
*Pfostenstecker für eigene Erweiterungen
*eigener TCP/IP und TCP/UDP Stack
*eigener HTTP-Server
*eigener DHCP-Client
*Uhr-Synchronisation mit Zeit-Server

http://www.mikrocontroller.net/topic/100177

===MicroWebServer===
Kleinst-Webserver mit ENC28J60, Mega168 und Pfostenleiste für GPIOs auf 38x31mm².

http://de.klinkerstein.m-faq.de/index.php/MicroWebServer

===I/O===
http://www.mikrocontroller.net/forum/read-1-402627.html

===OpenMCP===

*Platine 100mm x 80mm
*Microchip ENC28j60
*ATmega2561 mit 128 kB Flash und 8 kB SRAM
*Pfostenstecker für eigene Erweiterungen
*Eigener TCP/IP-Stack mit TCP,UDP,ARP,ICMP. Socketbasiert, mehrere Verbindungen gleichzeitig möglich
*HTTP-Server mit CGI-Support
*SNTP, DHCP, DNS, Telnet, Twitter, DynDNS
*MP3-Streamingclient (VS10xx) (nur auf dem OpenMCP-Board)
*Einfache Programmierung, halbwegs gute Dokumentation, komplett GPL, Weiterentwicklung des [https://berlin.ccc.de/wiki/AVR-Board_mit_Ethernet CCCB-Boards]
*Läuft auch auf dem AVR-NETIO, myEthernet, ATXM2 und dem Xplain mit Erweiterung

http://wiki.neo-guerillaz.de

===Ethersex===

*reines Firmware-Projekt
*läuft auf vielen verschiedenen AVR-Boards (u.a. Etherrape, AVR Net-IO,...)
*über Konfigurationsdateien leicht an eigene AVR-Boards anzupassen
*Anbindung über Ethernet (ENC28j60), Funk (RFM12), USB (Soft-Stack), USART
*TCP/IP, IPv4, IPv6, ZBUS (TCP/IP über RS232 oder RS485)
*IP-Routing zwischen den verschiedenen Schnittstellen
*OpenVPN
*Steuerung & Skripting über Ethersex Command (ECMD)
*Fertige Ansteuerung vieler gängiger Hardware (I2C, Onewire, LCDs, ADC, FS20,MMC/SD-Karten,...)
*ICMP,BOOTP,SMTP,NTP,DNS,IRC,Jabber/XMPP,HTTP,...
*GPLv3, Aktive Entwicklergemeinde

http://ethersex.de/

=== I/O Module mit Embedded AVR Webserver ===

*Zum Fernsteuern und Abfragen von Sensoren
*Reines Firmware Projekt
*Läuft auf ATmega und Xmega ab 64kB + CP2201 Ethernet Controller
*Basiert auf uIP von Adam Dunkels
*TCP/IP v4, UDP, ARP, ICMP, DHCP Client, HTTP Server, SMTP Client, IP-Socket (Telnet)
*Webserver mit dynamischen und statischen Seiten im Flash
*Mehrere Verbindungen gleichzeitig (konfigurierbar, je nach RAM Größe)
*Optionale Komponenten:
**Alarmierung per Email
**Steuerung seriell (RS232, USB, Bluetooth)
**Massenspeicher SD/SDHC/MMC Karten
**I/O Erweiterung durch Schieberegister und serielle A/D Wandler

Projekt-Homepage: http://stefanfrings.de/avr_io<br>
Fertigmodul erhältlich bei bei: http://chip45.com

----
[[Kategorie:Ethernet]]

Miniwebserver

2013-05-16T07:00:52Z

Stefanfrings de: Link zur Alarmanlage entfernt (ist schon in der Projekt-Homepage drin)

= Winzig kleine Webserver =
In diesem Artikel möchte ich Informationen über alle Geräte sammeln, die folgende Eigenschaften besitzen:
*Ethernetanschluss (Buchse oder Anschlusspins für eine Buchse)
*Webseiten ausliefern
*Sehr kleine Abmessungen

Keine Voraussetzung ist:
*Programme ausführen
*Weitere Anschlussmöglichkeiten
*Mailserver

== Kandidaten ==

===VIPAR (ab 12 Euro)===

Produkt noch nicht am Markt, erst angekündigt
Samples und EVAL ab August 2011

* Internet Chip based on Cortex-M3 core and Sevenstax TCP/IP technology
* Integrated Ethernet MAC/PHY
* License: Commercial (royalties included in chip cost)
* Runs custom Web Application from SPI Flash or microSD-Card
* Configuration using a single XML file
* Web Server, ZeroConf, Auto-IP, Messenger, IPv4/IPv6, …

Questions: http://www.vipar.eu

===XPort (ab 45 Euro)===

*Ethernetbuchse eingebaut
*Herstellerspezifisches SDK oder Linux
*GPIOs
*1-3 UARTS

===Picotux (ab 100 Euro)===

*Ethernetbuchse eingebaut

===Etherrape (Bausatz 59 Euro)===

* Kleinster Miniwebserver ohne SMD Teile, leider nicht ganz so winzig (100x80mm)

*[http://www.lochraster.org/etherrape Link zur Projektseite]

* Bausatz mit Platine
* Gehäuse als Zubehör erhältlich
* Atmega 644, ENC28J60, 2MByte DataFlash
* ENC28J60 als Ethernet Controller
* Weitere Anwendungen auf der Platine
** RS232
** RS485
** Dallas OneWire(TM) Bus
** Webcam Anschluss
** Senden und empfangen von IR Fenbedienungssignalen
** Integration des ELV FS20 Systems in der Firmware vorbereitet
** Alle Signale des Atmel auf Wannenstecker herausgeführt
* Firmware ist komplett OpenSource GPL Lizenz

===AVR-Board mit Ethernet (ca. 30 Euro)===

*[https://berlin.ccc.de/wiki/AVR-Board_mit_Ethernet Link zur Projektseite]

* Miniwebserver ohne SMD Teile
* ENC28J60 als Ethernet Controller
* Atmega 32, ENC28J60
* RS232
* Alle freien Ports sind nach außen gelegt
* Firmware ist komplett OpenSource GPL Lizenz

===FOX Board (139 Euro)===

*[http://elmicro.com/de/foxboard.html Elektronikladen.de]
*[http://www.acmesystems.it Hersteller]

*Ethernetbuchse eingebaut
*Axis ETRAX LX100 Multi Chip Module
*32 Bit RISC CPU, 100MHz Takt, MMU, 8KB Cache
*4 MB Flash, 16 MB SDRAM
*10/100 Mbps Ethernet Port (RJ45-Buchse)
*2x USB-Port (Full-Speed Host)
*RS232-Port (TTL-Pegel) und I2C
*IDE, SCSI oder Wide-SCSI
*zwei Stiftleisten mit je 2x20 Pins
*3,3V-IOs, 5V-tolerant
*Versorgung: 5V=, ca. 280mA
*Abmessungen: 66mm x 72mm
*Ready-to-run Embedded Linux System (Kernel 2.6)
*Standardanwendungen: HTTP (Web-Server), FTP, Telnet, DHCP, SSH, PPP...
*Firmwareupdates jederzeit einfach via LAN-SDK, FTP-Client oder Web-Browser!

=== ADDS-BF533-STAMP Blackfin Eval-Board (136.50 Euro excl. z.b bei Farnell) ===

*ADSP-BF533 500 MHz Blackfin®-Prozessor
*128 MB SDRAM (64M x 16)
*4 MB FLASH-Speicher
*Ethernet-Controller SMSC 91C111
*serielle RS232-Schnittstelle
*E/A-Erweiterungsanschlüsse für Blackfin-Peripherie
**PPI
**SPORT0 & SPORT1
**SPI
**Timer
**IrDA
**2-Leiter-Schnittstelle
*JTAG-Schnittstelle für Fehlersuche und FLASH-Programmierung
*LEDs (3) und Taster (3)
*Netzteil
*fertiger ucLinux-Port :)

=== ezTCP-Module (ab ca. 40 Euro)===

*[http://www.eztcp.com/en/index_en.html Hersteller-Seite]
*[http://elmicro.com/de/eztcp.html Elektronikladen.de]

*kleine Platine
*AVR ATmega* ist drauf
*RTL Netzwerkchip is drauf
*verschiedene Ausführungen: ezl-50 ist die kleinste / billigste

=== AVR Net-IO Bausatz von Pollin (19,95 Euro) ===

* [[AVR Net-IO Bausatz von Pollin]]
* Mitgelieferte Software muss durch eine andere Software ersetzt werden (diverse freie Software funktioniert)

[http://www.pollin.de/shop/dt/MTQ5OTgxOTk-/Bausaetze_Module/Bausaetze/Bausatz_AVR_NET_IO.html Shop bei pollin.de]

=== myAVR / myEthernet Embedded Webserver (ca. 60 Euro) ===

*[http://shop.myavr.de/index.php?sp=article.sp.php&artID=100065 Shop des Herstellers]

*sehr kleine Platine
*ATmega644P fest auf der Platine
*MicroSD-Slot gleich auf der Platine

=== CrumbX1-NET (ca 45 Euro) ===

* [http://go.chip45.com/crumbx1-net-1.2 Shop des Herstellers]

* Xmega 128 (8bit, 128kB Programmspeicher, 8kB Ram)
* CP2201 Ethernetcontroller mit MAC und Phy
* Ethernetübertrager onboard
* RJ45 Buchse
* Mini USB
* Micro SD/MMC Slot
* kann optional mit Bootloader bestellt werden
* Nur minimal größer als eine Streichholz-Schachtel
* kostenlose Software mit TCPIP Stack, Webserver, DHCP, Emailversand, etc.
* Steckplatz für optionales Power-Over-Ethernet (PoE) Addon Board

=== [http://www.raspberrypi.org/ Raspberry PI] (ca. 30 EUR) ===
* Broadcom SoC, 700 MHz
* Modell A: 256, B: 512 MB RAM on Chip
* 1 x Fast Ethernet
* 2 x USB
* 1 x HDMI-Ausgang
* 1 x S-Video-Ausgang
* 1 x 3,5 mm Audio-Ausgang
* SD-Kartenslot für Betriebssystem
* 26 Pins (2 x 13 @ 2,54 mm):
** 2 x 5 V
** 2 x 3,3 V
** 5 x GND
** 17 GPIO-Pins mit Alternativfunktionen:
*** UART
*** I2C
*** SPI
*** 1 x PWM
* etwa Kreditkartengröße
* Versorgung über Micro-USB mit 1000 mA
* div. Gehäuse erhältlich

=== Weitere Webserver ===

* [[Avr Webserver mit Wiznet WIZ810MJ]]
* [[Einfacher und billiger Webserver mit AtMega32]]
* Arduino Uno (ca. 24 EUR) mit Ethernet Shield (ca. 35 EUR) oder Arduino Ethernet (ca. 48 EUR)

== private Projekte ==
===avrETH1===
*winzige Maße: 32mm x 47.8mm x ~20mm (BxLxH)
*Microchip ENC28J60 Ethernetcontroller
*Atmel Atmega32 uC
*4MBit Atmel SPI Flash
*Webcam Support
*Temperaturlogger mit Ausgabe als Graph
*Stromversorgung über die freien Leitungen im Ethernet Kabel oder extern

http://avr.auctionant.de/avrETH1/

===ENC28J60 IO-Webserver===
*Platine: 74.9mm x 74.9mm
*Microchip [[ENC28J60]] Ethernetcontroller
*Atmel Atmega32 oder Atmega644 uC
*Software kompatibel zum AVR Net-IO von Pollin
*Div. Erweiterungsboards

http://mikrocontroller.heldt.eu/index.php?page=enc28j60-io-webserver

===mega-eth===
*Platine 100mm x 80mm
*Microchip ENC28J60
*SD/MMC-Slot
*FTDI USB/RS232-Wandler
*ATmega128 mit 64kBytes SRAM
*Pfostenstecker für eigene Erweiterungen
*eigener TCP/IP und TCP/UDP Stack
*eigener HTTP-Server
*eigener DHCP-Client
*Uhr-Synchronisation mit Zeit-Server

http://www.mikrocontroller.net/topic/100177

===MicroWebServer===
Kleinst-Webserver mit ENC28J60, Mega168 und Pfostenleiste für GPIOs auf 38x31mm².

http://de.klinkerstein.m-faq.de/index.php/MicroWebServer

===I/O===
http://www.mikrocontroller.net/forum/read-1-402627.html

===OpenMCP===

*Platine 100mm x 80mm
*Microchip ENC28j60
*ATmega2561 mit 128 kB Flash und 8 kB SRAM
*Pfostenstecker für eigene Erweiterungen
*Eigener TCP/IP-Stack mit TCP,UDP,ARP,ICMP. Socketbasiert, mehrere Verbindungen gleichzeitig möglich
*HTTP-Server mit CGI-Support
*SNTP, DHCP, DNS, Telnet, Twitter, DynDNS
*MP3-Streamingclient (VS10xx) (nur auf dem OpenMCP-Board)
*Einfache Programmierung, halbwegs gute Dokumentation, komplett GPL, Weiterentwicklung des [https://berlin.ccc.de/wiki/AVR-Board_mit_Ethernet CCCB-Boards]
*Läuft auch auf dem AVR-NETIO, myEthernet, ATXM2 und dem Xplain mit Erweiterung

http://wiki.neo-guerillaz.de

===Ethersex===

*reines Firmware-Projekt
*läuft auf vielen verschiedenen AVR-Boards (u.a. Etherrape, AVR Net-IO,...)
*über Konfigurationsdateien leicht an eigene AVR-Boards anzupassen
*Anbindung über Ethernet (ENC28j60), Funk (RFM12), USB (Soft-Stack), USART
*TCP/IP, IPv4, IPv6, ZBUS (TCP/IP über RS232 oder RS485)
*IP-Routing zwischen den verschiedenen Schnittstellen
*OpenVPN
*Steuerung & Skripting über Ethersex Command (ECMD)
*Fertige Ansteuerung vieler gängiger Hardware (I2C, Onewire, LCDs, ADC, FS20,MMC/SD-Karten,...)
*ICMP,BOOTP,SMTP,NTP,DNS,IRC,Jabber/XMPP,HTTP,...
*GPLv3, Aktive Entwicklergemeinde

http://ethersex.de/

=== I/O Module mit Embedded AVR Webserver ===

*Zum Fernsteuern und Abfragen von Sensoren
*Reines Firmware Projekt
*Läuft auf ATmega und Xmega ab 64kB + CP2201 Ethernet Controller
*Basiert auf uIP von Adam Dunkels
*TCP/IP v4, UDP, ARP, ICMP, DHCP CLient, HTTP Server, SMTP client, Socket Server (Telnet)
*Webserver mit dynamischen und statischen Seiten im Flash
*Mehrere Verbindungen gleichzeitig (konfigurierbar, je nach RAM Größe)
*Optionale Komponenten:
**Alarmierung von 8 Leitungen per Email
**Steuerung per RS232, USB oder Bluetooth (als Alternative zu HTTP und IP Socket)
**Massenspeicher SD/SDHC/MMC Karten mit FAT Filesystem
**I/O Erweiterung durch Schieberegister und serielle A/D Wandler

Projekt-Homepage: http://stefanfrings.de/avr_io<br>
Fertigmodul erhältlich bei bei: http://chip45.com

----
[[Kategorie:Ethernet]]

Miniwebserver

2013-05-16T07:00:08Z

Stefanfrings de: Titel korrigiert und Beschreibung verbessert

= Winzig kleine Webserver =
In diesem Artikel möchte ich Informationen über alle Geräte sammeln, die folgende Eigenschaften besitzen:
*Ethernetanschluss (Buchse oder Anschlusspins für eine Buchse)
*Webseiten ausliefern
*Sehr kleine Abmessungen

Keine Voraussetzung ist:
*Programme ausführen
*Weitere Anschlussmöglichkeiten
*Mailserver

== Kandidaten ==

===VIPAR (ab 12 Euro)===

Produkt noch nicht am Markt, erst angekündigt
Samples und EVAL ab August 2011

* Internet Chip based on Cortex-M3 core and Sevenstax TCP/IP technology
* Integrated Ethernet MAC/PHY
* License: Commercial (royalties included in chip cost)
* Runs custom Web Application from SPI Flash or microSD-Card
* Configuration using a single XML file
* Web Server, ZeroConf, Auto-IP, Messenger, IPv4/IPv6, …

Questions: http://www.vipar.eu

===XPort (ab 45 Euro)===

*Ethernetbuchse eingebaut
*Herstellerspezifisches SDK oder Linux
*GPIOs
*1-3 UARTS

===Picotux (ab 100 Euro)===

*Ethernetbuchse eingebaut

===Etherrape (Bausatz 59 Euro)===

* Kleinster Miniwebserver ohne SMD Teile, leider nicht ganz so winzig (100x80mm)

*[http://www.lochraster.org/etherrape Link zur Projektseite]

* Bausatz mit Platine
* Gehäuse als Zubehör erhältlich
* Atmega 644, ENC28J60, 2MByte DataFlash
* ENC28J60 als Ethernet Controller
* Weitere Anwendungen auf der Platine
** RS232
** RS485
** Dallas OneWire(TM) Bus
** Webcam Anschluss
** Senden und empfangen von IR Fenbedienungssignalen
** Integration des ELV FS20 Systems in der Firmware vorbereitet
** Alle Signale des Atmel auf Wannenstecker herausgeführt
* Firmware ist komplett OpenSource GPL Lizenz

===AVR-Board mit Ethernet (ca. 30 Euro)===

*[https://berlin.ccc.de/wiki/AVR-Board_mit_Ethernet Link zur Projektseite]

* Miniwebserver ohne SMD Teile
* ENC28J60 als Ethernet Controller
* Atmega 32, ENC28J60
* RS232
* Alle freien Ports sind nach außen gelegt
* Firmware ist komplett OpenSource GPL Lizenz

===FOX Board (139 Euro)===

*[http://elmicro.com/de/foxboard.html Elektronikladen.de]
*[http://www.acmesystems.it Hersteller]

*Ethernetbuchse eingebaut
*Axis ETRAX LX100 Multi Chip Module
*32 Bit RISC CPU, 100MHz Takt, MMU, 8KB Cache
*4 MB Flash, 16 MB SDRAM
*10/100 Mbps Ethernet Port (RJ45-Buchse)
*2x USB-Port (Full-Speed Host)
*RS232-Port (TTL-Pegel) und I2C
*IDE, SCSI oder Wide-SCSI
*zwei Stiftleisten mit je 2x20 Pins
*3,3V-IOs, 5V-tolerant
*Versorgung: 5V=, ca. 280mA
*Abmessungen: 66mm x 72mm
*Ready-to-run Embedded Linux System (Kernel 2.6)
*Standardanwendungen: HTTP (Web-Server), FTP, Telnet, DHCP, SSH, PPP...
*Firmwareupdates jederzeit einfach via LAN-SDK, FTP-Client oder Web-Browser!

=== ADDS-BF533-STAMP Blackfin Eval-Board (136.50 Euro excl. z.b bei Farnell) ===

*ADSP-BF533 500 MHz Blackfin®-Prozessor
*128 MB SDRAM (64M x 16)
*4 MB FLASH-Speicher
*Ethernet-Controller SMSC 91C111
*serielle RS232-Schnittstelle
*E/A-Erweiterungsanschlüsse für Blackfin-Peripherie
**PPI
**SPORT0 & SPORT1
**SPI
**Timer
**IrDA
**2-Leiter-Schnittstelle
*JTAG-Schnittstelle für Fehlersuche und FLASH-Programmierung
*LEDs (3) und Taster (3)
*Netzteil
*fertiger ucLinux-Port :)

=== ezTCP-Module (ab ca. 40 Euro)===

*[http://www.eztcp.com/en/index_en.html Hersteller-Seite]
*[http://elmicro.com/de/eztcp.html Elektronikladen.de]

*kleine Platine
*AVR ATmega* ist drauf
*RTL Netzwerkchip is drauf
*verschiedene Ausführungen: ezl-50 ist die kleinste / billigste

=== AVR Net-IO Bausatz von Pollin (19,95 Euro) ===

* [[AVR Net-IO Bausatz von Pollin]]
* Mitgelieferte Software muss durch eine andere Software ersetzt werden (diverse freie Software funktioniert)

[http://www.pollin.de/shop/dt/MTQ5OTgxOTk-/Bausaetze_Module/Bausaetze/Bausatz_AVR_NET_IO.html Shop bei pollin.de]

=== myAVR / myEthernet Embedded Webserver (ca. 60 Euro) ===

*[http://shop.myavr.de/index.php?sp=article.sp.php&artID=100065 Shop des Herstellers]

*sehr kleine Platine
*ATmega644P fest auf der Platine
*MicroSD-Slot gleich auf der Platine

=== CrumbX1-NET (ca 45 Euro) ===

* [http://go.chip45.com/crumbx1-net-1.2 Shop des Herstellers]

* Xmega 128 (8bit, 128kB Programmspeicher, 8kB Ram)
* CP2201 Ethernetcontroller mit MAC und Phy
* Ethernetübertrager onboard
* RJ45 Buchse
* Mini USB
* Micro SD/MMC Slot
* kann optional mit Bootloader bestellt werden
* Nur minimal größer als eine Streichholz-Schachtel
* kostenlose Software mit TCPIP Stack, Webserver, DHCP, Emailversand, etc.
* Steckplatz für optionales Power-Over-Ethernet (PoE) Addon Board

=== [http://www.raspberrypi.org/ Raspberry PI] (ca. 30 EUR) ===
* Broadcom SoC, 700 MHz
* Modell A: 256, B: 512 MB RAM on Chip
* 1 x Fast Ethernet
* 2 x USB
* 1 x HDMI-Ausgang
* 1 x S-Video-Ausgang
* 1 x 3,5 mm Audio-Ausgang
* SD-Kartenslot für Betriebssystem
* 26 Pins (2 x 13 @ 2,54 mm):
** 2 x 5 V
** 2 x 3,3 V
** 5 x GND
** 17 GPIO-Pins mit Alternativfunktionen:
*** UART
*** I2C
*** SPI
*** 1 x PWM
* etwa Kreditkartengröße
* Versorgung über Micro-USB mit 1000 mA
* div. Gehäuse erhältlich

=== Weitere Webserver ===

* [[Avr Webserver mit Wiznet WIZ810MJ]]
* [[Einfacher und billiger Webserver mit AtMega32]]
* Arduino Uno (ca. 24 EUR) mit Ethernet Shield (ca. 35 EUR) oder Arduino Ethernet (ca. 48 EUR)

== private Projekte ==
===avrETH1===
*winzige Maße: 32mm x 47.8mm x ~20mm (BxLxH)
*Microchip ENC28J60 Ethernetcontroller
*Atmel Atmega32 uC
*4MBit Atmel SPI Flash
*Webcam Support
*Temperaturlogger mit Ausgabe als Graph
*Stromversorgung über die freien Leitungen im Ethernet Kabel oder extern

http://avr.auctionant.de/avrETH1/

===ENC28J60 IO-Webserver===
*Platine: 74.9mm x 74.9mm
*Microchip [[ENC28J60]] Ethernetcontroller
*Atmel Atmega32 oder Atmega644 uC
*Software kompatibel zum AVR Net-IO von Pollin
*Div. Erweiterungsboards

http://mikrocontroller.heldt.eu/index.php?page=enc28j60-io-webserver

===mega-eth===
*Platine 100mm x 80mm
*Microchip ENC28J60
*SD/MMC-Slot
*FTDI USB/RS232-Wandler
*ATmega128 mit 64kBytes SRAM
*Pfostenstecker für eigene Erweiterungen
*eigener TCP/IP und TCP/UDP Stack
*eigener HTTP-Server
*eigener DHCP-Client
*Uhr-Synchronisation mit Zeit-Server

http://www.mikrocontroller.net/topic/100177

===MicroWebServer===
Kleinst-Webserver mit ENC28J60, Mega168 und Pfostenleiste für GPIOs auf 38x31mm².

http://de.klinkerstein.m-faq.de/index.php/MicroWebServer

===I/O===
http://www.mikrocontroller.net/forum/read-1-402627.html

===OpenMCP===

*Platine 100mm x 80mm
*Microchip ENC28j60
*ATmega2561 mit 128 kB Flash und 8 kB SRAM
*Pfostenstecker für eigene Erweiterungen
*Eigener TCP/IP-Stack mit TCP,UDP,ARP,ICMP. Socketbasiert, mehrere Verbindungen gleichzeitig möglich
*HTTP-Server mit CGI-Support
*SNTP, DHCP, DNS, Telnet, Twitter, DynDNS
*MP3-Streamingclient (VS10xx) (nur auf dem OpenMCP-Board)
*Einfache Programmierung, halbwegs gute Dokumentation, komplett GPL, Weiterentwicklung des [https://berlin.ccc.de/wiki/AVR-Board_mit_Ethernet CCCB-Boards]
*Läuft auch auf dem AVR-NETIO, myEthernet, ATXM2 und dem Xplain mit Erweiterung

http://wiki.neo-guerillaz.de

===Ethersex===

*reines Firmware-Projekt
*läuft auf vielen verschiedenen AVR-Boards (u.a. Etherrape, AVR Net-IO,...)
*über Konfigurationsdateien leicht an eigene AVR-Boards anzupassen
*Anbindung über Ethernet (ENC28j60), Funk (RFM12), USB (Soft-Stack), USART
*TCP/IP, IPv4, IPv6, ZBUS (TCP/IP über RS232 oder RS485)
*IP-Routing zwischen den verschiedenen Schnittstellen
*OpenVPN
*Steuerung & Skripting über Ethersex Command (ECMD)
*Fertige Ansteuerung vieler gängiger Hardware (I2C, Onewire, LCDs, ADC, FS20,MMC/SD-Karten,...)
*ICMP,BOOTP,SMTP,NTP,DNS,IRC,Jabber/XMPP,HTTP,...
*GPLv3, Aktive Entwicklergemeinde

http://ethersex.de/

=== I/O Module mit Embedded AVR Webserver ===

*Zum Fernsteuern und Abfragen von Sensoren
*Reines Firmware Projekt
*Läuft auf ATmega und Xmega ab 64kB + CP2201 Ethernet Controller
*Basiert auf uIP von Adam Dunkels
*TCP/IP v4, UDP, ARP, ICMP, DHCP CLient, HTTP Server, SMTP client, Socket Server (Telnet)
*Webserver mit dynamischen und statischen Seiten im Flash
*Mehrere Verbindungen gleichzeitig (konfigurierbar, je nach RAM Größe)
*Optionale Komponenten:
**Alarmierung von 8 Leitungen per Email
**Steuerung per RS232, USB oder Bluetooth (als Alternative zu HTTP und IP Socket)
**Massenspeicher SD/SDHC/MMC Karten mit FAT Filesystem
**I/O Erweiterung durch Schieberegister und serielle A/D Wandler

Projekt-Homepage: http://stefanfrings.de/avr_io<br>
Fertigmodul erhältlich bei bei: http://chip45.com<br>
Anwendungsbeispiel: http://stefanfrings.de/bfAlarm/index.html

----
[[Kategorie:Ethernet]]

Raspberry Pi Einführung

2013-05-08T07:21:42Z

Stefanfrings de: /* I/O Module mit USB */

''von Robert Knauer''

{{Wettbewerb Header}}

'''Wichtig''': ''Alle Informationen und Anleitungen in diesem Artikel beziehen sich auf das Model B mit erweitertem Arbeitsspeicher.''

[[Datei:Raspberry_Pi.jpg|thumb|Der Raspberry Pi]]
Der '''Raspberry Pi''' ist ein Einplatinen-Computer im Kreditkarten-Format mit einem SoC (System-on-a-Chip) von Broadcom. Dieser verfügt über folgende Eigenschaften:
* eine 700MHz ARMv6-CPU
* eine Broadcom VideoCore IV GPU
* 512 MB Arbeitsspeicher
Außerdem kann der Raspberry Pi über folgende Schnittstellen mit der Außenwelt kommunizieren:
* 2 USB 2.0 Host-Anschlüsse
* einen Composite Video-Ausgang
* einen HDMI-Ausgang (Video+Audio)
* einen 3,5mm Klinke-Audio-Ausgang
* einen SD-/MMC-Karten-Slot (Unterstützung für SDIO und SDHC)
* einen Ethernet-Port (10/100 MBit)
* 21 GPIO-Pins, teilweise gedacht als [[UART]], [[SPI]] und [[I2C]]
Die Energieversorgung wird über einen microUSB-Anschluss gewährleistet. Man sollte jedoch darauf achten, dass der USB-Anschluss, über den man den Raspberry Pi mit Energie versorgt mindestens 700 mA liefern kann, da in der USB 2.0 Spezifikation nur 500 mA vorgesehen sind. In diesem Artikel wird noch darauf eingegangen, wie man sich selbst ein entsprechendes Netzteil bauen kann, alternativ funktioniert auch ein entsprechend starkes USB-Ladegerät in Verbindung mit einem USB-A auf microUSB-B Kabel. (siehe [[Raspberry Pi#Stromversorgung]])

Um diese umfangreichen Möglichkeiten zu nutzen muss man mit einem anderen Computer ein Betriebssystem auf die SD-Karte laden, das dann vom Raspberry Pi gebootet wird. Am naheliegendsten ist hier natürlich Linux (Raspbian, Fedora, Debian und Arch Linux sind offiziell unterstützt), aber auch Plan 9 wurde schon auf dem kleinen Computer [http://www.heise.de/open/meldung/Plan-9-laeuft-auf-dem-Raspberry-1761392.html zum Laufen gebracht].

In diesem Artikel soll Schritt für Schritt der Weg vom Anschließen des Computers über das Einrichten von Arch Linux ARM bis zum Verwenden der verschiedenen Schnittstellen des Raspberry Pi beschrieben werden.

== Bezugsquellen & Zubehör ==
Der Raspberry Pi kann über verschiedene Quellen bezogen werden. Wichtig ist darauf zu achten, dass man das Model B mit 512 MB Arbeitsspeicher bestellt, da alle Anleitungen in diesem Artikel nur damit getestet sind und unter anderen Modellen eventuell nicht funktionieren. Ein in Deutschland ziemlich bekannter Elektronik-Versand, bei dem man den Raspberry Pi bestellen kann, ist Pollin, dort ist er zur Zeit für 39,95 € erhältlich. (Bestell-Nr.: 701 697, Stand: 31.12.2012)

Doch neben dem eigentlichen Computer braucht man natürlich noch etwas Zubehör, wenn man es nicht eh schon zu Hause rumliegen hat:
* ein Netzteil, das 5V bei mindestens 700 mA auf einem microUSB-Stecker liefert (siehe [[Raspberry Pi#Stromversorgung]])
* eine SD(HC)-Speicherkarte
* einen SD(HC)-Cardreader an einem anderen Computer
* ein RJ45-Netzwerkkabel
* ein Ethernet-Netzwerk mit Zugang zum Internet
Mit diesem Zubehör kann man nur über SSH zugreifen, wenn man direkt am Raspberry Pi arbeiten will und später evtl. auch eine grafische Oberfläche einrichten will braucht man noch folgendes:
* ein HDMI-Kabel und einen Fernseher bzw. Monitor mit HDMI-Eingang '''oder'''
* ein Composite-Kabel und einen Fernseher mit entsprechendem Video-Eingang
* eine USB-Tastatur
* eine USB-Maus (für eine grafische Oberfläche)
* evtl. einen aktiven USB-Hub, wenn die Ports des Raspberry Pi nicht genug Leistung für Maus und Tastatur liefern können

== Das Betriebssystem ==
Als Betriebssystem für die Anleitungen in diesem Artikel wird [http://archlinuxarm.org/ Arch Linux ARM] verwendet, das Meiste funktioniert jedoch auch unter anderen Linux-Distributionen und alles andere zumindest mit kleinen Anpassungen.
Es basiert auf den Prinzipien und teilweise auch der Software von [https://www.archlinux.org/ Arch Linux], hat aber vollständig unabhängige Paketquellen, in denen nur für ARM kompilierte Software verfügbar ist.

Arch Linux ist ein gutes Betriebssystem für einen Computer wie den Raspberry Pi, da es am Anfang sehr leichtgewichtig ist und vorerst keine grafische Oberfläche installiert hat (was gut ist wenn man den Raspberry Pi als Server verwenden will). Andererseits kann aber auch problemlos eine grafische Oberfläche nachinstalliert werden, wenn man den Raspberry Pi als Desktop-Computer, HTPC oder ähnliches verwenden will.

Man muss jedoch auch sagen, dass Arch Linux kein Betriebssystem für jemanden ist, der Linux noch nie verwendet hat. Man sollte schon etwas Erfahrung mit dem Arbeiten auf der Konsole haben, da grundlegende Dinge über Linux hier nicht erklärt werden.
Außerdem ist es teilweise notwendig, sich selbst weiterführende Informationen zu Arch Linux anzusehen, die in diesem Artikel verlinkt werden.

== Anschluss & Installation ==
Nun muss man zuerst alles anschließen. Die Netzwerk-Buchse wird über das Netzwerk-Kabel mit dem Ethernet-Netzwerk verbunden. Hier ist wichtig, dass in dem Netzwerk ein DHCP-Server läuft (also IP-Adressen automatisch bezogen werden können) und Zugriff zum Internet möglich ist. Wenn man sich für die Variante mit eigenem Bildschirm entschieden hat muss man außerdem die HDMI-Buchse mit dem Fernseher oder Monitor bzw. den Composite-Ausgang mit dem Fernseher verbinden und Tastatur und Maus über USB anschließen.
Dann folgt die Installation von Arch Linux ARM auf die SD-Karte.

Arch Linux ARM für Raspberry Pi kann man über folgende Links downloaden:
* [http://downloads.raspberrypi.org/images/archlinuxarm/archlinux-hf-2013-02-11/archlinux-hf-2013-02-11.zip.torrent Torrent-Download von Arch Linux ARM 2013-02-11]
* [http://downloads.raspberrypi.org/images/archlinuxarm/archlinux-hf-2013-02-11/archlinux-hf-2013-02-11.zip HTTP-Download von Arch Linux ARM 2013-02-11]
Wenn der etwa 194 MB große Download abgeschlossen ist und man über HTTP gedownloadet hat sollte man zuerst die Checksum überprüfen.
* SHA-1: 1d2508908e7d8c899f4a5284e855cb27c17645dc
Nachdem man das getan oder falls man über Torrent gedownloadet hat (dann passiert das automatisch) kann man das zip-Archiv entpacken.

Man erhält eine etwa 1,9 GB große Datei namens archlinux-hf-2013-02-11.img. Diese muss man nun auf die SD-Karte bringen. Unter Linux funktioniert das mit dem kleinen Programm dd, das in den GNU coreutils enthalten ist und damit auf fast jedem System vorinstalliert sein sollte. Dazu gibt man folgendes in die Konsole ein (als root, /dev/sdX durch den Pfad zur Gerätedatei der SD-Karte ersetzen, Pfad der img-Datei anpassen):
* dd if=/pfad/zur/archlinux-hf-2013-02-11.img bs=1M of=/dev/sdX
Unter Windows kann man dafür [https://launchpad.net/win32-image-writer Image Writer for Windows] benutzen.

Nachdem das Image auf die SD-Karte geschrieben ist muss man sich überlegen, ob man ein Display per HDMI anschließen wird oder nicht. Wenn man keines anschließen will (also nur SSH-Zugriff) oder sich noch nicht sicher ist, muss man die erste Partition der SD-Karte am Computer mounten und die Datei config.txt im Hauptverzeichnis editieren. Dort entfernt man das Raute-Zeichen vor '''hdmi_force_hotplug=1'''. Dadurch bootet der Raspberry Pi auch ohne, dass ein Display per HDMI angeschlossen ist. Danach entfernt man die Karte aus dem Cardreader des Computers und setzt sie in den Raspberry Pi ein. Dann verbindet man die Stromversorgung, indem man den microUSB-Stecker des Netzteils in die entsprechende Buchse auf der Platine steckt.

== Der erste Start ==
Wenn man ein Display angeschlossen hat, erscheint nach ein paar Sekunden ein Login-Prompt auf dem Bildschirm. Als Username gibt man ''root'' ein, wenn man dann nach dem Passwort gefragt wird gibt man wieder ''root'' ein.

Wenn man kein Display angeschlossen hat, muss man die IP-Adresse, die der Raspberry Pi sich vom DHCP-Server geholt hat, herausfinden. Wenn der DSL-Router diesen Dienst bereitstellt, kann man meistens auf der Web-Oberfläche eine Liste der verteilten IP-Adressen sehen. Alternativ kann man auch mit ''nmap'' einen Netzwerk-Scan machen, der die IP-Adressen von allen Computern im Netzwerk anzeigt. Das funktioniert unter Linux, indem man '''nmap -sn SUBNETZ''' im Terminal eingibt. Davor ersetzt man SUBNETZ durch das Subnetz, in dem auch der Raspberry Pi ist, in [https://de.wikipedia.org/wiki/Classless_Inter-Domain_Routing CIDR-Notation]. Wenn man z.B. in einem Netz ist, in dem IP-Adressen von ''192.168.1.0'' bis ''192.168.1.255'' verteilt werden, muss man
''192.168.1.0/24'' verwenden.

Nachdem man die IP-Adresse herausgefunden hat, verbindet man sich per SSH zu ihr und loggt sich als root, Passwort root ein. Unter Linux funktioniert das mit
* ssh root@IP-ADRESSE
Unter Windows verwendet man am besten [http://www.putty.org/ PuTTY].

Egal für welche Möglichkeit man sich entschieden hat, sitzt man jetzt vor einer root-Shell des Raspberry Pi, erkennbar am Shell-Prompt '''[root@alarmpi ~]#'''.

== Konfiguration ==
Nun geht es an die Konfiguration von Arch Linux ARM, diese erfolgt vollständig über das Editieren von Dateien auf der Konsole.

=== Lokalisierung ===
Man editiert die Datei /etc/locale.gen:
* nano /etc/locale.gen
und entfernt die Raute vor der Zeile mit der entsprechenden Sprache-Land-Kodierungs-Kombination, also z.B. vor '''de_DE.UTF-8 UTF-8''' für Deutschland.
Danach speichert man mit Strg+O -> Enter und Strg+X und erstellt die Lokalisierung neu:
* locale-gen
Danach editiert man die Datei /etc/locale.conf:
* nano /etc/locale.conf
Man ändert '''LANG=en_US.UTF-8''' zur entsprechenden Sprache, also z.B. '''LANG=de_DE.utf8''' und speichert mit Strg+0 -> Enter und Strg+X.

=== Tastatur-Layout ===
Um das Tastatur-Layout auf der Konsole anzupassen, muss man die Datei /etc/vconsole.conf ändern:
* nano /etc/vconsole.conf
Man ändert '''KEYMAP=us''' zu z.B. '''KEYMAP=de''' für QWERTZ und speichert wieder mit Strg+0 -> Enter und Strg+X.

=== Zeitzone ===
Um die Zeitzone zu ändern muss man einen Symlink zu /etc/localtime erstellen:
* ln -sf /usr/share/zoneinfo/ZEITZONE /etc/localtime
Also für Deutschland (Europe/Berlin):
* ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime

Um alle Änderungen zu übernehmen startet man den Raspberry Pi am besten neu:
* reboot
Wenn man per SSH verbunden war, wird die Verbindung geschlossen und man muss sich neu verbinden.

== Aktualisierung ==
Da das Image, das man auf die SD-Karte geschrieben hat, schon etwas veraltet sein kann, sollte man das System über die Paketverwaltung aktualisieren:
* pacman -Syu
Dieses Kommando downloadet die Datenbanken und alle neuen Pakete und installiert diese anschließend.

Dieses Kommando sollte man jede Woche mindestens einmal ausführen, um das System aktuell zu halten. Arch Linux ARM muss nie neu installiert werden, allein durch dieses Kommando wird es immer aktuell gehalten.

== Dateisystem vergrößern ==
Da das Image darauf ausgelegt ist, dass es auch auf nur 2GB großen SD-Karten geschrieben werden kann, ist auch das Haupt-Dateisystem etwa 2GB groß, selbst wenn man Arch Linux ARM auf eine größere SD-Karte geschrieben hat.

Doch das ist kein großes Problem. Um das Haupt-Dateisystem so zu vergrößern, dass es die gesamte SD-Karte ausfüllt, muss man den Raspberry Pi ausschalten und die SD-Karte in einen Cardreader an einem Linux-PC einsetzen.

In der folgenden Anleitung wird angenommen, dass die SD-Karte unter /dev/sdb und das Haupt-Dateisystem der SD-Karte unter /dev/sdb2 ist. Wenn das nicht zutrifft muss man die Pfade entsprechend ändern.

Zuerst muss man sicherstellen, dass keines der Dateisysteme gemountet ist:
* umount /dev/sdb1
* umount /dev/sdb2
Danach muss man einen Dateisystem-Test durchführen:
* fsck -n /dev/sdb2
... und das Journal entfernen:
* tune2fs -O "^has_journal" /dev/sdb2
Dann bearbeitet man die Partitionstabelle mit fdisk:
* fdisk /dev/sdb
Man kommt in eine Kommandozeile, in der man folgendes nacheinander eingibt:
* d
* 2
* n
* p
* 2
* <ohne Eingabe Enter>
* <ohne Eingabe Enter>
* w
Dadurch wird die zweite Partition gelöscht und neu angelegt, und zwar über den gesamten freien Bereich der SD-Karte.
Dann muss man wieder einen Dateisystem-Test durchführen:
* e2fsck -f /dev/sdb2
... und das Dateisystem vergrößern:
* resize2fs /dev/sdb2
Jetzt erfolgt erneut ein Dateisystem-Test:
* fsck -n /dev/sdb2
... und die Wiederherstellung des Journals:
* tune2fs -j /dev/sdb2
Jetzt kann man die SD-Karte aus dem Cardreader nehmen, in den Raspberry Pi einsetzen und ihn starten.

Wenn alles glatt gelaufen ist bootet der Raspberry Pi ganz normal und man hat plötzlich mehr Speicherplatz zur Verfügung. Aus
<pre># df -h /
Dateisystem Größe Benutzt Verf. Verw% Eingehängt auf
/dev/root 1,8G 805M 869M 49% /</pre>
wird bei einer 16GB SD-Karte zum Beispiel:
<pre># df -h /
Dateisystem Größe Benutzt Verf. Verw% Eingehängt auf
/dev/root 15G 905M 14G 7% /</pre>

''Dieser Abschnitt basiert auf einer [http://www.howtoforge.de/anleitung/wie-man-die-grose-von-ext3-partitionen-anpasst-ohne-daten-zu-verlieren/ Anleitung zum Verändern der Größe von ext3-Partitionen von HowtoForge].''

== Paketverwaltung ==
Arch Linux ARM setzt pacman als Paket-Manager ein. Das erste Kommando, das zur System-Aktualisierung, wurde schon in einem anderen Kapitel genannt:
* pacman -Syu
Dieses setzt sich aus zwei Teil-Kommandos zusammen:
* pacman -Sy
zum Downloaden der Paket-Datenbanken und
* pacman -Su
zum Downloaden und Installieren der neuen Pakete.

Um ein neues Paket zu installieren verwendet man folgendes Kommando:
* pacman -S PAKETNAME
oder um davor noch die Datenbanken zu aktualisieren:
* pacman -Sy PAKETNAME

Um ein Paket zu löschen verwendet man:
* pacman -R PAKETNAME
oder um alle danach nicht mehr benötigten Abhängigkeiten mit zu löschen:
* pacman -Rs PAKETNAME

Es gibt noch viele weitere Kommandos, z.B. zum Suchen von Paketen, Anzeigen von Informationen, Auflisten von Dateien. Einen Überblick findet man im [https://wiki.archlinux.de/title/Pacman Arch Linux Wiki] oder eine Auflistung aller Optionen in der Manpage:
* man pacman
Nach der Installation sind standardmäßig alle fünf Paketquellen von Arch Linux ARM aktiviert, eine Liste aller enthaltenen Pakete findet man [http://archlinuxarm.org/packages auf der Website].

== Datensicherung ==
Um neue Betriebssysteme auf dem Raspberry Pi auszuprobieren braucht man nicht zehn verschiedene SD-Karten, die man immer wechselt. Es reicht eine SD-Karte, von der man ein Backup macht, bevor man ein neues Betriebssystem aufspielt. Aber auch wenn man das nicht vorhat macht sich eine Datensicherung immer gut.

Dafür gibt es unter Linux verschiedene Möglichkeiten, einmal natürlich das Tool dd, mit dem man den gesamten Inhalt der SD-Karte Byte für Byte auf ein anderes Medium, z.B. die Festplatte, kopieren kann. Hier werden aber auch eigentlich leere Teile der SD-Karte mit gesichert, wodurch bei einer 16GB SD-Karte auch (unkomprimiert) ein 16GB-Backup entsteht, egal wie viel Daten man nun eigentlich auf der Karte gespeichert hat. Abhilfe schafft partclone, das die einzelnen Partitionen sichert, und zwar auch nur die wirklich verwendeten Teile. Die Handhabung ist etwas komplexer als bei dd, eine gute Anleitung und ein ausführlicherer Vergleich der beiden Tools ist auf [http://www.bitblokes.de/2013/03/sd-karte-des-raspberry-pi-sichern-dd-oder-partclone/ bitblokes.de] zu finden.

== SoC-Konfiguration ==
Generelle Einstellungen für den SoC, die noch vor dem Starten des Betriebssystems geladen werden, kann man in der Datei '''/boot/config.txt''' ändern.

Hier ist es z.B. möglich, Parameter für die Video-Ausgabe zu setzen, die Speicher-Aufteilung zwischen CPU und GPU zu ändern oder die CPU zu übertakten. Generell sollte man eher vorsichtig mit diesen Optionen umgehen, da sie bei falscher Verwendung auch mal dazu führen können, dass das Betriebssystem nicht mehr bootet oder das System instabil wird.

Eine genaue Auflistung der möglichen Konfigurations-Optionen findet man auf [http://elinux.org/RPiconfig eLinux.org].

== Die GPIO-Schnittstelle ==
[[Datei:Raspberry_Pi_GPIO.jpg|thumb|Die GPIO-Schnittstelle (P1-Anschluss)]]
Für Bastler besonders interessant ist die GPIO-Schnittstelle, diese kann man über verschiedene Wege ansteuern.
=== Belegung der Schnittstelle ===
'''Wichtig:''' Alle GPIO-Pins haben einen Pegel von 3,3V und sind '''nicht''' kompatibel zu 5V! Wenn man versucht, 5V anzuschließen, kann das zur Zerstörung des Raspberry Pi führen! Für Informationen zum Anschließen von 5V-Chips, siehe [[Pegelwandler]] oder [[Raspberry Pi#Erweiterungs-Boards]].
<gallery heights="300" widths="300">
Datei:Raspberry_Pi_GPIO.svg|Der P1-Anschluss
Datei:Raspberry_Pi_GPIO_P2.svg|Der P2-Anschluss (eigentlich das JTAG-Interface der GPU, aber trotzdem mit ein paar nützlichen Pins)
Datei:Raspberry_Pi_GPIO_P5.svg|Der P5-Anschluss auf der Rückseite der Platine
</gallery>

Im oberen Bild ist die Belegung der Anschlüsse zu sehen, die man als GPIO oder zur Stromversorgung nutzen kann. Die Beschriftungen sind genau so wie auf der Platine angebracht und sollen eine Orientierung ermöglichen.
Die 3,3V Anschlüsse (P1-1, P1-17, P2-1 und P5-2) dürfen maximal mit 50 mA belastet werden. Bei den 5V Anschlüssen (P1-2, P1-4 und P5-1) gibt es keine feste Grenze, hier kommt es auf den aktuellen Stromverbrauch des restlichen Boards und der Leistung des Netzteils an. Die Pins GPIO2 (P1-3) und GPIO3 (P1-5) sind jeweils mit einem 1,8 kΩ Pull-Up-Widerstand ausgestattet.

Der Anschluss P3 ist noch ein JTAG-Interface, der Anschluss P6 kann mit einem Reset-Knopf ausgestattet werden. Wenn man die beiden Pins verbindet verursacht das einen Soft Reset der CPU.

Hier eine Übersicht der Alternativ-Funktionen der Pins:
* P1-03 (GPIO2): I2C SDA (siehe [[Raspberry Pi#Der_I2C-Bus]])
* P1-05 (GPIO3): I2C SCL (siehe [[Raspberry Pi#Der_I2C-Bus]])

* P1-07 (GPIO4): GPCLK0 (General Purpose Clock)

* P1-08 (GPIO14): UART TXD (siehe [[Raspberry Pi#Der_UART]])
* P1-10 (GPIO15): UART RXD (siehe [[Raspberry Pi#Der_UART]])
* P1-11 (GPIO17): UART RTS (siehe [[Raspberry Pi#Der_UART]])

* P1-12 (GPIO18): PWM ([[Pulsweitenmodulation]])
* P1-13 (GPIO27): PCM (Puls-Code-Modulation) oder GPCLK1 (General Purpose Clock)

* P1-19 (GPIO10): SPI MOSI (siehe [[Raspberry Pi#Die_SPI-Schnittstelle]])
* P1-21 (GPIO9): SPI MISO (siehe [[Raspberry Pi#Die_SPI-Schnittstelle]])
* P1-23 (GPIO11): SPI SCLK (siehe [[Raspberry Pi#Die_SPI-Schnittstelle]])
* P1-24 (GPIO8): SPI Chip Select 0 (siehe [[Raspberry Pi#Die_SPI-Schnittstelle]])
* P1-26 (GPIO7): SPI Chip Select 1 (siehe [[Raspberry Pi#Die_SPI-Schnittstelle]])

=== Ansteuerung per sysfs ===
Ganz nach den UNIX-Prinzipien gibt es die Möglichkeit, auf die Schnittstelle über Dateien im sysfs zuzugreifen. Dafür existiert das Verzeichnis ''/sys/class/gpio/''.

Um einen GPIO-Pin zu verwenden muss man ihn zuerst aktivieren, indem man die Pin-Nummer in ''/sys/class/gpio/export'' schreibt. Wenn man über die Kommandozeile z.B. Pin 4 aktivieren will benutzt man folgendes Kommando:
* echo 4 > /sys/class/gpio/export
Dadurch wird automatisch ein Verzeichnis ''/sys/class/gpio/gpio4/'' erstellt. Nun kann man über die darin enthaltene Datei ''direction'' den Pin als Out- bzw. Input festlegen (standardmäßig sind alle Inputs):
* echo in > /sys/class/gpio/gpio4/direction
für einen Input und
* echo out > /sys/class/gpio/gpio4/direction
für einen Output. Jetzt kann man den Wert des Pins auslesen:
* cat /sys/class/gpio/gpio4/value
oder ihn setzen, wenn es ein Output-Pin ist:
* echo 1 > /sys/class/gpio/gpio4/value
* echo 0 > /sys/class/gpio/gpio4/value
Wenn man den Pin nicht mehr benutzen will sollte man ihn wieder deaktivieren:
* echo 4 > /sys/class/gpio/unexport
Dadurch verschwindet das Verzeichnis ''/sys/class/gpio/gpio4/'' wieder. All das kann man natürlich nicht nur auf der Shell verwenden, sondern auch in jeder Programmiersprache, indem man einfach in die entsprechenden Dateien schreibt bzw. aus ihnen liest.

=== Beispiel: Shell-Blinklicht ===
Dieses kleine Shellscript aktiviert den GPIO-Pin, den man als Argument übergeben hat, setzt ihn als Output und schaltet ihn alle 500ms um:
<pre>
#!/bin/bash
## Check arguments:
if [[ ! $# -eq 1 ]]; then
echo "Usage: $0 GPIO" > /dev/stderr
exit 1
fi
## Activate GPIO:
echo "Activating GPIO$1"
echo $1 > /sys/class/gpio/export || exit 1
## Create trap:
trap "echo 'Deactivating GPIO$1' && echo in > /sys/class/gpio/gpio$1/direction && echo $1 > /sys/class/gpio/unexport" EXIT
## Set as output:
echo "out" > /sys/class/gpio/gpio$1/direction || exit 1
## Reset value:
echo 0 > /sys/class/gpio/gpio$1/value || exit 1
## Blink loop:
while true; do
echo "Switching GPIO$1 on"
echo 1 > /sys/class/gpio/gpio$1/value || exit 1
sleep 0.5
echo "Switching GPIO$1 off"
echo 0 > /sys/class/gpio/gpio$1/value || exit 1
sleep 0.5
done
</pre>
Wenn man an dem entsprechenden Pin eine LED anschließt eignet sich das Script gut zum Testen der GPIO-Schnittstelle.

=== Ansteuerung per Python-Modul ===
Mit dem Modul [https://pypi.python.org/pypi/RPi.GPIO RPi.GPIO] kann man unter Python die GPIO-Pins steuern und auslesen. Auf der Projekt-Website gibt es auch ein Beispiel, mit dem man die Handhabung schnell lernt.

Jedes Python-Script, das dieses Modul nutzen will, muss als root laufen.

=== Ansteuerung mit Java ===
Das [http://pi4j.com/ Pi4J-Projekt] ermöglicht unter Java die Verwendung der GPIO-Pins, dem UART, des I2C-Bus und der SPI-Schnittstelle. Eine ausführliche Anleitung gibt es auf der Website.

Jedes Java-Programm, dass dieses Modul nutzen will, muss als root laufen.

=== Ansteuerung mit WiringPi ===
[https://projects.drogon.net/raspberry-pi/wiringpi/ WiringPi] bietet ein Kommandozeilen-Tool ('''gpio''', Details siehe '''man gpio'''), das man auch als normaler Nutzer (ohne root-Rechte) verwenden kann und eine C-Bibliothek (Header-Datei ''wiringPi.h'' und Linker-Option ''-lwiringPi''), mit der man die GPIO-Pins in C-Programmen verwenden kann.

Auf der Website gibt es Beispiele und eine Installationsanleitung. Bei Arch Linux ARM ist es auch in den Paketquellen und kann per Paketverwaltung installiert werden:
* pacman -S wiringpi

== Der I2C-Bus ==
Auch auf den I2C-Bus des Raspberry Pi kann man zugreifen. Die Pins dafür liegen an P1-03 (GPIO2, SDA) und P1-05 (GPIO3, SCL).
=== Ansteuerung per devfs ===
Den I2C-Bus kann man direkt über die Datei '''/dev/i2c-0''' erreichen.
=== Ansteuerung per i2c-tools ===
Komfortabler geht das aber über die i2c-tools. Dazu muss man erst einmal das Paket aus den Arch Linux ARM Paketquellen installieren:
* pacman -S i2c-tools
Nun muss man die nötigen Kernel-Module laden:
* modprobe i2c-bcm2708
* modprobe i2c-dev
Soll das beim Systemstart automatisch passieren, legt man eine *.conf-Datei im Verzeichnis '''/etc/modules-load.d/''' mit folgendem Inhalt an:
<pre>i2c-bcm2708
i2c-dev</pre>
Jetzt sollten folgende Kommandozeilen-Tools funktionieren:
* '''i2cdetect''' zum Auflisten der I2C-Busse und zum Anzeigen der Eigenschaften und Geräte
* '''i2cdump''' zum Herausfinden von I2C-Registern
* '''i2cget''' zum Lesen von I2C-Registern
* '''i2cset''' zum Setzen von I2C-Registern
Die Manpages und Hilfe-Meldungen der einzelnen Tools geben Auskunft über die genaue Verwendung. Wichtig ist, dass man den I2C-Bus 0, '''nicht''' den I2C-Bus 1 verwendet. Ein kleines Beispiel gibt es auch in der Ausgabe 5 des MagPi im Artikel „Temperature Sensor“. Dort wird ein Temperatursensor per I2C ausgelesen.

== Der UART ==
Die Pins für den UART liegen auch an P1. TXD an Pin 08 (GPIO14), RXD an Pin 10 (GPIO15) und RTS an Pin 11 (GPIO17).

Zugreifen kann man über das devfs, genauer gesagt über die Datei '''/dev/ttyAMA0'''. Um zu testen, ob das funktioniert, kann man minicom benutzen:
* pacman -S minicom
* minicom -b 115200 -o -D /dev/ttyAMA0

== Die SPI-Schnittstelle ==
Die Pins für die SPI-Schnittstelle liegen genau wie I2C und UART an P1. MOSI an Pin 19 (GPIO10), MISO an Pin 21 (GPIO9), SCLK an Pin 23 (GPIO11), CS0 an Pin 24 (GPIO8) und CS1 an Pin 26 (GPIO7).

Der Zugriff erfolgt über die Dateien '''/dev/spidev0.0''' (Gerät an CS0) und '''/dev/spidev0.1''' (Gerät an CS1), in die man direkt schreiben und aus denen man auch direkt lesen kann.

== Audio-Ausgabe ==
[[Datei:Raspberry_Pi_Audio.jpg|thumb|Der 3,5mm Klinke-Anschluss]]
Der Raspberry Pi verfügt über zwei Möglichkeiten der Audio-Ausgabe, einmal digital per HDMI und wenn kein Display angeschlossen ist wird automatisch auf die analoge Ausgabe per 3,5mm-Klinken-Anschluss umgeschaltet.

Nach der Installation von Arch Linux ARM funktioniert jedoch vorerst keine der beiden Möglichkeiten, da das nötige Kernel-Modul nicht automatisch geladen wird.

Manuell lässt es sich mit '''modprobe''' laden, beim nächsten Neustart ist das Problem dann jedoch wieder da:
* modprobe snd_bcm2835
Wenn man will, dass das Modul bei jedem Start automatisch geladen wird, muss man eine *.conf Datei im Verzeichnis /etc/modules-load.d/ erstellen und dort den Namen des Moduls hineinschreiben. Es bietet sich z.B. der Name sound.conf an, über die Kommandozeile ist die Datei schnell erstellt:
* echo "snd_bcm2835" > /etc/modules-load.d/sound.conf
Jetzt sollte die Audio-Ausgabe problemlos funktionieren. Testen kann man das beispielsweise per '''aplay''', das im Paket '''alsa-utils''' enthalten ist:
* pacman -S alsa-utils
* aplay name_der_datei.wav
In diesem Paket ist auch '''alsamixer''' enthalten, ein Programm mit dem man über eine ncurses-Oberfläche die Ausgabe-Lautstärke regeln kann.

Man muss beachten, dass nur '''root''' und Nutzer in der Gruppe '''audio''' auf die Soundkarte zugreifen können. Wenn man nicht als '''root''' arbeiten will sollte man seinen Benutzer der Gruppe hinzufügen:
* gpasswd -a USERNAME audio

=== Standard-Ausgabegerät ===
Normalerweise wird der Sound automatisch über HDMI ausgegeben, wenn das angeschlossene Gerät das unterstützt, andernfalls über den Klinke-Anschluss. Will man das ändern, z.B. weil man einen Monitor per HDMI angeschlossen hat, den Sound aber trotzdem über die Anlage hören will, geht das ganz schnell über die Kommandozeile:
* amixer -c 0 cset numid=3 <nummer>
Dabei muss man ''<nummer>'' durch eine 0 für automatisches Wechseln, eine 1 für den Klinke-Anschluss oder eine 2 für den HDMI-Anschluss ersetzen. Soll das bei jedem Systemstart automatisch ausgeführt werden, erstellt man bei Arch Linux eine Service-Datei für systemd, z.B. so:
<pre>
[Unit]
Description=Set Default Audio Output

[Service]
Type=oneshot
ExecStart=/usr/bin/amixer -c 0 cset numid=3 <nummer>

[Install]
WantedBy=multi-user.target
</pre>
Hier ersetzt man wieder ''<nummer>'' durch das gewünschte Ziel, speichert die Datei unter ''/etc/systemd/system/default-audio.service'' ab und aktiviert den soeben erstellten Service noch:
* systemctl enable default-audio.service
Ab dem nächsten Systemstart wird dadurch das Ausgabegerät automatisch eingestellt.

== Erweiterungs-Boards ==
Für die GPIO-Schnittstelle des Raspberry Pi gibt es verschiedene Erweiterungs-Boards, die zusätzliche Schnittstellen bereitstellen und 3,3V zu 5V Pegelwandler besitzen. Durch diese kann man den Raspberry Pi in bestehende, 5V-basierte Schaltungen und Projekte einbinden.

=== Prototyping-Board für den Raspberry Pi ===
In der Ausgabe 16 des embedded projects journal wurde auf Seite 13 ein Prototyping-Board für den Raspberry Pi vorgestellt.

Das Board besitzt eine Spannungsversorgung, an die man 7 bis 15V anschließen kann und die auch den Raspberry Pi mitversorgt. Dadurch wird ein per microUSB angeschlossenes Netzteil überflüssig. Außerdem gibt es einen Pegelwandler, der acht GPIO-Pins des Raspberry Pi als 5V-GPIO-Pins zur Verfügung stellt und einen I2C-Pegelwandler, durch den auch hier der Anschluss von 5V-Chips möglich wird.

Weitere Informationen gibt es im embedded projects journal und auf der [http://bastelstube.rocci.net/projects/MBS19_RasPi-GPIO/RasPi-GPIO.html Website des Projekts].

=== Berrybush Pi ===
Ebenfalls in der Ausgabe 16 des embedded projects journal wurde auf Seite 28 der „Berrybush Pi“ vorgestellt, der ein paar mehr Schnittstellen als das Prototyping-Board bietet.

Auch dieses Board bietet eine Spannungsversorgung für den Raspberry Pi und acht 5V-GPIO-Pins, diese sind jedoch mit Darlington-Transistoren und LEDs zur Status-Anzeige ausgestattet. Außerdem gibt es eine 3,3V (sic) SPI-Schnittstelle, die einfach zum Raspberry Pi durchgeschleift wird, einen 5V-I2C-Bus (mit Pegelwandler zum Raspberry Pi), einen RS485-Bus und eine RS232-Schnittstelle, die jedoch in den RS485-Bus gespeist wird.

Als kleines Highlight gibt es noch die Möglichkeit, ein LCD anzuschließen. Dafür sind Portexpander und Potentiometer für Helligkeit und Kontrast vorhanden.

Genauere Informationen, Schaltpläne und Bilder gibt es im embedded projects journal.

=== Arduino Shield Bridge ===
Mit diesem Board aus Spanien kann man Arduino-Aufsteckplatinen mit dem Raspberry Pi verwenden.
[http://www.cooking-hacks.com/index.php/raspberry-pi-to-arduino-shield-connection-bridge.html Cooking-hacks.com]

Dazu existiert eine Library "arduPi":
"In order to make complete the compatibility we have created the arduPi library which allows to use Raspberry with the same code used in Arduino. To do so, we have implemented conversion functions so that you can control in the same way as in Arduino all the I/O interfaces: i2C, SPI, UART, analog, digital, in Raspberry Pi."

=== I/O Module seriell/USB ===

Alternativ bieten sich Schnittstellen-Erweiterungen über seriellen Port oder USB an, zum Beispiel mit einem handelsüblichen AVR Mikrocontroller-Modul und der Firmware von Stefan Frings
[http://stefanfrings.de/avr_io/].

== Projekte ==
Um den Raspberry Pi hat sich inzwischen eine große Community gebildet, von der immer wieder neue Projekte mit und Erweiterungen für den Raspberry Pi entwickelt werden. Eine Quelle, über die man von den Projekten erfährt ist z.B. der offizielle [http://www.raspberrypi.org/ Raspberry Pi Blog], aber es gibt auch noch viele andere Möglichkeiten, sich zu informieren.

Einige dieser Möglichkeiten und einige ausgewählte Projekte werden in diesem Artikel vorgestellt.

=== Pideas ===
[http://pideas.co.uk/projects.php Pideas] ist eine Seite, auf der Projekte für den Raspberry Pi gesammelt werden.

=== The MagPi ===
[http://www.themagpi.com/ The MagPi] ist ein freies Online-Magazin, das (normalerweise) monatlich erscheint und in dem interessante Projekte genauer vorgestellt werden. Außerdem gibt es Programmier-Tutorials, Anleitungen für Linux-Software und Interviews.

==== Ausgabe 1 ====
Die Ausgabe 1 vom Mai 2012 behandelt folgende Themen:
* „The Pioneers“ - eine kleine Übersicht, wie es zur Entwicklung des Raspberry Pi kam
* „Skutter“ - ein Roboterarm für den Raspberry Pi
* „RacyPy“ - eine Linux Live-CD, basierend auf Puppy Linux und speziell angepasst für einen leichten Einstieg in die Programmierung
* eine Anleitung zum Installieren von Debian in einer virtuellen Maschine
* „Scratch“ - eine Programmiersprache und Entwicklungsumgebung zum kinderleichten Einstieg in die Programmierung
* „the python pit“ - ein Einstieg in die Programmierung mit Python

==== Ausgabe 2 ====
Die Ausgabe 2 vom Juni 2012 behandelt folgende Themen:
* „PiSetup“ - eine Anleitung zum Einrichten des Raspberry Pi
* „In Control“ - ein Einstieg in die GPIO-Programmierung mit dem Raspberry Pi und Python
* „Pi Dissection“ - ein genauerer Blick auf die Einzelteile des Raspberry Pi
* Fortsetzung von „Skutter“ aus Ausgabe 1
* „Command Line Clinic“ - eine Einführung in die Benutzung der Linux-Shell
* „Computer Music“ - eine Anleitung zur Installation von „Schism Tracker“, einem Sequencer-Programm
* Fortsetzung der Debian-Anleitung aus Ausgabe 1, diesmal mit einer Anleitung zum Einrichten und Verwenden von Python
* Fortsetzung von „the python pit“ aus Ausgabe 1

==== Ausgabe 3 ====
Die Ausgabe 3 vom Juli 2012 behandelt folgende Themen:
* eine Anleitung zum automatischen Starten der grafischen Oberfläche von Debian
* Fortsetzung von „In Control“ aus Ausgabe 2
* Fortsetzung von „Command Line Clinic“ aus Ausgabe 2
* Fortsetzung von „Skutter“ aus Ausgabe 1 und 2
* „To Protect and Serve your Raspberry Pi“ - eine einfache Anleitung, um die GPIO-Pins des Raspberry Pi vor Kurzschlüssen zu schützen
* „Meeting Pi“ - Vorschäge, wie man Kinder an den Raspberry Pi heranführen kann
* „The C Cave“ - ein C-Tutorial
* Fortsetzung von „Scratch“ aus Ausgabe 1
* Fortsetzung von „the python pit“ aus Ausgabe 1 und 2
* „Programming Fundamentals“ - ein Artikel, der die Grundlagen (fast) aller Programmiersprachen auf einfachem Weg zeigen will

==== Ausgabe 4 ====
Die Ausgabe 4 vom August 2012 behandelt folgende Themen:
* Fortsetzung von „In Control“ aus Ausgabe 2 und 3
* „3-Axis Accelerometer“ - eine Anleitung für einen Beschleunigungs-Sensor am Raspberry Pi
* „Kernow Pi Launch“ - ein Artikel darüber, wie der Raspberry Pi an Schulen gebracht wurde
* „MagPi Exclusive Interview“ - ein Interview mit Eben und Liz von der Raspberry Pi Foundation
* „How to customise your LXDE menu“ - eine Anleitung zum Anpassen von LXDE
* Fortsetzung von „Command Line Clinic“ aus Ausgabe 2 und 3
* Fortsetzung von „The C Cave“ aus Ausgabe 3
* Fortsetzung von „Scratch“ aus Ausgabe 1 und 3
* Fortsetzung von „the python pit“ aus Ausgabe 1, 2 und 3

==== Ausgabe 5 ====
Die Ausgabe 5 vom September 2012 behandelt folgende Themen:
* „Steady Hands“ - eine Anleitung zum Bau eines „Heißer Draht“-Spiels mit dem Raspberry Pi
* „Temperature Sensor“ - eine Anleitung zum Anschluss eines I2C-Temperatursensors an den Raspberry Pi
* „XBMC Media Center“ - eine Einführung in Rasbbmc, einer HTPC-Distribution für den Raspberry Pi
* „Squeezy or Wheezy?“ - ein Vergleich von Debian 6 „Squeeze“ und Debian 7 „Wheezy“
* Fortsetzung von „Command Line Clinic“ aus Ausgabe 2, 3 und 4
* Fortsetzung von „The C Cave“ aus Ausgabe 3 und 4
* Fortsetzung von „Scratch“ aus Ausgabe 1, 3 und 4
* „RasPiThon 2012“ - ein Bericht über den Rasbperry Pi Programmier-Marathon
* Fortsetzung von „the python pit“ aus Ausgabe 1, 2, 3 und 4

==== Ausgabe 6 ====
Die Ausgabe 6 vom Oktober 2012 behandelt folgende Themen:
* „Skutter Returns“ - Fortsetzung von „Skutter“ aus Ausgabe 1, 2 und 3
* „Portable Power for your Pi“ - eine Anleitung für eine mobile Stromversorgung
* „Star Letter: An FET Buffer Stage for GPIO Access“ - eine Möglichkeit, wie man die GPIO-Pins des Raspberry Pi belastbarer machen kann
* „Pumpkin Pi“ - ein Kürbis mit Bewegungs-Sensor und RGB-LEDs
* „Camera Pi“ - ein Interview mit David Hunt, einem Bastler, der seine Kamera mit einem Raspberry Pi ausgestattet hat
* „Our Raspberry Pi Summer“ - ein Beispiel für ein kleines Spiel, das mit Scratch programmiert wurde
* „Baby steps in a Big World“ - ein Ada-Tutorial
* Fortsetzung von „The C Cave“ aus Ausgabe 3, 4 und 5
* Fortsetzung von „Scratch“ aus Ausgabe 1, 3, 4 und 5
* Fortsetzung von „the python pit“ aus Ausgabe 1, 2, 3, 4 und 5

==== Ausgabe 7 ====
Die Ausgabe 7 vom November 2012 behandelt folgende Themen:
* „Raspberry Pi & Arduino“ - ein Artikel über die Kommunikation zwischen Arduino und Raspberry Pi mithilfe von Python
* „A little Ray of Sunshine“ - eine Solar-Stromversorgung für den Raspberry Pi und andere USB-Geräte
* „The Raspberry Ladder Board“ - ein Board zum Einstieg in die GPIO-Programmierung mit dem Raspberry Pi
* „Interrupts and Other Activities with GPIO Pins” - eine Anleitung für Interrupts und GPIO-Pins im Allgemeinen auf dem Raspberry Pi
* „Raspbian“ - ein Interview mit Mike Thompson, dem Erfinder von Raspbian
* „Turbopi“ - eine Anleitung zum Übertakten des Raspberry Pi
* „Pi-Evolution“ - eine Übersicht über die Entwicklung des Raspberry Pi
* „Make“ - eine Einführung in GNU Make und Makefiles
* „Welcome to the C++ Cache!“ - eine Einführung in C++
* Fortsetzung von „Scratch“ aus Ausgabe 1, 3, 4, 5 und 6
* Fortsetzung von „the python pit“ aus Ausgabe 1, 2, 3, 4, 5 und 6

==== Ausgabe 8 ====
Die Ausgabe 8 vom Dezember 2012 behandelt folgende Themen:
* „Skutter Returns“ - Fortsetzung von „Skutter“ aus Ausgabe 1, 2 und 3 bzw. „Skutter Returns“ aus Ausgabe 6
* „The Santa Trap“ - Heimautomation mit dem Raspberry Pi
* „Control your Arduino board with Raspberry Pi and Python“ - ein Python-Modul zum Steuern eines Arduino
* „PiGauge“ - eine Anleitung, wie man Servo-Motoren übers Internet mithilfe des Raspberry Pi steuern kann
* „Quick2Wire“ - Erweiterungs-Board für den Raspberry Pi
* „Kickstarter“ - eine Vorstellung der Kickstarter-Kampagne, um The MagPi auf Papier zu bannen
* „Programming the Raspberry Pi: Getting Started with Python“ - eine kurze Vorstellung des gleichnamigen Buches von Simon Monk
* „pibow interview“ - ein Interview mit den Erfindern des PiBow, einem Gehäuse für den Raspberry Pi
* „CESIL Pi“ - ein CESIL Programmier-Tutorial für den Raspberry Pi
* Fortsetzung von „Welcome to the C++ Cache!“ aus Ausgabe 7
* Fortsetzung von „Baby steps in a Big World“ aus Ausgabe 6
* „MySQL Database Bootcamp“ - eine Einführung in MySQL
* Fortsetzung von „the python pit“ aus Ausgabe 1, 2, 3, 4, 5, 6 und 7

==== Ausgabe 9 ====
Die Ausgabe 9 vom Februar 2013 (Januar wurde ausgelassen) behandelt folgende Themen:
* „adafruit Interview“ - Interview mit der Gründerin von adafruit, einem Shop für DIY Elektronik
* „WebIOPi“ - eine REST-Schnittstelle, um die GPIO-Pins des Raspberry Pi per Javascript zu steuern
* „Backup your Raspberry Pi“ - eine Anleitung für die Datensicherung der SD-Karte
* „Pi Interface Board Review Quick2Wire“ - ein genauerer Blick auf das Erweiterungs-Board „Quick2Wire“, das in Ausgabe 8 schon kurz gezeigt wurde
* „RISC OS Pi“ - eine Anleitung zur Installation von RISC OS auf dem Raspberry Pi
* „Installing & Configuring ArchLinux“ - eine Anleitung zur Installation von Arch Linux auf dem Raspberry Pi, die auch die Installation von XFCE umfasst
* „Introducing Vala“ - ein kleines Vala Programmier-Tutorial für den Raspberry Pi und das LedBorg Erweiterungs-Board
* Fortsetzung von „The C Cave“ aus Ausgabe 3, 4, 5 und 6
* Fortsetzung von „Scratch“ aus Ausgabe 1, 3, 4, 5, 6 und 7
* Fortsetzung von „the python pit“ aus Ausgabe 1, 2, 3, 4, 5, 6, 7 und 8

==== Ausgabe 10 ====
Die Ausgabe 10 vom März 2013 behandelt folgende Themen:
* Fortsetzung von „WebIOPi“ aus Ausgabe 9
* „Try a Cocktail of Projects“ - ein Artikel, der verschiedene Erweiterungs-Möglichkeiten für den Raspberry Pi zeigt
* „Backing up - part 2“ - Fortsetzung von „Backup your Raspberry Pi“ aus Ausgabe 9
* „Bash Gaffer Tape“ - ein Bash-Tutorial
* „Charm on the Raspberry Pi“ - ein Charm Programmier-Tutorial für den Raspberry Pi
* „C++ Cache”: Fortsetzung von „Welcome to the C++ Cache!“ aus Ausgabe 7 und 8
* Fortsetzung von „Scratch“ aus Ausgabe 1, 3, 4, 5, 6, 7 und 9
* Fortsetzung von „the python pit“ aus Ausgabe 1, 2, 3, 4, 5, 6, 7, 8 und 9

==== Ausgabe 11 ====
Die Ausgabe 11 vom April 2013 behandelt folgende Themen:
* Heizungssteuerung mithilfe des Raspberry Pi über ein Smartphone
* eine Vorstellung vom „Power and I/O Expansion Board“
* eine Anleitung zum Einrichten eines WLAN-Access-Points auf dem Raspberry Pi (per USB-WLAN-Dongle)
* Vorstellung von der Minecraft Pi-Edition
* „Printing with Cups“: Configuring Cups
* „Setting up a simple intranet“ mit einer Anleitung zum Einrichten vom Apache HTTPD
* eine Einführung in die Assembler-Programmierung auf dem Raspberry Pi
* Fortsetzung von „Charm on the Raspberry Pi“ aus Ausgabe 10
* kurze Anleitung zum Verwenden von Farben auf der Kommandozeile
* Fortsetzung von „Scratch“ aus Ausgabe 1, 3, 4, 5, 6, 7, 9 und 10

=== Raspberry Pi multi-effects ===
Ein Musiker hat mit einem Raspberry Pi, einem Arduino Uno und einer USB-Soundkarte ein Gitarren-Effektboard gebaut und das Ganze in seinem Blog [https://guitarextended.wordpress.com/2013/01/31/raspberry-pi-multi-effects-overview-of-the-setup/ beschrieben]. Das alles sieht im [https://www.youtube.com/watch?v=NwJNeouLqgQ Video] noch etwas sperrig aus, es sollte aber kein Problem sein, die Soundkarte und den Raspberry Pi auch noch mit ins Effektboard zu integrieren.

Als Software verwendet er Raspbian, also das Standard-Betriebssystem des Raspberry Pi, und [http://puredata.info/ Pure Data], eine Echtzeit-Umgebung für Audio-, Video- und Grafik-Verarbeitung. Diese ist jedoch auch in den Arch Linux ARM Paketquellen verfügbar, einem Versuch, das ganze auch mit Arch Linux auszuprobieren, steht also theoretisch nichts im Wege.

Die Installation und Konfiguration von Pure Data hat er ebenfalls in seinem Blog [https://guitarextended.wordpress.com/2013/01/28/rpi-as-guitar-effects-processor-installing-and-configuring-pd/ beschrieben].

=== Raspberry Pi guitar tuner ===
Ein anderer Nutzer hat ein Gitarren-Stimmgerät gebaut. Dazu hat er einen Raspberry Pi, eine USB-Webcam zur Ton-Aufnahme, eine 7-Segment-Anzeige zur Anzeige des Tons und 15 LEDs zur Anzeige der Abweichung vom Ton verwendet.

Ausgewertet und angesteuert wird das Ganze über ein selbstgeschriebenes Java-Programm, ein Video und ein paar zusätzliche Informationen gibt es auf [https://www.youtube.com/watch?v=oB4F5VhzQf8 YouTube].

=== Circadian Lighting ===
Auch für Menschen, die sich mit dem Morgen manchmal schwer tun, gibt es ein Projekt mit dem Raspberry Pi, das im Blog [http://www.raspberrypi.org/archives/3267 vorgestellt wurde]. In Verbindung mit ein paar RGB-LEDs kann man den Raspbrry Pi zu einem Wecker machen, der einen nicht mit lautem, nervigen Piepsen aus dem Schlaf reißt, sondern langsam in Verbindung mit einem künstlichen Sonnenaufgang weckt. Fehlt nur noch ein Relais, über das die Kaffeemaschine angeschaltet wird, und der Morgen ist perfekt.

Bei diesem Projekt gibt es sogar den [https://github.com/rasathus/circadianLighting Quellcode], eine [http://rasathus.blogspot.co.uk/2013/01/circadian-lighting-part-one.html Hardware-Liste] und ein [https://www.youtube.com/watch?v=Q9_tqoOkmCU Video], das einige der Funktionen zeigt. Und mit ein paar Python-Kenntnissen kann man alles seinen Bedürfnissen anpassen und erweitern.

=== Raspberry Leaf ===
Die einfachsten Ideen sind doch manchmal die Besten. „Dr. Monk” hat in seinem Blog eine Pinbelegung des Raspberry Pi [http://www.doctormonk.com/2013/02/raspberry-pi-and-breadboard-raspberry.html veröffentlicht], die (in der richtigen Größe ausgedruckt) genau auf den P1-GPIO-Anschluss des Raspberry Pi passt. So vergisst man nie die Pinbelegung, wenn man gerade mal wieder mit dem Raspberry Pi bastelt und auch ein falsches Anschließen, das zur Zerstörung des Mini-Computers oder der angeschlossenen Teile führen kann, passiert nicht mehr so leicht.

=== raspberry-tools ===
Eine Tool-Sammlung für den Raspberry Pi, veröffentlicht unter der GNU General Public License Version 2 und gehostet auf [https://github.com/rookies/raspberry-tools github]. Momentan enthält diese Sammlung nur ein Programm, es folgen aber noch weitere nützliche Tools.

==== scope ====
Scope ist Teil von raspberry-tools. Es zeichnet digitale Signale von einem oder mehreren GPIO-Pins auf und bereitet die Daten für eine Auswertung mit [http://xoscope.sourceforge.net/ xoscope] auf.

Wenn man sich den Quellcode geholt hat, muss man erst einmal das Hauptprogramm für den Raspberry Pi kompilieren. Das geht entweder direkt auf dem Raspberry Pi oder per Cross-Compiler.
* g++ -o RasPi_logGPIO RasPi_logGPIO.cpp
Nachdem sowohl die entstandene Datei ''RasPi_logGPIO'' als auch das Script ''RasPi_logGPIO.sh'' im gleichen Ordner auf dem Raspberry Pi sind, kann man die Aufzeichnung starten:
* ./RasPi_logGPIO.sh [Liste mit GPIO-Pins] > ausgabedatei.txt
Für die Pins 14, 31 und 23 sieht das Kommando z.B. so aus:
* ./RasPi_logGPIO.sh 14 31 23 > ausgabedatei.txt
Die Aufzeichnung kann mit Strg+C gestoppt werden.

Jetzt kann man die entstandene Datei (z.B. hier ausgabedatei.txt) normalisieren und ins xoscope-Format umwandeln, das funktioniert auch problemlos auf einem anderen Computer:
* ./RasPi_normalizeGPIO.py ausgabedatei.txt > ausgabedatei.dat
Nun entsteht die Datei ''ausgabedatei.dat'', die man mit xoscope ansehen kann:
<gallery heights="300" widths="300">
Datei:RasPiTools_scope_sample1.png|eine Beispiel-Aufnahme
Datei:RasPiTools_scope_sample2.png|die gleiche Aufnahme, vergrößert
</gallery>
Dazu muss man nur die Datei laden und die entsprechenden Memory-Einträge anzeigen lassen. In diesem Beispiel ist Pin 14 in Mem A, Pin 31 in Mem B und Pin 23 in Mem C, also genau in der Reihenfolge, in der man die Pin-Nummern dem Programm übergeben hat.

== Anhang ==
=== Stromversorgung ===
[[Datei:Raspberry_Pi_Power.jpg|thumb|Der microUSB-Anschluss zur Stromversorgung]]
Um den Raspberry Pi mit Strom zu versorgen gibt es verschiedene Möglichkeiten. Entscheidend ist nur, dass möglichst konstante 5V bei bis zu 700 mA auf einem microUSB-Stecker geliefert werden.
==== mit USB-Netzteil ====
Wenn man ein genügend starkes USB-Netzteil mit einem microUSB-Kabel verbindet hat man eine passende Stromversorgung für den Raspberry Pi.
Gut funktioniert zum Beispiel das iPhone-Ladegerät, aber auch andere, günstigere Netzteile sollten keine Probleme machen.
==== Netzteil selbst bauen ====
Wenn man kein USB-Netzteil zur Hand hat kann man auch selbst ein Steckernetzteil, das 5V Gleichspannung liefert, mit einem microUSB-Kabel zusammenlöten.

Dafür braucht man erst einmal ein microUSB-Kabel und ein passendes Steckernetzteil. (siehe Abb. 1)
Man entfernt den USB-A-Stecker und befreit das Kabelende ein Stück von seinem Mantel, es kommen vier Adern zum Vorschein. (siehe Abb. 2)
Uns interessiert die grüne und die weiße Ader nicht, da wir keine Daten übertragen wollen.
Jetzt muss auch noch der Stecker vom Netzteil entfernt und die Adern abisoliert werden. (siehe Abb. 3)
Bei manchen Netzteilen ist eine Markierung für Plus- oder Minus-Pol angebracht. Wenn das nicht der Fall ist, muss man mit einem Multimeter nachmessen. (siehe Abb. 4)
Nun isoliert man auch noch die schwarze und rote Ader des USB-Kabels ab und verlötet die schwarze Ader mit dem Minus-Pol des Netzteils und die rote Ader mit dem Plus-Pol des Netzteils. Danach packt man um die Adern jeweils einen Schrumpfschlauch zur Isolation. Wenn man um die ganze Verbindung noch einen großen Schrumpfschlauch packt wird die Verbindung nochmal um einiges stabiler. (siehe Abb. 5)
<gallery>
Datei:RasPi_Netzteil_Selbstbau1.jpg|Abb. 1: Die Ausgangsmaterialien
Datei:RasPi_Netzteil_Selbstbau2.jpg|Abb. 2: Das USB-Kabel ohne Mantel mit der roten (+5V), schwarzen (GND), grünen (Data+) und weißen (Data-) Ader
Datei:RasPi_Netzteil_Selbstbau3.jpg|Abb. 3: Das Netzteil mit abisolierten Kabelenden
Datei:RasPi_Netzteil_Selbstbau4.jpg|Abb. 4: Das Multimeter zeigt eine positive Zahl an, daher ist das Kabel mit der roten Klemme der Plus-Pol, das Kabel mit der schwarzen Klemme der Minus-Pol.
Datei:RasPi_Netzteil_Selbstbau5.jpg|Abb. 5: Das fertige Netzteil, die Verbindung ist mit einem Schrumpfschlauch geschützt.
</gallery>
=== USB-Geräte ===
[[Datei:Raspberry_Pi_USB.jpg|thumb|Die beiden USB Host-Anschlüsse]]
Generell kann man am Raspberry Pi alle USB-Geräte verwenden, die vom Linux-Kernel unterstützt werden und somit auch an anderen Linux-PCs funktionieren.

Es ist allerdings zu beachten, dass die USB-Ports nur vergleichsweise wenig Strom liefern können (nicht die vollen 500 mA, die laut USB2.0 Standard maximal möglich sind), für größere Verbraucher wie z.B. 2,5-Zoll-Festplatten ohne externe Stromversorgung muss man daher einen externen USB-Hub mit Stromversorgung verwenden.
==== Maus & Tastatur ====
Da es für Mäuse und Tastaturen Standard-Profile gibt, die auch von allen (bis auf extrem wenige Ausnahmefälle) Geräten eingehalten werden, sollte es hier keine Probleme geben. Die Eingabegeräte sollten sofort verwendbar sein und auch Hot-Plugging stellt im Normalfall kein Problem dar.
==== USB-Sticks & USB-Festplatten ====
Wenn man seinem Raspberry Pi zusätzlichen Speicherplatz verpassen will bietet es sich an, USB-Sticks bzw. -Festplatten anzuschließen. Da es auch hier Standard-Profile gibt sollten diese sofort vom Linux-Kernel erkannt werden. Einhängen ([https://de.wikipedia.org/wiki/Mounten mounten]) muss man sie jedoch unter Arch Linux ARM generell selbst, wenn man nicht einen [https://de.wikipedia.org/wiki/Fstab fstab-Eintrag] erstellt hat oder eine Desktop-Oberfläche installiert hat, die das automatisch erledigt.
==== WLAN-Sticks ====
Wird der WLAN-Stick vom Kernel erkannt (erkennbar daran, dass ein entsprechendes Interface von '''ifconfig -a''' aufgelistet wird), kann man ein Netzwerk-Profil mit [https://wiki.archlinux.org/index.php/Netcfg netcfg] (Quasi-Standard unter ArchLinux, bei dem die Profile über Konfigurationsdateien erstellt werden), dem [https://wiki.archlinux.org/index.php/NetworkManager NetworkManager] oder [https://wiki.archlinux.org/index.php/Wicd Wicd] erstellen. Sollte die Karte nicht erkannt werden, hilft eventuell ein Blick auf die [https://wiki.archlinux.org/index.php/Wireless_Setup Wireless Setup] Seite im ArchLinux Wiki.
==== TV-Karten ====
Will man den Raspberry Pi als HTPC verwenden, kann es sinnvoll sein, eine TV-Karte per USB anzuschließen.
Hier gibt es generell 4 Möglichkeiten:
* '''DVB-T''', also digitales Fernsehen, das per Funk ausgestrahlt wird - kostenlos, jedoch nicht überall verfügbar
* '''DVB-S''', also digitales Fernsehen, das per Satellit ausgestrahlt wird - kostenlos und generell überall verfügbar, jedoch wird eine Satelliten-Schüssel benötigt
* '''DVB-C''', also digitales Fernsehen, das über das Kabelnetz ausgestrahlt wird - Kosten für den Kabelanschluss fallen an, Sender-Angebot vom Kabelanbieter abhängig
* '''Analog-TV''', also analoges Fernsehen, das über das Kabelnetz ausgestrahlt wird - Kosten für den Kabelanschluss fallen an, kein HD, Sender-Angebot vom Kabelanbieter abhängig

Nicht alle Geräte werden von Linux unterstützt, eine Übersicht, die nach Übertragungstechnik (DVB-T/-S/-C oder Analog) und Anschluss-Art (beim Raspberry Pi immer USB) geordnet ist, findet man im [http://linuxtv.org/wiki/index.php/Hardware_Device_Information LinuxTVWiki], zu dem man natürlich auch selbst beitragen kann, wenn man ein Gerät getestet hat.
==== Soundkarten ====
Da der Klinke-Ausgang des Raspberry Pi nicht mit einem D/A-Wandler, sondern nur per PWM funktioniert, ist die Sound-Qualität nicht gerade überragend. Wenn man das verbessern will, oder wenn man Sound per Line-Eingang oder per Mikrofon aufnehmen will, bietet es sich an, eine USB-Soundkarte anzuschließen.

Ist man unsicher, ob die Soundkarte unterstützt wird, hilft ein Blick ins [http://www.alsa-project.org/main/index.php/Matrix:Main Wiki vom ALSA-Projekt].

== Downloads ==

* [http://downloads.raspberrypi.org/images/archlinuxarm/archlinux-hf-2013-02-11/archlinux-hf-2013-02-11.zip.torrent Torrent-Download von Arch Linux ARM 2013-02-11]
* [http://downloads.raspberrypi.org/images/archlinuxarm/archlinux-hf-2013-02-11/archlinux-hf-2013-02-11.zip HTTP-Download von Arch Linux ARM 2013-02-11] (SHA-1: 1d2508908e7d8c899f4a5284e855cb27c17645dc)

== Siehe auch ==

* [http://www.raspberrypi.org/ offizielle Website des Raspberry Pi] (englisch)
* [https://de.wikipedia.org/wiki/Raspberry_Pi Wikipedia: Raspberry Pi] (deutsch)
* [http://www.themagpi.com/ The MagPi] (englisch)
* [http://archlinuxarm.org/ Arch Linux ARM] (englisch)
* [https://www.archlinux.org/ Arch Linux] (englisch)
* [https://de.wikipedia.org/wiki/Arch_Linux Wikipedia: Arch Linux] (deutsch)
* [http://www.kammerath.net/asterisk-virtuelle-telefonanlage.html Asterisk auf dem Raspberry Pi] (deutsch)

[[Kategorie:Raspberry Pi]]

Brushless-Controller für Modellbaumotoren

2013-05-07T09:14:49Z

Stefanfrings de: Akku Typen und Spannungsbereich erweitert

== Einleitung ==

Im Internet gibt es einige grundlegende Informationen zur Funktionsweise und Ansteuerung von Brushless-Motoren (BLDC). Für die Entwicklung eines solchen Reglers findet man aber nur wenig richtig detaillierte Informationen und Erfahrungsberichte. In diesem Artikel sollen genau diese Lücken geschlossen werden. Es soll hier aber kein fertiges Produkt (Schaltplan + Layout + Software) angeboten werden. Viel mehr soll es die Eigenentwicklung unterstützen, Ideen und Erfahrungen anbieten.

An dieser Stelle weise ich noch darauf hin, dass man bei den [[#Weblinks]] noch einige sehr gute Informationen findet! Es gibt dort Hardware und Software, es lohnt sich die Links mal anzuschauen.

==== Um welche Motoren geht es genau? ====

Es geht hier um die sogenannten elektrisch kommutierten bürstenlosen Gleichstrommotoren (BLDC) aus dem Modellbaubereich.

Deren Eigenschaften sind:
* Haben drei Anschlüsse für die drei Phasen, ansonsten sind keine weiteren Anschlüsse vorhanden
* Werden in der Regel mit LiPo oder Nickel Akkus versorgt
* Leistung im Bereich von ca. 100W bis 2kW
* Spannungen im Bereich von ca. 7 bis 50V
* Ströme im Bereich von ca. 5 bis 120A

==== Um welche Motoren geht es hier nicht? ====

* Motoren mit Hallsensoren für die Rückmeldung
* Festplattenmotoren

Unter Umständen kann aber dieser Artikel auch für solche Motoren nützlich sein.

== Funktionsweise dieser Motoren ==

=== Ansteuerung ===

[[Datei:BLDC_Spannungs_Diagramm.png|thumb|right|250px|Ansteuerung der 3 Phasen]]

Grundsätzlich werden die 3 Phasen nacheinander bestromt, die Phasenspannungen wären also drei um 120° phasenverschobene Rechteckspannungen. Ein sinusförmiger Drehstrom ist nicht nötig, es genügen Rechteckspannungen. Mit einer Raumzeigermodulation könnte man die Stromaufnahme und die Geräuschentwicklung zwar noch verringern, macht die Ansteuerung aber einiges aufwändiger. Sogar die käuflichen Regler arbeiten nur mit Rechtecksignalen, zumindest die die ich kenne.

Dabei gibt es für jede Phase die Zustände „Low“, „High“ und „Floating“. Low bedeutet 0V (GND), High entspricht der Versorgungsspannung und Floating ist keines von beidem, die Phase „hängt in der Luft“. Bei „High“ wird aber noch der Mittelwert der Spannung per PWM eingestellt, über das Tastverhältnis wird schlussendlich die Drehzahl verändert! Dazu aber später mehr.

In der Grafik rechts kann man den Spannungsverlauf sehr gut erkennen. Das Diagramm zeigt aber nur den theoretischen Verlauf der Spannungen, wobei die gestrichelten Linien den Zustand "floating" symbolisieren. Dies kann man in einem Diagramm ja nicht wirklich darstellen, das ist einfach symbolisch gemeint. Interessanterweise sehen die Spannungen aufgrund der BEMF aber tatsächlich ziemlich ähnlich aus wie im Diagramm!

=== Die 6 Zustände ===

Wie man erkennen kann, werden 6 Zustände gebraucht, die sich dann immer wiederholen. Die Kommutierung ist also einfach ein Weiterschalten des Zustandes.
''Diese 6 Zustände sind nicht mit den drei Zuständen von oben (High, Low, Floating) zu verwechseln, das ist ein anderes Thema!''

In einer Tabelle dargestellt würde das folgendermassen aussehen:

{| class="wikitable"
! Zustand || Phase A || Phase B || Phase C || Stromfluss || Komparator-Eingänge
|-
| 1 || PWM || Floating || GND || A --> C || MITTEL <--> NULL_B
|-
| 2 || Floating || PWM || GND || B --> C || MITTEL <--> NULL_A
|-
| 3 || GND || PWM || Floating || B --> A || MITTEL <--> NULL_C
|-
| 4 || GND || Floating || PWM || C --> A || MITTEL <--> NULL_B
|-
| 5 || Floating || GND || PWM || C --> B || MITTEL <--> NULL_A
|-
| 6 || PWM || GND || Floating || A --> B || MITTEL <--> NULL_C
|}

Hinweise:
* Die Nummern in der ersten Spalte entsprechen genau den sechs Zuständen, die auch im obigen Diagramm nummeriert sind (Alle 6 Zustände zusammen bilden einen Zyklus, wie es auch im Diagramm dargestellt ist)
* Den Inhalt der letzten Spalte wird später noch erläutert. Die Bezeichnungen beziehen sich auf die [[#BEMF-Schaltung]].

=== Einsatz der BEMF ===
Das schaut bis jetzt eigentlich wie ein Synchronmotor oder Schrittmotor aus, was ein BLDC im Prinzip auch ist.

Wie schon erwähnt wurde, wird ein BLDC elektronisch kommutiert. Das heisst, die Kommutierung wird nicht einfach stur vorgegeben, sondern es wird immer Rücksicht auf die Ankerposition genommen. Dazu muss man allerdings wissen, wann man die Kommutierung genau auslösen soll.

Dieses Verfahren heißt Block-Kommutierung und ist ein Kompromiss aus Aufwand und Ergebnis:
Idealerweise werden die Ströme im Stator so eingeprägt, dass der Statorfluss dem Rotorfluss immer um 90° vorauseilt. Nur so wird das ideale Drehmoment erzeugt (siehe Literatur zur permanenterregten Synchronmaschine). Allerdings hat dieses Verfahren, auch Feldorientierte Regelung oder Vektor-Regelung genannt, den Nachteil, dass meistens teure Positionssensorik für den Rotor nowendig ist und auch die nötige Rechenleistung stark ansteigt. Die komplette Regelung muss für jede PWM-Periode gerechnet werden, damit sich der Aufwand lohnt.
Im Fall der Block-Kommutierung ist der ideale Kommutierungszeitpunkt also der, bei dem das Stator-Feld dem Rotor-Feld im Mittel um 90 ° vorauseilt. Dieser ideale Kommutierungszeitpunkt ist wegen der als konstant angenommenen Rechenzeit für die Kommutierung drehzahlabhängig.

Zur Erreichung einer höheren Maximaldrehzahl kann das Rotorfeld durch das Statorfeld im sogenannten Feldschwäch-Betrieb geschwächt werden. Es ergeben sich Feldschwäch-(Blind)ströme im Bereich der Nennströme.

Grundsätzlich kann auch ein BLDC nicht ohne Kenntnis der Lage des Rotors kommutiert werden. Und hier kommt die sogenannte Back Electromotive Force (BEMF) zum Einsatz. Von den drei Phasen liegt ja zu jedem Zeitpunkt genau eine Phase in der Luft wie man am Diagramm oben erkennen kann. Aufgrund des drehenden Magnetfeldes im Motor wird an dieser Phase nun eine Spannung induziert. Und genau diese induzierte Spannung gibt nun Auskunft darüber, in welchem Winkel sich der Anker befindet, und daraus kann man dann auch den Zeitpunkt der nächsten Kommutierung bestimmen.

Zusätzlich wird aber auch noch die Sternmittelpunktspannung der drei Phasen benötigt, welche aber leider nicht direkt zur Verfügung steht. Das ist aber kein Problem, mit drei Widerständen kann man sich die selber erzeugen (siehe [[#BEMF-Schaltung]]).

Jetzt sollten die BEMF-Spannungen die Sternmittelpunktspannung ständig kreuzen, was man dann mit einem Komparator erfassen kann. Und den Interrupt, den der Komparator auslöst, ist nun verantwortlich für die nächste Kommutierung.
Der Komparator wird natürlich nacheinander mit den drei Phasen gefüttert, es darf immer nur die Phase an den Komparator angeschlossen sein, die auch in der Luft hängt! In der Tabelle [[#Die 6 Zustände]] sieht man, welche zwei Spannungen der Komparator jeweils vergleichen muss.

Als Komparator kann man übrigens den integrierten nehmen, den es in den AVRs gibt. Diese (alle?) haben auch den benötigten Multiplexer, um zwischen den drei Analogquellen wählen zu können. Näheres dazu im Abschnitt [[#Software]].

== Hardware ==

=== Leistungsteil ===

==== Treiber ====

Um die drei notwendigen Zustände (''Low'', ''High'' und ''Floating'') für jede der drei Phasen realisieren zu können, werden drei Halbbrücken mit Mosfets benötigt. Hier gibt es dann auch schon mehrere Varianten, wie man das aufbauen kann. Grundsätzlich muss man sich mal überlegen ob fertige FET-Treiber oder diskrete Treiber verwendet werden sollen. Die FET-Treiber haben einige sehr schöne Vorteile, deshalb sollte man diese meiner Meinung nach bevorzugen.

Die Vorteile wären:

* Integrierter Kurzschlussschutz mit dead time, ein Softwarefehler kann die FETs nicht zerstören. Das kann in der Entwicklungsphase sehr von Vorteil sein :-)
* Die FETs können mit ordentlicher Geschwindigkeit geschaltet werden, und die Mikrocontroller-Ports werden trotzdem nicht stark belastet. So kann die Wärmeentwicklung der FETs noch etwas reduziert werden.
* Bei Treibern die mit nur einem Eingang zwischen Lowside und Highside Mosfets toggeln (z.B. IR2104), ist der sogenannte „aktiver Freilauf“ bereits in Hardware realisiert und ermöglicht so mit wenig Aufwand eine extrem niedrige Erwärmung der Mosfets. Das ermöglicht schon sehr grosse Ströme auch ohne Kühlkörper!
* Es können günstigere Mosfets verwendet werden, es müssen keine TTL-Kompatible FETs sein. Auch ist eine niedrige Gatekapazität nicht so von Bedeutung wie bei direkter Ansteuerung mit einem Mikrocontroller.
* Je nach dem welchen Treiber man verwendet, kann der Softwareaufwand und die Fehleranfälligkeit deutlich reduziert werden.

Nachteile von Treiber sind:

* Mehr Bauteile auf der Platine.
* Vermutlich insgesamt etwas teurer, auch wenn die FETs günstiger sind.
* Bei vielen Treibern ist eine Minimalspannung von ca. 10V notwendig, damit sie funktionieren. Bei einem fast leeren 3S LiPo Akku könnte das vielleicht schon kritisch werden. Auch darf z.B. beim IR2104 eine Spannung von 20V nicht überschritten werden. Daher kommt (ohne StepUp und StepDown Wandler) eigentlich fast nur noch ein 4S Akku in Frage. Möchte man einen grösseren Eingangsspannungsbereich haben muss man noch entsprechende Spannungsregler einbauen.

Ich persönlich habe es schon mit einem IR2104S probiert, dieser erscheint mir sehr geeignet für diese Aufgabe. Ich betreibe ihn mit einem 4S LiPo, damit läuft das Teil perfekt. Kann ich nur weiterempfehlen!

==== Beispielschaltung ====
[[Datei:BLDC_Leistungsteil_1.png|thumb|right|300px|Beispiel einer Halbbrücke inklusive Strommessung]]
Hier ein Beispiel, wie der Leistungsteil einer Phase aussehen könnte.

Für die exakte Beschaltung der Treiber muss man natürlich dessen Datenblatt studieren!

Hier sieht man auch gleich noch die Strommessung, die man natürlich nicht für jede Phase einzeln aufbauen muss. Man kann sie sogar ganz weglassen, sie könnte aber nützlich sein um eine Überlast des Motors erkennen zu können.

Der Widerstand R20 ist dazu da, dass auf dem Treiber das PWM-Signal liegt, sobald die Leitung „IN_A“ in der Luft hängt (uC Pin als Eingang definiert). So wird nur ein einziger PWM-Ausgang vom Mikrocontroller benötigt für alle drei Phasen, erfordert also kein Soft-PWM oder sonst irgend ein Murks. Diese Schaltung habe ich übrigens beim Mikrokopter-Projekt abgeschaut.

Übrigens muss an die Versorgung unbedingt noch ein grosser Elko gehängt werden, am besten möglichst nahe an die Mosfets (keine langen Leitungen zwischen Elko und Mosfets). Die erforderliche Kapazität hängt davon ab, wieviel Strom der Motor braucht. bei kleinen bis mittleren Motoren sollten so 220uF bis 680uF ausreichend sein.

=== BEMF-Schaltung ===

[[Datei:BLDC_BEMF_schaltung.png|thumb|right|300px|BEMF-Schaltung]]

Ein wichtiger Teil ist aber auch die BEMF-Schaltung. Dabei wird häufig die Schaltung vom Mikrokopter eingesetzt (siehe Schaltung rechts).

Die Schaltung besteht erstmal aus drei Spannungsteilern, die die Phasenspannungen auf ein Spannungsniveau heruntersetzen, das man auf die Mikrokontrollereingänge legen darf. Keramikkondensatoren glätten diese Spannungen, weil die aufgrund der PWM sonst sehr stark ausschlagen. Dann gehen diese drei Spannungen (''NULL_A'', ''NULL_B'' und ''NULL_C'') auf drei ADC-Eingänge des Mikrocontrollers.

Und dann sind da noch die drei Widerstände, die aus den Spannungen ''NULL_A'', ''NULL_B'' und ''NULL_C'' einen virtuellen Sternmittelpunkt bilden. Diese Mittelpunktspannung (''MITTEL'') kommt dann auf den Komparatoreingang ''AIN0'' vom AVR. Diese Spannung soll der Komparator später dann mit jeweils einer der Spannungen ''NULL_A'', ''NULL_B'' und ''NULL_C'' vergleichen um den Kommutierungszeitpunkt bestimmen zu können.

Man kann die Widerstands-/ und Kapazitätswerte auch noch anpassen. Bei höheren Eingangsspannungen muss man darauf achten, dass die Eingänge vom AVR keine zu hohe Spannung abkriegen! Ein Regler, den ich gekauft habe, hat einiges höhere Widerstandswerte und kommt sogar ohne Kondensatoren aus. Hier hat man also durchaus noch Spielraum um ein bisschen zu tüfteln, für den Anfang ist die abgebildete Schaltung aber bestens geeignet.

=== Mikrocontroller ===

Als Mikrocontroller sind viele Typen aus der AVR-Serie geeignet. Bei der BrushlessCtrl wird zum Beispiel ein ATMega168 eingesetzt. Mit diesem habe ich auch mal angefangen, der scheint wirklich gut geeignet zu sein. Es reicht aber auch ein ATMega88 wenn man nicht alle möglichen Protokolle und Ansteuerungsarten (I2C, SPI, PPM) gleichzeitig einbauen will.

Viele Regler verwenden auch einen AT90PWM, vorallem wenn mehrere PWM-Kanäle gebraucht werden.

Übrigens wird bei käuflichen Reglern extrem häufig ein ATMega8 eingesetzt! Wenn man nur Software entwickeln möchte kann man auch einen solchen Regler kaufen und das eigene Programm aufspielen. Bei den [[#Weblinks]] findet man dazu auch noch Informationen.

Um eine Raumzeigermodulation zu implementieren wird dann aber vermutlich schon ein 32-Bit Mikrocontroller nötig sein. Aber wie schon erwähnt ist für ein Modellbaumotor eine Raumzeigermodulation keinesfalls ein must-have.

== Software ==

Bei der Software kommt es jetzt natürlich sehr stark darauf an, wie die Hardware aufgebaut ist. Ich möchte hier aber nicht auf jede Variante eingehen, das gäbe viel zu viel Arbeit. Auch will ich ja keinen fertigen Code bereitstellen, sondern nur Hinweise und Tipps geben. Wer nicht selber programmieren will, der kann ja mal die Mikrokopter-Firmware herunterladen, die älteren Versionen davon gibt es auf der Mikrokopter-Seite zum downloaden.

Wichtig sind auf jeden Fall [[#Die 6 Zustände]]. Der Mikrocontroller muss die Phasen jeweils nacheinander so wie in der Tabelle ansteuern. Das ist soweit ja kein Problem, schwierig ist aber immer der richtige Zeitpunkt für die Kommutierung zu finden.

Falls man einen IR2104 oder einen ähnlichen Treiber verwendet, würde die Software ungefähr so aussehen:

* Beim Programmstart wird schonmal der PWM-Ausgang mit einem Timer aktiviert. Die Frequenz liegt normalerweise so im Bereich 12 bis 25kHz. Ich selber verwende 20kHz, da hört man dann auch dieses Pfeifen nicht mehr.
* Der Interrupt vom Analogkomparator muss aktiviert werden, um die Kommutierungszeitpunkte bestimmen zu können.
* Dann habe ich eine Funktion, welche den Zustand (1 bis 6) eins weiterschaltet und die Ausgänge entsprechend setzt. Dabei werden die Pins, die das PWM-Signal enthalten sollen, einfach als Eingang definiert, wie ich schonmal erwähnte.
* Wichtig ist ausserdem, dass bei jeder Kommutierung auch noch der richtige ADC-Kanal auf den Komparator geleitet wird per Multiplexer. Dieser Kanal wird bei jeder Kommutierung eins weitergeschaltet.
* Danach muss nur noch gewartet werden bis der Analogkomparator einen Interrupt auslöst. Sobald dies geschieht, wird die nächste Kommutierung per Timer (30° Verzögerung) ausgelöst, und das Spiel beginnt wieder von vorne.

Je nach Komplexität des BLDC Controllers und des damit verbundenen Programmieraufwands ist es aber auch möglich (wie von sehr vielen Nutzern implementiert) die Kommutierung direkt nach dem Analog-Komparator Interrupt auszulösen - d.h. mit 0° Verzögerung. In diesem Fall spricht man von Phasenvoreilender (phaseadvance) Ansteuerung. Der Motor kann dadurch eine höhere Maximaldrehzahl erreichen, jedoch mit geringerem Drehmoment - die Stromaufnahme ist höher und der Wirkungsgrad geringer (siehe [http://ww1.microchip.com/downloads/en/AppNotes/01083a.pdf AN1083, Seite 18]). Der Effekt ist ähnlich dem Feldschwächebetrieb einer Asynchronmaschine.

Die Drehzahl des Motors lässt sich jetzt ganz bequem ändern, indem man den Duty-Cycle des PWM-Signales verändert. Der Motor beschleunigt bzw. bremst dann von alleine. Übrigens ist es empfehlenswert, den Sollwert etwas zu "dämpfen", damit keine schlagartigen Änderungen des Duty-Cycles erfolgen können. Vor allem schlagartige Abbremsmanöver können starke Überspannungsspitzen hervorrufen, die den Regler zerstören können!

=== Anlauf ===

So, das war jetzt die Beschreibung für einen Motor, der bereits läuft. '''Bis''' der Motor allerdings mal dreht, muss man anders vorgehen, weil der stillstehende Motor ja keine Komparator-Interrupts auslöst, da keine BEMF vorhanden ist.

Daher muss man den Motor zuerst mit einem starren Drehfeld auf eine gewisse Drehzahl beschleunigen, wie bei einem Schrittmotor. Sobald eine genügend hohe Drehzahl erreicht wurde, kann man in den geregelten Betrieb schalten. Am besten schaltet man dazu einfach alle Phasen ab und aktiviert den Komparator. Sobald der erste Interrupt vom Komparator ausgelöst wird, werden die Phasen wieder eingeschaltet.

Der ganze Startvorgang ist aber schon eine Wissenschaft für sich. Es braucht (nach meiner Erfahrung) viel Zeit und Nerven, bis alles richtig funktioniert. Man kann aber am Anfang den Motor auch von Hand anwerfen, das geht viel einfacher als mit einer Zwangskommutierung. Ein Oszilloskop ist eigentlich auch absolut notwendig, um analysieren zu können was der Regler und die BEMF genau macht.

Ganz wichtig aber an dieser Stelle: '''Wenn der Motor mit einem starren Drehfeld angesteuert wird, sieht die BEMF alles andere als schön aus!''' Das liegt daran, dass der Motor bei jeder Kommutierung beschleunigt, und danach wieder abgebremst wird, der Motor läuft einfach nicht „rund“. Wenn ihr also irgendwas komisches auf dem Oszilloskop seht, ist das kein Fehler in eurer Schaltung, das ist normal bei Zwangskommutierung!

Wenn Ihr die BEMF auf dem Oszilloskop anschauen wollt, könnt Ihr entweder den Motor einfach von Hand drehen, oder ihr dreht den Motor mit Zwangskommutierung hoch, und schaltet dann alle Phasen ab (nicht auf GND, in der Luft hängend). Direkt nach dem Abschalten der Phasen sollte die BEMF einen relativ schönen Drehstrom zeigen (muss ich selbst noch kontrollieren ob das wirklich der Fall ist :-) )
Anmerkung JB: Gerade an einem Festplattenmotor getestet, bei Drehung von der Hand lassen bis zu 600mVss sinusförmig auf dem Oszilloskop blicken, Frequenz bis zu 20 Hz, muss sich umeinen mehrpoligen Motor Handeln, so schnell hab ich nicht gedreht ;)

Bis jetzt habe ich es mit dieser Variante aber noch nicht so richtig geschafft, einen brauchbaren Anlaufvorgang hinzukriegen. Ich glaube auch, dass gekaufte Regler das nicht so machen. Diese scheinen nur einen kräftigen Strom auf eine Phase zu geben, und werten dann die entstandene BEMF aus, aus der dann berechnet werden kann, welche Phase als nächstes bestromt werden muss. So richtig habe ich das aber noch nicht angeschaut, '''vielleicht weiss hier jemand besser Bescheid und könnte es hier beschreiben?'''

Das Prinzip eines Anlaufvorgangs eines sensorlosen BLDC ist folgendes:
- Man präge ein Feld ein, bei dem angenommen werden muss, dass der Motor diesem ab Stillstand auch folgt.
- Sobald diese Annahme durch Auftreten eines durch BEMF erzeugten Ereignisses bestätigt wird, kann in den geregelten Betrieb umgeschaltet werden.

=== Komparator ===

Wenn man sich für die Kommutierungs-Erkennung per Analogkomparator entscheidet, muss man noch ein sehr nützliches Feature von den AVRs kennen. Da man ja abwechslungsweise drei verschiedene Signale (BEMF_A...C) mit der Mittelpunktspannung vergleichen muss, aber nur ein einziger Analogkomparator vorhanden ist, muss man den sogenannten Analog-Multiplexer benutzen. Mit diesem in den AVRs integrierten Multiplexer kann man nun die Spannung am Pin "AIN0" mit einem beliebigen Analogeingang (ADC0...ADC7) vergleichen. Natürlich kann man nicht mehrere Kanäle gleichzeitig anwählen, da es nur einen einzigen Komparator gibt. Das ist für unsere Anwendung allerdings kein Problem, wir müssen immer nur eines der BEMF-Signale mit der Mittelpunktspannung vergleichen.

Näheres dazu und wie man den Multiplexer benutzt erfährt man im Datenblatt des verwendeten Mikrocontrollers. Der entsprechende Abschnitt heisst "Analog Comparator Multiplexed Input" (unter "Analog Comparator").

=== Schnittstellen ===

Man kann nun den Sollwert der Drehzahl wahlweise über einen PPM-Eingang, über [[UART]], [[SPI]], [[I2C]] oder mit einem Potentiometer vorgeben. Welche Ansteuerung man wählt hängt davon ab, wie und wo der Motor eingesetzt werden soll und ist deshalb jedem selber überlassen.

== Bildmaterial ==
=== Oszillogramme ===

[[Datei: BLDC_Oszillogramm_Phasen_PWM.png|300px]]

Die drei Phasen während dem geregelten Betrieb, die BEMF ist sehr schön zu erkennen (immer zwischen den Zuständen "PWM" und "LOW").

[[Datei: BLDC_Oszillogramm_Phasen_Vollgas.png|300px]]

So sehen die drei Phasen bei Vollgas aus (100% PWM). Die BEMF ist jetzt sogar so steil, dass sie die beiden Zustände ''Low'' und ''High'' mit einer fast perfekten Geraden verbindet!

[[Datei: BLDC_Oszillogramm_BEMF_richtig.png|300px]]

* Gelb: Phase A, BEMF sehr schön erkennbar
* Blau: Mittelpunktspannung
* Rot: BEMF von Phase A (nach der BEMF-Schaltung!)
* Grün: Komparator-Interrupts (steigende Flanke) Jeder dritte Interrupt gehört zur Phase A, die anderen Interrupts stammen von den anderen Phasen, die nicht auf dem Bild zu sehen sind.

[[Datei: BLDC_Oszillogramm_BEMF_falsch.png|300px]]

So kann z.B. die BEMF während der Zwangskommutierung aussehen. Dadurch werden auch zu viele Komparator-Interrupts (Grün, jede Flanke) ausgelöst. Kein schöner Anblick...

[[Datei: BLDC_Oszillogramm_Anlauf_1.png|300px]]

So sieht der Anlaufvorgang bei einem gekauften Regler aus. eine extrem kurze Geschichte im Vergleich mit meinen paar Umdrehungen mit Zwangskommutierung. Wer kennt das Geheimnis?

=== Layouts ===

Als Anregung, wie so ein Regler aussehen könnte (nur 40x26mm klein, inklusive Optokoppler, drei Treibern und drei schönen Stecker!):

[[Datei: BLDC_Eagle3d_top_1.jpg|300px]]

[[Datei: BLDC_Eagle3d_bot_1.jpg|300px]]

Der HCPL-0600 auf der Unterseite ist übrigens ein Optokoppler um das PPM-Eingangssignal galvanisch zu entkoppeln. Ist nicht zwingend nötig, war aber grad Platz da... :-)

== Siehe Auch ==
* [http://www.mikrocontroller.net/topic/248509 Diskussion zum Artikel]
* [[BLDC Demo Board]]
* [[Treiber]]
* [[Mosfet-Übersicht]]
* [[Leiterbahnbreite]] Unbedingt beachten bei grösseren Strömen!
* [[Kühlkörper]] Bei sehr hohen Strömen evtl. nötig

== Weblinks ==
* [http://www.atmel.com/Images/doc8012.pdf AppNote AVR444 von Atmel]
* [http://ww1.microchip.com/downloads/en/AppNotes/00885a.pdf BLDC Theorie(AN885 Microchip)]
* [http://www.mikrokopter.de/ucwiki/BrushlessCtrl BrushlessCtrl vom Mikrokopter]
* [http://svn.mikrokopter.de/listing.php?repname=BL-Ctrl& Software vom Mikrokopter Brushless-Regler]
* [http://home.versanet.de/~b-konze/ Die Seite von B. Konze, einer der Pioniere in diesem Bereich]
* [http://www.rcgroups.com/forums/showthread.php?t=1513678 Ein Thema auf rcgroups.com (Englisch) wo einige käuflichen Regler näher angeschaut wurden und eine eigene Firmware angeboten wird]
* [http://rmmx.gmxhome.de/bldchv/start.html Ein Regler-Projekt für etwas grössere Motoren]
* [http://www.fc00.de/quadrokopter_6_kw.htm Regler für sehr grosse Motoren]
* [http://ww1.microchip.com/downloads/en/AppNotes/01083a.pdf Appnote AN1083 von Microchip, sehr detailliert]
[[Kategorie:Motoren]]