RN-Wissen.de - Benutzerbeiträge [de]

LCD-Modul am AVR

2009-06-12T13:12:38Z

Ratzfatz: /* 4-Bit Ansteuerung mit Busy(I/O Mode) */

[[Bild:lcdmodul_2.jpg|right|thumb|350px|LCD-Modul]]

==Einleitung==

LCD ist eine Abkürzung und bedeutet '''''L'''iquid '''C'''rystal '''D'''isplay''. Übersetzt bedeutet dies Flüssigkristall-Anzeige. Flüssigkristalle sind organische Verbindungen, die Eigenschaften von Flüssigkeiten und Festkörpern besitzen. Zwischen zwei Glasplatten mit Polarisationsfiltern schwimmen die Flüssigkristalle. Durch Anlegen einer Wechselspannung ändert sich die Polarisationsebene der Flüssigkristalle und damit, ob das einfallende Licht reflektiert oder absorbiert wird.

Bei einem LCD-Modul befindet sich neben dem LCD auch ein Controller zur Ansteuerung des LCDs.

==Text-Displays==

Text-Displays kommen wegen der problemlosen Anbindung in Mikrocontroller Projekten wie Robotern am häufigsten zum Einsatz. Bei Text-LCDs kommen meistens der HD44780 von Hitachi oder ein kompatibler Controller zum Einsatz. Dieser Controller unterstützt Displays mit bis zu 80 Zeichen. Gängige Displaygrößen sind: 8 × 1, 8 × 2, 16 × 1, 16 × 2, 20 × 2, 20 × 4, 40 × 2 Zeichen Displays (Spalten × Zeilen). Hat das Display mehr als 80 Zeichen, dann benötigt das Display 2 Controller und verhält sich nach außen zur Ansteuerung, wie 2 Displays (zusätzliche Enable Leitung)

===Anschlußbelegung für ≤80 Zeichen Displays===

