variabele op hd44780 display

Wat bedoel je met 'harde' karakters?

Welke librarie gebruik je?

voor int : itoa()
voor long : ltoa()

Als in:

   char Buffer[20];

   int x = 5;
   itoa(x, Buffer, 10);

   long y = 1000;
   ltoa(y, Buffer, 10);

Dat levert een ASCII string in Buffer die je naar je display kunt sturen.

Een goed librarie heeft iets in de richting van putInt en putLng.

Als je wat info zoekt over itoa en ltoa dan kom je vaak dit tegen.

This is a non-standard function. Even though the prototype given is commonly used by compilers on other platforms, there is no guarantee that this function will behave the same on all platforms, in all cases. You can use this function to help port applications from other platforms, but you should avoid using it when writing new applications, in order to ensure maximum portability.

Op 29 juni 2020 17:50:35 schreef buckfast_beekeeper:
Wat bedoel je met 'harde' karakters?

Welke librarie gebruik je?

harde karakters, tsja,...ik bedoelde eigenlijk dat je alleen letters & cijfers kunt sturen naar het display,.....het is slecht verwoord door mij

ik gebruik een libary gedownload van electrosome.com, moet even zoeken.

komt van deze pagina:
https://electrosome.com/lcd-pic-mplab-xc8/

harde karakters, tsja,...ik bedoelde eigenlijk dat je alleen letters & cijfers kunt sturen naar het display,.....het is slecht verwoord door mij

Dat is niet waar: je kunt ook custom characters aanmaken...

klopt, dat wist ik wel ....slecht verwoord.

@trix: lees de door je geposte pagina een keer goed. Ik denk dat het antwoord gewoon op de website staat.

sprintf() to Format Outputs

sprintf() can be used to write formatted string to a variable. It can be used with this LCD library to format displayed texts. This enables us to display integers and floating point numbers on the LCD very easily. You should include the header file stdio.h for using sprintf().

Alles rond het gebruik van sprintf kan je hier lezen.

Als je de datasheet van je display er op na slaat, dan staat daar meer dan waarschijnlijk ook de ganse karakter lijst in. Door de juiste waarde naar je display te sturen kan je die ook tevoorschijn toveren.

En zoals Arco ook al zegt, je kan 8 eigen karakters aanmaken. Die kan je opslaan van adres 0 tot 7. Let wel dit is RAM en geen ROM. Elk karakter dien je dan zelf te definiëren. Maar ook daarvan staat een voorbeeld in de datasheet.

Die display leeft inderdaad alleen een ASCII interface.
En dan kun je sprintf() gebruiken om de strings aan te maken:

   char Buffer[20];

   int a = 12;
   sprintf(Buffer, "Integer = %d", a);
   Lcd_Set_Cursor(2,1);
   Lcd_Write_String(Buffer);

Maar dat is nogal in-efficient want dan komt de string ook in SRam.
Die kun je beter in flash plaatsen met sprintf_P():

   char Buffer[20];

   int a = 12;
   sprintf_P(Buffer, PSTR("Integer = %d"), a);
   Lcd_Set_Cursor(2,1);
   Lcd_Write_String(Buffer);

Zoals gedefinieerd in:

   #include <stdio.h>
   #include <avr/pgmspace.h>

Alles rond het gebruik van sprintf kan je hier lezen.

Nou, alles? Voor Avr-gcc zijn er nog wel een paar extra puntjes van belang die daar niet vermeld staan.

Zie avr-libc-user-manual.pdf
Die komt mee met elke install. Ook met atmet studio, al zit hij wel diep verstopt in de toolchain directory:

"C:\Program Files (x86)\Atmel\Studio\7.0\toolchain\avr8\avr8-gnu-toolchain\doc"

even op me in laten werken en inderdaad nog eens goed lezen.

Ik gebruik de custom characters altijd voor batterij symbooltjes...

Ik heb eens een treintje over het display laten rijden

Als je een print-teken functie hebt, die een enkel teken op je display zet (en ervoor zorgt dat het volgende teken erachter komt) dan kun je vrij eenvoudig printf() gebruiken:

void print_char(char c)
{
  // do display stuff
}
FILE display_stream = FDEV_SETUP_STREAM(printchar, NULL, _FDEV_SETUP_WRITE);
stdout = &display_stream;

En dan kun je overal printf() gebruiken.

ik ben nu aan het testen om een variabele op het scherm te krijgen, en dat lukt ook wel. maar ik had toch nog wat vraagjes:
volgens het voorbeeld op:
https://electrosome.com/lcd-pic-mplab-xc8/
(jemoet naar beneden scrollen naar: sprintf() to Format Outputs)

int a = 56;
char s[20];

sprintf(s, "Integer = %d", a);
Lcd4_Set_Cursor(2,1);
Lcd4_Write_String(s);

krijg ik keurig 56 op het display.

vraag: wat doet die char s[20]; daar eigenlijk, dat is toch een array ?
eigenlijk is mij die hele syntax niet erg duidelijk.

ik heb nu dus mooi die 56 op het display, maar eigenlijk wil ik die binair op het display. hoe doe ik dat het best ?

char s[20] is inderdaad een array. Met sprintf(s, "Integer = %d", a) steek je "Integer = %d" in het array waar %d een signed integer moet voorstellen en a is de variabele die je op %d gaat weergeven.

Set cursor zal wel duidelijk zijn.

Met Lcd4_Write_String(s) zet je de string die je aangemaakt hebt met sprintf op het scherm.

