Én hasonlót úgy csináltam, hogy a háttérben binárisan tárolom a kiírandó számot, és megjelenítéskor konvertálom a bcd-vé, majd annak számjegyeit megjelenítem.

Gombnyomást figyelem, ha jön egy számjegy, először megnézem, hogy befére-e még, azaz a szám jelen esetben 999 alatt van (3 számjegy), ha nem akkor eldobom.

Ha befér, akkor megszorzom (igazából shifelés + összeadással) a számot 10-zel, majd hozzáadom az újabb számjegy értékét.

A 4 számjegy 16 biten tárolható, azaz 2 byte. Nekem erre vannak makróim, amivel pl megy az összehasonlitás, összeadás, shift. stb. (CMPC16, MOV16, ADD16, SHL16, stb.), de meg lehet csinálni enélkül is, csak munkásabb.

Csak megjeleníteni szeretnéd, vagy valós értékké tenni?
Azaz ha beütöd, hogy 1,2,3 az simán csak így jelenjen meg, vagy legyen belőle 123?
Mert ha a megjelenítés csak a cél, akkor baromi egyszerű.
Használsz 4 változót, 1000-es 100-as 10-es 1-es helyiérték.
Alapban mindegyik 0. Billentyű lenyomásakor billentyű értékét tárolod BILLENTYU változóban, majt a 100-as helyiértéket átmásolod az 1000-es be, a 10-est a 100-asba az 1-est a 10-esbe BILLENTYU-t az 1-esbe. Ha konkrét szám is kell, akkor tagonként felszorzod a helyiértékkel, majd összeadod.

Köszönöm szépen neked is és majkimesternek is a segítséget.
Egy kicsit visszább kellett lépjek, mert rájöttem, hogy egy csomó felesleges dolog volt a kódban.
Most ott tartok, hogy le tudom kérdezni a billentyűzetet, egy táblázatból kiolvasom a hozzátartozó értéket és megjelenítem a kijelzőn.
Most abban kérnék segítséget, hogyan tudnám megoldani azt, hogy tudjam volt e gombnyomás?
Jelenleg úgy működik, hogy bekapcsolom a billentyűzeten az első oszlopot, végigkérdezem a sorokat, ha volt gombnyomás, akkor beállítom a gomb számértékének megfelelő értékre a változót, 0-tól, 9-ig.
Sajnos nem jut eszembe semmilyen módszer arra, hogy megbizonyosodjak arról, hogy volt-e megnyomva egy gomb vagy sem.

Ezt én úgy csinálom, hogy van egy vátozó KEYB_buffer, amiben az uoljára megnyomott gomb érékét tárolom, és van egy KEYB_flags változó, amiben különböző állapotokat tárolok egy-egy biten:
BUFFERFULL - bufferben van feldolgozatlan adat, addig nem rakok új adatot bele, amíg az előző fel nem lett dolgozva.
DEBOUNCE - egyszer beolvastam egy gombot, de mégegyszer is ugyanazt kell olvasnom, hogy elfogadjam helyesnek az értéket.
WAITREL - a felengedére várok, addig nem rakok újabb értéket a KEYB_buffer-be, amíg az előző gombot el nem engedték.

Van egy KEY_poll függvényem, amit timer IT-ből 10 ... 50 mS-enként hívok, ha a buffer tele, akkor nem csinál semmit, amig azt fel nem dolgoztam, ha üres, akkor megnézi a bill mátrixot, ha van lenyomott gomb, eltárolja egy temp változóba és beáíítja a DEBOUNCE flag-et, kövekező hívásnál ha még mindig ugyanaz az érték, akkor berakja a bufferbe és beállítja a BUFFERFULL flag-et és a WAITREL-t is. A KEY_poll következőben arra vár, hogy ne legyen lenyomott gomb.

A főprogramban meg van egy KEYB_get, ami a BUFFER_FULL flag alapján visszatér 0-val, ha nincs semmi a bufferben, vagy a lenyomott gomb ASCII kódjával, ha van. Ekkor törli a BUFFER_FULL-t.

Lehet elsőre bonyolúltnak látszik, de korrekt eredményt ad.

Még rágódom rajta, valóban egy kicsit bonyolult. Azt a részt nem nagyon értem, hogy honnan tudni, hogy a buffer tele van? Hiszen a nulla is egy gombnak az értéke, praktikusan a nulláé

azért van a BUFFERFULL flag, ami jelzi ezt. Ha akarsz ITT belenézhetsz. keyboard_101.zip

Bocs, de napok óta nem ültem gép előtt.
Én nem olyan profi, cserébe egyszerű módszert szoktam használni. Elindítom a billentyűzet beolvasását mátrixból 12 lépésben. Első sor olvasásához kimenet bekapcsol, majd egyenként nézem a bemeneteket. Ha van találat, bekapcsolok egy beírok egy értéket egy változóba (az adott gomb értékét), kiugrok az olvasási rutinból a beírási rutinba. Ott először ellenőrzök egy bitet, ami azt mondja meg, volt-e már itt a program. Ha volt kiugrok onnan, és megy a program a dolgára. Ha nem volt, először bekapcsolom ezt a bitet, majd elvégzem amit kell a vátozóba írt adattal, majd megy tovább a program. A bit akkor törlődik, ha a beolvasás lefutott és nem talált megnyomott gombot.

Megintcsak köszönöm mindkettőtöknek!
Nagyon jó ötleteket adtatok. Végül egy talán nem túl elegáns, de egyszerű megoldást találtam ki. A gombok értékei felülírják a váltózó értékét, 0-12 közötti értékkel. A változó értékének legfelső bitjét 1-be állítom a gombok rutinjának elején, utána ezt ellenőrzöm a kiértékelés során. Ha egy maradt, akkor nem volt gombnyomás, ha nulla, akkor megnézem milyen érték íródott bele.