AVR-Einstieg leicht gemacht

Einen Controller zum Leben zu erwecken ist nicht schwer, manchmal reichen ein paar Teile! Beispiel mit Mega8

Wir starten mit einem ATMega32

Immer wieder gibt es in Foren, wie dem Roboternetz, Einsteiger, die das erste Mal mit einem Microcontroller in Berührung kommen. Trotz zahlreicher Einstiegsbeiträge im Forum wiederholen sich doch bestimmte Anfängerfragen immer wieder. Daher soll dieser Artikel noch einmal aufzeigen, wie die ersten Schritte aussehen, um einen Controller zum Leben zu erwecken. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile benötigt werden und welche Funktion sie besitzen. Als Controller verwenden wir einen AVR ATMega32, der derzeit größte AVR-Controller, welcher noch im bastlerfreundlichen DIP-Gehäuse verfügbar ist. Für kleine bis mittlere Projekte ein sehr empfehlenswerter Controller, zumal er preislich mit ca. 3-4 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

Wie auf dem Bild zu sehen ist, verfügt auch der etwas günstigere ATMega16 über die gleiche Pinbelegung, daher könnten wir in diesem Tutorial auch diesen Typ verwenden. Der ATMega32 hat aber doppelt soviel Speicherplatz für Programmdaten (Flash), daher hat man für eine geringe Preisdifferenz doch mehr Möglichkeiten. Wer noch 1-2 Euro sparen will, dem sei der ATMega8 oder ATMega168 empfohlen, diese Typen sind sehr ähnlich, so dass das Tutorial weitgehend auch auf diese Typen bezogen werden kann. Allerdings haben diese Typen deutlich weniger Anschlussmöglichkeiten (28 Pin DIP Gehäuse).

Die Frage, ob man mit einem fertigen Controllerboard, einer Experimentierplatine oder einem Steckbrett beginnen sollte, wurde ja in dem RN-Wissen Wiki Beitrag "Mit welchem Controllerboard fang ich an" angesprochen. In den meisten Fällen favorisiert der Autor dieses Artikels ein fertiges Controllerboard. Warum das so ist, dazu am Ende noch ein paar Anmerkungen. Dennoch soll diese Einführung schrittweise anhand eines Steckbrettes erläutert werden.

Start mit handelsüblichem Steckbrett

Ein Steckbrett hat den Vorteil, dass man theoretisch ohne Löten alle Bauteile relativ zügig zusammenstecken kann. Bestimmte Steckkontakte innerhalb einer Reihe sind im Steckbrett miteinander verbunden, so dass man nachher pro Bauteilbeinchen noch einige Steckkontakte zum Verdrahten mit Schaltdraht oder speziell konfektionierter Litze verwenden kann.

Die Vorteile eines Steckbretts:

• Bauteile können ohne Löten eingesetzt und verdrahtet werden
• recht zügiger Schaltungsaufbau
• eine Schaltung kann leicht geändert oder korrigiert werden, defekte Teile sind leicht tauschbar
• ein Steckbrett kann auch für ganz andere Schaltungen verwendet werden

Die Nachteile eines Steckbretts gegenüber gedruckten Schaltungen und Experimentierplatinen sind:

• nicht alle Bauteile passen, so dass wir doch noch etwas löten müssen
• nur geringer Schaltungsumfang möglich, da es schnell unübersichtlich wird
• sehr störanfällig wegen grosser Kabellängen, dadurch oft Funktionsstörungen
• Bauteile müssen zum Teil verbogen werden, damit sie passen

Man beginnt, indem man den Controller AVR ATMega32 auf das Board aufsetzt:

Die Grundschaltung

