Igen, köszönöm.
Közben ez a része megoldódott adat struktúrával amely aztán típus definícióval deklarálva lesz.
Természetesen ez is jó megoldás csak így kellene még egy függvényt használnom ami kicsit bonyolítaná a program tekinthetőségét. (véleményem szerint)

Az strukturálisában például nem értem miként adódik át úgy egy 16bites adat, hogy az adatszerkezet 2 változójába egységesen oszlik fel.
Kiolvastam a könyv adatstruktúrájáról szóló fejezetet, de nem írja le, vagy csak számomra nem érthető...

Tehát egy példa:
Típus definició

typedef union INT16
{
sort int Value;
struct
{
unsigned char LB;
unsigned char HB;
} bytes;
} INT16

Aztán jöhet a main() függvényben a deklaráció

INT16 temp;

Aztán adunk át értéket, mondjuk 900-at.

temp.Value = 900;

Ez az én gondolat menetem szerint 2részre bomlik, 2db 1bájtos részre.
temp.LB-ben lesz az első (alacsonyabb helyi értéken lévő) 8bit és temp.HB-ben a második (magasabb helyi értéken lévő) 8bit.
Szóval így: 900 16bites bináris értéke == 00000011 10000100

Amit nem értek, hogy a miért és milyen elv szerint rendezi el önkényesen az átadott adatokat?

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

A bájt sorrend az teljesen megvan szóval ez rendben van...
Itt inkább maga az érték átadás folyamatára lennék kíváncsi miként töltődik fel az adatstruktúrában lévő változók.

Talán itt a túlcsordulás miatt ugrik egyet az adatstruktúra?
Tehát az első 8bit befér a LB-be de a 9-edik bittől már túlcsordulás van és a következő változóba esetünkben a HB-be töltődik be a maradék 8bit?

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

A kérdésem erősen szorítkozik az adatstruktúrára.
Pontosabban a kérdés az adatstruktúra feltöltésévél kapcsolatos.
Miként történik a feltöltődés.
Valószínűleg túlcsordulássál, de majd megnézi valaki szaki is és kijavít ha még sem így van.

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Próbáld ki PC-n. Ha valaminek a működésében nem vagyok biztos, és az utána olvasás sem segített, akkor mindig kipróbálom PC-n.

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!

Igen, PC-n vagy is MAC-en próbálom ki, de...
Értem...Próbáljam meg vissza fejteni a működést kísérletezéssel.
Jó ötlet. Köszi... (nem is értem miért nem ezzel kezdtem )

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Sikeres volt a vissza fejtés..
Rájöttem, hogy mivel 16bit-es adatot adok át így hexában tárolja. (logikus )
Itt egy példa ha valaki le akarja még tesztelni:

typedef union INT16 {
short int value;
struct{
unsigned char low;
unsigned char hight;
}bytes;
}INT16;
void main(void){
INT16 temp;
temp.value = 900;
printf("%x\n", temp.bytes.low);
printf("%x\n", temp.bytes.hight);
printf("%i\n", temp.bytes);

}

Most már világos
Köszi a rávezetést...

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Mit szerettél volna írni?
Ne hagyjuk mert minden apróság számít.. Jól kell megtanulni mert egy kis hiba is félre vezethet és később gondot okozhat...
Annyiban korrigálnék, hogy az adatstruktúra binárisan tárolja az adatokat és a fórdító gondoskodik a struktúra változóinak feltöltéséről.
Ezért nem árt letesztelni....

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Nem másoltam..., én írtam a teszt progit.
Binárisan nem tudtam megjeleníteni mert egy külön függvény kellett volna írnom, így maradt a hexa.
De feljebb korrigáltam is a dolgot

Na ja, kellene egy kis rend a fejembe ezekkel kapcsolatban is mert én is tudom, hogy nem jól fogalmazok.
Idővel megtanulom.

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Kedves Fórum társak!

Kérdezném tisztelettel, hogy mi a véleményetek a "goto" utasításról? (a könyv nem ajánlja, legalább is nem észnélkül)
Van egy menürendszer melyben elég erősen kell ugrálnom a menürendszerem opciói közt így ezt használnám.
Sok a feltétel és erősen tudnám csökkenteni, ha "goto" utasítással ugrálhatnék.
Gyakorlatilag 5 opció közt kellene manővereznem egy csomó feltételrendszer megfelelései szerint.
Vélemény?

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

