Ich habe vor ca. einem Monat ( ~ Mitte Oktober ) ein 2x16 LCD Display geschenkt bekommen ( siehe Abb.1 ). Nun wollte ich natürlich unbedingt das Teil auch ausprobieren. Allerdings hatte ich so meine Startschwierigkeiten, weswegen ich es erst vor wenigen Tagen geschafft habe.
Problem:
Die Anschlussbelegung ( s. Abb.2 ):
Es gibt viele Tutorials, in denen gezeigt wird, wie man so ein LCD Display mit einem Standart Controller anschließt und auch ansteuert. Manche Tutorials sind allerdings unverständlich und auch manchmal falsch, was bei der Anschlussbelegung ( also wie man die 16 Pins des Displays anschließt ) zur Folge hat, dass nichts funktioniert.
Im AVR-GCC Tutorial von mikrocontroller.net habe ich allerdings ein gutes und funktionierendes Tutorial mit Code gefunden. Zum Tutorial
Anschlussbelegung bei einem LCD Display mit dem HD44780-Controller:
Abb.2: Belegung der Pins.
Abb.3: So sieht das ganze verkabelt aus.
Pin #-LCD
Bezeichnung-LCD
Pin-µC
1
Vss
GND
2
Vcc
VCC
3
Vee
mit 330 OHM Wiederstand an GND
4
RS
PD4
5
RW
GND
6
E
PD5
7
DB0
offen (unbenutzt)
8
DB1
9
DB2
10
DB3
11
DB4
PD0 am AVR
12
DB5
PD1 am AVR
13
DB6
PD2 am AVR
14
DB7
PD3 am AVR
15
LED - Beleuchtung: -
VCC
16
LED - Beleuchtung: +
PB7
Abb.4: Mit Pollin-Board von oben.
Programmieren mit C:
Zum Programmieren habe ich die Headerdatei lcd-routines.h, sowie die lcd-routines.c Datei vom Tutorial genommen, da diese gut funktioniert und einfach zu benutzen ist. Danach musste ich die .c Datei noch compilieren, aber das geht mit ProgrammersNotepad2 ( aus WIN-AVR Paket ) ja ganz schnell.
Nach anfänglichen Schwierigkeiten auch auf Seiten des Programmtextes gibts hier nun den fertigen Code.
Abb.5: Steckbrett mit LCD-Display.
//
// Anpassungen im makefile:
// lcd-routines.c in SRC = ... Zeile ANHÄNGEN
//
#include <avr/io.h>
#include <util/delay.h>
#include "lcd-routines.h"
int main(void)
{
DDRB |= 1 << PORTB7;
// Initialisierung des LCD
// Nach der Initialisierung müssen auf dem LCD
vorhandene schwarze Balken
// verschwunden sein
lcd_init();
PORTD ^= 1 << PORTD7;
int i = 0;
while(1)
{
PORTD ^= 1 << PORTD7;
_delay_us(i);
}
return 0;
}
// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
// http://www.mikrocontroller.net/articles/HD44780
//
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//
// Die Pinbelegung ist über defines in lcd-routines.h
einstellbar
////////////////////////////////////////////////////////////////////////////////
// Sendet eine 4-bit Ausgabeoperation an das LCD
static void lcd_out( uint8_t data )
{
data &=
0xF0;
// obere 4 Bit maskieren
////////////////////////////////////////////////////////////////////////////////
// Sendet ein Datenbyte an das LCD
void lcd_data( uint8_t data )
{
LCD_PORT |= (1<<LCD_RS);
// RS auf 1 setzen
lcd_out( data
);
// zuerst die oberen,
lcd_out( data<<4
); // dann die
unteren 4 Bit senden
_delay_us( LCD_WRITEDATA_US );
}
////////////////////////////////////////////////////////////////////////////////
// Sendet einen Befehl an das LCD
void lcd_command( uint8_t data )
{
LCD_PORT &=
~(1<<LCD_RS); // RS auf 0 setzen
lcd_out( data
);
// zuerst die oberen,
lcd_out( data<<4
); //
dann die unteren 4 Bit senden
_delay_us( LCD_COMMAND_US );
}
////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl zur Löschung des Displays
void lcd_clear( void )
{
lcd_command( LCD_CLEAR_DISPLAY );
_delay_ms( LCD_CLEAR_DISPLAY_MS );
}
////////////////////////////////////////////////////////////////////////////////
// Sendet den Befehl: Cursor Home
void lcd_home( void )
{
lcd_command( LCD_CURSOR_HOME );
_delay_ms( LCD_CURSOR_HOME_MS );
}
////////////////////////////////////////////////////////////////////////////////
// Setzt den Cursor in Spalte x (0..15) Zeile y (1..4)
void lcd_setcursor( uint8_t x, uint8_t y )
{
uint8_t data;
switch (y)
{
case 1:
// 1. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE1 + x;
break;
case 2:
// 2. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE2 + x;
break;
case 3:
// 3. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE3 + x;
break;
case 4:
// 4. Zeile
data = LCD_SET_DDADR + LCD_DDADR_LINE4 + x;
break;
default:
return;
// für den Fall einer falschen Zeile
}
lcd_command( data );
}
////////////////////////////////////////////////////////////////////////////////
// Schreibt einen String auf das LCD
// Ansteuerung eines HD44780 kompatiblen LCD im 4-Bit-Interfacemodus
//
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
//
#ifndef LCD_ROUTINES_H
#define LCD_ROUTINES_H
////////////////////////////////////////////////////////////////////////////////
// Hier die verwendete Taktfrequenz in Hz eintragen, wichtig!
#ifndef F_CPU
#define F_CPU 3686400
#endif
////////////////////////////////////////////////////////////////////////////////
// Pinbelegung für das LCD, an verwendete Pins anpassen
// Alle LCD Pins müssen an einem Port angeschlossen sein und
die 4
// Datenleitungen müssen auf aufeinanderfolgenden Pins liegen
////////////////////////////////////////////////////////////////////////////////
// Zeilendefinitionen des verwendeten LCD
// Die Einträge hier sollten für ein LCD mit einer
Zeilenlänge von 16 Zeichen passen
// Bei anderen Zeilenlängen müssen diese Einträge
angepasst werden
////////////////////////////////////////////////////////////////////////////////
// Initialisierung: muss ganz am Anfang des Programms aufgerufen
werden.
void lcd_init( void );
////////////////////////////////////////////////////////////////////////////////
// Cursor in die 1. Zeile, 0-te Spalte
void lcd_home( void );
////////////////////////////////////////////////////////////////////////////////
// Cursor an eine beliebige Position
void lcd_setcursor( uint8_t spalte, uint8_t zeile );
////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines einzelnen Zeichens an der aktuellen Cursorposition
void lcd_data( uint8_t data );
////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Strings an der aktuellen Cursorposition
void lcd_string( const char *data );
////////////////////////////////////////////////////////////////////////////////
// Definition eines benutzerdefinierten Sonderzeichens.
// data muss auf ein Array[8] mit den Zeilencodes des zu
definierenden Zeichens
// zeigen
void lcd_generatechar( uint8_t code, const uint8_t *data );
////////////////////////////////////////////////////////////////////////////////
// Ausgabe eines Kommandos an das LCD.
void lcd_command( uint8_t data );
////////////////////////////////////////////////////////////////////////////////
// LCD Befehle und Argumente.
// Zur Verwendung in lcd_command
// Set DD RAM Address --------- 0b1xxxxxxx (Display Data RAM)
#define
LCD_SET_DDADR
0x80
#endif
Download als .zip
( Die Makefile-Datei muss natürlich an den Mikrocontroller, den ihr habd angepasst werden. UND die lcd-routines.c muss eingetragen werden -> s.u. )
LCD-Routines.c in Makefile eintragen:
1.) Makefile mit MFile o.ä. öffnen. 1.1) Wenn ihr MFile nutzt: Unter dem Menüpunkt "Makefile" den Punkt "Enable Editing of Makefile" aktivieren. 2.) Unter SRC = ... folgenes ändern: Normal steht dort: SRC = $(TARGET).c
Ihr Schreibt hin: SRC = $(TARGET).c lcd-routines.c 3.) Speichern und fertig
Das wars auch schon wieder. Ich hoffe ich konnte euch ein paar Interessante Dinge zeigen und/oder euch beibringen. Ich werde gucken, was ich dem nächst mache. Schriebt doch mal in die Kommentare, was ihr gerne wissen wollt, oder interessant fändet. Ich freue mich für alle möglichen Antworten ;)
ich habe natürlich auch in Foren etc. meinen Blog vorgestellt und somit auch einige Leser gewonnen.
Unter anderem ist auch bekannt geworden, dass ich ja in Bascom programmiere. Das hat dann eine große Welle von "Warum?" und "Bascom ist Sch****!" losgeschlagen.
Bisher haben mir alle zur Sprache C geraten. Als ich dann vor wenigen Tagen bei meinem Onkel war ( selbst Fachinformatiker ) hat er ebenfalls gesagt, dass ich doch in C programmieren solle.
Ich habe mir natürlich Gedanken gemacht und mich informiert, weil selbst mein Onkel mir dazu geraten hat.
Kurz und gut:
Ich bin auf C umgestiegen.
Warum?
1.) Weil alle es mir geraten haben.
2.) Weil ich nach ein bisschen Recherchen auch bemerkt habe, dass es garnicht so schlecht ist.
Unterschiede, sowie Vor- und Nachteile:
Also von der Syntax ist C eine ganz andere Welt wie Bascom. Es ist in manchen Punkten komplizierter ( alleine schon einen Port an/aus stellen, sprich 5 oder 0V geben ). Aber man merkt auch, dass es halt C, also eine weit verbreitete und bekannte Sprache ist: In mehr Foren findet man Infos und Hilfe und die Syntax ist einem evt. schon durch Java o.ä. bekannt. Wer C kann hat da natürlich einen Vorteil ;) Vor- Nachteile:
+ Mehr Funktionsumfang
+ Bekannte Syntax
+ Mehr Support in Foren und im Internet
- Schwerer zu lernen
- unverständlicher ( für mich ein wenig )
Wie man genau damit programmiert und welche Programme man nutzen kann werde ich dann in den/dem nächsten Post(s) vorstellen.
Auch werde ich demnächst mal ein paar Scripte posten, wenn sie funktionieren. Das kann noch ein wenig dauern, da ich auch bei meinem RPG weiterkommen möchte, aber das krieg ich schon hin.
Man sollte beachten: Ich musste wieder bei 0 anfangen, da ich ja bisher in Bascom programmiert habe.
ich wollte nochmal was posten und zwar: Ich habe im Letzten Post ja schon aufgeführt, dass ich mir so eine 40-Polige Steckleiste bekauft habe ( s. Bild rechts ). Ich habe die Einzelteile mal zusammengelötet und auf ein passendes Steckbrett gesteckt ( so viele Stecker ;) ).
Beim basteln habe ich dann bemerkt, dass ich ALLE Pins vom ATMega16 ( auch die zum programmieren des Chips ) auch dieser Pfostenleiste und somit auf der Steckleiste befinden. Zum Glück sind auch der Platine selbst schon die Bezeichnungen abgedruckt ( GND, VCC, etc.: s. Bild rechts ).
Hier ein Bild zu der Pfosten- und Steckleiste:
Ein IDE Kabel verbindet Board mit Steckbrett.
Pollin-Board ( links ) mit Steckbrett ( rechts ). Die Steckleiste ist mit einem
normalen IDE Kabel mit dem Board Verbunden.
Was man beachten sollte:
Bild 1: 35 Stifte ( vorne ) und Pfostenleiste
mit Lücke ( hinten )
In der Packung die man beim bestellen bekommt sind drei Teile drin: 1x Pfostenleiste, 1x Platine und 1x Stiftleiste. Die Pfosten- und Stiftleiste sind jeweils 40-polig. Die Platine hat aber nur 35 Pole ( !!! ). Man muss daher 5 ( ! ) Stifte abknipsen ( mit einem Seitenschneider o.ä. ) um die anderen 35 Stifte dann an die Platine zu löten.
In der bitte der Pfostenleiste gibt es eine 2-Pin breite Lücke ( s. Bild 1 ). Diese Lücke muss richtung Stifte zeigen, da sonst die Belegung nicht passt.
Nicht alle Pins der Pfostenleiste sind mit der Stiftleiste verbunden, einige bleiben unbelegt.
Bild 2: Die Lücke muss zu den Stiften zeigen!
Bei manchen Steckbrettern muss man Mut haben die Siftleiste hinein zu
drücken. Am besten geht das, wenn man die Platine mit einem
Schraubenzieher zwischen Pfosten- und Stiftleiste hineindrückt
Prüft ob alle Stifte Kontakt zur Pfostenleiste haben!
Programmieren mit der Stiftleiste:
Das Progrsmmieren mit der Stiftleiste ist ganz einfach und unterschiedet sich eigentlich nicht vom normalen Programmieren. Jeder Pin der Stiftleiste hat eine Bezeichnung ( PB0, PB5, PA1, etc. ) Jeden Pin kann man ansteuern ( Output oder Input ). Wenn man nun beim ATMega16 den Port D5 ( PD5 ) als Output definiert und eine Spannung anlegt, dann leuchtet auf dem Pollin-Board die LED1 und gleichzeitig hat man auf dem Steckbrett am 5. Stift von oben eine Spannung anliegen ( dort liegt nämlich der Port D5 ).
Videos:
Demnächst stelle ich ein Video online, wo ich dann zeige, wie das alles genau geht. Eventuell erstelle ich auch einen eigenen Youtube-Kanal. Mal sehen.
!!! Schreibt bitte in die Kommentare, wie es euch bisher gefällt und wie ihr die Idee mit den Youtube-Kanal findet !!!
endlich ist mein bestellter Kram da. Was ich mir alles bestellt habe, seht ihr in folgender Liste:
Das habe ich momentan bestellt:
- Atmel Evaluationsboard 2.0.1 ( auch bekannt als "Pollin-Board" )
- Den ATMega 16 von Atmel
- Den MySmart USB light Adapter ( USB auf 6-Poligen ISP )
- Einen Adapter von 6-Poligem ISP auf 10-Poligem ISP ( da auf dem Board der 10 Polige ISP Anschluss zum programmieren da ist )
- Einen Streifen-/Punktrasterplatinenadapter ( 40-Polige Pfostenleiste auf 40-Polige Stiftleiste )
Hier ein paar Fotos der bisherigen Sachen:
Der MySmart USB light Adapter mit ISP-Adapter und Verpackung.
Die beiden Adapter kombiniert. Es bleibt ein 6-Poliges ISP Kabel übrig.
Karton des Pollin-Boardes.
Pollin-Board mit 9V Batterie. Die Netz-LED leuchtet, das heißt, dass das Board unter Strom steht
Die Pfostenleiste ( oben ) und Stiftleiste ( unten ) mit zugehöriger Platine ( mitte ). Alles noch unverlötet.
Programmieren des ATMega16:
Zum Programmieren nehme ich das Programm BASCOM-AVR. Es lässt sich recht einfach Konfigurieren und der Chip lässt sich somit auch von totalen Anfängern programmieren.
Um den Code von Rechner auf den ATMega16 zu bekommen, benutze ich wie oben aufgeführt den MySmart USB light Adapter. Die Konfiguration in BASCOM-AVR war etwas fummelig, aber nach ein paar Versuchen kann man mit F7 oder einem Klick den Code compilieren und direkt auf den Mikrocontroller laden. Das ganze dauert ca. 5-10 Sekunden.
Warum nicht C/C++ oder Assembler:
Weil C/C++ oder Assemlber für mich und evt. auch für euch als Einsteiger nicht einfach ist. Bascom bietet da eine passende Alternative. Eventuell schaue ich mir auch mal Basic an ... mal gucken.
ich starte hier einen neuen Blog zum Thema Mikrocontroller. Ich hoffe einige interessieren sich dafür, bzw. eventuell kann ich einige dafür begeistern.
Warum?
Ich wollte einfach mal sehen ob das ankommt, da ich schon einen anderen Blog habe, habe ich schon ein bisschen Erfahrung im bloggen.
Der Grund, warum ich hier anfange ist der, dass ich mich in die Thematik der Mikrocontroller reinarbeite. Ich habe schon ein paar Sachen bestellt und werde mich darim stetig üben.
Was kommt hier hin?
Alles was ich so erlebe und lerne. Ich teile alle meine Erfahrungen hier und hoffe, dass es nicht langweilig wird. Eventuell drehe ich auch ein paar Videos.
Wann gehts weiter?
Ich habe bei einer gewissen Internetseite ein paar Teile bestellt ( ein Board, einen Mikrocontroller, Zusatzteile ). Wenn alle Teile, die ich gekauft habe ( sind noch ein paar mehr ) eingetroffen sind, beschreibe ich, was ich habe und was ich damit mache.