Damit ein Controller erst mal zum Laufen kommt, benötigt man zumindest einen 10-k-Widerstand, einen 100-nF-Kondensator und eine 5V-Spannungsquelle. Das Ganze muss entsprechend dem unteren Schaltplan verschaltet werden, man spricht von einer sogenannten Grundschaltung. In dem Schaltplan wurde der Controller im Übrigen pinkompatibel als Schaltzeichen verwendet, die Pinreihenfolge ist also im Schaltplan identisch mit der echten Bauteilpin-Reihenfolge. Diese Darstellung erleichtert den Nachbau der Schaltung auf einem Steckbrett aber auch einer Experimentierplatine ungemein. Gewöhnlich verwendet man in Schaltplänen eine etwas andere Darstellung, bei der die Pins nach Funktionsgruppen geordnet sind. Bei solchen Schaltplänen muss man sich dann anhand der Pin-Nummern orientieren, man wird dies am Ende des Artikels noch bei dem IC MAX232 sehen.

Wenn man schon einige Grundschaltungen in anderen Tutorials gesehen hat, dann wird man bemerken, dass unsere doch noch etwas einfacher ist und weniger Bauteile benötigt. Hier wird beispielsweise kein Quarz verwendet, da der ATMega32 auch intern einen Takt generieren kann. Wer mit dem ADC genau messen will, sollte statt der Beschaltung im Bild, zwischen Vcc und AVcc eine Spule von 10uH und einen Kondensator von 100nF zwischen AVcc und GND schalten. Will man AVcc als Referenzspannung verwenden, muss noch ein 100nF Kondensator von ARef nach GND.

Auf dem Steckbrett sieht die obere Schaltung wie folgt aus:

Um den Controller in Betrieb zu nehmen, benötigt man bei dieser Schaltung ein Netzteil, das eine stabilisierte Spannung von 4 bis 5V liefert. Wir gehen erst einmal davon aus, dass man über dieses verfügt. Erwähnenswert ist noch, dass der Kondensator als Abblockkondensator zur Unterdrückung von Störungen dient. Er muss so nah wie möglich an die Spannungszuführung am Controller selbst gesetzt werden. Ohne Kondensator enstehen erhebliche Störungen in der Versorgungsspannung, das Bild verdeutlicht es:

Der Widerstand in der Grundschaltung dient dazu, die Reset-Leitung konstant auf definiertem High-Pegel zu halten. Verbindet man diesen RESET-Pin später kurz mit GND (Masse), dann wird das Programm im Controller neu gestartet.

Woran merkt man, dass der Controller funktioniert?

Gute Frage! Man merkt es garnicht. Genau genommen funktioniert ja auch trotz korrekter Schaltung noch immer nichts, denn es muss zuerst ein Programm in den Controller geladen werden, damit er überhaupt weiß, was zu tun ist. Ohne Programm ist der Controller quasi tot.

Wie bekommt man das Programm in den Controller?