3 éve programozok C-ben. Egyszer sem kellett használnom a goto-t.

Jellemzően generált kódokban fordul elő, mert könnyebbé teszi a program tervezést, de ember által írt kódban egyáltalán nem általános és nem ajánlott.

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!

Szerintem csinálj egy állapotgépet sokkal átláthatóbb és biztonságosabb mint a goto.

A goto pár helyen teljesen normális megoldás C-ben, pl. akkor, ha több, egymásba ágyazott ciklusból akarsz kiszállni vagy ha a függvényből több helyen is ki lehet szállni, viszont mindenhol meg kell csinálni ugyanazt (file-t lezárni, memóriát felszabadítani, ilyesmi).

Arra viszont, amire te akarod használni, határozottan ellenjavallt.
Az nem derült ki pontosan, hogy mi kell neked, de az egészen biztos, hogy sokkal jobb megoldások vannak rá, mint a goto.

DRM is theft

Hogy nem általános és nem ajánlott az nézőpont kérdése. A linux kernel például tele van vele (konkrétan 112235 darabot számoltam össze), mert erőforrás felszabadításhoz hiba után hasznos. Például:

gcm_zeroes = kzalloc(16, GFP_KERNEL);
if (!gcm_zeroes) return -ENOMEM;

err = crypto_register_template(&crypto_gcm_base_tmpl);
if (err) goto out;

err = crypto_register_template(&crypto_gcm_tmpl);
if (err) goto out_undo_base;

err = crypto_register_template(&crypto_rfc4106_tmpl);
if (err) goto out_undo_gcm;

err = crypto_register_template(&crypto_rfc4543_tmpl);
if (err) goto out_undo_rfc4106;
return 0;

out_undo_rfc4106:
crypto_unregister_template(&crypto_rfc4106_tmpl);
out_undo_gcm:
crypto_unregister_template(&crypto_gcm_tmpl);
out_undo_base:
crypto_unregister_template(&crypto_gcm_base_tmpl);
out:
kfree(gcm_zeroes);
return err;

Jester

Igazából, most megírtam pár részt, hogy miként működik és elég gyorsan és jól. (elsőre legalább is)
Ha nem "goto" utasítással ugrok vissza egy-egy program részhez akkor egy "else if"-ágas feltétel rendszert kell alkotnom és egy előre deklarált navigációs változóban kell megadjam, hogy éppen melyik ág érvényesüljön.
Így elsőre a "goto" elég átlátható struktúrát adott számomra, de persze nem rossz az "else" ág sem.
Azt olvastam a könyvben, hogy nem jó túl sok feltételt használni a programozás során persze ellenállításként azt is megemlíti, hogy a túl kevés sem jó...
Szóval azt tanácsoljátok, hogy hagyjam a "goto" utasítást?
Nem biztonságos?
Biztonságosabb az "else if" elágazás?

A program egy forrasztó állomás vezérlését fogja kiszolgálni.
Pár mondatban összefoglalom hogyan is állok most és mi lenne az elképzelés:

Gép bekapcsolásnál ellenőrzés megy végbe mely megvizsgálja az utolsó használt hőprofilt és ha van ilyen akkor betölti és automatikusan felkínálja a program elindítását. (nem térek ki a program futására...)

Ha nincs utoljára betöltött hőprofil vagy hibás akkor ezt a hibát közli és ugrania kell a menüre.

A menüben több menüpontból lehet választani mint pl.: Új profil hozzáadása, Aktuális profil szerkesztése, Elmentett profilok kilistázása, és még pár.

Ezek közt kell gyakorlatilag navigálnom...

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Látatlanban csak találgatunk. Nem lehet, hogy inkább egy switch kellene neked?

Jester

Természetesen itt még benne van, ha valahová belépek és még sem akarok semmit akkor vissza kell lépjek és akkor vagy a menüre vagy a profilba amely be van töltve kell vissza ugorjak módosítás nélkül...

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Itt például mi szerepe a gotonak? azakot ahova ugrik nem lehetne az ifek után rakni?

De, oda lehetne:

gcm_zeroes = kzalloc(16, GFP_KERNEL);
if (!gcm_zeroes) return -ENOMEM;

err = crypto_register_template(&crypto_gcm_base_tmpl);
if (err)
{
kfree(gcm_zeroes);
return err;
}