Text-Displays verfügen über genormte 14 Anschluss Pins (LCD-Module mit Backlight über 16 Pins). Lediglich bei der Backlight Versorgungsspannung und Polung kann es Unterschiede geben. Im Zweifelsfall hilft hier der Blick ins Datenblatt. Entweder sind die Anschlüsse in einer Reihe (1 × 14(16)) oder zweireihig (2 × 7(8)) herausgeführt.

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Pin'''
|'''Bezeichnung'''
|'''Beschreibung'''
|-
|1
|GND
|Masse
|---
|2
|VCC
|Spannungsversorgung +5V
|---
|3
|VEE
|Kontrast Poti 0..0,5V
|---
|4
|RS
|Register Select, 1=Daten schreiben / 0=Kommando senden.
|---
|5
|R/W
|1=Read / 0=Write zum lesen / schreiben in das Display RAM
|---
|6
|Enable
|Fallende Flanke -> Übertragen des Kommandos oder der Daten, H-Pegel -> Lesen von Daten aus dem Display
|---
|7
|DB0
|Datenbus Bit0 LSB
|---
|8
|DB1
|Datenbus Bit1
|---
|9
|DB2
|Datenbus Bit2
|---
|10
|DB3
|Datenbus Bit3
|---
|11
|DB4
|Datenbus Bit4
|---
|12
|DB5
|Datenbus Bit5
|---
|13
|DB6
|Datenbus Bit6
|---
|14
|DB7
|Datenbus Bit7 MSB
|}

===HD44780 kompatibler LCD Controller===

Der HD44780 LCD Controller besitzt 3 Speicher. Den DDRAM (Display Data RAM) Darin werden die anzuzeigenden Daten geschrieben.
Der CGROM (Character Generator ROM) enthält die Zeichen in Form von 5x8 oder 5x10 Punktmatrizen.
Im CGRAM (Character Generator RAM) können acht benutzerdefinierte Zeichen 5x8 Pixel oder vier 5x10 Pixel abgelegt werden.

====Befehlsübersicht====

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Befehl'''
| '''RS'''
| '''R/W'''
| '''DB7'''
| '''DB6'''
| '''DB5'''
| '''DB4'''
| '''DB3'''
| '''DB2'''
| '''DB1'''
| '''DB0'''
| '''Beschreibung'''
| '''Ausführungszeit bei f<sub>osc</sub>=250kHz'''
|-
|Clear Display
|0
|0
|0
|0
|0
|0
|0
|0
|0
|1
|Löscht das Display und setzt den Cursor auf den Anfang der 1. Zeile (Addresse 0).
|1.64mS
|-
|Cursor Home
|0
|0
|0
|0
|0
|0
|0
|0
|1
|*
|setzt den Cursor auf das Anfang der 1. Zeile (Addresse 0)
|1.64mS
|-
|Entry mode set
|0
|0
|0
|0
|0
|0
|0
|1
|I/D
|S
|Setzt die Cursor Bewegungsrichtung (I/D), spezifiziert das Display zu schieben (S). Diese Operationen werden während des Daten lesen/schreiben durchgeführt.
|40uS
|-
|Display on/off Control
|0
|0
|0
|0
|0
|0
|1
|D
|C
|B
|Schaltet an/aus: das gesamte Display (D), Den Cursor (C) Cursor blinken (B).
|40uS
|-
|Cursor/Display shift
|0
|0
|0
|0
|0
|1
|S/C
|R/L
|*
|*
|Setzt Cursor Bewegung oder Display Bewegung (S/C), Bewegungsrichtung (R/L)
|40uS
|-
|Function set
|0
|0
|0
|0
|1
|DL
|N
|F
|*
|*
|Einstellen der Schnittstellen Datenlänge (DL), Anzahl Display Zeilen (N) und Zeichen Font (F).
|40uS
|-
|Set CGRAM Address
|0
|0
|0
|1
|colspan=6 |CGRAM Adresse
|Setzen der CGRAM Adresse. CGRAM Daten werden gesendet und empfangen nach dem setzen.
|40uS
|-
|Set DDRAM Address
|0
|0
|1
|colspan=7 |DDRAM Adresse
|Setzen der DDRAM Adresse. DDRAM Daten werden gesendet und empfangen nach dem setzen.
|40uS
|-
|Read busy-flag and address counter
|0
|1
|BF
|colspan=7 |CGRAM / DDRAM Adresse
|Liest das Busy-flag (BF), welches anzeigt das interne Operationen ausgeführt werden, und liest den CGRAM oder DDRAM Adress Zeiger Inhalt.
|0uS
|-
|Write to CGRAM or DDRAM
|1
|0
|colspan=8 |Schreib Daten
|Schreibt Daten zum CGRAM oder DDRAM.
|40uS
|-
|read from CGRAM or DDRAM
|1
|1
|colspan=8 |Lese Daten
|Liest Daten vom CGRAM oder DDRAM.
|40uS
|}

Anmerkungen:
* DDRAM = Display Data RAM.
* CGRAM = Character Generator RAM.
* DDRAM Adresse entspricht der Cursor Position.
* * = egal.

{|{{Blauetabelle}}
|-{{Hintergrund1}}
|'''Bit Name'''
|'''Einstellung / Status'''
|
|-
|I/D
|0 = Erniedrige Cursor Position
|1 = Erhöhe Cursor Position
|-
|S
|0 = Display nicht schieben
|1 = Display schieben
|-
|D
|0 = Display aus
|1 = Display an
|-
|C
|0 = Cursor aus
|1 = Cursor an
|-
|B
|0 = Cursor blinken aus
|1 = Cursor blinken an
|-
|S/C
|0 = Bewege Cursor
|1 = Schiebe Display
|-
|R/L
|0 = Schiebe nach links
|1 = Schiebe nach rechts
|-
|DL
|0 = 4-bit Interface
|1 = 8-bit Interface
|-
|N
|0 = 1/8 oder 1/11 Duty (1 Zeile)
|1 = 1/16 Duty (2 Zeilen)
|-
|F
|0 = 5x7 Punkte
|1 = 5x10 Punkte
|-
|BF
|0 = Befehle werden akzeptiert
|1 = Interne Operation wird ausgeführt
|}

===8-Bit Ansteuerung (Busmode)===

Für die 8-Bit Busmode Ansteuerung funktioniert nur bei AVR Prozessoren mit externem Bus Interface. Diesen Mode unterstützen allerdings nur die wenigsten Atmel AVR Prozessoren, z.B. der AT90S8515 und ATmega128. Der Busmode empfiehlt sich, wenn man in der Applikation auch externen Speicher verwendet.

