Hallo mensen,
Ik wil voor mijn atmega32, met daaraan gekoppeld een HD44780 LCD scherm, een header file maken zodat ik niet ieder karakter afzonderlijk naar de LCD hoef te schrijven.
Als ik mijn naam wilde spellen op de HD44780 moest ik doen:
PORTC = 0b10xxxxxx (S)
PORTC = 0b10xxxxxx (T)
PORTC = 0b10xxxxxx (E)
etc
etc
Nou begin ik dit erg moe te raken en ik wil een soort van commando maken bijvoorbeeld:
LCD_Write("STEFAN")
Ik heb al een subroutine gemaakt om de LCD te initialiseren:
DDRC = 0xFF;
PORTC = 0x00;PORTD = 0xFF; //D0 t/m D7
PORTD = 0x00; //R/S and RWvoid Init_LCD()
{
PORTC = 0b00111100; //Function Set (8-Bit Interface, 2 line modus, 5*10 dots)
_delay_ms(1);PORTC = 0b00001100; //Display on, Cursor off, Blink off
_delay_ms(1);PORTC = 0b00000001; //Clear Display
_delay_ms(2);PORTC = 0b00000001; //Entry Mode Set
}
Ik heb al veel geprogrammeerd met een 8051 controller, maar daar waren de header files al voorgeschreven. Ik hoefde enkel maar in te kloppen wat op de LCD moest komen te staan.
Mijn vraag aan jullie is: Willen jullie me op weg helpen om een header file te maken voor mijn LCD schermpje? Een nodige dosis C-programmeren is aanwezig, alleen zover kom ik nog niet.
Alvast bedankt,
Stefan
Progger
GMT+1
waarom werkt dat niet? Port C is voor data in jouw geval.
volgens mij moest je om een karakter weg te schrijven de RW lijn toggelen en dan data op de databus zetten oid?
ff heel bot pseudocode:
functie lcd_write(string,lengte)
{
for index = 0 tot lengte
{
PORTD = 0bnogwat; // RW toggle
portC = string[index]
portd = 0x00 // rw weer uit
}
}Ik denk niet dat je code die je nu hebt, gaat werken. Ik zie namelijk geen Enable-lijn, die normaal gebruikt wordt om de data in te klokken.
Je kan beter eerst kijken hoe anderen het hebben gedaan, je bent immers niet de eerste die een hd44780 aan wil sturen vanuit een microcontroller 
Op deze site staat een hoop info mbt hd44780's: http://home.iae.nl/users/pouweha/lcd/lcd0.shtml#hd44780
@Progger: dat is dus de Enable-lijn, die je steeds toggled. Met de R/W lijn bepaal je of je schrijft naar of leest van het lcd. Als je alleen wil schrijven kan je die ook gewoon hard aan ground leggen.
[Bericht gewijzigd door JER00N op (20%)]
Iets als dit?
void LCD_Write(char* input)
{
char* p = input;
while (*p != 0)
{
PORTD ^= (1 << PIN_ENABLE);
PORTC = *(p++);
PORTD &= 0xFF ^ (1 << PIN_ENABLE);
}
}
Maakt een pointer naar je input, en scant de hele string af tot eind (het laatste karakter is altijd 0x00), output deze naar PORTC. Misschien is het nog nodig een delay toe te voegen na het 'PORTC = ...' statement - maar gezien je reeds geposte code is dat niet noodzakelijk. Wel zal je even moeten kijken of de HD44780 karakterset overeenkomt met de ASCII-karakterset, en mogelijk hier en daar conversies toepassen.
Update: PIN_ENABLE is het pinnummer (0-7) van de pin op PORTD die aan de Enable-pin van het display is verbonden. Die pin maken we hoog alvorens de data uit te schrijven, en na het schrijven weer laag.
Verder lijken de karakterset van het LCD en de ASCII-karakterset niet overeen te komen. Daar zal nog een vertaaltabelletje tussen moeten...
Zie hier: http://home.iae.nl/users/pouweha/lcd/lcd0.shtml#charset
[Bericht gewijzigd door Bert M op (30%)]
Progger
GMT+1
bert heeft het juist. moet je alleen nog ff op die website kijken voor de delay en de clock of r/w ofzo die je moet togglen
Dank jullie wel Progger & Bert. Dat met die delays heb ik al uit de datasheet gehaald die ik bij het ding gekregen heb. Ik heb het scherm al aangestuurd gekregen, alleen letter voor letter. (en dat was een kl*tewerk)
Nu rest mij nog een vraagje. We hebben vrij weinig met Pointers gewerkt. Nou heb ik deze site gevonden en doorgelezen:
http://pw1.netcom.com/~tjensen/ptr/ch1x.htm
Maar ik ben er nog niet helemaal achter hoe een pointer werkt. Als ik het goed begrijp "wijst" een pointer naar een andere variabele.?
Op 16 juni 2010 18:40:51 schreef Stefanh001:
Maar ik ben er nog niet helemaal achter hoe een pointer werkt. Als ik het goed begrijp "wijst" een pointer naar een andere variabele.?
Correct. Een pointer is eigenlijk een getalletje, dat overeenkomt met een geheugenadres.
Stel, we hebben een string "STEFAN" op adres 0 t/m 5 in het geheugen staan, en de pointer is 4. Dan is de 'waarde' van de pointer gelijk aan het karakter 'A'. Hogen we de pointer met één op, dan wordt de waarde 'N'. Hogen we nu de 'waarde' van de pointer op met één, dan wordt deze 'O'.
Natuurlijk begint je geheugenadressering waarschijnlijk niet op adres 0, maar dit maakt natuurlijk niet uit.
In C:
string a = "STEFAN";
char* p = &a; // de pointer krijgt het adres van string a mee, operator '&' geeft dat adres
// *p is de 'waarde' op het huidige adres van de pointer, operator '*' geeft die waarde
// *p is nu dus gelijk aan 'S'
p++; // hoog het adres van p op met één
// *p is nu gelijk aan 'T', p is gelijk aan (&a + 1)
p+=5;
// einde van string. Omdat een string altijd wordt afgesloten met een NUL-karakter, is *p nu gelijk aan 0x00