err = crypto_register_template(&crypto_gcm_tmpl);
if (err)
{
crypto_unregister_template(&crypto_gcm_base_tmpl);
kfree(gcm_zeroes);
return err;
}

err = crypto_register_template(&crypto_rfc4106_tmpl);
if (err)
{
crypto_unregister_template(&crypto_gcm_tmpl);
crypto_unregister_template(&crypto_gcm_base_tmpl);
kfree(gcm_zeroes);
return err;
}

err = crypto_register_template(&crypto_rfc4543_tmpl);
if (err)
{
crypto_unregister_template(&crypto_rfc4106_tmpl);
crypto_unregister_template(&crypto_gcm_tmpl);
crypto_unregister_template(&crypto_gcm_base_tmpl);
kfree(gcm_zeroes);
return err;
}
return 0;

Jester

En ilyenkor mindenkeppen kulon kezelnem az adatokat (a menustrukturat) meg annak a kezeleset - az elobbit adatstrukturakban tarolnam es a kod csak azokat a strukturakat manipulalna - ahelyett, hogy beleirnam a programkodba a menupontokat (mert ha jol veszem ki a szavaidbol, akkor pont ezt csinalod). Ugyanis igy egyreszt joval kisebb es atlathatobb kod lesz, atlathatobbak lesznek az adatok is es a modositas is joval egyszerubb lesz.

DRM is theft

Jelenleg programoktól függően külön van választva több részre a teljes program kód.

1. inicializáló függvények és típusdefiníciók, adatstruktúrák, I/O portok beállítása...stb
2. függvények melyek mindent külön kezelnek. (Memória IC, PIC Eeprom, időzítők és egyéb vezérlők)
3. PIC láb definíciók
4. Megszakítások (Magas és alacsony prioritásúak)
5. maga a program amely összevonja a feljebb felsoroltakat. ( main() )

Természetesen még van pár része a programnak melyekre nem tértem ki, de nem is fontosak a mondanivalómhoz.

A programban nem kezelhetek mindent adatstruktúrákban, de egy részét abban kell vagy legalább is jobb abban kezelni nyilván.
Maga a főmenüt és elágazásait egy ciklusban kell kezeljem, ha nem "goto" paranccsal ugrálok a ciklusok közt.
Nyilván itt a 4x4-es mátrix interfész miatt kell egyben kezeljem mert azon keresztül tudom csak manuálisan kezelni a programot.
Muszáj pergetnem, különben nem tudom figyelni folyamatosan a gombok állapotát.

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Szerintem nem ertettel

Azt mondtam, hogy a menupontokat meg egyebeket nem mindenfele ifekbe kodolnam bele, hanem beleraknam static tombokbe.

DRM is theft

Ja értem most már..
Itt sokat nem kell változtatni a menüpontokon szóval csak azokért nem használnék külön struktúrát.

Itt egy kis részlet a kódomból:
E programrész felett ellenőrzöm az Eepromban tárolt adatokat és, ha van elmentett profil akkor azt a memóriából kiolvasva betöltöm.

/****************************************************************************
+ "menu" goto utasítás
+ Ha nincs betölthető profil akkor ugrás a menu goto utasításra
*****************************************************************************/
menu:
lcd_clear();
i=0;
while(1){
keyval = get_key(KeyAlfOrNum); //numerikus gombok engedélyezése
if(keyval=='1'){
//Új profil hozzáadása
}else if(keyval=='2'){
//Aktuális profil szerkesztése
}else if(keyval=='3'){
//Profilok listázása
}else if(keyval=='4'){
//Ugrás a már betöltött profilra
goto profil_betoltve;
}
printf("1. Uj profil hozzaad");
lcd_write(0xC0,0,1,1);
printf("2. Akt. prof. szerk.");
lcd_write(0x94,0,1,1);
printf("3. Profilok listaja ");
lcd_write(0xD4,0,1,1);
printf("4. Vissza ");
lcd_write(0x80,0,1,1);
}

Itt látszik valamennyire, hogy oldottam meg a programok közi ugrálást...

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Összedobtam egy kis részletet miről is van szó és ami jóbban szemlélteti a dilemmámat.
goto vagy else if megoldással:

main(){
menu:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Meghívhatja saját magán kívül mindegyiket
pofil_betoltve:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Meghívhatja a menu-t és a start-ot
uj_profil:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Meghívhatja a menu-t és a pofil_betoltve-t
prifil_szerkesztes:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Csak a menu-t hívhatja meg
profil_lista:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Meghívhatja a pofil_betoltve-t és a menu-t
start:
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
//goto Egyéb más funkciót fog tudni meghívni és visszatérésként a pofil_betoltve-t
}