edit: voor een binair formaat zal je zelf wat moeten schrijven in een loop waar je de char array zelf vult vermoed ik.

edit 2: voorbeeld code.

[Bericht gewijzigd door buckfast_beekeeper op zondag 5 juli 2020 10:06:47 (10%)

die array heeft dan 20 plaatsen, waarom 20 ? is dat zomaar een voorbeeld ?
waarom moet je die uberhaupt in en array stoppen ?

edit: dat omrekenen ga ik bekijken, tnx

[Bericht gewijzigd door trix op zondag 5 juli 2020 10:11:38 (15%)

20 is meer dan waarschijnlijk gekozen omdat heel veel displays 20 tekens lang zijn. Uiteraard kan je dat aanpassen aan je behoefte. Elk karakter 'te veel' is verspilde ruimte.

Een string is een array van karakters. Stuur je "Integer = 56" naar je display stuur je eigenlijk een array met de I op plaats 0, n op plaats 1 en zo verder.

edit: Bij HD44780 displays er op letten dat op een display van 2*20 het 21ste teken niet op de 2^de regel zal verschijnen. Karakter 21 zie je wel op een 4*20 karakter display op regel 3. Regel 2 begint standaard op 0x40.

[Bericht gewijzigd door buckfast_beekeeper op zondag 5 juli 2020 11:05:59 (26%)

Op 30 juni 2020 08:04:06 schreef mel:
Ik heb eens een treintje over het display laten rijden

En is het display heel gebleven. _{(sorry kon het niet laten)}

Je denkt veel te moeilijk - komt vaker voor bij mensen die nooit fatsoenlijk assembly geleerd hebben.

Goed, je hebt een stuk text en daar wil je wat mee. In dit geval naar het display sturen. Kort door de bocht zijn er 2 mogelijkheden: je houdt bij hoe lang het is en waar het begint (zo doet pascal het). Of je houdt bij waar het begint en gebruikt een 'special character' wat anders nooit voor zal komen als terminator (zo doet C het).

Voor beide methoden is wat te zeggen. Bij de eerste is de lengte beperkt (immers, in Pascal is de 'length' een byte, en daarmee je string beperkt tot 255 characters). Bij de 2de is de soort van data die je erin kunt douwen beperkt (nl. een 0 als waarde is 'einde', dus die kun je nooit opslaan). Voor dingen die weergegeven moeten worden, is dat prima. Immers, ASCII 0 is niets zichtbaars.

Als je dus (in C) een array van 20 elementen declareert, dan kun je er dus 19 characters en 1 terminator in kwijt (ja, die fout wordt vaak gemaakt).

Wat ZOU KUNNEN (en dat hoeft dus zeer zeker niet zo te zijn), is dat de maker van de lib eea. 1-op-1 op het display laat matchen. Dat zou die 20 characters verklaren. Erg onhandig, want als je een strcpy zou gebruiken met 20 chars, dan schrijf je dus 1 byte te ver - en dus over wat anders heen. Dit is dus de manier om stack plat te schrijven en op een PC je eigen code uit te voeren.

Waarom het een array is? Welnu, ik denk dat dat gewoon makkelijk uit kwam in de syntax.
Daarnaast zit C redelijk dicht tegen assembly aan. In assembly moet je ook gewoon 20 bytes declareren en zelf bepalen welk mechanisme je gebruikt. Dat zit in je library functions, niet direct in je taal. Dit is de 1-op-1 vertaling ervan.

[Bericht gewijzigd door EricP op zondag 5 juli 2020 11:12:51 (13%)

Op 5 juli 2020 11:01:22 schreef pa3gws:
[...]
En is het display heel gebleven. _{(sorry kon het niet laten)}

Op 5 juli 2020 11:04:55 schreef EricP:
Je denkt veel te moeilijk

heb ik heel mijn leven al last van
het word al wat duidelijker, tnx

edit: ik heb trouwens een 4x20 (hd44780)

[Bericht gewijzigd door trix op zondag 5 juli 2020 11:45:47 (10%)

Je moet met die sprintf dus erg oppassen dat je resultaat niet te lang wordt. Dan ga je over ander memory heen schrijven.
Kijk evt. ook eens naar snprintf.

Verder: Ik ken de lib die je gebruikt niet. In de documentatie daarvan zou moeten staan hoe die de data verwacht.

over dat te lang, moet ik nog even over nadenken. dat zou wel heel vage errors kunnen geven in je code.

ik begrijp natuurlijk wel dat het resultaat niet langer mag zijn dan wat in de array past.

[Bericht gewijzigd door trix op zondag 5 juli 2020 12:00:13 (31%)

Ja. Je weet niet wat daarachter staat. Verdiep je in stack en heap in C.
Het algemene gebruik als aanvalsvector (dat zal voor een controller in deze context wel loslopen hoor):

• Zoek iets wat een crash veroorzaakt
• Kijk naar de code en analyseer waarom het struikelt
• Kijk of je bij een return address op de stack kunt komen zodat je dat kunt modificeren
• Zet je eigen code neer en laat op de return daarheen springen.

Wat er feitelijk gebeurt als je een CALL doet is dat op de stack het return address gezet wordt - waar moet de instruction pointer heen als je een RET doet? Daarna worden locals geallocceerd. Stack groeit van boven naar beneden, dus als je in een local teveel schrijft, dan schrijf je eerst de volgende local plat en uiteindelijk je return address. En ja, dat kan hele rare bijeffecten geven.