- A Motorola Edge is különleges textúrával várható
- Vivo X200 Pro - a kétszázát!
- Yettel topik
- Samsung Galaxy S24 Ultra - ha működik, ne változtass!
- Samsung Galaxy Watch (Tizen és Wear OS) ingyenes számlapok, kupon kódok
- Samsung Galaxy Z Fold7 - ezt vártuk, de…
- Huawei Watch Fit 5 Pro - jó forma
- Honor Magic7 Pro - kifinomult, költséges képalkotás
- Samsung Galaxy S26 Ultra - fontossági sorrend
- Samsung Galaxy A52s 5G - jó S-tehetség
-
Mobilarena
Mobilarena
Új hozzászólás Aktív témák
-
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.. -
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... -
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.. -
-
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.
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... -
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.
-
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();
} -
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();
} -
Nem a két hónappal van a probléma, hiszen valahol el kell kezdeni, hanem azzal, hogy a fél fórum gyakorlatilag ugyanazt szajkózza, de kötöd az ebet a karóhoz. Hidd el ezek a jelenségek, mint pl. függvények ugyanazt a változót használják és társaik általános jelenségek nyelvtől függetlenül, és erre vannak általános megoldások is.
Assembly-ztél már?
-
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
![;]](//cdn.rios.hu/dl/s/v1.gif)
."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... -
Ö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?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
. -
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: .
-
Ö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? -
Szerintem nem ertettel
Azt mondtam, hogy a menupontokat meg egyebeket nem mindenfele ifekbe kodolnam bele, hanem beleraknam static tombokbe.
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...
-
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.Szerintem nem ertettel
Azt mondtam, hogy a menupontokat meg egyebeket nem mindenfele ifekbe kodolnam bele, hanem beleraknam static tombokbe.
-
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.
-
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...
-
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; -
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...
-
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...
-
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.
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...
-
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? -
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? -
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? -
Hat a hexaban tarolason akadt fent a szemem. Ha jol latom ezt a kovetkeztetest abbol vontad le, hogy az altalad irt (vagy valahonnan kopizott) programban a printf a %x -szel formaz... szet kene kicsit valasztani a fejedben az "ertek" (mit jelent neked), "abrazolas" (milyen modon tarolodik a memoriaban), "megjelenites" (mit latsz a kepernyon amikor lekered, ld. printf) kozott. Es akkor me'g jonnek a cast-ok, mint pl. ez a union... de szamokra is van cast, az abrazolt erteket masik ertelmezessel hasznalni.
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. -
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.... -
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...
Hagyjuk... -
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.
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... -
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.
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 ) -
En feladtam. Sajnos nem ertem mit szeretnel tudni. Remelem jon valaki, aki erti, es valaszol.
Talan me'g azt tehetnem hozza, hogy a 2 byte adatot tekintsd egy 1 jegyu 256-os szamrendszerbeli szamnak. Az egyik byte az a nullasok, a masik a 256-osok szama. Ha erre gondolsz, de nem hiszem. -
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? -
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;
} INT16Aztá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 10000100Amit nem értek, hogy a miért és milyen elv szerint rendezi el önkényesen az átadott adatokat?
-
"Amikor ki akarok írni memóriába egy 16bites adatot akkor ott (short int) hogy tudom kiírni amikor maximum 1bájtonként tud írni a buffer regiszterbe?"
(Gondolom ez a buffer regiszter vmi i/o port)
Ertelemszeruen byte-onkent
typedef unsigned short u16;
void u16_to_port(u16 input)
{
buffer_reg = u16 & 0xff;
// write buffer
buffer_reg = u16 >> 8;
// write buffer
} -
Igen használok már 16bites struktúrát (struct) a memória címzésnél.
SPI 25LC640 memória címzésnél írásnál és olvasásnál.
Amikor ki akarok írni memóriába egy 16bites adatot akkor ott (short int) hogy tudom kiírni amikor maximum 1bájtonként tud írni a buffer regiszterbe?"Amikor ki akarok írni memóriába egy 16bites adatot akkor ott (short int) hogy tudom kiírni amikor maximum 1bájtonként tud írni a buffer regiszterbe?"
(Gondolom ez a buffer regiszter vmi i/o port)
Ertelemszeruen byte-onkent
typedef unsigned short u16;
void u16_to_port(u16 input)
{
buffer_reg = u16 & 0xff;
// write buffer
buffer_reg = u16 >> 8;
// write buffer
} -
"Nem ertem mit akarsz osszevonni, megmondom oszinten... lesz x byte teruleted, arra rateszel egy olyan strukturat, amilyen illik az adatokra. Lesz benne char[] es lesz benne unsigned byte meg unsigned short."
Csak kérdeztem, hogy megoldható e, hogy egyszerre 2 típust tároljak egy változóba, de ez nem megoldható.
Így marad egy külön char ami 8bites és egy short int ami 16bites.
Hozzáteszem, hogy csak egy adat az alsó fűtés igényel 1bájtnál nagyobb területet.
Ezt túl is tárgyaltuk...En me'g azt nem ertem, hogy ha rogton az elejen hogy lehet 2 VAGY 3 byte/char... feltoltod ugy hogy (karakteresen) #12 akkor honnan fogod tudni, hogy igy kell olvasni, es a 2 nem az utana kovetkezo adathoz tartozik es a #1-rol van szo?
Itt a "#" kettős kereszt lesz egy speciális karakter amely jelzi az érvényes adatblokk kezdetét. (ez 1bájt)
Az utána következő 1bájtban egy szám lesz ami 0-14 közt van mivel maximum 15db különálló profilt lehet majd előre rögzíteni a memóriába.
A program elején egy feltétel vizsgálattal ellenőrzöm és beazonosítom az utolsó betöltött profilt.
Az azonosítás több részből áll, de ez már más téma... -
Lattam a video elejet korabban, de nem erdekelt vegig
Vagy nem ez volt, de a kutyudre emlekszem.
Ja, akkor tenyleg 6 adatod van a kozepen is, ez nem volt vilagos.
Hozzateszem, nem vagyok ilyen hardverkozeli programozo, az elso hsz-om is csak a tarolasrol szolt.
Nem ertem mit akarsz osszevonni, megmondom oszinten... lesz x byte teruleted, arra rateszel egy olyan strukturat, amilyen illik az adatokra. Lesz benne char[] es lesz benne unsigned byte meg unsigned short. Nem ez lenne a trivialis? Vagy valamiert mindenkepp egy valamilyen tomb kene legyen?
En me'g azt nem ertem, hogy ha rogton az elejen hogy lehet 2 VAGY 3 byte/char... feltoltod ugy hogy (karakteresen) #12 akkor honnan fogod tudni, hogy igy kell olvasni, es a 2 nem az utana kovetkezo adathoz tartozik es a #1-rol van szo? Raadasul 4 bitnyi adatrol van szo... fura, vagy tovabbra se ertem, nezd el nekem.
Ha csak nagyon helyszukeben lennel, de a prog. hossza nem szamit, akkor a betuket tudnad me'g tomoriteni (mivel a billrol ha jol latom kb. 40 fele karaktert tudsz bevinni, az 6 bitbe befer; na de ezt oda-vissza konvertalgatni macera (kodterulet, hibalehetoseg...), es mindossze 4 byte roviditest ad 16 byte-nal. -
Mikrokontroller programozásról van szó.
A program nyelvünk a C.
A mikrokontroller alap programmemóriája 2KB így csínján kell bánni vele.
Elég nagy lesz a program szóval spórolni szeretnék ahol tudok.
A mikrokontroller Eeprom memóriája 256bájt, ezen területen fogom tárolni az utolsó betöltött állásokat, áramszünet vagy kikapcsolás esetére...
Természetesen csatolni fogok SPI csatlakoztatással egy 64KB-os memóriát is melyben a profil adatokat fogom tárolni.
Ezen memória területeket el kell lássam egy azonosító jellel melyet vissza keresve tudom majd ellenőrizni, hogy az érvényes profilbeállítás.
Ez az érvényes azonosító kerül be az Eeprom területre, és ez alapján töltöm be a memóriából az utolsó elmentett profil állapotot.
A kijelzés egy 2x16 és vagy 4x20karakteres LCD kijelző lesz amelyen a lehető legkifejezőbben szeretném értesíteni a felhasználót az éppen aktuális állapotról.A név hosszán már is spóroltam így csak maximum 16karakter lehet.
A kérdésem pont arra vonatkozott, hogy megoldható e az összevont tárolás, hogy karaktert és számot egyaránt tudjak tárolni.
De úgy fest külön kell megoldanom mint ahogy én is megcsináltam azt eredetileg.
Talán így érthetőbb.
Így meg szerintem totál meg fogod érteni az eredeti elképzelésem: nézd meg kérlek
Köszi...Lattam a video elejet korabban, de nem erdekelt vegig
Vagy nem ez volt, de a kutyudre emlekszem.
Ja, akkor tenyleg 6 adatod van a kozepen is, ez nem volt vilagos.
Hozzateszem, nem vagyok ilyen hardverkozeli programozo, az elso hsz-om is csak a tarolasrol szolt.
Nem ertem mit akarsz osszevonni, megmondom oszinten... lesz x byte teruleted, arra rateszel egy olyan strukturat, amilyen illik az adatokra. Lesz benne char[] es lesz benne unsigned byte meg unsigned short. Nem ez lenne a trivialis? Vagy valamiert mindenkepp egy valamilyen tomb kene legyen?
En me'g azt nem ertem, hogy ha rogton az elejen hogy lehet 2 VAGY 3 byte/char... feltoltod ugy hogy (karakteresen) #12 akkor honnan fogod tudni, hogy igy kell olvasni, es a 2 nem az utana kovetkezo adathoz tartozik es a #1-rol van szo? Raadasul 4 bitnyi adatrol van szo... fura, vagy tovabbra se ertem, nezd el nekem.
Ha csak nagyon helyszukeben lennel, de a prog. hossza nem szamit, akkor a betuket tudnad me'g tomoriteni (mivel a billrol ha jol latom kb. 40 fele karaktert tudsz bevinni, az 6 bitbe befer; na de ezt oda-vissza konvertalgatni macera (kodterulet, hibalehetoseg...), es mindossze 4 byte roviditest ad 16 byte-nal. -
Általában a char 8 bites szokott lenni, ami ugye 1 bájt (unsigned 0 - 255). A short int 16 bites, ami ugye 2 bájt (usnigned 0 - 65535). Az int 32 bites, ami ugye 4 bájt (unsigned 0 - 4 G).
Ha te egy unsigned char-ba teszel 256-t, akkor abban a változóban 0 lesz az értékadás után, mert átvitel fog képződni (signed esetén ezt túlcsordulásnak hívják). Ha te 255-nél nagyobb számot akarsz letárolni, akkor muszáj használnod a short int-et. Vagy char tömbbe is letárolhatod, és akkor rugalmasan lehet bővíteni. Például én most SPI-al akarok meghajtani 6 shift regisztert, ahol char tömbben tárolom le az egyes shift regiszterek bájtait.
Ismerkedj meg a struktúrával. Például:
typedef struct
{
unsigned short int temperature_min;
unsigned short int temperature_max;
unsigned char foo_bar[32];
} FOO_BAR_S; -
Par dolgot nem ertek.
1. ha sporolni akarsz, es raadasul egyszerubben olvashato tarteruletet, akkor miert 2-3 (valtozo hossz!) karakter a sorszam, mikor befer egy byte-ba (sot, ha hexa jegykent irod le, akkor ugymond olvashato formaban is marad '1'..'9','A',...)?
2. miert nem a nev hosszan sporolsz (felteszem nem kell annyira kifejezonek lennie, regen 8 (max+3)-ba mi minden belefert )
3. most akkor hogyan 6 byte a ho- es idoprofil (ott karakteresen tarolsz szamot, es egy tol-ig ahol mindket szelso lehet 3 jegyu?), de 2 byte szamabrazolt az also futes? nekem maga az eredeti elkepzeles nem konzisztens -
Húú annyi információt kaptam, hogy még jobban össze zavart.
Tehát a lényeg, hogy van egy memória területem amiben 32bájt helyem van.
A 32bájt helyre szeretném elmenteni a következőket.:
2-3 karakter a sor azonosító, egy speciális karakter és egy szám 0-14-ig (#0-#14)
16 karakter a név, (min 3 - max 16) 16bájt
6 számérték a hőprofil, (1-255) 6x1bájt
6 számérték az időprofil, (1-255) 6x1bájt
1 számérték az alsó fűtés (1-1023) 2bájtA számadatok unsigned int változóba a karakterek unsigned char változóba vannak jelenleg elmentve és így működik is ahogyan szeretném, de véleményem szerint sok memóriát emészt fel és szeretnék spórolni a felhasználható programmemóriával. (mikrokontroller)
A kérdésem arra irányul, hogy ezen adatokat egy unsigned char változóba is beírhatom úgy hogy a számértékek mint pl.: 255 az maximum 1bájt-ot foglaljanak?
Vagy ez nem megoldható.
Nem tudom mennyire érthető a kérdésem...Par dolgot nem ertek.
1. ha sporolni akarsz, es raadasul egyszerubben olvashato tarteruletet, akkor miert 2-3 (valtozo hossz!) karakter a sorszam, mikor befer egy byte-ba (sot, ha hexa jegykent irod le, akkor ugymond olvashato formaban is marad '1'..'9','A',...)?
2. miert nem a nev hosszan sporolsz (felteszem nem kell annyira kifejezonek lennie, regen 8 (max+3)-ba mi minden belefert )
3. most akkor hogyan 6 byte a ho- es idoprofil (ott karakteresen tarolsz szamot, es egy tol-ig ahol mindket szelso lehet 3 jegyu?), de 2 byte szamabrazolt az also futes? nekem maga az eredeti elkepzeles nem konzisztens -
A program melyet írtam le korlátozza a számértékeket a megengedett 1-255-re (1bájt).
Ha már 256 akkor hibával tér vissza a program, illetve az alsó fűtés értéke lehet nagyobb mint 255, de kisebb mint 65536 vagy is 2bájt.
unsigned char változóba lennének mentve ideiglenesen bevitt értékek...Ja és még ide annyi, hogy mivel a nevet és minden számértéket egy változóba akarok menteni így nem lehet int típusú.
Ez lenne a lényege a dolognak.
unsigned char buffer[32]={0}; //ebbe lenne minden tárolva -
Húú annyi információt kaptam, hogy még jobban össze zavart.
Tehát a lényeg, hogy van egy memória területem amiben 32bájt helyem van.
A 32bájt helyre szeretném elmenteni a következőket.:
2-3 karakter a sor azonosító, egy speciális karakter és egy szám 0-14-ig (#0-#14)
16 karakter a név, (min 3 - max 16) 16bájt
6 számérték a hőprofil, (1-255) 6x1bájt
6 számérték az időprofil, (1-255) 6x1bájt
1 számérték az alsó fűtés (1-1023) 2bájtA számadatok unsigned int változóba a karakterek unsigned char változóba vannak jelenleg elmentve és így működik is ahogyan szeretném, de véleményem szerint sok memóriát emészt fel és szeretnék spórolni a felhasználható programmemóriával. (mikrokontroller)
A kérdésem arra irányul, hogy ezen adatokat egy unsigned char változóba is beírhatom úgy hogy a számértékek mint pl.: 255 az maximum 1bájt-ot foglaljanak?
Vagy ez nem megoldható.
Nem tudom mennyire érthető a kérdésem... -
Fiúk, Lányok!
Lenne egy valószínűleg vicces kérdésem, de muszáj megkérdeznem mert nem vagyok biztos a gondolat menetemben.
A lényeg, hogy van 2 típus, char és int.
El akarom menteni memóriába és az a kérdésem, hogy ha számokat akarok elmenteni char típusként akkor 1 szám 1bájtot fog foglalni?
Tehát ha egy 8-as számot akarok char típusként elmenteni akkor az 1bájtot fog foglalni a memóriában?
És ha 12-őt akkor az már 2bájtot igaz?
Viszont int típusként 0-255-ig 1bájt igaz?
Vagy char típusként is megmarad a 0-255-ig az 1bájt?Én úgy gondolom, hogy char típusnál 1 szám vagy betű 1bájtot foglal.
Okosítsatok fel.
Előre is köszi.. -
Fiúk, Lányok!
Lenne egy valószínűleg vicces kérdésem, de muszáj megkérdeznem mert nem vagyok biztos a gondolat menetemben.
A lényeg, hogy van 2 típus, char és int.
El akarom menteni memóriába és az a kérdésem, hogy ha számokat akarok elmenteni char típusként akkor 1 szám 1bájtot fog foglalni?
Tehát ha egy 8-as számot akarok char típusként elmenteni akkor az 1bájtot fog foglalni a memóriában?
És ha 12-őt akkor az már 2bájtot igaz?
Viszont int típusként 0-255-ig 1bájt igaz?
Vagy char típusként is megmarad a 0-255-ig az 1bájt?Én úgy gondolom, hogy char típusnál 1 szám vagy betű 1bájtot foglal.
Okosítsatok fel.
Előre is köszi.. -
Fiúk, Lányok!
Lenne egy valószínűleg vicces kérdésem, de muszáj megkérdeznem mert nem vagyok biztos a gondolat menetemben.
A lényeg, hogy van 2 típus, char és int.
El akarom menteni memóriába és az a kérdésem, hogy ha számokat akarok elmenteni char típusként akkor 1 szám 1bájtot fog foglalni?
Tehát ha egy 8-as számot akarok char típusként elmenteni akkor az 1bájtot fog foglalni a memóriában?
És ha 12-őt akkor az már 2bájtot igaz?
Viszont int típusként 0-255-ig 1bájt igaz?
Vagy char típusként is megmarad a 0-255-ig az 1bájt?Én úgy gondolom, hogy char típusnál 1 szám vagy betű 1bájtot foglal.
Okosítsatok fel.
Előre is köszi.. -
-
Valaki tud ebbe a feladatba segíteni?
Egy üres sakktáblán a felhasználó által mondott mezőre helyezzünk el egy
futót és jelöljük meg azokat a mezőket, amelyre a futóval lépni lehet.Az éppen vizsgált mező: x
A mező, ahol áll a futó: a
Adott mező melyik sorban van: row()
Adott mező melyik oszlopban van: col()
Szám abszolút értéke: abs()Azok lesznek a keresett mezők, melyekre igaz, hogy
abs(row(a) - row(x)) == abs (col(a) - col(x))
Azaz amelyeknek az a-tól vett oszloptávolgása és sortávolsága megegyezik.
Kivéve persze azt, ahol állunk -
Eszembe jutott még egy lehetőség, és akkor nem kell karakterenként vizsgálnod. Láttam, hogy van printf függvényed, így gondolom sscanf is előfordul. Ha mondjuk %d-t keresel a stringben, és az sscanf visszatérési értéke 1, akkor szám volt, ha 0, akkor meg nem sikerült.
Az sajnos nincs.. mármint sscanf() függvényem, nyilván egyszerübb lenne sok minden, ha pont úgy működne mint PC-én, de sajnos nem
A 4x4-es mátrix gombsort folyamatosan ellenőrzi a progi amit írtam rá és ha gombnyomás történik akkor a gombhoz párosított karaktert menti egy ideiglenes változóba.
Ez után, ha végig ment a kiértékelésen betöltődik egy tömbbe és az ideiglenes változót töröljük és újrakezdődik a folyamat addig ameddig el nem érjük a kívánt karakterszámot vagy ENTER-nek megfelelő gombot meg nem nyomjuk.Érdekes dolog ez a mikrokontroller programozás.
Ui:
Közben így módosítottam a vizsgáló kódom:unsigned int i=0;
unsigned char teszt[4] = {'1','A','3','\0'};
for(i=0; i<=sizeof(teszt)-2; i++){
if ( (teszt[i] >= '0' && teszt[i] <= '9') )
printf("Ez egy számjegy!\n");
else
printf("Ez egy betű!\n");
}Viszont a változó méretű, de maximum 18 karakter férőhelyes tömbömben majd vizsgálnom kell a végét is és ez felveti azt a problémát, hogy a sizeof() függvényt le kell cseréljem egy általam vagy már létező strlen() függvényre.
De, ezek már részletkérdések.. -
Közben rájöttem
Kicsit agyalnom kellett az eddig tanultakon bár annak nem örülök, hogy lépésenként kell végignézni a karaktereket ...unsigned int i=0;
unsigned char teszt[4] = {'1','A','3','\0'};
for(i=0; i<=sizeof(teszt)-1; i++){
if ( (teszt[i] >= 'A' && teszt[i] <= 'Z') )
printf("Ez egy betű!\n");
else
printf("Ez egy számjegy!\n");
}Közben látom, hogy megelőztetek
Köszi..Szerk:
Értem akkor inkább a számokat vizsgáljam, mert az rövidebb ideig tart.
Világos.. Mindig tanulok valami újat.
Néztétek a videót amit linkeltem ezzel kapcsolatban?
Kukk meg itt: [link] -
Az atoi semmiképp se jó választás, hiszen ha nem számjegy karakterrel találkozik, azt simán kihagyja. A "11A" stringedre ha jól saccolom, a visszatérési érték 11.
Az elemenkénti végignézést javasolnám személy szerint, az nem túl költséges, és biztos jó eredményt ad. Mondjuk az a-zA-Z vizsgálat helyett sokkal egyszerűbb azt nézni, hogy az i-edik karakter >= '0' és <= '9'
Na meg nyilván ha == 0, akkor le kell állni a ciklussal.
alapz@j: Ha a memset ezt az intrinsic megoldást használná, nem lenne az egész optimalizáció vs. biztonság mizéria
Közben rájöttem
Kicsit agyalnom kellett az eddig tanultakon bár annak nem örülök, hogy lépésenként kell végignézni a karaktereket ...unsigned int i=0;
unsigned char teszt[4] = {'1','A','3','\0'};
for(i=0; i<=sizeof(teszt)-1; i++){
if ( (teszt[i] >= 'A' && teszt[i] <= 'Z') )
printf("Ez egy betű!\n");
else
printf("Ez egy számjegy!\n");
}Közben látom, hogy megelőztetek
Köszi..Szerk:
Értem akkor inkább a számokat vizsgáljam, mert az rövidebb ideig tart.
Világos.. Mindig tanulok valami újat.
Néztétek a videót amit linkeltem ezzel kapcsolatban?
Kukk meg itt: [link] -
Köszi, de mikrokontrollerbe használom így azt hiszem vagy is azt gondolom, hogy nem működne ez ebben a formában.
Főként talán azért mert nem emlékszem, hogy a C18-as könyvtárban lenne ilyen "intrin.h" állomány.Egyébként ha működne miért lenne ez jobb mint az előző?
A tömbökben amiket törlök memset()-el rövid életűek és csak az interfészen bevitt karaktereket tárolják majd ha végeztem a 14 adat bekérésével kimentem memóriába a tömb adatait és utána rögtön törlöm is.Tényleg ha már itt tartok:
Hogy tudom ellenőrizni a tömb tartalmát hogy abban karaktert vagy számot írtam?
Mutatok egy példát:unsigned char teszt[4] = {'1','2','3','\0'};
//ellenőrzés pedig
if(atoi(teszt)>0 & atoi(teszt)<255){
printf("Csak szám\n");
}else{
printf("Nem csak szám\n");
}
//Másik változat
unsigned char teszt[4] = {'1','1','A','\0'};
//ellenőrzés pedig
if(atoi(teszt)>0 & atoi(teszt)<255){
printf("Csak szám\n");
}else{
printf("Nem csak szám\n");
}Eredménye:
1. Csak szám - ez helyesen értékelődik ki
2. Csak szám - ez hibásan értékelődik ki mivel tartalmaz egy betűt isTegnap próbálkoztam vele és pl: ha betűvel kezdődik a tömb akkor helyesen értékelődik ki, de ha az elején szám van és a végére betűt írok akkor hibás a kiértékelődés.
Hogyan tudom megvizsgálni a tömböt, hogy abban csak számok van?
Köszi előre is..ui: tömb bejárásnál eszembe jutott, hogy talán elemnkénti vizsgálattal pl:
if(tomb[i] != 'A - Z' & tomb[i] != 'a - z') //helyes
Vagy valami ilyesmi...
Az atoi semmiképp se jó választás, hiszen ha nem számjegy karakterrel találkozik, azt simán kihagyja. A "11A" stringedre ha jól saccolom, a visszatérési érték 11.
Az elemenkénti végignézést javasolnám személy szerint, az nem túl költséges, és biztos jó eredményt ad. Mondjuk az a-zA-Z vizsgálat helyett sokkal egyszerűbb azt nézni, hogy az i-edik karakter >= '0' és <= '9'
Na meg nyilván ha == 0, akkor le kell állni a ciklussal.
alapz@j: Ha a memset ezt az intrinsic megoldást használná, nem lenne az egész optimalizáció vs. biztonság mizéria
-
Köszi, de mikrokontrollerbe használom így azt hiszem vagy is azt gondolom, hogy nem működne ez ebben a formában.
Főként talán azért mert nem emlékszem, hogy a C18-as könyvtárban lenne ilyen "intrin.h" állomány.Egyébként ha működne miért lenne ez jobb mint az előző?
A tömbökben amiket törlök memset()-el rövid életűek és csak az interfészen bevitt karaktereket tárolják majd ha végeztem a 14 adat bekérésével kimentem memóriába a tömb adatait és utána rögtön törlöm is.Tényleg ha már itt tartok:
Hogy tudom ellenőrizni a tömb tartalmát hogy abban karaktert vagy számot írtam?
Mutatok egy példát:unsigned char teszt[4] = {'1','2','3','\0'};
//ellenőrzés pedig
if(atoi(teszt)>0 & atoi(teszt)<255){
printf("Csak szám\n");
}else{
printf("Nem csak szám\n");
}
//Másik változat
unsigned char teszt[4] = {'1','1','A','\0'};
//ellenőrzés pedig
if(atoi(teszt)>0 & atoi(teszt)<255){
printf("Csak szám\n");
}else{
printf("Nem csak szám\n");
}Eredménye:
1. Csak szám - ez helyesen értékelődik ki
2. Csak szám - ez hibásan értékelődik ki mivel tartalmaz egy betűt isTegnap próbálkoztam vele és pl: ha betűvel kezdődik a tömb akkor helyesen értékelődik ki, de ha az elején szám van és a végére betűt írok akkor hibás a kiértékelődés.
Hogyan tudom megvizsgálni a tömböt, hogy abban csak számok van?
Köszi előre is..ui: tömb bejárásnál eszembe jutott, hogy talán elemnkénti vizsgálattal pl:
if(tomb[i] != 'A - Z' & tomb[i] != 'a - z') //helyes
Vagy valami ilyesmi...
-
-
-
Hölgyek, Urak!
Hogy tudok egyszerűen és gyorsan törölni egy tömböt?
Pl. van egy ilyen tömböm:
tomb[] = {a,b,c,d,e,f,1,2,3};
Szeretném ennek teljes tartamát törölni, de lehetőleg nem bejárással.
Van erre valami jól bevált vagy legalább hatékonyan használható parancs vagy kód?
Köszi előre is.. -
Nos közben haza értem külföldről és kipróbáltam a kódodat, ilyesfajta bits varázslatokat nem fogad el a C18
Sebaj az első belinkelt kódom kicsi átalakítással már megy is tökéletesen.
Vannak még hibái a programnak, de ha elkészülök dobok fel vidit róla mit sikerült összekovácsolnom...Ígértem egy kis videót a programról amit írtam.
Még nem tökéletes, de rajta vagyok erősen
4x4 alfanumerikus matrix:
video link -
-
Így gondoltad?
unsigned char ttomb[] = {'a','b','c','d','e','f'};
printf("Alap: %s\n", ttomb);
memset(ttomb,'\0',strlen(ttomb));
printf("törlölve: %s\n", ttomb);Ez az elso printf-nel el fog szallni, mert nincs lezarva nullaval, aztan utana az strlen-nel ugyanazert
Ha csak egy stringet akarsz torolni, akkor
ttomb[0] = 0;Ha meg az egesz tombot torolni akarod, akkor meg
memset(ttomb, 0, sizeof(ttomb));(A '\0' erosen tul van cicomazva szerintem
) -
Hölgyek, Urak!
Hogy tudok egyszerűen és gyorsan törölni egy tömböt?
Pl. van egy ilyen tömböm:
tomb[] = {a,b,c,d,e,f,1,2,3};
Szeretném ennek teljes tartamát törölni, de lehetőleg nem bejárással.
Van erre valami jól bevált vagy legalább hatékonyan használható parancs vagy kód?
Köszi előre is.. -
Szeretném én is kiegészíttetni a téma összefoglalót.
Magyar nyelvű könyvekhez:
Kónya László-Kopják József - PIC Mikrovezérlők alkalmazástechnikája [link]Fejlesztő környezetek:
Clang
cross-platform (Windows / Linux / OSX) csak fordítóMPLABX
cross-platform (PIC) fejlesztőkörnyezetEclipse CDT
fordítót nem tartalmaz, de konfigurálhatósága miatt szinte minden platforma minden fordítóval lehet benne fejleszteniLPCXpresso
cross-platform (NXP Cortex-M, ARM7, és ARM9 alapú mikrokontrollerek) fejlesztőkörnyezetAtmel Studio
cross-platform (AVR8, AVR32, Atmel ARM-ok) fejlesztő környezetarm-none-eabi
cross-platform (ARM Cortex-M és Cortex-R) csak fordítóEzek mind ingyenesen használhatóak. Az MPLABX-ben nem vagyok biztos.
-
Szeretném én is kiegészíttetni a téma összefoglalót.
Magyar nyelvű könyvekhez:
Kónya László-Kopják József - PIC Mikrovezérlők alkalmazástechnikája [link]Fejlesztő környezetek:
Clang
cross-platform (Windows / Linux / OSX) csak fordítóMPLABX
cross-platform (PIC) fejlesztőkörnyezetEclipse CDT
fordítót nem tartalmaz, de konfigurálhatósága miatt szinte minden platforma minden fordítóval lehet benne fejleszteniLPCXpresso
cross-platform (NXP Cortex-M, ARM7, és ARM9 alapú mikrokontrollerek) fejlesztőkörnyezetAtmel Studio
cross-platform (AVR8, AVR32, Atmel ARM-ok) fejlesztő környezetarm-none-eabi
cross-platform (ARM Cortex-M és Cortex-R) csak fordítóEzek mind ingyenesen használhatóak. Az MPLABX-ben nem vagyok biztos.
-
Nos közben haza értem külföldről és kipróbáltam a kódodat, ilyesfajta bits varázslatokat nem fogad el a C18
Sebaj az első belinkelt kódom kicsi átalakítással már megy is tökéletesen.
Vannak még hibái a programnak, de ha elkészülök dobok fel vidit róla mit sikerült összekovácsolnom... -
Ja, igen, get_key() helyett konzekvensen getchar()-t irtam, felig mar autopiloton volt az agyam
""PORT_B4" egyenlő a következővel : PORTBbits.RB4"
Ja, akkor az egy bitfield lesz, azon meg meg sokkal egyszerubb vegigmenni, tomb se kell hozza:
#define SOROK_SZAMA 4
#define NO_KEY 0
#define FIRST_ROW_BIT_POSITION 4
#define FIRST_COL_BIT_POSITION 4
#define NO_OF_COLS 4
int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };
unsigned char get_key()
{
unsigned int i, k=0;
for( i=0; i < SOROK_SZAMA ; i++ )
{
SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) ); //Léptetjük a sorok szintjét
for ( j = FIRST_COL_BIT_POSITION ; j < FIRST_COL_BIT_POSITION + NO_OF_COLS ; j++ )
{
k++;
if( PORTBbits & (1 << j) )
{
while( PORTBbits & (1 << j) ); //Várakozunk a gomb felengedéséig
return k;
}
}
}
return NO_KEY;
}"Ha igen akkor ő nem a bit állással kell vissza jöjjön hanem a beolvasott karakterrel ami 1,2,3...16-ig."
Igen, pont ezert mondtam, hogy ott nem jo az, hogy azt adod vissza, hogy ALACSONY, mert az nem karakter
"Ez egy végtelen ciklus nem?"
De, ez az, errol irtam, hogy ez nem szamit, mert a k-t ezen belul inicializaljuk.
Nos közben haza értem külföldről és kipróbáltam a kódodat, ilyesfajta bits varázslatokat nem fogad el a C18
Sebaj az első belinkelt kódom kicsi átalakítással már megy is tökéletesen.
Vannak még hibái a programnak, de ha elkészülök dobok fel vidit róla mit sikerült összekovácsolnom... -
for(;fv(inputa()) || (fv(inputb()) - 1););
vagy
while(fv(inputa()) || (fv(inputb()) - 1));
(#4590) Wyll: A fordító más megvilágítás alá helyezi a kódot, ha ternary operátor van benne. Ugyanez van a for(;;) és while(1) esetén is. Van olyan fordító ahol az utóbbinál tényleg érték ellenőrzés van. Ez mind fordító függő, illetve PC-n nem is kritikus ezzel foglalkozni, mert van bőven számítási kapacitás, illetve hely is.
jaja - másodikat írni akartam, csak már nem volt időm javítani és nem volt kedvem tovább spammelni
-
for(;fv(inputa()) || (fv(inputb()) - 1););
vagy
while(fv(inputa()) || (fv(inputb()) - 1)); (#4590) Wyll: A fordító más megvilágítás alá helyezi a kódot, ha ternary operátor van benne. Ugyanez van a for(;;) és while(1) esetén is. Van olyan fordító ahol az utóbbinál tényleg érték ellenőrzés van. Ez mind fordító függő, illetve PC-n nem is kritikus ezzel foglalkozni, mert van bőven számítási kapacitás, illetve hely is.
-
ezek csak pszeudo-függvények: inputa és inputb-vel töltöd fel az a és b változók értékeit...
Viszont ha csak kiértekeléskor kéri be az értékeket, akkor:
while(1) {
if (fv(inputa())) break;
fb = fv(inputb());
if (fb == 0 || fb == 2) break;
}Így a b-t be sem kéri, ha az első input hatására kilépett az első függvénynél.
Illetve csúnyán
while(1) {
if (fv(inputa()) || (fv(inputb()) - 1)) break;
}
![;]](http://cdn.rios.hu/dl/s/v1.gif)
.
Hagyjuk...
.
Amúgy szép 
Új hozzászólás Aktív témák
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- E-roller topik
- A Motorola Edge is különleges textúrával várható
- Vivo X200 Pro - a kétszázát!
- Sorozatok
- AMD Ryzen 9 / 7 / 5 7***(X) "Zen 4" (AM5)
- A fociról könnyedén, egy baráti társaságban
- Először kombinálja a Full HD-t az 1000 Hz-cel egy monitor
- Óra topik
- Yettel topik
- PlayStation 5
- További aktív témák...
- 24 magos AMD Threadripper alapú munkára kiváló félgép, 128GB RAM-mal
- HP ZBook Fury 15 G7 i7-10850H 32GB 512GB SSD Quadro T2000 4GB FHD HUN bill, szép állapotban eladó
- Eladó MacBook Pro 16,1 2019 CTO
- új 0 km es garanciás lenovo loq rtx 5050 8gb
- Eladó teljesen újszerű karcmentes Samsung Galaxy Watch Ultra
- HIBÁTLAN iPhone 14 Pro Max 128GB Gold -2 ÉV GARANCIA - Kártyafüggetlen, MS5211
- Audi A6 C5 Multimedia - 1/32GB / 12 hó jótállás
- HP ProBook 650 G5 - i5 8265U, 8-16GB RAM, SSD, jó akku, számla, 6 hó gar
- "ÚJ" RITKA MINT A FEHÉR HOLLÓ" ASUS ROG STRIX GeForce RTX 3090 24GB (GARANCIA 3 ÉVIG)
- Xiaomi Redmi Note 14 Pro+ 5G 512GB, Kártyafüggetlen, 1 Év Garanciával
Állásajánlatok
Cég: Laptopműhely Bt.
Város: Budapest