[[Bild:lcdmodul_8bit_schem.png|center|thumb|600px|8-Bit Ansteuerung. Quelle: Peter Fleury]]

====BASCOM-AVR Programm====
Das Programm zur Ansteuerung des Displays im 8-Bit Bus Mode.
<pre>
$regfile = "8515def.dat"
$crystal = 4000000
$lcd = &HC000 'Adresse LCD Daten
$lcdrs = &H8000 'Adresse LCD Register select

Config Lcdbus = 8 'LCD im 8-Bit Bus Mode
Config Lcd = 16 * 2 'wir verwenden ein 16 x 2 Zeichen Display

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

Das Programm zur Ansteuerung des Displays im 8-Bit Bus Mode. Verwendet wird die lcdlibrary von Peter Fleury.

Folgende Einstellungen sind für obiges Beispiele in der Header Datei lcd.h vorzunehmen:

<pre>
...

/**
* @name Definitions for MCU Clock Frequency
* Adapt the MCU clock frequency in Hz to your target.
*/
#define XTAL 4000000 /**< clock frequency in Hz, used to calculate delay timer */

/**
* @name Definition for LCD controller type
* Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
*/
#define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/**
* @name Definitions for Display Size
* Change these definitions to adapt setting to your display
*/
#define LCD_LINES 2 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 16 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */

#define LCD_IO_MODE 0 /**< 0: memory mapped mode, 1: IO port mode */
#if LCD_IO_MODE
...
#elif defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || defined(__AVR_ATmega64__) || \
defined(__AVR_ATmega8515__)|| defined(__AVR_ATmega103__) || defined(__AVR_ATmega128__) || \
defined(__AVR_ATmega161__) || defined(__AVR_ATmega162__)
/*
* memory mapped mode is only supported when the device has an external data memory interface
*/
#define LCD_IO_DATA 0xC000 /* A15=E=1, A14=RS=1 */
#define LCD_IO_FUNCTION 0x8000 /* A15=E=1, A14=RS=0 */
#define LCD_IO_READ 0x0100 /* A8 =R/W=1 (R/W: 1=Read, 0=Write */
#else
#error "external data memory interface not available for this device, use 4-bit IO port mode"

#endif

...
</pre>

So sieht das Programmbeispiel in AVR-GCC aus:

<pre>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"

