AVR-Einstieg leicht gemacht: Unterschied zwischen den Versionen

Version vom 29. Dezember 2005, 01:58 Uhr

Immer wieder gibt es in Foren wie dem Roboternetz Einsteiger die das erste mal mir einem Microcontroller in Berührung kommen. Trotz zahlreicher Einstiegsbeiträge im Forum wiederholen sich bestimmte Anfängerfragen immer wieder, daher soll dieser Artikel noch einmal aufzeigen, wie man den ersten Schritt tut und einen Controller zum Leben erweckt. Als Controller verwenden wir einen AVR ATMega32. Der derzeit größe 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40 Pin Gehäuse auch reichlich Anschlußmöglichkeiten besitzt.

Die Frage, ob man mit einem fertigen Controllerboard, 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 da sso ist, dazu am Ende noch ein paar Anmerkungen Dennoch soll diese Einführung schrittweise anhand eines Steckbrettes erläutert werden.

Start mit handelsüblichen Steckbrett

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

Die Nachteile von einem Steckbrett sind:

• nicht alle Bauteile passen, so das wir doch noch etwas löten müssen
• nur geringer Schaltungsumfang möglich da es schnell unübersichtlich wird
• sehr Störanfällig wegen Kabellängen

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 10k 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 den 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 Pin´s 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 das 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.

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 das man über dieses verfügt. Erwähnenswert ist noch das 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. Der Widerstand dient dazu die Reset Leitung konstant auf definierten High Pegel. Verbindet man diesen RESET Pin später kurz mit GND (Masse), dann wird das Programm im Controller neu gestartet.

Woran merkt man das der Controller funktioniert?

Gute Frage! Man merkt es garnicht. Genau genommen funktioniert ja auch trotz korrekter Schaltung noch immer nix denn es muss zuerst ein Programm in den Controller geladen werden, damit er überhaupt weiss 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 Pin´s (SPI) kann der Controller mit einer geeigneten PC-Software (zum Beispiel Bascom) programmiert werden. Zum Anschluß an den PC benötigt man jedoch einen sogenannten ISP-Dongel oder auch Programmieradapter genannt. Hier gibt es verschiedene Lösungen, serielle und parallele Adapter. Original von Atmel oder kompatible Lösungen. Der am meisten verwendetet ISP-Dongel wird am Druckerport betrieben. Diese gibt es inzwischen recht preiswert, so das 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-Dongel Bauanleitung und sogar eine fertige Platine dafür (AVR-ISP_Programmierkabel).

Sowas sieht dann so aus:

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) paßt 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-Programmieranschluß ergänzen:

Auf dem Steckbrett sieht das gleiche so aus:

Jetzt endlich ist es soweit, jetzt kann man den Controller über ein ISP-Programmieradapter mit dem PC verbinden. Aber unbedingt darauf achten das auch alles korrekt nach Schaltplan gesteckt wurde und das die Betriebsspannung 5V nicht übersteigt. Ansonsten könnte man sich Dongel 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 gibt’s kostenlos als Demo bis 4K Code, für unsere Beispiele und den Einstieg reich das allemal, siehe dazu Artikel Bascom. Wie man ein Programm schreibt, compiliert 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.

Als erstes compilieren 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 das 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 ausgebaut 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 siehts 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 compilieren 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 aus 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 Pin´s beim ATMega32 können auf diese Weise als Ausgangsport betrieben werden. Somit alssen sich nicht nur viele Led´s, sondern unter Zuhilfenahme eines Treibers (z.B-Transistors) auch Relais und andere Aktoren schalten.

Eingangsport fragt Taster ab

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

Der Port wird in der Software so konfiguriert, das er als Eingang arbeitet und indern ü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 das bei gedrückter Taste die LED leuchtet und bei, loslassen wieder aus geht.

'###################################################
'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 aus 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 was wichtiges. Oft ist es nämlich wichtig das ein Controller sehr genaue Frequenzen messen 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 siehts also inzwischen so aus:

Normalerweise sollte der Quarz genauso wie die beiden 22pF Kondensatoren möglichst nahe am Controller plaziert werden. Auf dem Steckbrett ist das manchmal garnicht so einfach insbesondere wenn man wie in diesem fall den Quarz erst später hinzufügt. Wichtig ist nämlich das die Leitungen vom Quarz zum Controller möglichst kurz sind, bei gedruckten Schaltungen oft nur 1 bis 2 cm! Ist dies nicht der Fall, wie auch in unserem Bild, dann fungieren quasi diese Leitungen fast wie eine Funkantenne. Dies führt also zu starken Hochfrequenzsignalen die nicht nur unsere Schaltung sondern auch andere Schaltungen in der Nähe stören könnten. 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 arbeiten 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 das 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 unser Basis-Schaltung für Experimente inzwischen schon ganz nett ist, so ist es doch etwas ungünstig das 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 fas alle Entwicklungsboards wie (RN-Control, STK500 etc.) über einen Spannungsregler. 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. Wir erweitern unsere Schaltung somit wie folgt:

Auf dem Steckbrett siehts 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 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 anpaßt. Gewöhnlich nimmt man hier das IC MAX232, welches inzwischen sehr preiswert erhältlich ist.

Wir müssen also die Schaltung nochmals erweitern:

Auf dem Steckbrett siehts 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 aus 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 siehts auch schon recht wirr aus, dabei haben wir nur die wichtigsten Grundelemente auf dem Board. Für eine Roboterr-Steuerung oder andere Anwendung fehlen doch noch einiges. Zum Beispiel weitere tastet, weitere LED´s, Motortreiber damit der Controller auch Motoren ansteuern und I2C-Bus Anschuß. Dies alles noch auf einem Steckbrett zu realisieren macht wenig Sinn, zumal bereits jetzt schon durch die doch recht langen Leitungen/Verkabelungen erhebliche Steuerungen auftreten. In der letzten Phase ist es immer mehr zu Übertragungsfehlern beim programmieren gekommen, oft mußte es 20 mal wiederholt werden. Dies zeigt das ein Steckbrett bestenfalls ganz kleine Controller-Experimente. Für Größere Dinge sollte man dann doch zu einer Lösung auf einer gedruckten Platine greifen. Spezielle Experimentierboard´s 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. Das war Ziel dieses Artikels.

Autor

• Frank

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