main(){
unsigned char navigacio; //Függően attól hogy a felette lévő feltételek miként értékelődnek ki a szerint töltődik fel értékkel
while(1){ //végtelen ciklusban pörög és folyamatosan vizsgálnia a kell a feltételeket
if(navigacio==0){
//hasonlóan mint feljebb
//szükséges változók nullázása
//Sok sor program kód
//navigacio-s változót írjuk felül attól függően melyik feltételbe akarunk navigálni
}else if(navigacio==1){
//-- " --
}else if(navigacio==2){
//-- " --
}else if(navigacio==3){
//-- " --
}else if(navigacio==4){
//-- " --
}else if(navigacio==5){
//-- " --
} //-- " --
}
}

Így talán átláthatóbb és érthetőbb a kérdésem.
Ki melyiket használná?
GOTO vagy ELSE IF?

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Miért büdös az egyes ágakat külön függvényekbe tenni?
Egyébként én egyiket se, switchelnék az egy karakter alapján.

“All nothings are not equal.”

Nem büdös, csak nem tudom bele tenni.
Ha beleteszem akkor iszonyat mennyiségű globális változót kellene használnom vagy túlbonyolítani a programot a függvényesítés miatt.
Minden program rész összefügg és folyamatos kapcsolatban kell lenniük a memória kezelése miatt.
Így is van vagy 20db külön függvény már és még lesz legalább ennyi...

A switch utasítás meg ugyan az lenne mint az if csak itt nem else if lenne leírva soronként hanem a case: .

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Ha a main függvényben előre definiált 20 változót használod mindenhol, akkor azok is globális változók logikailag. Az, hogy a soha véget nem érő main függvény miatt a stacken vannak, ahhoz képest elhanyagolható tény.

“All nothings are not equal.”

Próbálom úgy szétbontani a programot, hogy a függvények egy külön becsatolt állományként működjenek.
Ha ugyan abban a fájlban lennének a függvények amelyikben használni akarom akkor nem lenne gond maximum több ezer sorra duzzadna a az egy helyen leírt program kód.
Ez átláthatatlanságot eredményezne.

Még agyalok mi legyen, de sajnos a függvényesítés nem jó, már próbáltam egyszer, de lehet még szánok rá egy kis időt hátha meg tudom okosan oldani..

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

typedef enum
{
STATE_MENU = 0u,
...
} STATE_E;

static STATE_E menu_func(void)
{
//szükséges változók nullázása
//Sok sor program kód egy while() ciklusban pereg
// returnbe azt adsz vissza, amit akarsz
....
return STATE_PROFIL_LOAD;
}

main() {

STATE_E state = STATE_MENU;

while(1)
{

switch(state)
{
case STATE_MENU:
state = menu_func();
break;
case STATE_PROFIL_LOAD:
state = profil_load();
break;
}
}
}

Ha nem akarod keverni a szezont a fazonnal, akkor az állapot gép függvényeit külön modulba is rakhatod, ahol modulra lokális változókat használsz, ha a függvények között szükséges az adatáramlás. Nem tudom, hogy mit akarsz csinálni, de a 2 kB borítékolhatóan kevés lesz, de szerintem még a 4 kB is. Gondolom valamilyen LCD-t is használsz. Egy frankón megírt LCD kijelző vezérlő is ~800 B, ami semmi extrát nem tud csak szöveget ír ki, de azt kényelmesen.

Nem vagy egy könnyű eset .

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!

"Nem vagy egy könnyű eset"
Azt megmondom..., de 2hónap után nem is olyan rossz szerintem
Ezt a felépítést nem ismertem szóval érdekes lehet...
Megnézem
Köszi...

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

"Assembly-ztél már?"
Soha..

PHP-és vagyok, de ott sokkal egyszerűbbek voltak a dolgok.
Könnyebben lehet ott kezelni a változókat.

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Olyan is a PHP...

Sziasztok!

Egy két másodperces késleltetőt szeretnék implementálni. Ehhez tudom az aktuális időt, ennek is a másodperc értékét szeretném felhasználni. Azt szeretném meghatározni, hogy meddig várjak, tehát az aktuális másodperchez hozzáadok 2-t. Csak ugye 60, 61, 62 esetben nekem 0, 1 és 2 kell. Erre van valamilyen bitműveletes kód, vagy simán if és mask?