int main(void)
{

/* Initialisiere Display, Cursor aus */
lcd_init(LCD_DISP_ON);

/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
lcd_clrscr();

/* String auf Display anzeigen */
lcd_puts("Hello world.");

...
</pre>

===4-Bit Ansteuerung mit Busy(I/O Mode)===

Mit die häufigste Anbindungsart ist sicher die 4-Bit Ansteuerung. Dabei werden die Display-Daten Nibble-weise in den Display Speicher übertragen. Das ist zwar etwas langsamer als im 8-Bit Mode, das spielt aber kaum eine Rolle. Für diese Ansteuerung werden 7 Prozessor Ports benötigt. Die Abfrage des Busy Flags ist durch die Verdrahtung des R/W Pins möglich.

[[Bild:lcdmodul_4bitbusy_schem.png|center|thumb|600px|4-Bit Ansteuerung mit Busy]]
Anmerkung: Unbenutzte Pins des Datenports vom LCD sollten auf GND gelegt werden, da sie ansonsten auf keinen definierten Pegel liegen und Störsignale empfangen.

Hier ein [http://picasaweb.google.de/lh/photo/7xU12-9CwCJUXh5XCC7LsQ?authkey=Gv1sRgCI3H2aul1-TmNg&feat=directlink Beispielaufbau] auf einem Steckboard.

====BASCOM-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode benötigt einer spezielle LCD Bibliothek, die 'lcd4busy.lib'. Leider müssen bei der Verwendung dieser Bibliothek alle Pins des LCD Modul an den selben Prozessor Port angeschlossen werden.
<pre>
$lib "lcd4busy.lib" 'ersetzt die Standard LCD Bibliothek
$regfile = "m32def.dat"
$crystal = 16000000

Config Lcd = 20 * 4 'wir verwenden ein 4 x 20 Zeichen Display
Const _lcdport = Portc
Const _lcdddr = Ddrc
Const _lcdin = Pinc
Const _lcd_e = 1
Const _lcd_rw = 2
Const _lcd_rs = 3

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode. Verwendet wird die lcdlibrary von Peter Fleury.

Folgende Einstellungen sind für obiges Beispiele in der Header Datei lcd.h vorzunehmen:

<pre>
...

/**
* @name Definitions for MCU Clock Frequency
* Adapt the MCU clock frequency in Hz to your target.
*/
#define XTAL 16000000 /**< clock frequency in Hz, used to calculate delay timer */

/**
* @name Definition for LCD controller type
* Use 0 for HD44780 controller, change to 1 for displays with KS0073 controller.
*/
#define LCD_CONTROLLER_KS0073 0 /**< Use 0 for HD44780 controller, 1 for KS0073 controller */

/**
* @name Definitions for Display Size
* Change these definitions to adapt setting to your display
*/
#define LCD_LINES 4 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 20 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 0 /**< 0: no wrap, 1: wrap at end of visibile line */

#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */
#if LCD_IO_MODE
/**
* @name Definitions for 4-bit IO mode
* Change LCD_PORT if you want to use a different port for the LCD pins.
*
* The four LCD data lines and the three control lines RS, RW, E can be on the
* same port or on different ports.
* Change LCD_RS_PORT, LCD_RW_PORT, LCD_E_PORT if you want the control lines on
* different ports.
*
* Normally the four data lines should be mapped to bit 0..3 on one port, but it
* is possible to connect these data lines in different order or even on different
* ports by adapting the LCD_DATAx_PORT and LCD_DATAx_PIN definitions.
*
*/
#define LCD_PORT PORTC /**< port for the LCD lines */
#define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN 4 /**< pin for 4bit data bit 0 */
#define LCD_DATA1_PIN 5 /**< pin for 4bit data bit 1 */
#define LCD_DATA2_PIN 6 /**< pin for 4bit data bit 2 */
#define LCD_DATA3_PIN 7 /**< pin for 4bit data bit 3 */
#define LCD_RS_PORT LCD_PORT /**< port for RS line */
#define LCD_RS_PIN 3 /**< pin for RS line */
#define LCD_RW_PORT LCD_PORT /**< port for RW line */
#define LCD_RW_PIN 2 /**< pin for RW line */
#define LCD_E_PORT LCD_PORT /**< port for Enable line */
#define LCD_E_PIN 1 /**< pin for Enable line */
...
</pre>

So sieht das Programmbeispiel in AVR-GCC aus:

<pre>
#include <stdlib.h>
#include <avr/io.h>
#include "lcd.h"

int main(void)
{

/* Initialisiere Display, Cursor aus */
lcd_init(LCD_DISP_ON);

/* loesche das LCD Display und Cursor auf 1 Zeile, 1 Spalte */
lcd_clrscr();

/* String auf Display anzeigen */
lcd_puts("Hello world.");

...
</pre>

===4-Bit Ansteuerung ohne Busy(I/O Mode)===

Mit die häufigste Anbindungsart ist sicher die 4-Bit Ansteuerung. Dabei werden die Display-Daten Nibble-weise in den Display Speicher übertragen. Das ist zwar etwas langsamer als im 8-Bit Mode, das spielt aber kaum eine Rolle. Für diese Ansteuerung werden 6 Prozessor Ports benötigt. Die R/W Leitung des Displays kann man dabei einfach auf GND legen, dann ist aber keine Busy-Bit Abfrage möglich.

[[Bild:lcdmodul_4bit_schem.png|center|thumb|600px|4-Bit Ansteuerung]]

====BASCOM-AVR Programm====

Das Programm zur Ansteuerung des Displays im 4-Bit I/O Mode.
<pre>
$regfile = "m32def.dat"
$crystal = 16000000

Config Lcd = 20 * 4 'wir verwenden ein 4 x 20 Zeichen Display
' Im I/O Mode wird jeder Prozessor Pin einzeln angegeben
Config Lcdpin = Pin , Db4 = Portc.0 , Db5 = Portc.1 , Db6 = Portc.2 , Db7 = Portc.3 , E = Portc.5 , Rs = Portc.4

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über Porterweiterung===

Mit einem Porterweiterungs Baustein wie dem 74HC595 lassen sich weitere Prozessor-Ports einsparen. Diese Lösung kommt mit 4 Prozessor Ports aus, läßt man die Abfrage des Busy-Bits (PC5) weg, sogar nur mit 3 Prozessor Ports. Trotzdem wird das Display im 8-Bit Mode betrieben.

[[Bild:lcdmodul_portexp_schem.png|center|thumb|600px|Ansteuerung über Porterweiterung]]

====BASCOM-AVR Programm====

Das BASCOM Programm für diese Ansteuerung ist nicht ganz so einfach, da es nicht von der BASCOM Library unterstützt wird. Die Routinen zum Ansprechen des Displays muß man selbst coden.

<pre>

TODO....

</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über I²C===

Nur 2 Prozessor Ports benötigt man bei der I²C-Ansteuerung. Dazu wird als I²C Porterweiterungs IC der PCF8574P benötigt.

[[Bild:lcdmodul_i2c_schem.png|center|thumb|600px|I²C-Ansteuerung]]

====BASCOM-AVR Programm====
Diese Ansteuerung basiert auf der Application Note AN#118 von MCS electronics. Dazu gibt es auch eine fertige Library zu BASCOM-AVR, die die Standard LCD Library ersetzt. Dadurch können die gleichen Befehle zur Ansteuerung verwendet werden wie bei der Standard LCD Library. Das BASCOM-AVR Programm, um das LCD-Modul über I²C anzusprechen, sieht dann so aus.
<pre>
$lib "Lcd_i2c.lib" 'ersetzt die Standard LCD Library
$regfile = "m32def.dat"
$crystal = 16000000

Const Pcf8574_lcd = &H40 'I2C Adresse
Config Scl = Portc.0 'I2C SCL Pin
Config Sda = Portc.1 'I2C SDA Pin
Dim _lcd_e As Byte
_lcd_e = 128 'LCD im 4-Bit Mode betreiben

Cls 'loesche das LCD Display
Locate 1 , 1 'Cursor auf 1 Zeile, 1 Spalte
Lcd "Hello world." 'String auf Display anzeigen

...
</pre>

====AVR-GCC Programm====

<pre>

TODO....

</pre>

===Ansteuerung über RS232===

Ebenfalls nur 2 Pins zur Ansteuerung benötigt die Lösung. Allerdings ist die serielle Schnittstelle bei Mikrocontrollern oft schon mit anderen Aufgaben belegt. Deshalb befindet sich meistens noch zusätzlich eine I²C-Bus Schnittstelle zur Ansteuerung auf dem Modul.

==Graphik-Displays==

In Mikrocontroller-Anwendungen werden seit neuestem, einhergehend mit der größeren Verbreitung von Controllern mit mehr Speicherplatz, auch immer öfter Grafik-Displays und Farb-TFTs eingesetzt. Der Aufwand an Software und Hardware ist hier allerdings um einiges höher (jedes Pixel ist einzeln anzusteuern).

==LCD über RN LCD Adapter Std an RN-Control==

Hierbei handelt es sich um eine Beispielansteuerung eines LCD über RN LCD Adapter Std an RN-Control in C.

Komfortabel lässt sich ein LCD in C mit der LCD Library von Peter Fleury ansteuern (LCD Controller HD44780 & KS0073).
Die Library selbst sowie deren Online Dokumentation und weiterführende informationen sind von [http://jump.to/fleury Peter Fleury's Home Page]zu entnehmen.

Im hier aufgeführten Beispiel wird ein Crystalfontz 20x4 LCD verwendet (CFAH2004A-YYH-JPE).

Pinbelegung nach [http://www.crystalfontz.com/product/CFAH2004AYYHJPE.html Datenblatt]
<pre>
Pin No. Symbol Level Description
1 VSS 0V Ground
2 VDD 5.0V Supply Voltage for logic
3 VO (Variable) Operating voltage for LCD
4 RS H/L H: DATA, L: Instruction code
5 R/W H/L H: Read(MPU?Module) L: Write(MPU?Module)
6 E H,H?L Chip enable signal
7 DB0 H/L Data bit 0
8 DB1 H/L Data bit 1
9 DB2 H/L Data bit 2
10 DB3 H/L Data bit 3
11 DB4 H/L Data bit 4
12 DB5 H/L Data bit 5
13 DB6 H/L Data bit 6
14 DB7 H/L Data bit 7
15 A - LED +
16 K - LED -
</pre>

Pinbelegung des LCD Adapters nach [http://www.robotikhardware.de/download/rn_LCD_adapter_std.pdf Datenblatt]
<pre>
Pin 1 LCD DB7
Pin 2 LCD DB6
Pin 3 LCD DB5
Pin 4 LCD DB4
Pin 5 Licht ein/aus per Port (da EN2 hier nicht benötigt wird)
Pin 6 LCD EN
Pin 7 LCD R/W
Pin 8 LCD RS
Pin 9 GND LCD GND und Licht Kathode
Pin 10 +5V LCD VCC und Licht Anode
</pre>

Berücksichtigt man die folgenden Tatsachen:
* ATMega32 auf dem RN-Control stellt kein "external memory interface" zur Verfügung, daher ist ohne Weiteres keine 8-Bit Ansteuerung des LCD möglich. Es wird 4-Bit I/O verwendet
* die Zählweise der Pins beginnt in lcd.h bei 0, nicht bei 1
* der LCD Adapter ist mit PORTC des RN Control verbunden (Vorteil: an den LEDs von PORTC kann erkannt werden, ob überhaupt Daten an das LCD gesendet werden)
* der Controler im LCD ist ein SPLC780D, welcher mit dem in lcd.h genutzten HD44780 kompatibel ist
müssen die nachfolgenden Zeilen in lcd.h entsprechend angepasst werden.

<pre>
#define XTAL 16000000 /**< clock frequency in Hz, used to calculate delay timer */
</pre>
Die DDRAM Adressen der einzelnen Zeilen sind im Datenblatt hinterlegt. Zeile 1 und 3 sowie 2 und 4 bilden intern je eine Zeile.
Der manuelle Zeilenumbruch am Ende des Codeblocks bleibt Geschmacksache.
<pre>
#define LCD_LINES 4 /**< number of visible lines of the display */
#define LCD_DISP_LENGTH 20 /**< visibles characters per line of the display */
#define LCD_LINE_LENGTH 0x40 /**< internal line length of the display */
#define LCD_START_LINE1 0x00 /**< DDRAM address of first char of line 1 */
#define LCD_START_LINE2 0x40 /**< DDRAM address of first char of line 2 */
#define LCD_START_LINE3 0x14 /**< DDRAM address of first char of line 3 */
#define LCD_START_LINE4 0x54 /**< DDRAM address of first char of line 4 */
#define LCD_WRAP_LINES 1 /**< 0: no wrap, 1: wrap at end of visibile line */
</pre>
4-Bit I/O Mode wird verwendet.
<pre>
#define LCD_IO_MODE 1 /**< 0: memory mapped mode, 1: IO port mode */
</pre>
Wie oben angedeutet werden die Pins von 0 an gezählt. "LCD_DATA3_PIN 0" ist somit Pin 1 des LCD Adapters.
<pre>
#define LCD_PORT PORTC /**< port for the LCD lines */
#define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */
#define LCD_DATA1_PORT LCD_PORT /**< port for 4bit data bit 1 */
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */
#define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */
#define LCD_DATA0_PIN 3 /**< pin for 4bit data bit 0 */
#define LCD_DATA1_PIN 2 /**< pin for 4bit data bit 1 */
#define LCD_DATA2_PIN 1 /**< pin for 4bit data bit 2 */
#define LCD_DATA3_PIN 0 /**< pin for 4bit data bit 3 */
#define LCD_RS_PORT LCD_PORT /**< port for RS line */
#define LCD_RS_PIN 7 /**< pin for RS line */
#define LCD_RW_PORT LCD_PORT /**< port for RW line */
#define LCD_RW_PIN 6 /**< pin for RW line */
#define LCD_E_PORT LCD_PORT /**< port for Enable line */
#define LCD_E_PIN 5 /**< pin for Enable line */
</pre>

Testprogramm:
<pre>
#include <stdlib.h>
#include <avr/io.h>
#include <lcd.c>

int main(void)
{

lcd_init(LCD_DISP_ON_CURSOR_BLINK);
lcd_clrscr();
lcd_puts("test");

return 0;
}
</pre>

==Siehe auch==

* [[Bascom_und_LCD%27s|BASCOM und LCD's]]
* [[Portexpander_am_AVR|Portexpander am AVR]]
* [[AVR]]
* [[I2C|I²C-Bus]]

==Weblinks==

* [http://www.mcselec.com/index.php?option=com_content&task=view&id=82&Itemid=57 MCS electronics AN #118] - I²C LCD and Keyboard library
* [http://jump.to/fleury Peter Fleury's Homepage] - Interfacing a HD44780 Based LCD to an AVR, LCD library for HD44870 based LCD's
* [http://www.display3000.com Display3000 Homepage] - Verkaufen Farb-TFTs und TFT-Komplettlösungen inkl. Bascom und GCC (WinAVR) Ansteuerung und div. Utilities

==Autore(en)==

[[Benutzer:m_a_r_v_i_n|m a r v i n]]

[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Quellcode_Bascom]]
[[Kategorie:Quellcode_C]]

AVR-Einstieg leicht gemacht

2009-06-11T13:22:45Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

AVR-Einstieg leicht gemacht

2009-06-11T13:16:54Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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".

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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

AVR-Einstieg leicht gemacht

2009-06-11T13:15:46Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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.]]

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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

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".

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

AVR-Einstieg leicht gemacht

2009-06-11T13:15:16Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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.]]

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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

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".

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

AVR-Einstieg leicht gemacht

2009-06-11T13:14:28Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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.]]

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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

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".

Im Bascom stellt man, um mit diesen einfachen Programmierkabeln zu arbeiten folgendes ein:
Unter "Options/Programmer" wird "STK200/STK300 Programmer" eingestellt, wenn es nicht schon so da steht.

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

AVR-Einstieg leicht gemacht

2009-06-11T13:07:58Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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.]]

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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

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".

Im Bascom stellt man, um mit diesen einfachen Programmierkabeln zu arbeiten folgendes ein:
Unter "Options/Programmer" wird "STK200/STK300 Programmer" eingestellt, wenn es nicht schon so da steht.

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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.

Als erstes kompilieren und übertragen wir folgendes Programm:
Das Kompilieren geht in BASCOM mit der Taste F7 oder dem entsprechenden ICON.

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

AVR-Einstieg leicht gemacht

2009-06-11T12:48:49Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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.]]

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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

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".