Der Controller verfügt über eine sogenannte ISP-Schnittstelle. Das bedeutet, über bestimmte Pins (SPI) kann der Controller mit einer geeigneten PC-Software (zum Beispiel Bascom) programmiert werden. Zum Anschluss an den PC benötigt man jedoch einen sogenannten ISP-Dongle, auch Programmieradapter genannt. Hier gibt es verschiedene Lösungen: Adapter, die über die serielle oder parallele Schnittstelle arbeiten, und zukunftsweisend auch welche, die das Programm über USB-Schnittstelle auf den Mikrocontroller übertragen. Es gibt sowohl Originale von Atmel als auch kompatible Lösungen. Der am meisten verwendete ISP-Dongle wird am Druckerport betrieben. Diese gibt es inzwischen recht preiswert, sodass sich das Selbstbauen eigentlich nicht lohnt. Da man auch gern auf ein paar Fehlerquellen verzichten sollte, würde ich eine Fertiglösung empfehlen. Wer ihn selbst bauen möchte, findet (hier eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür (AVR-ISP_Programmierkabel).

Sowas sieht dann so aus:

Der Schaltplan eines solchen Programmierkabels:

Schaltplan des ISP-Dongels nach unserem Wiki-Bauplan, mit SUB-D Buchse. Bitte beachten, dass das IC1 hier im Plan als verschiedene Blöcke (IC1A/IC1B) dargestellt wird. Dies dient nur zur Übersicht, es handelt sich nur um ein IC, einfach auf die Pinnummern achten. Zum vergrößern anklicken.

Ein noch einfacheres Programmierkabel ist auf der Seite http://thomaspfeifer.net/ beschrieben. Dort findet man unter "AVR-Projekte" den Artikel "Ein einfaches Programmierkabel für Atmel-AVR Mikrocontroller". Will man dieses Kabel verwenden, sollte man in BASCOM unter "Options/Programmer" den Programmertyp "Samples Electronic Programmer" wählen, sonst funktioniert das Autodetect, das die eingestzte Version des AVR (Mikrocontroller) erkennt nicht.

Das Problem ist nun, wie schließe ich einen handelsüblichen ISP-Programmieradapter an den Controller auf dem Steckbrett an? Der normale 10-polige Wannenstecker (nach RN-Definitionen) passt nicht in ein Steckbrett. Das ist wieder so ein typischer Nachteil bei Steckbrettern! In unserem Beispiel haben wir dazu auf einem kleinen Stück Experimentierplatine einen steckbaren Adapter für das Steckboard gelötet. Somit kann man die Schaltung um einen üblichen 10-poligen ISP-Programmieranschluss ergänzen:

Auf dem Steckbrett sieht das gleiche so aus:

Jetzt endlich ist es soweit, jetzt kann man den Controller über einen ISP-Programmieradapter mit dem PC verbinden. Aber unbedingt darauf achten, dass auch alles korrekt nach Schaltplan gesteckt wurde und dass die Betriebsspannung 5V nicht übersteigt. Ansonsten könnte man sich Dongle oder sogar die PC-Schnittstelle beschädigen. Als Entwicklungsumgebung nutzen wir hier im Tutorial Bascom. Bascom ist ein sehr beliebter Basic-Compiler, der zahlreiche AVR Controllertypen programmieren kann. Da auch ein Terminalprogramm und ein Programmer integriert ist, enthält diese PC-Software alles, was man braucht, das erleichtert den Einstieg zusätzlich. Die Software gibts kostenlos als Demo bis 4K Code, für unsere Beispiele und den Einstieg reicht das allemal, siehe dazu Artikel Bascom.

Wie man ein Programm schreibt, kompiliert und überträgt, wurde schon in diesem Beitrag Bascom - Erstes Programm in den AVR Controller übertragen ausführlich behandelt, wir ersparen uns deshalb diese Details. Man sollte aber bei Unklarheiten zum Kompilieren und Übertragen diesen Artikel auf jeden Fall lesen.

Als erstes kompilieren und übertragen wir folgendes Programm:

'###################################################
'step1.bas.BAS
'für
'RoboterNetz.de AVR Tutorial in RN-Wissen
'
'Autor: Frank Brall
'Weitere Beispiele und Beschreibung der Hardware
'unter
'  http://www.Roboternetz.de oder
'  http://www.Roboternetz.de/wissen
'#######################################################

$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 1000000

Do
Loop

End

Das Programm macht eigentlich nichts, außer dass es eine Endlosschleife ausführt. Aber da wir noch überhaupt nix am Controller angeschlossen haben, können wir eh noch nicht sehen, ob ein Programm nun richtig ausgeführt wird oder nicht. Allerdings können wir schonmal üben, das Programm mit Bascom zu übertragen. Wenn wir alles richtig aufgebaut haben und Spannung anliegt, dann sollte automatisch der Controller in Bascom erkannt werden. Die Übertragung sollte dann ohne Fehlermeldung erfolgen können. Wenn wir das geschafft haben, geht’s weiter.

Läuft die Schaltung und das Programm?

Damit wir nun endlich sehen, ob sich bei unserer Schaltung auch was tut, schließen wir eine LED über einen 1k-Vorwiderstand an einen Port an. Da wir die Kathode an den Controllerpin und die Anode an Plus legen, leuchtet die LED immer dann, wenn dieser Pin auf Low geschaltet wird.

Auf dem Steckbrett sieht's nun so aus:

Damit man nun auch wirklich sieht, ob das Programm läuft, schreiben wir ein kleines Basic-Programm, welches eine LED abwechselnd ein– und ausschaltet. Wir kompilieren und übertragen also folgendes Programm:

'###################################################
'step2.bas.BAS
'für
'RoboterNetz.de AVR Tutorial in RN-Wissen
'
'Autor: Frank Brall
'Weitere Beispiele und Beschreibung der Hardware
'unter
'  http://www.Roboternetz.de oder
'  http://www.Roboternetz.de/wissen
'#######################################################

$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 1000000

Config Portc.0 = Output       'Ein Pin wird als Ausgang konfiguriert PC0 (also Pin0 von Port C)

Do
  Portc.0 = 1                 'Pin wird auf High, also 5V geschaltet
  Waitms 100
  Portc.0 = 0                 'Pin wird auf Low, also 0V geschaltet
  Waitms 100
Loop

End

Wenn die LED nun schnell blinkt, dann funktioniert die aufgebaute Schaltung perfekt. Wir haben gleichzeitig gelernt, wie man einen Ausgangsport, also Controllerpin, ein- und ausschalten kann. Nahezu alle Pins beim ATMega32 können auf diese Weise als Ausgangsport betrieben werden. Somit lassen sich nicht nur viele Leds, sondern unter Zuhilfenahme eines Treibers (z.B. Transistors) auch Relais und andere Aktoren schalten.

Alternativ das gleiche Programm in C (für AVR-GCC):

// Testprogramm: Blinken auf Pin PC0
//
#ifndef MCU             // Welcher AVR genutzt wird, wird i.A. im Makefile definiert
#define MCU  atmega32
#endif

#ifndef F_CPU           // kann auch im Makefile definiert sein
#define F_CPU 1000000UL // Takt als LONG definieren, da zu groß für Integer 
#endif

#include <avr/io.h>     // Namen der IO Register
#include <util/delay.h> // Funktionen zum warten
// Achtung, damit delay richtig funktioniert muß mit Optimierung compiliert werden

int main(void)
{
 DDRC = _BV(0);         // Nur PC0 als output,  _BV(0) = (1<<0) = 1
 PORTC = 254;           // Pullups auf allen anderen Pins 
    
 while (1)
 { 
   PORTC &= 255-_BV(0); //  0 auf Bit 0 Ausgeben, Rest so lassen
   _delay_ms(100);      //  100 ms Warten
   PORTC |= _BV(0);     //  1 auf Bit 0 Ausgeben, Rest so lassen
   _delay_ms(100);
 }
}

Eingangsport fragt Taster ab

Nun erweitern wir die Schaltung noch um einen Taster. Nahezu jedes Port kann bei einem ATMega32 auch per Software als Eingangsport konfiguriert werden. Wir schließen z.B. einen Taster an Port-Pin PA7 an.

Das Port wird in der Software so konfiguriert, dass es als Eingang arbeitet und intern über einen hohen Widerstand (Pullup-Widerstand) ständig auf High-Pegel gelegt wird. Wird nun eine Taste gedrückt, so wird der Pegel auf Low gezogen. Das Beispielprogramm ist nun so gestaltet, dass bei gedrückter Taste die LED leuchtet und beim Loslassen wieder ausgeht.

'###################################################
'step3.bas.BAS
'für
'RoboterNetz.de AVR Tutorial in RN-Wissen
'
'Autor: Frank Brall
'Weitere Beispiele und Beschreibung der Hardware
'unter
'  http://www.Roboternetz.de oder
'  http://www.Roboternetz.de/wissen
'#######################################################


$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 1000000

Config Portc.0 = Output        'Ein Pin wird als Ausgang konfiguriert PC0 (also Pin0 von Port C)

Config Pina.7 = Input          'Ein Pin (PA0) wird als Eingang definiert
Porta.7 = 1                    'Interner Pullup Widerstand ein


Do
  If Pina.7 = 1 Then
    Portc.0 = 1                'Pin wird auf High, also 5V geschaltet
  Else
    Portc.0 = 0                'Pin wird auf Low, also 0V geschaltet
  End If
Loop


End

Grundschaltung mit Quarz

Obwohl wir ab der letzten Schaltung schon einiges mit dem Controller anfangen können, so fehlt doch noch etwas Wichtiges. Oft ist es nämlich notwendig, dass ein Controller sehr genaue Frequenzen mißt oder ganz genaue Taktraten ausgeben kann. Leider ist der interne Taktgenerator nicht 100% exakt, was bei manchen Anwendungen störend ist. Zum Beispiel können über die RS232-Schnittstelle Daten nicht immer ganz fehlerfrei übertragen werden, wenn die Taktfrequenz nicht genau stimmt. Daher wird in den meisten Anwendungsfällen ein Quarz zur Takterzeugung genutzt, Sie kennen das sicher aus anderen Grundschaltungen. Also erweitern wir unsere Schaltung gleich noch um einen Quarz mit den zugehörigen 22pF-Kondensatoren.

Auf unserem Steckbrett wird's langsam voller, hier sieht's also inzwischen so aus:

Normalerweise sollte der Quarz genauso wie die beiden 22pF-Kondensatoren, die zum Anschwingen des Quarzes dienen, möglichst nahe am Controller platziert werden. Auf dem Steckbrett ist das manchmal gar nicht so einfach, insbesondere wenn man wie in diesem Fall den Quarz erst später hinzufügt. Wichtig ist nämlich, dass die Leitungen vom Quarz zum Controller möglichst kurz sind, bei gedruckten Schaltungen oft nur 1 bis 2 cm! Auch die einzelnen Bauteilbeinchen, z.B. der Kondensatoren, sollten normalerweise so kurz wie möglich sein. Ist dies nicht der Fall, wie auch in unserem Bild, dann fungieren diese Leitungen fast wie eine Funkantenne. Dies führt in der Regel zu starken Hochfrequenzsignalen, die nicht nur unsere Schaltung, sondern auch andere Schaltungen in der Nähe stören könnten. Man merkt dies auch oft daran, dass sich ein Board bei höherer Quarzfrequenz immer seltener fehlerfrei ohne Übertragungsfehler programmieren läßt. Grundsätzlich sind daher Schaltungen mit Quarz auf einem Steckbrett nicht sonderlich zu empfehlen, die Betriebssicherheit ist nicht immer gegeben.

Auch wenn nun ein Quarz angeschlossen ist, so wird er noch immer nicht genutzt. Noch immer arbeitet der ATMega32 mit seiner intern voreingestellten 1 Mhz Taktfrequenz. Um dies umzustellen, muss man ein sogenanntes Fusebit im Controller umprogrammieren. Auch dies wurde schon im Beitrag Bascom - Erstes Programm in den AVR_Controller übertragen näher beschrieben. Hier sei daher nur nochmals gesagt, dass dies auch sehr bequem in Bascom erfolgt:

Sobald wir das umgestellt haben, müssen wir auch in dem Programm die Anweisung

$crystal = 1000000 

durch

$crystal = 16000000 

ersetzen, denn unser Quarz taktet nun mit 16 MHz.

Spannung stabilisieren

Auch wenn unsere Basis-Schaltung für Experimente inzwischen schon ganz nett ist, so ist es doch etwas ungünstig, dass wir stets 5V zur Verfügung haben müssen. Nicht immer steht ein geeignetes Netzteil zur Verfügung, zudem soll ein Controller auch oft mit Batterien versorgt werden. Aus diesem Grund verfügen fast alle Entwicklungsboards wie (RN-Control, STK500 etc.) über einen Spannungsregler.

Spannungsregler 78S05

Dieser wandelt eine höhere Eingangsspannung (ca. 7 bis 20 V) immer genau in 5V um. Sowas erhöht die Betriebssicherheit einer Schaltung nochmals immens. Als Spannungsregler (IC2) wird oft der 7805 genutzt.

Die beiden 100nF-Kondensatoren sind wichtig, sie sollen HF-Störungen und Schwingungen vermeiden. Der Elko vor dem Spannungsregler ist vor allem dann wichtig, wenn die Spannung von einem Netzgerät kommt und noch etwas geglättet werden muss. Je höher der Strombedarf der Schaltung, desto größer muss man die Kapazität wählen. Es schadet nicht, wenn man den Elko einige Nummern größer wählt, man ist dann quasi für alle Fälle gerüstet. So sind Werte zwischen 100 uF und 2200 uF durchaus denkbar.

Wir erweitern unsere Schaltung somit wie folgt:

Auf dem Steckbrett sieht's wie folgt aus:

Daten und Texte zum PC übertragen

In vielen Programmen müssen Daten oder Texte vom Controller an den PC oder umgekehrt gesendet werden. Insbesondere bei komplexen Programmen kann man auf diese Weise Variableninhalte ausgeben und somit auch Fehler im Programmcode schneller finden und korrigieren. In der Regel ist das ganz einfach, denn der Microcontroller ATMega32 verfügt über einen internen UART, also ein Modul, das Daten über die RS232-Schnittstelle zum PC senden bzw. auch von ihm empfangen kann. Leider arbeitet jedoch die Controllerschnittstelle mit 5V und die PC-Schnittstelle der Norm entsprechend mit +-12V. Daher muss unbedingt ein Schaltkreis dazwischen, welcher die Pegel anpasst. Gewöhnlich nimmt man hier das IC MAX232(CPE), welches inzwischen sehr preiswert erhältlich ist.

Wir müssen also die Schaltung nochmals erweitern.

Das IC Max232 ist im Schaltplan in der üblichen funktionsorientierten Darstellung gezeichnet. Zur besseren Übersichtlichkeit wurden die immer benötigten Anschlüsse für VCC (Pin 16) und GND (Pin 15) am MAX232 getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

Über eine dreipolige Stiftleiste (RN-Definitionen) wird nun das Steckboard mit der RS232-Schnittstelle des PC verbunden. Es ist nun ein Leichtes, mit einem Programm Daten zum PC zu senden. Das nachfolgende Programm gibt Hinweise mit der Anweisung PRINT aus:

'###################################################
'step5.bas.BAS
'für
'RoboterNetz.de AVR Tutorial in RN-Wissen
'
'Autor: Frank Brall
'Weitere Beispiele und Beschreibung der Hardware
'unter
'  http://www.Roboternetz.de oder
'  http://www.Roboternetz.de/wissen
'#######################################################


$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 16000000
$baud = 9600

Config Portc.0 = Output              'Ein Pin wird als Ausgang konfiguriert PC0 (also Pin0 von Port C)

Config Pina.7 = Input                'Ein Pin (PA0) wird als Eingang definiert
Porta.7 = 1                          'Interner Pullup Widerstand ein


Do
  If Pina.7 = 1 Then
    Portc.0 = 1                      'Pin wird auf High, also 5V geschaltet
    Print "Schalter nicht gedrückt"
  Else
    Portc.0 = 0                      'Pin wird auf Low, also 0V geschaltet
    Print "Schalter gedrückt"
  End If
  Wait 1
Loop

End

Möglichkeiten des Steckbrettes erreicht

Inzwischen füllt der Schaltplan fast ein DIN-A4-Blatt und auf dem Steckbrett sieht's auch schon recht wirr aus, dabei haben wir nur die wichtigsten Grundelemente auf dem Steckbrett. Für eine Roboter-Steuerung oder andere Anwendung fehlt doch noch einiges. Zum Beispiel weitere Taster, weitere LEDs, Motortreiber, damit der Controller auch Motoren ansteuern kann und ein I2C-Bus-Anschluss. Dies alles noch auf einem Steckbrett zu realisieren macht wenig Sinn, zumal bereits jetzt schon durch die doch recht langen Leitungen/Verkabelungen erhebliche Störungen auftreten. In der letzten Phase ist es immer öfters zu Übertragungsfehlern beim Programmieren gekommen, oft musste dies 20mal wiederholt werden. Dies zeigt, dass ein Steckbrett bestenfalls für ganz kleine Controller-Experimente herhalten kann. Für größere Dinge sollte man dann doch zu einer Lösung auf einer gedruckten Platine greifen. Spezielle Experimentierboards bieten mehr Sicherheit und haben neben den Grundelementen, die hier beschrieben wurden, noch eine ganze Menge mehr drauf. Bei RN-Control zum Beispiel 5 Tasten, 8 Leds, Motortreiber, Lautsprecher, diverse Anschlüsse etc. Der Größenunterschied wird im Bild deutlich:

Auch wenn das Steckbrett also kein Controllerboard ersetzen kann, so hat das kleine Tutorial doch gezeigt, wie eine Avr-Schaltung aufzubauen ist. Dieses Wissen sollte man auch besitzen, wenn man ein Controllerboard nutzt.

Was braucht man, wenn man mit einem Controllerboard den Einstieg startet?

ISP-Programmierkabel

Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein AVR-ISP Programmierkabel. Wenn der PC noch einen Parallelport oder RS232 Port on Board hat, kann man ein einfaches Programmierkabel nutzen. Das kann man selbst bauen oder auch fertig mitzubestellen (siehe Bild).

Wenn man nur USB zur verfügung hat, wird man den Programmer wohl kaufen müssen, denn USB-RS232 oder USB-LPT Adapter funktionieren fast nie mit den einfachen Programmern, die man gut selber bauen kann. Die Kombination aus eine USB-RS232 und einem Intelligenten Seriellen Programmer (z.B. STK500) funktioniert dagegen.

Als zweites braucht man natürlich eine Stromversorgung. Ideal sind Gleichspannungsnetzgeräte, die zwischen 9 und 12V liefern, vorausgesetzt, das Board hat einen Spannungsregler wie in der Regel die RN-Boards. Man kann hier ein normales Steckernetzteil oder ein komfortables Labornetzteil nehmen. Um etwas Reserve zu haben, wäre es gut, wenn das Netzteil mindestens 200 mA (mit Motoren besser 1 A) liefern kann. Der Controller selber baucht nur etwa 1 mA je MHz Taktfrequenz. Alternativ kann man auch Akkupacks oder Batterien nutzen, allerdings mindestens 7,2V sollten die schon liefern können, sicherer sind 8,4-, 9,6- oder 12V-Akkus. Das wäre eigentlich schon das Wichtigste, um ein Board in Betrieb zu nehmen und Experimente zu machen.

Allerdings, ein RS232-Kabel ist ebenfalls noch sehr empfehlenswert. Dieses erlaubt die Ausgabe von Texten und Variablen auf den PC, wir haben es ja oben im Steckbrettbeispiel schon gesehen. Dazu wird auf dem PC ein Terminalprogramm gestartet und über die RS232 Schnittstelle mit dem PC verbunden. Bei manchen Boards ist sowieso ein RS232 Kabel unerläßlich, wie z.B. RN-Motor, RN-Speak etc. Nützlich ist es aber überall. Man kann ein solches Kabel selbst bauen oder gleich beim Kauf eines Boardes mitbestellen.

Also nochmal die Zusammenfassung für den Einstieg:

• Controllerboard
• AVR-ISP Programmierkabel mit 10-poligem Wannenstecker
• RS-232-Kabel (mit 3-poligem Adapter, wenn Board RN-Definitionen erfüllt)
• Netzgerät oder Akku (ideal 9 bis 12V, notfalls auch 7,2 bis 20V)
• Bascom-Compiler-Vollversion ist nur nötig, wenn man gleich größere Sachen anstrebt, ansonsten reicht das Demo, genauso wie ein Avr-gcc-Compiler. Bei RN-Boards sind diese Programme beim Board- oder Platinenkauf sowieso dabei, ansonsten kann man diese im Internet downloaden.
• Ein gutes Buch ist immer gut, siehe Buchvorstellungen

Autor

• Frank

Quellen

• Abblockkondensator Artikel von Uwegw
• RN-Board Dokumentationen aus Kategorie:Projekte
• diverse Datenblätter

Siehe auch

• AVR-ISP Programmierkabel
• Mit welchem Controllerboard fang ich an
• Abblockkondensator
• Bascom
• Bascom - Erstes Programm in den AVR_Controller übertragen
• Avr
• Atmel Controller Mega16 und Mega32
• Spannungsregler
• Hallo_Welt_für_AVR_(LED_blinken)#Quellcode

Weblinks

• Neu - Video zu AVR Experimentierboard RN-AVR Universal