- Luck Dragon: Asszociációs játék. :)
- Klaus Duran: Youtube AI szinkron
- sziku69: Fűzzük össze a szavakat :)
- sziku69: Szólánc.
- f(x)=exp(x): A laposföld elmebaj: Vissza a jövőbe!
- bambano: Bambanő háza tája
- gban: Ingyen kellene, de tegnapra
- GoodSpeed: AMD Ryzen 7 7700X vs AMD Ryzen 9 9900X Cinebench R23 & R24 Benchmarkokban mérve
- D1Rect: Nagy "hülyétkapokazapróktól" topik
- Argos: Adjátok vissza a netet! - szeretnék elaludni!
Új hozzászólás Aktív témák
-
buherton
őstag
válasz
don_peter
#4698
üzenetére
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.
-
don_peter
senior tag
válasz
buherton
#4697
üzenetére
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... -
don_peter
senior tag
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.. -
don_peter
senior tag
-
Jester01
veterán
válasz
tototos
#4687
üzenetére
Á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ő.
-
válasz
tototos
#4687
üzenetére
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.
-
tototos
addikt
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();
} -
buherton
őstag
válasz
don_peter
#4683
üzenetére
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?
-
buherton
őstag
válasz
don_peter
#4677
üzenetére
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)
. -
don_peter
senior tag
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..
-
-
don_peter
senior tag
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: .
-
don_peter
senior tag
Ö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? -
don_peter
senior tag
válasz
dabadab
#4675
üzenetére
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...
-
don_peter
senior tag
válasz
dabadab
#4673
üzenetére
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. -
válasz
don_peter
#4668
üzenetére
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.
-
Jester01
veterán
válasz
tototos
#4671
üzenetére
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; -
don_peter
senior tag
válasz
buherton
#4664
üzenetére
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...
-
Jester01
veterán
válasz
buherton
#4664
üzenetére
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; -
válasz
don_peter
#4663
üzenetére
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. -
-
don_peter
senior tag
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? -
don_peter
senior tag
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. -
axioma
veterán
válasz
don_peter
#4660
üzenetére
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.
-
don_peter
senior tag
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.... -
don_peter
senior tag
válasz
buherton
#4656
üzenetére
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...
-
-
axioma
veterán
válasz
don_peter
#4653
üzenetére
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. -
don_peter
senior tag
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? -
don_peter
senior tag
válasz
dabadab
#4650
üzenetére
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?
-
válasz
don_peter
#4645
üzenetére
"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
} -
don_peter
senior tag
Igen használok adatstruktúrát és azt union-ban (típus definícióval) megadva megadom a memória címzését hexában...
De azt hogy egy adott 2bájtos adatot, hogyan adok át egy memóriának mikor az maximum 1bájtot tud egyszerre a buffer regiszterébe kezelni....ez nem fér a fejembe..
A többi dolgot megoldom sort int és unsigned char típusú változókkal. -
don_peter
senior tag
"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... -
axioma
veterán
válasz
don_peter
#4644
üzenetére
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. -
don_peter
senior tag
-
don_peter
senior tag
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... -
axioma
veterán
válasz
don_peter
#4639
üzenetére
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 -
buherton
őstag
válasz
don_peter
#4641
üzenetére
Á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; -
don_peter
senior tag
válasz
k.kristof
#4640
üzenetére
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 -
don_peter
senior tag
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... -
Karma
félisten
válasz
don_peter
#4635
üzenetére
Képzavarban vagy.
A char, short, int, long, long long különböző méretű, egy számot tároló típusok. Ha nem is a száraz C szabványt, legalább a Wikipédia felsorolását nézd meg.
A méretük fix, nincs olyan hogy egy int 255 alatt csak egy, fölötte több bájt, mindig négy (tipikus fordítóknál, PC-n). A char meg mindig egy bájt. Ha nagyobb számot akarsz beleírni, mint amit ábrázolni tud, akkor átfordul az érték. Pl. unsigned char esetén 255 + 3 = 2.
Gyanús, hogy belekeverted a karakterláncokat gondolatban (char*, char[]).
-
kispx
addikt
válasz
don_peter
#4635
üzenetére
Nem egészen.
Az egy számjegyű számokat eltudod menteni char típusba mivel egy betűből áll. A 2 vagy több karakterből álló számokhoz string kell. (és ide a lezáró nullát bele kell számolni.). (És ennél a pontnál már az 1 jegyű számokat is úgy tárold)
> "És ha 12-őt akkor az már 2bájtot igaz?"
És még a lezáró '\0' karaktert is hozzá kell számolni.> "Viszont int típusként 0-255-ig 1bájt igaz?"
Nem. Az int típusnak fix a mérete (általában 4 bájt). A charnak is fix a mérete 1 bájt. -
k.kristof
őstag
válasz
don_peter
#4635
üzenetére
A char típus mérete 1 bájt, azaz 8 bit, ez maximálisan 256-féle érték tárolására képes. Alapértelmezetten signed char a típus, ekkor [-128,+127] az ábrázolható tartomány, ha unsigned chart használsz, akkor pedig [0,255].
Ajánlom ezt a linket neked: Difference between signed / unsigned char.
-
don_peter
senior tag
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.. -
Wyll
őstag
válasz
kezdő91
#4631
üzenetére
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 -
don_peter
senior tag
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.. -
Karma
félisten
válasz
don_peter
#4628
üzenetére
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.
-
don_peter
senior tag
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] -
Karma
félisten
válasz
don_peter
#4625
üzenetére
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
-
don_peter
senior tag
válasz
alapz@j
#4623
üzenetére
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...
-
alapz@j
tag
-
válasz
don_peter
#4615
üzenetére
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
) -
don_peter
senior tag
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.. -
buherton
őstag
válasz
dabadab
#4608
üzenetére
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.
-
don_peter
senior tag
válasz
dabadab
#4578
üzenetére
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... -
buherton
őstag
válasz
sztanozs
#4602
üzenetére
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.
-
alapz@j
tag
-
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.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
.
Hagyjuk...
.
Amúgy szép 
Új hozzászólás Aktív témák
Hirdetés
● olvasd el a téma összefoglalót!
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Telefon felvásárlás!! iPhone 13 Mini/iPhone 13/iPhone 13 Pro/iPhone 13 Pro Max
- Telefon felvásárlás!! Honor Magic6 Lite, Honor Magic6 Pro, Honor Magic7 Lite, Honor Magic7 Pro
- HP Elite / ZBook Thunderbolt 3 docking station
- ÁRGARANCIA!Épített KomPhone i7 14700KF 32/64GB RAM RTX 5070 Ti 16GB GAMER PC termékbeszámítással
- Eladó Karcmentes állapotban levő Samsung A40 4/64GB / 12 hó jótállás
Állásajánlatok
Cég: FOTC
Város: Budapest