Most ezt képzeltem

int act_sec = GetSec();
int wait = act_sec+2;
if(wait>=60)
{
wait = wait&0x03;
}
while(act_sec<wait)
{
act_sec=GetSec();
}

sec += 2;
sec %= 60;

Mondjuk a "while(act_sec<wait)" az problemas lesz tulcsordulaskor.

De mondjuk olyan fuggveny nincs, ami eleve masodpercben (msec-ben, usec-ben) adja vissza az idot?

(#4685) don_peter: "PHP-és vagyok, de ott sokkal egyszerűbbek voltak a dolgok."

Egyszerubbek semmikeppen nem voltak, csak valoszinuleg nem csinaltal semmi olyat, ahol kellett volna tudnod, hogy a konkret bitek szintjen mi is tortenik.

[ Szerkesztve ]

DRM is theft

Általános esetben inkább kivonás mint maszkolás mert ez utóbbi nem mindig jó.
Amúgy osztási maradékot lehet még használni, de az sokkal lassabb szokott lenni.

Egyébként 62 sosem lesz, hiszen maximum 59+2=61 lehet.

A while(act_sec<wait) viszont rossz, hiszen ha az act_sec 59 akkor a wait 1 lesz és bele sem megy a ciklusba.

Ami még probléma lehet, hogy esetleg éppen az aktuális másodperc végén jársz és így akár közel 1 másodpercre is zsugorodhat a várakozási idő.

Jester

Köszi, nem jutott eszembe az osztás. Igen a while-t át kell írni while(act_sec!=wait)-re.
Nincs sajnos, regiszter szinten talán le tudnám, kérdezni az aktuális értéket, de oda már nem akarok lemenni a kódban.

Igen igazad van..
PHP-ben nincsenek ilyen bit dolgok, és relatív, hogy kinek mi az egyszerű ...
Szeretem a PHP-t, de már untam a sok virtuális alkotást.
Akartam valamit ami fizikailag is kivetülhet..
Ezért csípem jobban most a C-ét és a PIC programozást...

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Ohhh...
Soha az életbe nem kellett alkalmaznom... pedig jó néhány dolgot megírtam már az elmúlt tízen pár évben...

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Van arra mód, hogy egy függvény a paraméterként kapott char* pointerről eldöntse, hogy az read-only, read-write memóriaterületre vagy a heap-re mutat?

const fordításidőben? Futásidőben csak plusz változó bevezetésével lehet eldönteni.

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!

Srácok...
Van egy ilyen tömböm:
unsigned char listabuffer[15][18];
Sajnos fordításnál ki írja a program, hogy a "verem keret túl nagy".

A program lényege, hogy a memóriából a 15db előre elmentett nevet kiolvasom amelyek külön-külön 17karakteres +1 a lezáró.
Ötletet kérnék, hogy még is, hogy váltsam ki a többdimenziós tömb használatát?
A gond az, hogy az összes nevet meg kell jelenítsem, hogy választani lehessen belőle.
Illetve van egy mód amire gondolok, de annak kivitelezését kerülném, ha van hatékonyabb megoldás.
(Az én ötletem az, hogy mivel az LCD kijelző maximum 4sort tud egyszerre mutatni így négyesével olvasnám be és léptetném.)
Ötletek?
Előre is köszi..

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Jól értem, akkor nem változik a tömb tartalma? Neked is csak ajánlani tudom a const-t.

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!

Sajnos mindig változik.
A memória IC tartamától függően.
Van mód a szerkesztésre szóval a memória terület az folyton változhat.
Valószínűleg 3masával fogom feltölteni a tömböt és úgy listáztatom ki léptetéssel a 15-öt, nincs jobb ötletem.
így a tömböm is sokkal kisebb lesz így beleférek a verem keretbe...

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Nem nagyon látok bele, hogy mi az ami készülődik, de két dolgot hozzá fűznék. 1. amit lehet azt tedd const tömbbe, mert flash-ből mindig több van, mint RAM-ból és még akkor is megéri ha egy kicsit bonyolultabb tőle a kód. 2. nem tudom milyen projekt keretében csinálod, de szerezz be egy nagyobb uC.

tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!

Hol definiáltad ezt a tömböt? Merthogy globális változóba kéne, nem pedig stackre.

“All nothings are not equal.”