Im Bascom stellt man, um mit diesen einfachen Programmierkabeln zu arbeiten folgendes ein:
Unter "Options/Programmer" wird "Sample Electronics Programmer" eingestellt, wenn es nicht schon so da steht.

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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.

Als erstes kompilieren und übertragen wir folgendes Programm:

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

AVR-Einstieg leicht gemacht

2009-06-11T12:47:45Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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.]]

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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

Ein noch einfacheres Programmierkabel ist auf der Seite http://thomaspfeifer.net/ beschrieben.
Dort gibts es unter "AVR-Projekte" den Artikel "Ein einfaches Programmierkabel für Atmel-AVR Mikrocontroller".

Im Bascom stellt man, um mit diesen einfachen Programmierkabeln zu arbeiten folgendes ein:
Unter "Options/Programmer" wird "Sample Electronics Programmer" eingestellt, wenn es nicht schon so da steht.

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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.

Als erstes kompilieren und übertragen wir folgendes Programm:

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]

AVR-Einstieg leicht gemacht

2009-06-11T12:45:30Z

Ratzfatz: /* Wie bekommt man das Programm in den Controller? */

[[Bild:avr8.jpg|thumb|300px|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 erstemal 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 man den ersten Schritt tut und einen Controller zum Leben erweckt. Es werden verschiedene Grundschaltungen aufgezeigt und erläutert, welche Bauteile welche Funktion 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. 6-7 Euro noch sehr günstig ist und zudem mit seinem 40-Pin-Gehäuse reichlich Anschlussmöglichkeiten besitzt.

[[Bild:Mega1632.gif|center]]

Wie auf dem Bild zu sehen, 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 3 bis 4 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:

[[Bild:avrtutorial_steckbrettmega32.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_mega32.gif|center|500px]]

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:

[[Bild:avrtutorial_steckbrett1.jpg|center]]

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:

[[Bild:Abblockkondensator OhneC amAVR.jpg|center]]

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 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 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, serielle und parallele Adapter. Original von Atmel oder 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 ([[AVR-ISP_Programmierkabel|hier]] eine ISP-Dongle-Bauanleitung und sogar eine fertige Platine dafür ([[AVR-ISP_Programmierkabel]]).

Sowas sieht dann so aus:

[[Bild:Avrtutorial_ispkabel.jpeg|center]]

Der Schaltplan eines solchen Programmierkabels:

[[Bild:ispschaltplan.gif|center|thumb|400px|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.]]

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:

[[Bild:avrtutorial_grundschaltung_mitisp.gif|center|500px]]

Ein noch einfacheres Programmierkabel ist auf der Seite http://thomaspfeifer.net/ beschrieben.

Im Bascom stellt man, um mit diesen einfachen Programmierkabeln zu arbeiten folgendes ein:
Unter "Options/Programmer" wird "Sample Electronics Programmer" eingestellt, wenn es nicht schon so da steht.

Auf dem Steckbrett sieht das gleiche so aus:

[[Bild:avrtutorial_steckbrett_mitisp.jpg|center]]

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.

Als erstes kompilieren und übertragen wir folgendes Programm:

<pre>
'###################################################
'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
</pre>

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.

[[Bild:avrtutorial_grundschaltung_mitled.gif|center|500px]]

Auf dem Steckbrett sieht's nun so aus:

[[Bild:avrtutorial_steckbrett_mitled.jpg|center]]

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:

<pre>
'###################################################
'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
</pre>

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.

==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.

[[Bild:avrtutorial_grundschaltung_mittaster.gif|center|500px]]

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.

<pre>
'###################################################
'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
</pre>

==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.

[[Bild:avrtutorial_grundschaltung_mitquarz.gif|center|500px]]

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

[[Bild:avrtutorial_steckbrett_mitquarz.jpg|center|500px]]

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 [[Fusebits|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:

[[Bild:avrtutorial_bascomfusebitquarz.gif|center]]

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]].
[[Bild:78s05.jpg|thumb|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, empfehlenswert ist der Typ 78S05, welcher 2A verträgt sowie über einen Kurzschluss- und Überlastungsschutz verfügt.
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 kann 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:

[[Bild:avrtutorial_grundschaltung_spannung.gif|center|500px]]

Auf dem Steckbrett sieht's wie folgt aus:

[[Bild:avrtutorial_steckbrett_spannung.jpg|center]]

==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.

[[Bild:avrtutorial_grundschaltung_max232.gif|center|500px]]

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) getrennt oben rechts im Schaltplan dargestellt. Also nicht vergessen !!

Auf dem Steckbrett sieht's so aus:

[[Bild:avrtutorial_steckbrett_max232.jpg|center|500px]]

Ü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:

<pre>
'###################################################
'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
</pre>

==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:

[[Bild:avrtutorial_steckbrett_rncontrol.jpg|center|500px]]

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?==

[[Bild:avrtutorial_ispkabel.jpg|thumb|ISP-Programmierkabel]]Neben dem eigentlichen Board braucht man, wie schon zuvor angesprochen, ein [[AVR-ISP Programmierkabel]]. Da das Selbstbauen kaum billiger ist, ist zu empfehlen, ein solches fertig mitzubestellen. Am preiswertesten und zugleich vielseitigsten sind die ISP-Adapter, die man an das Druckerport anschließt (siehe Bild). Es gibt aber auch USB-Lösungen, wobei diese jedoch oft teuer sind und auch oft weniger Controller programmieren können. Hat man jedoch einen PC oder Notebook ohne parellelen Druckeranschluss, so muss man wohl oder übel in den meisten Fällen zu einem seriellen oder USB-Programmieradapter greifen. Neben den erwähnten Nachteilen hat der USB Dongle aber oft auch den Vorteil, dass er etwas schneller ist. Dieser Unterschied macht sich aber nur bei sehr großen Programmen und Controllern wirklich bemerkbar.

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 1 A liefern kann. 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==
*[[Benutzer:Frank|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]]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]
[[Kategorie:Elektronik]]
[[Kategorie:Microcontroller]]
[[Kategorie:Projekte]]