- Samsung Galaxy A56 - megbízható középszerűség
- Telekom mobilszolgáltatások
- Fotók, videók mobillal
- Bemutatkozott az Oppo kamerás csúcsmodellje
- Milyen okostelefont vegyek?
- Samsung Galaxy A55 - új év, régi stratégia
- Samsung Galaxy S24 Ultra - ha működik, ne változtass!
- Xiaomi 14 - párátlanul jó lehetne
- Okosóra és okoskiegészítő topik
- Szaporodik és sokasodik a One UI 8.5
-
Mobilarena
Mobilarena
Új hozzászólás Aktív témák
-
Mire kell az fv() ?? -- Jaa, hogy az az én fv()-m?
Szerintem nem jó ez a megoldás. Mert pl. nem lép ki ha az első lépésben 2-es a visszatérési érték.Nem használják egymás eredményét.
Annyiszor kéri be az értékeket, ahányszor a visszatérési érték függvényében lefutnak a függvények.
Háromfajta visszatérési érték van:
0 -> ok, továbbmehetünk
1 -> visszalépés az előző állapotba
2 -> megszakítjuk a folyamatotJa dehogynem lép ki, hülye vagyok...
Akkor asszem jó
De akkor minek kell az inputa() ill. inputb() ? Egyetlen függvényem van.. -
Asszem valahogy így (remélem jól értettem az ábrát):
while(1) {
a = inputa();
b = inputb();
if (fv(a)) break;
fb = fv(b);
if (fb == 0 || fb == 2) break;
}Vagy az értékeket csak egyszer kéri be? De akkor ha fv(a) == 0 és fv(b) = 1 akkor végtelen ciklus lesz...
Vagy egymás eredményét használják fel?
a = input >> b = fv(a) >> a = fv(b)?Mire kell az fv() ?? -- Jaa, hogy az az én fv()-m?
Szerintem nem jó ez a megoldás. Mert pl. nem lép ki ha az első lépésben 2-es a visszatérési érték.Nem használják egymás eredményét.
Annyiszor kéri be az értékeket, ahányszor a visszatérési érték függvényében lefutnak a függvények.
Háromfajta visszatérési érték van:
0 -> ok, továbbmehetünk
1 -> visszalépés az előző állapotba
2 -> megszakítjuk a folyamatot -
Volna egy apró feladatom, aki szereti az ilyen kis apró agytornákat - na nem mintha olyan nehéz volna, csak mégis. Arra volnék kíváncsi, ki hogyan oldaná meg az alábbi bekérési folyamatot:
Igazából a két kocka a program egy-egy állapotát jelzi, amikor ugyanazt a függvényt egyik vagy másik (de mindig ugyanazon egyik vagy másik) paraméterrel kell meghívni, a nyilak pedig hogy a visszatérési érték függvényében mit kell csinálni a következő lépésben.
A folyamat a baloldali állapotban kell hogy induljon.
Ha mindkétszer sikerrel lefutott (0, 0) akkor készen vagyunk,
2es eredmény után mindkét esetben gondolkodás nélkül ki kell lépnünk a folyamatból,
1es eredmény után alapvetően "visszalépünk", de ez az első esetben szintén kilépést jelent. -
Wyll
őstag
Volna egy apró feladatom, aki szereti az ilyen kis apró agytornákat - na nem mintha olyan nehéz volna, csak mégis. Arra volnék kíváncsi, ki hogyan oldaná meg az alábbi bekérési folyamatot:
Igazából a két kocka a program egy-egy állapotát jelzi, amikor ugyanazt a függvényt egyik vagy másik (de mindig ugyanazon egyik vagy másik) paraméterrel kell meghívni, a nyilak pedig hogy a visszatérési érték függvényében mit kell csinálni a következő lépésben.
A folyamat a baloldali állapotban kell hogy induljon.
Ha mindkétszer sikerrel lefutott (0, 0) akkor készen vagyunk,
2es eredmény után mindkét esetben gondolkodás nélkül ki kell lépnünk a folyamatból,
1es eredmény után alapvetően "visszalépünk", de ez az első esetben szintén kilépést jelent. -
Ha nincs ellenvetes, akkor a DevC++-t lecserelem QtCreatorre.
Meg igy jobban megnezve, a Turbo C is lehet, hogy aktualitasat vesztette. Ahelyett mondjuk VS Express?Mindenképpen jobb lenne a QT Creator és a VS Express
. Illetve néhány oldallal ezelőtt volt az a másik windowsos IDE, az is megérhet egy említést. -
"Gondolom hogy működik, csak szokatlan."
Igen, mukodik, es tokeletesen illik C filozofiajaba. Szerintem pl. az a "szokatlan", hogy a return paramteret nem kell zarojelbe rakni
Most nézem a téma összefoglalót: ajánljátok benne a DevC++ -t. Tisztelettel indítványoznám ennek az újragondolását ezen cikk alapján.
-
Sziasztok!
? :
argumentumai lehetnek változók is, ugye? (Expression, azaz kifejezés kell legyen az argumentum, és ahogy az a + b egy kifejezés, úgy gondolom a sima a is egy kifejezés).
Namost, függvényhívásnál paraméterként átadott változót meg lehet-e adni ilyen módon? Tehát pl. működik-e az, hogy
switch ( fuggveny(a, b, i == 1 ? c : d) ) {
/*switch body*/
}Gondolom hogy működik, csak szokatlan.
"Gondolom hogy működik, csak szokatlan."
Igen, mukodik, es tokeletesen illik C filozofiajaba. Szerintem pl. az a "szokatlan", hogy a return paramteret nem kell zarojelbe rakni
-
Fél szemmel figyelemmel követem az OpenBSD-s srácok OpenSSL újraíró projektjét (LibreSSL) és annak kommentárjait a Opensslrampage.org -on. Az egyik legutóbbi gyöngyszemük az OpenSSL kódból:
strncpy(dest, src, strlen(src))
Ez azért komoly kérdéseket vet fel a kód minőségét illetően...
-
Lehetne rekurzivan, de ez a feladat sztem pont nem alkalmas arra, hogy lasd, mire valo a rekurzio (az "ugyanaz a feladat" helyett itt pont a rekurzio melysege szerinti if-es szetagazasok vannak). Itt inkabb a helyedben a kulso if-ben (az 'a' erteke pozitiv es 4000 alatti) tennek ciklust, akkor nem szamit a sorrendje az if-eknek. Sot, ha jobban megnezed, akkor az if-ek igazabol nem kene kulon kezeljek azt, hogy nincs mar tobb kiirando, lehet mindig 1-gyel csokkenteni az n-et, mert megteheto hogy a 0 az nem fuz semmit az outputhoz (me'gis lesz 0. elem minden statikus tombben, ami az ures string ""). Vagy nezheted ugy, hogy az n-re nincs is szukseged, csak az 'a'-ra, aminek egy ciklusban mindig csak a legfelso szamjegyet ertekeled ki (es magat az a-t modositod, nem az n-et). Igazabol a szamkent kezeles se feltetlen kene, ha marad stringben, akkor cimezheted az (inp-'0')-val a statikus tombodet... Es raadasul me'g a tombjeidet is szervezhetned tombbe, akkor az i. karakterhez az i. tombbol kell venned ezt az erteket (nyilvan ekkor hatulrol kezdve szamozva, de length-1 -tol lefele szamolva a ciklust). Ebbol mar eleg kompakt kis kod keletkezne.
-
Hat akkor az a baj, ami ott else-ben van (en is jol atneztem felette, ugy tunt mintha az futna le - nem veletlen a minden egy utasitasos blokkot is zarojelparba szokas) az rakna' at az outputba... az egyeseknel ottmarad a romai-ban... amelyikben meg nem volt egyes, az rafut erre, ott meg tok foloslegesen ujra atmasolja.
szerk. jo, lehet a tomb jo (es nem csak mukodo
), vegulis a * es a [] "valahol" egyenertekuek, lehet hogy csak tolem idegen szokas.Igazad van, köszi. Így már jó is
Most jön az hogy rekurziót kezelő fv-t írjak... Arról jelenleg fingom sincs, hogyan kéne
-
hát az n==1-nél csak strcat van.
a memória foglalásnál tudom, hogy az sima char, már kijavítottam, csak úgy néz ki az egyel régebbi verziót sikerült bemásolnom.(#4582): de eddig nem volt baj a tömbök ilyen jellegű megoldásával, futott is rendesen, meg csak az egyes helyiértéknél van gáz. +másnál is láttam már ilyesmi megoldást
Hat akkor az a baj, ami ott else-ben van (en is jol atneztem felette, ugy tunt mintha az futna le - nem veletlen a minden egy utasitasos blokkot is zarojelparba szokas) az rakna' at az outputba... az egyeseknel ottmarad a romai-ban... amelyikben meg nem volt egyes, az rafut erre, ott meg tok foloslegesen ujra atmasolja.
szerk. jo, lehet a tomb jo (es nem csak mukodo
), vegulis a * es a [] "valahol" egyenertekuek, lehet hogy csak tolem idegen szokas. -
Eloszor is a 12. sorban (4*n, char) a parameter es nem char*, bar ez nem okozhatja elvileg a hibat (bar odaillobb lenne egy +1 is az elsohoz, a 888 lezaro nullaja miatt).
Masodszor en nem vagyok ennyire benne a C-s stringfuggvenyekben es most utananezni sincs kedvem, de a feltuno kulonbseg az, hogy az n==1-nel nem strcat-olsz. Azt gyanitanam, hogy a stringvegzodest jelzo nullat az a fuggveny rantja a tobbinel helyre. -
Eloszor is a 12. sorban (4*n, char) a parameter es nem char*, bar ez nem okozhatja elvileg a hibat (bar odaillobb lenne egy +1 is az elsohoz, a 888 lezaro nullaja miatt).
Masodszor en nem vagyok ennyire benne a C-s stringfuggvenyekben es most utananezni sincs kedvem, de a feltuno kulonbseg az, hogy az n==1-nel nem strcat-olsz. Azt gyanitanam, hogy a stringvegzodest jelzo nullat az a fuggveny rantja a tobbinel helyre. -
Sziasztok!
Segítenétek nekem? Itt ez a kód ami arabból csinál római számokat, alapból úgy írtam meg, hogy sztringként tér vissza és csa 1 int változót kell neki megadni, de a feladat amibe szükségem van rá, úgy köveleti meg ahogy most van. A gondom az, hogy amíg az előbb említett verzióban volt akkor tökéletesen működött, viszont az átírt verzióval valami gond van, mert ha az egyesek helyi értékén 0tól különböző szám van akkor csak memória szemetet ír ki...
Pl. ha 960-at akarok átváltani akkor minden oké, de ha 969-et, 58-at vagy 3-at akkor mindig az előbb említett jelenség jön elő és nem jövök rá mi a gond. -
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.
Ez akkor most vissza tér egy char típusú karakterrel ami 1-16-ig van, gombnyomástól függően.
Ez eddig szép és jó. Mellesleg köszönöm, hogy tisztába raktad a dolgot és leegyszerűsítetted, sokat fogok belőle tanulni.
A fő kérdés viszont az, hogy miként kivitelezhető az, hogy mint a telefonnál alfanumerikus módon is írhassak?
Tehát van egy 4x4-es mátrix nyomó gombsorom, az rá van csatlakoztatva a mikrovezérlőmre és szépen, ha megnyomom valamelyik gombot akkor 1-től 16-ig vissza adja nekem a benyomott gomb értékét.
4x4 keypad
Ezt nem tudom tovább gondolni, hogy miként lehetne megoldani, hogy egy-egy gomb többszöri megnyomásánál már alfanumerikus értékként a gombonkénti eltárolt 3 betű egyikét adja vissza.
Arra gondoltam, hogy valami ciklusban ciklust kellene futtatni és mivel egy gombot megnyomok és várakoztatnom kellene legalább 1-2mp-et, és vizsgálnom, hogy van e ugyan azon a gombon közvetlen, további nyomás és az szerint váltani a betűket, hogy hány további nyomás történik.Legalább is erre felé gondolkodom, persze ez lehet nem jó irány.
Gyakorlatilag mint a telefon gombsora úgy működne a dolog annyi kivétellel, hogy nem lenne annyi karakter.
Csak az angol nagy betűs A-Z-ig és 0-9-ig számok kellenek.
Illetve egy BACK és SPACE gomb, hogy vissza törölhető és léptethető legyen a dolog.
Ez természetesen csak a gombsor egy részét foglalná le ami 4sorból és 3oszlopból állna.
A 4. oszlop 4sora külön funkció gombok lennének.
Szóval ezen a dolgon rágom magam már lassan 1 hete, de túlnő rajtam ez a globális gondolkodás.
Tudsz ebben segíteni?
Ha csak elméletben azt is megköszönöm.
Természetesen az eddig megírt és leegyszerűsített kódot kellene kiegészíteni ezzel a nem kis résszel
Előre is köszi a segítséget. (Ha valamit nem világosan írtam, csak kérdezz bele bátran) -
Az a baj, hogy alig másfél hónapja kezdtem el a C-ét és a C18-at vagy is a PIC programozást egyszerre így sajnos nem tudok még rendesen érthetően megfogalmazni a kérdéseimet.
"SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) );"
Gyakorlatilag, ha két >> jelet teszünk az azt jelenti, hogy a 2 hatványával léptetjük a változó értékét a megadott irányban? (Ha igen akkor már is tanultam ismét valamit, vagy is tanultam már csak nem értettem meg ezek szerint)"int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Hogy ez is tiszta legyen:
"PORT_B4" egyenlő a következővel : PORTBbits.RB4
Gyakorlatilag ez egy (port) regiszter mellyel a chip egy adott porton adott láb állapotát tudjuk lekérdezni, hogy az 1 vagy 0.
Ha 1 akkor annak állapota magas szintű, értelemszerűen a 0 = alacsony szinttel.
A portok nekem egy header állományban külön definiálva vannak, pl. így:
#define PORT_B4 PORTBbits.RB4"#define NO_KEY 0"
Teljesen igazad van.
Jobb rászokni az olvasható kód írásra...Ezt a részt nem igazán értem: "Viszont a getchar() egyaltalan nem egy bit allasat adja vissza, hanem egy karakterkodot, ami logikailag abszolút más dolog."
Vagy itt elírás történt és valójában getchar() az get_key() akart lenni?
Ha igen akkor ő nem a bit állással kell vissza jöjjön hanem a beolvasott karakterrel ami 1,2,3...16-ig."A ciklus végtelen pergésben van"
while(1){
bill_ertek = get_key();
Delay10TCYx(10);
}//while()
Ez egy végtelen ciklus nem?
Ebben minden ciklusnál újratöltődik a bill_ertek változó még ha egyelőre nem is jól van megadva."Ha arra gondoltál, hogy a getchar()-t kívülről végtelen ciklusban hívod, az meg nem számít, mert azzal kezdődik, hogy lenullázod a k-t"
Feltételezem, hogy itt is get_key()-re gondolsz.
Igen igazad van mert ha vége a ciklusnak akkor az újra meghívásnál nullázódik alapból is a k.
Próbálkozom erősen, de kellenek a szakik tanácsai és gondos szemeiJa, 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.
-
[ disclaimer: elso komoly programozasi dolgaim C64-en, assemblerben voltak, aztan utana modernebb mikrokontrollerekhez is volt szerencsem, szoval ismerem ezt a vilagot
]"#define FIRST_ROW_BIT_POSITION 4"
Így gyakorlatilag csak egy értéket adunk FIRST_ROW_BIT_POSITION nak és nem tudjuk később léptetni a mikrocsip lábait.De. Azert adunk hozza i-t. Vegyuk eszre, hogy a
SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) );
ugyanaz, mint a
SOROK = ( ( 1 >> FIRST_ROW_BIT_POSITION ) >> i ) );
ami meg jelen esetben nem mas, mint
SOROK = ( 0x08 >> i ) );
(Mondjuk elrontottam, mert FIRST_ROW_BIT_POSITION helyes erteke 3, nem 4)
"int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Ezt ugyan nem próbáltam még ilyen formában, de van egy sejtésem, hogy nem jó mivel értéknét adjuk át a az egyes portok egyes lábait.Nem volt teljesen egyertelmu, hogy ezek micsodak, de ha memory mapped portok, akkor annyi valtozik, hogy nem int, hanem char * lesz az oszlopok[] tipusa.
"#define NO_KEY 0"
Gyakorlatilag ugyan az mint az én
"#define ALACSONY 0" definícióm.Legfeljebb a fordito szempontjabol, de a kodot hasznalo programozok szempontjabol egyaltalan nem.
Ugyanis ott az ALACSONY jol lathatoan a MAGAS parja, amit arra hasznalsz, hogy megvizsgald, hogy valamelyik bit hogyan all.
Viszont a getchar() egyaltalan nem egy bit allasat adja vissza, hanem egy karakterkodot, ami logikailag abszolut mas dolog."A ciklus végtelen pergésben van"
Nincs abban. Az eredeti kododban egyetlen ciklus van, ami pontosan negyszer fut le.
Ha arra gondoltal, hogy a getchar()-t kivulrol vegtelen ciklusban hivod, az meg nem szamit, mert azzal kezdodik, hogy lenullazod a k-t, vagyis nem tud 16 fole noni az erteke (es teljesen feleslegesen nullazod, mert auto valtozokent a stacken van az erteke, a kovetkezo hivasig nem orzodik meg - persze csinalhatnal belole staticet, de annak meg semmi ertelme nem lenne, mert nincs ra szukseged)."Egyszóval, ha sima C programnak tekintjük akkor tökéletes a példád, de sajnos itt figyelembe kell venni, hogy mikrokontrollert programozunk fel illetve a lábak szintjeit ellenőriztük."
Ilyen szempontbol ez tok sima C program, tenyleg nincs benne semmi extra. Persze, embedded cuccoknal lehetnek extra kovetelmenyek (pl. hogy ROM-ot lehessen belole forditani, vagyis pl. a konstans tomboket nem lehetne koddal inicializalni, csak statikus ertekekkel), akkor az hozhatna par dolgot, de igazabol az is sima C. A mikrokontroller-programozas tenyleg nem az a nagy varazslat
Az a baj, hogy alig másfél hónapja kezdtem el a C-ét és a C18-at vagy is a PIC programozást egyszerre így sajnos nem tudok még rendesen érthetően megfogalmazni a kérdéseimet.
"SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) );"
Gyakorlatilag, ha két >> jelet teszünk az azt jelenti, hogy a 2 hatványával léptetjük a változó értékét a megadott irányban? (Ha igen akkor már is tanultam ismét valamit, vagy is tanultam már csak nem értettem meg ezek szerint)"int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Hogy ez is tiszta legyen:
"PORT_B4" egyenlő a következővel : PORTBbits.RB4
Gyakorlatilag ez egy (port) regiszter mellyel a chip egy adott porton adott láb állapotát tudjuk lekérdezni, hogy az 1 vagy 0.
Ha 1 akkor annak állapota magas szintű, értelemszerűen a 0 = alacsony szinttel.
A portok nekem egy header állományban külön definiálva vannak, pl. így:
#define PORT_B4 PORTBbits.RB4"#define NO_KEY 0"
Teljesen igazad van.
Jobb rászokni az olvasható kód írásra...Ezt a részt nem igazán értem: "Viszont a getchar() egyaltalan nem egy bit allasat adja vissza, hanem egy karakterkodot, ami logikailag abszolút más dolog."
Vagy itt elírás történt és valójában getchar() az get_key() akart lenni?
Ha igen akkor ő nem a bit állással kell vissza jöjjön hanem a beolvasott karakterrel ami 1,2,3...16-ig."A ciklus végtelen pergésben van"
while(1){
bill_ertek = get_key();
Delay10TCYx(10);
}//while()
Ez egy végtelen ciklus nem?
Ebben minden ciklusnál újratöltődik a bill_ertek változó még ha egyelőre nem is jól van megadva."Ha arra gondoltál, hogy a getchar()-t kívülről végtelen ciklusban hívod, az meg nem számít, mert azzal kezdődik, hogy lenullázod a k-t"
Feltételezem, hogy itt is get_key()-re gondolsz.
Igen igazad van mert ha vége a ciklusnak akkor az újra meghívásnál nullázódik alapból is a k.
Próbálkozom erősen, de kellenek a szakik tanácsai és gondos szemei -
Köszönöm a kiigazítást.
Gondolom én voltam félreérthető az első bejegyzésemben."#define FIRST_ROW_BIT_POSITION 4"
Így gyakorlatilag csak egy értéket adunk FIRST_ROW_BIT_POSITION nak és nem tudjuk később léptetni a mikrocsip lábait.
Tehát ez "SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) ); " helyett az kell amit eredetileg is írtam.
SOROK = (0x08>>i); Ezzel gyakorlatilag a mikrocsip B portjának lábaira adunk magas szintet."int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Ezt ugyan nem próbáltam még ilyen formában, de van egy sejtésem, hogy nem jó mivel értéknét adjuk át a az egyes portok egyes lábait.
Bár elképzelhető, hogy ha minden ciklusba adom át a tömbnek az értékeket akkor elvileg működhet is."#define NO_KEY 0"
Gyakorlatilag ugyan az mint az én
"#define ALACSONY 0" definícióm."A k-t állítgató résznek semmi értelme"
A ciklus végtelen pergésben van és ha nem érkezik gombnyomás akkor a 4 ciklusonként nullázni kell az értékét hiszen 4x4 vagy is 16gomb van.Egyszóval, ha sima C programnak tekintjük akkor tökéletes a példád, de sajnos itt figyelembe kell venni, hogy mikrokontrollert programozunk fel illetve a lábak szintjeit ellenőriztük.
Azt hiszem erre irányuló kérdésem a C topikban nem állja meg a helyét.
Köszönöm ettől függetlenül a segítőkészséget.[ disclaimer: elso komoly programozasi dolgaim C64-en, assemblerben voltak, aztan utana modernebb mikrokontrollerekhez is volt szerencsem, szoval ismerem ezt a vilagot
]"#define FIRST_ROW_BIT_POSITION 4"
Így gyakorlatilag csak egy értéket adunk FIRST_ROW_BIT_POSITION nak és nem tudjuk később léptetni a mikrocsip lábait.De. Azert adunk hozza i-t. Vegyuk eszre, hogy a
SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) );
ugyanaz, mint a
SOROK = ( ( 1 >> FIRST_ROW_BIT_POSITION ) >> i ) );
ami meg jelen esetben nem mas, mint
SOROK = ( 0x08 >> i ) );
(Mondjuk elrontottam, mert FIRST_ROW_BIT_POSITION helyes erteke 3, nem 4)
"int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Ezt ugyan nem próbáltam még ilyen formában, de van egy sejtésem, hogy nem jó mivel értéknét adjuk át a az egyes portok egyes lábait.Nem volt teljesen egyertelmu, hogy ezek micsodak, de ha memory mapped portok, akkor annyi valtozik, hogy nem int, hanem char * lesz az oszlopok[] tipusa.
"#define NO_KEY 0"
Gyakorlatilag ugyan az mint az én
"#define ALACSONY 0" definícióm.Legfeljebb a fordito szempontjabol, de a kodot hasznalo programozok szempontjabol egyaltalan nem.
Ugyanis ott az ALACSONY jol lathatoan a MAGAS parja, amit arra hasznalsz, hogy megvizsgald, hogy valamelyik bit hogyan all.
Viszont a getchar() egyaltalan nem egy bit allasat adja vissza, hanem egy karakterkodot, ami logikailag abszolut mas dolog."A ciklus végtelen pergésben van"
Nincs abban. Az eredeti kododban egyetlen ciklus van, ami pontosan negyszer fut le.
Ha arra gondoltal, hogy a getchar()-t kivulrol vegtelen ciklusban hivod, az meg nem szamit, mert azzal kezdodik, hogy lenullazod a k-t, vagyis nem tud 16 fole noni az erteke (es teljesen feleslegesen nullazod, mert auto valtozokent a stacken van az erteke, a kovetkezo hivasig nem orzodik meg - persze csinalhatnal belole staticet, de annak meg semmi ertelme nem lenne, mert nincs ra szukseged)."Egyszóval, ha sima C programnak tekintjük akkor tökéletes a példád, de sajnos itt figyelembe kell venni, hogy mikrokontrollert programozunk fel illetve a lábak szintjeit ellenőriztük."
Ilyen szempontbol ez tok sima C program, tenyleg nincs benne semmi extra. Persze, embedded cuccoknal lehetnek extra kovetelmenyek (pl. hogy ROM-ot lehessen belole forditani, vagyis pl. a konstans tomboket nem lehetne koddal inicializalni, csak statikus ertekekkel), akkor az hozhatna par dolgot, de igazabol az is sima C. A mikrokontroller-programozas tenyleg nem az a nagy varazslat
-
Köszönöm a kiigazítást.
Gondolom én voltam félreérthető az első bejegyzésemben."#define FIRST_ROW_BIT_POSITION 4"
Így gyakorlatilag csak egy értéket adunk FIRST_ROW_BIT_POSITION nak és nem tudjuk később léptetni a mikrocsip lábait.
Tehát ez "SOROK = (1 >> ( FIRST_ROW_BIT_POSITION + i ) ); " helyett az kell amit eredetileg is írtam.
SOROK = (0x08>>i); Ezzel gyakorlatilag a mikrocsip B portjának lábaira adunk magas szintet."int oszlopok[] = { PORT_B4, PORT_B5, PORT_B6, PORT_B7 };"
Ezt ugyan nem próbáltam még ilyen formában, de van egy sejtésem, hogy nem jó mivel értéknét adjuk át a az egyes portok egyes lábait.
Bár elképzelhető, hogy ha minden ciklusba adom át a tömbnek az értékeket akkor elvileg működhet is."#define NO_KEY 0"
Gyakorlatilag ugyan az mint az én
"#define ALACSONY 0" definícióm."A k-t állítgató résznek semmi értelme"
A ciklus végtelen pergésben van és ha nem érkezik gombnyomás akkor a 4 ciklusonként nullázni kell az értékét hiszen 4x4 vagy is 16gomb van.Egyszóval, ha sima C programnak tekintjük akkor tökéletes a példád, de sajnos itt figyelembe kell venni, hogy mikrokontrollert programozunk fel illetve a lábak szintjeit ellenőriztük.
Azt hiszem erre irányuló kérdésem a C topikban nem állja meg a helyét.
Köszönöm ettől függetlenül a segítőkészséget. -
#define SOROK_SZAMA 4
#define NO_KEY 0
#define FIRST_ROW_BIT_POSITION 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 = 0 ; j < sizeof(oszlopok) ; j++ )
{
k++;
if(oszlopok[j] == MAGAS)
{
while( oszlopok[j] == MAGAS ); //Várakozunk a gomb felengedéséig
return k;
}
}
}
return NO_KEY;
}Vagyis az oszlopokat szepen tombbe lehet rakni, es akkor a ciklusbol tenylegesen ciklust lehet csinalni.
A k-t allitgato resznek semmi ertelme nem volt, mert csak arra allitotta, ami amugy is az erteke volt (illetve a vegen nullara, de azt meg nem hasznaltad sehol).
Es ha nem talal semmit, akkor nem ALACSONY-t adunk vissza, hanem valami sajat erteket, mert az logikailag ket kulonbozo dolog - akkor is, ha a konkret ertek pont ugyanaz (most - aztan lehet, hogy kesobb nem lesz az).
Illetve a kodba lehetoseg szerint nem illik mindenfele konstansokat elhinteni, ha valami konstans, akkor legyen az, C-ben tipikusan #DEFINE-nal.
-
Oksa közben rájöttem, hogy az oszlop1, oszlop 2...stb-re gondolsz.
És közben arra is rájöttem, hogy mivel az oszlop1, ...oszlop4 változok a mikrovezérlő lábait tartalmazzák így azokat nem tömbösíthetem.
Az if() feltétben a mikrovezérlő lábainak szintjét ellenőrzöm, hogy magas vagy alacsony szinten áll. -
Közben rájöttem, hogy van a kódban még hiba így azt javítottam.:
unsigned char get_key(){
unsigned int i, k=0;
for(i=0; i<4; i++){
SOROK = (0x08>>i); //Léptetjük a sorok szintjét
k++;
if(oszlop1 == MAGAS){
while(oszlop1==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop2 == MAGAS){
while(oszlop2==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop3 == MAGAS){
while(oszlop3==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop4 == MAGAS){
while(oszlop4==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
if(i>0){ //Ha a második lefutásnál sincs találat
k=(i+1)*4;
}else if(i==3){ //Ha az utolsó is lepörgött nullázzuk k-t
k=0;
SOROK = 0x08; //Sorok szintjét vissza állítjuk az elejére.
}else{ //Első lefutás után a k értéke 4 lesz
k=4;
}
}
return ALACSONY;
}Arra célzol, hogy gondolkozzak 2 dimenziós tömbökbe?
-
Hölgyek, Urak segítséget szeretnék kérni alfanumerikus 4x4-es keypad programjának megírásához.
Angol ABC és 0-9-ig számok lennének kb. mint a telefonnál vagy hasonlóan gondoltam kivitelezni.
Tudtok segíteni elméletben vagy akár gyakorlatban?
Hogyan lehet ezt legegyszerűbben megírni?
P18F4550-es mikrokontroller fogja feldolgozni az adatokat.
Ilyen lenne a keypad:A sima 16 gomb kezelésére írtam már programot, talán ebből ki lehetne indulni csak nem tudom, hogy miként vagy milyen irányban haladjak tovább..
A megírt kódom most így néz ki:#include <delays.h>
#define SOROK LATD //Sorok
#define oszlop1 PORT_B4 //Oszlopok bemenet
#define oszlop2 PORT_B5
#define oszlop3 PORT_B6
#define oszlop4 PORT_B7
#define MAGAS 1
#define ALACSONY 0
/*----- Prototípus --------*/
unsigned char get_key();
unsigned int bill_ertek; //Globális változó
void main(void){
unsigned int i,k=0;
ADCON1 = 7; //Analóg portok digitálisra állítva
TRISB = 0xf0; //B port felső 4 bit (nagyobb helyi értéken 7:4) bemenet
//alsó 4 bit (kisebb helyi értéken 3:0) kimenet
//0b11110000
while(1){
bill_ertek = get_key();
Delay10TCYx(10);
}//while()
}//main()
//Függvények
unsigned char get_key(){
unsigned int i, k=0;
for(i=0; i<4; i++){
SOROK = (0x08>>i); //Léptetjük a sorok szintjét
k++;
if(oszlop1 == MAGAS){
while(oszlop1==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop2 == MAGAS){
while(oszlop2==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop3 == MAGAS){
while(oszlop3==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop4 == MAGAS){
while(oszlop4==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
if(i>0){ //Ha a második lefutásnál sincs találat
k=(i+1)*4;
}else if(i==3){ //Ha az utolsó is lepörgött nulláztuk k-t
k=0;
}else{ //Első lefutás után a k értéke 4 lesz
k=4;
}
}
return ALACSONY;
}Minden ötletet szívesen fogadok.
-
don_peter
senior tag
Hölgyek, Urak segítséget szeretnék kérni alfanumerikus 4x4-es keypad programjának megírásához.
Angol ABC és 0-9-ig számok lennének kb. mint a telefonnál vagy hasonlóan gondoltam kivitelezni.
Tudtok segíteni elméletben vagy akár gyakorlatban?
Hogyan lehet ezt legegyszerűbben megírni?
P18F4550-es mikrokontroller fogja feldolgozni az adatokat.
Ilyen lenne a keypad:A sima 16 gomb kezelésére írtam már programot, talán ebből ki lehetne indulni csak nem tudom, hogy miként vagy milyen irányban haladjak tovább..
A megírt kódom most így néz ki:#include <delays.h>
#define SOROK LATD //Sorok
#define oszlop1 PORT_B4 //Oszlopok bemenet
#define oszlop2 PORT_B5
#define oszlop3 PORT_B6
#define oszlop4 PORT_B7
#define MAGAS 1
#define ALACSONY 0
/*----- Prototípus --------*/
unsigned char get_key();
unsigned int bill_ertek; //Globális változó
void main(void){
unsigned int i,k=0;
ADCON1 = 7; //Analóg portok digitálisra állítva
TRISB = 0xf0; //B port felső 4 bit (nagyobb helyi értéken 7:4) bemenet
//alsó 4 bit (kisebb helyi értéken 3:0) kimenet
//0b11110000
while(1){
bill_ertek = get_key();
Delay10TCYx(10);
}//while()
}//main()
//Függvények
unsigned char get_key(){
unsigned int i, k=0;
for(i=0; i<4; i++){
SOROK = (0x08>>i); //Léptetjük a sorok szintjét
k++;
if(oszlop1 == MAGAS){
while(oszlop1==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop2 == MAGAS){
while(oszlop2==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop3 == MAGAS){
while(oszlop3==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
k++;
if(oszlop4 == MAGAS){
while(oszlop4==MAGAS); //Várakozunk a gomb felengedéséig
return k;
}
if(i>0){ //Ha a második lefutásnál sincs találat
k=(i+1)*4;
}else if(i==3){ //Ha az utolsó is lepörgött nulláztuk k-t
k=0;
}else{ //Első lefutás után a k értéke 4 lesz
k=4;
}
}
return ALACSONY;
}Minden ötletet szívesen fogadok.
-
Ereshkigal
őstag
-
A "Valaminev#60#120#185#225#240#260" -ből egy ciklussal a kettőskereszteket nullára cseréled:
Valaminev\060\0120\0185\0225\0240\0260
így létrejön 7 stringed. A char memtomb[7][46] helyett egy pointer tömböt csinálsz (char *memtomb[7]) és menet közben mindig feljegyzed az aktuális stringedre mutató pointert:
unsigned char meminput[] = "Valaminev#60#120#185#225#240#260";
unsigned char *memtomb[7];
memtomb[0] = meminput;
size_t len = strlen(meminput);
int memptr = 1;
for (int i = 0; i < len; ++i) {
if (meminput[i] == '#') {
meminput[i] = 0;
memtomb[memptr++] = meminput + i + 1;
}
}
for (int i = 0; i < 7; ++i)
printf("%s\n", memtomb[i]);Köszi, ezt átnézem és megpróbálom értelmezni.
Szerintem menni fog.
A mutatókat még eddig én nem alkalmaztam, de itt az ideje -
Ez ebben a formában még magas nekem, de azért köszi a szándékot.
A mutatókat már ismerem, de csak felületesen.
Átvariáltam a dolgot mivel a fentebbi kódomnál csak a char típus jöhetett szóba és így pazaroltam a bájtokat illetve a megfelelő típusmódosítások is igényeltek további sorokat.
Az új verzában már külön szedtem a char és int típusokat és így már szebben lehet e memóriába beírni és kiolvasni.
Nem kellenek az elválasztó karakterek sem.
Ahogy tanulom és gyakorlom a dolgot úgy értem meg egyre jobban a működéseket. -
> Van esetleg egyszerűbb és hatékonyabb megoldás a következő kódomra?
Ha az eredeti meminput tömbre nincs szükséged, akkor hatékonyabb, ha a kettőskereszteket kicseréled 0 értékekre és az azokat követő karakterre mutató pointereket tárolod el egy char *[]-ban.Ez ebben a formában még magas nekem, de azért köszi a szándékot.
A mutatókat már ismerem, de csak felületesen.
Átvariáltam a dolgot mivel a fentebbi kódomnál csak a char típus jöhetett szóba és így pazaroltam a bájtokat illetve a megfelelő típusmódosítások is igényeltek további sorokat.
Az új verzában már külön szedtem a char és int típusokat és így már szebben lehet e memóriába beírni és kiolvasni.
Nem kellenek az elválasztó karakterek sem.
Ahogy tanulom és gyakorlom a dolgot úgy értem meg egyre jobban a működéseket. -
Ereshkigal
őstag
-
alapz@j
tag
Véletlenszám generátor inicializálásához szükségem lenne (legalább) 128 bit adathoz (seed). Szívesen fogadnék bármiféle ötletet a szokásos rendszeridő, process id, stb. megoldásokon túl.
-
Közben meg is oldottam a dolgot.
A kérdésem a következő lenne:
Van esetleg egyszerűbb és hatékonyabb megoldás a következő kódomra?
#define MAXTOMBSIZE 32 //headerbe
//main()
unsigned int maxmemtomb;
char meminput[MAXTOMBSIZE] = "Valaminev#60#120#185#225#240#260";
char memtomb[7][46];
int i,z,x;
char ek = '#';
maxmemtomb = MAXTOMBSIZE;
x=0;
z=0;
for(i=0; i<=maxmemtomb-1; i++){
if(meminput[i] == ek){
z=0;
x++;
printf("\n%c", meminput[i+1]);
memtomb[x][z] = meminput[i+1];
z++;
i++;
}else{
printf("%c", meminput[i]);
memtomb[x][z] = meminput[i];
z++;
}
}
printf("\n\nTömbbe rendezve:\n");
for(i=0; i<=6; i++){
printf("%i. adat: %s\n",i, memtomb[i]);
}
Illetve az is érdekel, hogy miért kellett a "char memtomb[7][46];" többdimenziós tömböm második paraméterébe minimum 46-ot tennem, hogy jó eredményt kapjak?
Ezt nem értem még akkor sem, ha így működik...
Elviekben ott a maximum 9 karakter lehet mert a "Valaminev" a leghosszabb string nem? Vagy nem jól értelmezek valamit? -
Nem olyan nagyon jó
Mivel az OS valószínűsíthetően tiszta lappal indítja a processzed, ezért ez a memóriaszemét jó eséllyel determinisztikus lesz. Ráadásul fordítási és memóriaellenőrzési (valgrind) figyelmeztetést is okoz."Nem olyan nagyon jó"
Az openSSL is hasznalja ezt a technikat azert, hogy legyen egy kis plusz entropia (bar az elmult napok tukreben nem vagyok biztos, hogy ez ajanlas vagy elrettentes
) -
Ereshkigal
őstag
Nem olyan nagyon jó
Mivel az OS valószínűsíthetően tiszta lappal indítja a processzed, ezért ez a memóriaszemét jó eséllyel determinisztikus lesz. Ráadásul fordítási és memóriaellenőrzési (valgrind) figyelmeztetést is okoz.Észrevettem.
Egyelőre próbálom gyűjteni a lehetőségeket, aztán meglátjuk. Igyekszem majd lecsípni mindenhonnan az "értékes" biteket. -
Jester01
veterán
Köszi, egynek jó.
Nem olyan nagyon jó
Mivel az OS valószínűsíthetően tiszta lappal indítja a processzed, ezért ez a memóriaszemét jó eséllyel determinisztikus lesz. Ráadásul fordítási és memóriaellenőrzési (valgrind) figyelmeztetést is okoz. -
Ereshkigal
őstag
-
buherton
őstag
Véletlenszám generátor inicializálásához szükségem lenne (legalább) 128 bit adathoz (seed). Szívesen fogadnék bármiféle ötletet a szokásos rendszeridő, process id, stb. megoldásokon túl.
-
Ereshkigal
őstag
-
En alapvetoen java-s vagyok, csak az elvi hibakat szurom - foleg annak aki ennyire rendes, hogy a holgyeket is megemliti
. Felteszem van valami split fuggveny stringekre es felteszem hogy az legalabb olyan jol van megirva mint amit te meg tudsz, de nem ismerem a C-s fg-konyvtarakat, hogy konkretabban megadjam. Az azert valoszinu, hogy egy regota ebben elo C-s az forditva csinalna, megkeresne a kovetkezo #-et (vagy nullat, hogy altalanos legyen, neked most csak pont erre a hosszra muxik), es utana az elozotol addig egyben masoltatna'.Igen van ilyen, csak nem jutottam előrébb vele és ezért kezdtem el gondolkodni a lépéseken.
Itt a függvény:
#include<string.h>
#include<stdio.h>
int main()
{
char input[16] = "abc,d";
char *p;
p = strtok(input, ",");
if(p)
{
printf("%s\n", p);
}
p = strtok(NULL, ",");
if(p)
printf("%s\n", p);
return 0;
}
Szerintem ő jól dolgozik, csak nem jutottam vele dűlőre -
Húúú mennyire igazad van..
A lezárót elfelejtettem.
Most már jó...char memtomb[7][10];
És
memtomb[x][z] = '\0';egyébként ez véleményed szerint hatékony módszer vagy ennél van egyszerűbb és hatékonyabb mód a szétválasztásra és tömbbe másolásra?
Gondolom ha a számokat már int típusra akarom alakítani akkor a típusmódosítással el tudom érni azt.
int elsoszam;
elsoszam = (int)memtomb[1];
Ez így jó lesz?En alapvetoen java-s vagyok, csak az elvi hibakat szurom - foleg annak aki ennyire rendes, hogy a holgyeket is megemliti
. Felteszem van valami split fuggveny stringekre es felteszem hogy az legalabb olyan jol van megirva mint amit te meg tudsz, de nem ismerem a C-s fg-konyvtarakat, hogy konkretabban megadjam. Az azert valoszinu, hogy egy regota ebben elo C-s az forditva csinalna, megkeresne a kovetkezo #-et (vagy nullat, hogy altalanos legyen, neked most csak pont erre a hosszra muxik), es utana az elozotol addig egyben masoltatna'. -
Ha jol ertem, stringek tombjet szeretned a kulonszedett elemekkel, tehat a memtomb az char[][], es a meretvalasztasnal 1-gyel tobb kell mint a leghosszabb elem, bar a Valaminev-nel lazan a 7-t is kifutod... Persze annak az indexet is kovetned kell, hogy mikor melyikbe irsz, es annak is hanyadik elemere (bar eccerubb, ha megjegyzed az utolso elvalasztas helyet, es csak kivonogatsz, de vszinu atlathatatlanabb is egyuttal).
Masreszt meg amikor # jon az inputban, akkor az aktualis memtomb-elemedet le kell zarni egy 0-val.szerk. nem frissitettem, nalam keresztposzt...
Most nezem, az utolso sor azert kelleni fog neked...Húúú mennyire igazad van..
A lezárót elfelejtettem.
Most már jó...char memtomb[7][10];
És
memtomb[x][z] = '\0';egyébként ez véleményed szerint hatékony módszer vagy ennél van egyszerűbb és hatékonyabb mód a szétválasztásra és tömbbe másolásra?
Gondolom ha a számokat már int típusra akarom alakítani akkor a típusmódosítással el tudom érni azt.
int elsoszam;
elsoszam = (int)memtomb[1];
Ez így jó lesz? -
Urak, Hölgyek!
A következő kóddal van bajom:
//headerbe
#define MAXTOMBSIZE 32
//main()
unsigned int maxmemtomb;
char meminput[MAXTOMBSIZE] = "Valaminev#60#120#185#225#240#260";
char memtomb[7];
int i;
char ek = '#';
maxmemtomb = MAXTOMBSIZE;
for(i=0; i<=maxmemtomb-1; i++){
if(meminput[i] == ek){
printf("\n%c", meminput[i+1]);
//memtomb[i] = meminput[i+1];
i++;
}else{
printf("%c", meminput[i]);
//memtomb[i] = meminput[i];
}
}
//for(i=0; i<=6; i++){
//printf("\nAdatok: %s\n", memtomb);
// }A program lényege, hogy a "Valaminev#60#120#185#225#240#260" karakterláncot a # karakternél szétválasszam és a szétválasztott elemeket egy tömbbe töltsem.
Addig jó a program, hogy kiírja a képernyőre a szétválasztott elemeket egymás alá, de mikor bele akarom tölteni egy tömbbe a szétválasztott elemeket akkor zagyvaságokat ír bele.
Próbáltam már kismillió formában, de a végén nem lesz jó az eredmény.
Mit cseszek el folyamatosan?
Hogy tudnám ezt megoldani?A program élesben egy 64KB-os memória 32bájt-ját fogja beolvasni ami hasonlóan vagy pont így fogja tárolni az adatot, a szétválasztott adatok külön-külön lesznek hasznosak.
De ha nem jó a megközelítésem szívesen veszem a kiokításokat. -
Urak, Hölgyek!
A következő kóddal van bajom:
//headerbe
#define MAXTOMBSIZE 32
//main()
unsigned int maxmemtomb;
char meminput[MAXTOMBSIZE] = "Valaminev#60#120#185#225#240#260";
char memtomb[7];
int i;
char ek = '#';
maxmemtomb = MAXTOMBSIZE;
for(i=0; i<=maxmemtomb-1; i++){
if(meminput[i] == ek){
printf("\n%c", meminput[i+1]);
//memtomb[i] = meminput[i+1];
i++;
}else{
printf("%c", meminput[i]);
//memtomb[i] = meminput[i];
}
}
//for(i=0; i<=6; i++){
//printf("\nAdatok: %s\n", memtomb);
// }A program lényege, hogy a "Valaminev#60#120#185#225#240#260" karakterláncot a # karakternél szétválasszam és a szétválasztott elemeket egy tömbbe töltsem.
Addig jó a program, hogy kiírja a képernyőre a szétválasztott elemeket egymás alá, de mikor bele akarom tölteni egy tömbbe a szétválasztott elemeket akkor zagyvaságokat ír bele.
Próbáltam már kismillió formában, de a végén nem lesz jó az eredmény.
Mit cseszek el folyamatosan?
Hogy tudnám ezt megoldani?A program élesben egy 64KB-os memória 32bájt-ját fogja beolvasni ami hasonlóan vagy pont így fogja tárolni az adatot, a szétválasztott adatok külön-külön lesznek hasznosak.
De ha nem jó a megközelítésem szívesen veszem a kiokításokat. -
-
Lehet nálam van nagyon hétfő még de nem tudom hogy lehetne ezt egy loop segítségével megoldani
Ja, tenyleg hetfo reggel van, nem vettem eszre, hogy ez nem egy darab fuggveny
Viszont akkor egyre jobban nem ertem az egeszet. Mi az a taskN parameter es miert nem az RTOS_tasks-hoz valo indexet adod at a fuggvenynek, ahelyett, hogy beledrotozod?
-
-
Sziasztok!
Egy kis macro segítség kellene. A következő sorokat szeretném kiváltani macroval:
task_Function[0] = task1;
task_Function[1] = task2;
task_Function[2] = task3;
task_Function[3] = task4;
task_Function[4] = task5;
task_Function[5] = task6;
task_Function[6] = task7;
static portTASK_FUNCTION(task1,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[0].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[0].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task2,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[1].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[1].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task3,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[2].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[2].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task4,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[3].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[3].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task5,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[4].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[4].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task6,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[5].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[5].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}
static portTASK_FUNCTION(task7,params){
portTickType xLastWakeTime;
const portTickType xFrequency = RTOS_tasks[6].period_ldu32 / portTICK_RATE_MS;
// Initialize the xLastWakeTime variable with the current time.
xLastWakeTime = xTaskGetTickCount();
while(1)
{
RTOS_tasks[6].taskFunction(params);
// Wait for the next cycle.
vTaskDelayUntil( &xLastWakeTime, xFrequency );
}
}Meg lehet ezt valósítani? Köszi.
-
Olvasd el az interrupt kezelést még egyszer, hogy tisztában legyél hogyan működik. A következő azaz, hogy a kiválasztott perifériának engedélyezni kell, hogy megszakítson, aztán engedélyezni kell a globális a megszakítást. Ha jól emlékszem, akkor elég buta megszakítás kezelője van, mert egy függényt hívogat mindig, és azon belül kell megnézni, hogy mely periféria flag-e állt be. Vagy lehet keverem egy másikkal? Nem akarok hitvitát indítani, de ez egy ritka rossz megoldása a megszakítás kezelésnek. Eddig 4 architektúrára fejlesztettem és ebből 3-nak azonos az elv, kivéve a PIC-ét, továbbá a FreeRTOS sem képes stabilan futni rajta. Ha javasolhatom, akkor inkább AVR, de még inkább az ARM Cortex-M0-t javaslom. Ez lenne a legjobb választás.
-
Ereshkigal
őstag
Valaki tuna nekem segíteni ebben a feladatba?
Adottak az n elemű a, b, c vektorok. Meg kell számlálni, hogy a c vektor hány eleménél teljesül az ai < ci < bi (i = 0,1,…,n-1) feltétel. Adja meg még a feltételt kielégítő ci elemek összegét is!eddig sikerült megcsinálni:
#include <stdio.h>
#include <stdlib.h>int main()
{
int a[] = {2, 5, 7, 13};
int b[] = {9, 54, 98, 56};
int c[] = {8, 8, 43, 17};int i;
int db = 0;for(i = 0; i < 4; i++)
if(a < c(i) && c(i)< b(i))
db++;
printf("%i", db);return 0;
}
Csak nekem az kéne hogy úgy töltöm fel a tömbbe az elemeket hogy saját magam írom be. Pl így: A vektor elemei: 1 2 3 4
B vektor elemei: 1 2 3 4 -
Ereshkigal
őstag
Valaki tuna nekem segíteni ebben a feladatba?
Adottak az n elemű a, b, c vektorok. Meg kell számlálni, hogy a c vektor hány eleménél teljesül az ai < ci < bi (i = 0,1,…,n-1) feltétel. Adja meg még a feltételt kielégítő ci elemek összegét is!eddig sikerült megcsinálni:
#include <stdio.h>
#include <stdlib.h>int main()
{
int a[] = {2, 5, 7, 13};
int b[] = {9, 54, 98, 56};
int c[] = {8, 8, 43, 17};int i;
int db = 0;for(i = 0; i < 4; i++)
if(a < c(i) && c(i)< b(i))
db++;
printf("%i", db);return 0;
}
Csak nekem az kéne hogy úgy töltöm fel a tömbbe az elemeket hogy saját magam írom be. Pl így: A vektor elemei: 1 2 3 4
B vektor elemei: 1 2 3 4 -
Ami biztosan problema az a "char seged[3];", ugyanis egy n karakterbol allo stringnek n+1 meretu helyre van szuksege, mert a vegere kell hely a lezaro 0-nak is.
Egyebkent a tanar nem buzdit kommentirasra?
És most jó !!
Köszönöm szépen a segítséged, nagyon hálás vagyok ! :p
Gondolhattam volna a lezáró 0-ra
Egyébként magamtól tanulom a programozást mert az infótanárom csak pascal-t ismeri, és mivel BME-re készülök, célszerűbbnek gondoltam megtanulni a C-t, oda úgy is az kell a legelején, szóval a tanár ebben nem tud segíteni -
Sziasztok !
Kezdő vagyok a C nyelvben, emelt szintű érettségihez tanulom. Nincsenek nagy követelmények, megcsináltam már pár feladatsort, mentek is. Az eleje úgy kezdődik mindig, hogy egy txt fájlból kell adatokat beolvasni tömbökbe. Ez eddig ment mindig, most viszont valami nagyon nem stimmel, és egyszerűen nem tudom miért, jól jönne egy kis segítség :/
Szóval van egy fájl, konkrétan ez[link]Mivel az első sor tartalmaz a későbbiekben fontos adatokat, azokat csak sima változóba kell beolvasnom, tehát a tömbökbe való beolvasás a 2. sortól kezdődik. A problémám az, hogy mikor leellenőrzöm, hogy mindent jól olvasott-e be, nem azokat a számokat dobja ki, amiket kéne. Nem is látok benne logikát, hogy miért azokat dobja ki, amiket. Ráadásul valamelyik tömbelem jó, valamelyik nem.
Itt a kódom, ha valamit magyarázzak hozzá, csak szóljatok.
A txt-ben az első sor első száma azt jelenti, hogy hány sor van a tömbben a 2.-tól kezdődöen. 3 tömbbe olvasom az adatokat egy segédtömb segítségével. A segéd azért 3 elemű, mert a txt-ben lévő számok maximum 3 számjegyűek.int eladott_jegyek, vonal_hossz, fizetendo_osszeg, i;
char seged[3];
FILE * eladott = fopen ("eladott1.txt","rt");
fscanf(eladott,"%s",seged);
eladott_jegyek = atoi(seged);
fscanf(eladott,"%s",seged);
vonal_hossz = atoi(seged);
fscanf(eladott,"%s",seged);
fizetendo_osszeg = atoi(seged);
int ules_szam[eladott_jegyek], fel_szall[eladott_jegyek], le_szall[eladott_jegyek];
for (i=0;i<eladott_jegyek;i++) {
fscanf(eladott,"%s",seged);
ules_szam[i] = atoi(seged);
fscanf(eladott,"%s",seged);
fel_szall[i] = atoi(seged);
fscanf(eladott,"%s",seged);
le_szall[i] = atoi(seged);
}
for (i=0;i<eladott_jegyek;i++) {
printf("%d ",ules_szam[i]);
printf("%d ",fel_szall[i]);
printf("%d\n",le_szall[i]);
}Például már eleve az első sorok nem jók, az ules_szam tömb 0. eleme még jó, a fel_szall tömb 0. eleme szintén jó, majd a le_szall 0. eleme teljesen rossz, 12 helyett 1958474236-t olvas be.
Nem értem, hogy miért, légyszi segítsetek :/
Előre is köszönöm annak, aki fáradozik azzal hogy segítsen !!Ami biztosan problema az a "char seged[3];", ugyanis egy n karakterbol allo stringnek n+1 meretu helyre van szuksege, mert a vegere kell hely a lezaro 0-nak is.
Egyebkent a tanar nem buzdit kommentirasra?
-
JmL
csendes tag
Sziasztok !
Kezdő vagyok a C nyelvben, emelt szintű érettségihez tanulom. Nincsenek nagy követelmények, megcsináltam már pár feladatsort, mentek is. Az eleje úgy kezdődik mindig, hogy egy txt fájlból kell adatokat beolvasni tömbökbe. Ez eddig ment mindig, most viszont valami nagyon nem stimmel, és egyszerűen nem tudom miért, jól jönne egy kis segítség :/
Szóval van egy fájl, konkrétan ez[link]Mivel az első sor tartalmaz a későbbiekben fontos adatokat, azokat csak sima változóba kell beolvasnom, tehát a tömbökbe való beolvasás a 2. sortól kezdődik. A problémám az, hogy mikor leellenőrzöm, hogy mindent jól olvasott-e be, nem azokat a számokat dobja ki, amiket kéne. Nem is látok benne logikát, hogy miért azokat dobja ki, amiket. Ráadásul valamelyik tömbelem jó, valamelyik nem.
Itt a kódom, ha valamit magyarázzak hozzá, csak szóljatok.
A txt-ben az első sor első száma azt jelenti, hogy hány sor van a tömbben a 2.-tól kezdődöen. 3 tömbbe olvasom az adatokat egy segédtömb segítségével. A segéd azért 3 elemű, mert a txt-ben lévő számok maximum 3 számjegyűek.int eladott_jegyek, vonal_hossz, fizetendo_osszeg, i;
char seged[3];
FILE * eladott = fopen ("eladott1.txt","rt");
fscanf(eladott,"%s",seged);
eladott_jegyek = atoi(seged);
fscanf(eladott,"%s",seged);
vonal_hossz = atoi(seged);
fscanf(eladott,"%s",seged);
fizetendo_osszeg = atoi(seged);
int ules_szam[eladott_jegyek], fel_szall[eladott_jegyek], le_szall[eladott_jegyek];
for (i=0;i<eladott_jegyek;i++) {
fscanf(eladott,"%s",seged);
ules_szam[i] = atoi(seged);
fscanf(eladott,"%s",seged);
fel_szall[i] = atoi(seged);
fscanf(eladott,"%s",seged);
le_szall[i] = atoi(seged);
}
for (i=0;i<eladott_jegyek;i++) {
printf("%d ",ules_szam[i]);
printf("%d ",fel_szall[i]);
printf("%d\n",le_szall[i]);
}Például már eleve az első sorok nem jók, az ules_szam tömb 0. eleme még jó, a fel_szall tömb 0. eleme szintén jó, majd a le_szall 0. eleme teljesen rossz, 12 helyett 1958474236-t olvas be.
Nem értem, hogy miért, légyszi segítsetek :/
Előre is köszönöm annak, aki fáradozik azzal hogy segítsen !! -
Persze. Nanoszekundumot a clock_gettime függvénnyel kapsz, ha a CLOCK_REALTIME órát adod neki paraméternek.
Műxik
-
Srácok és lányok
Nem tartozik ide szorosan, de hátha nem köveztek meg egy ilyen kérdésért.
A lényeg, hogy C programozásban gondolkodom vagy is valószínűleg komolyabban is bele fogom ásni magam a dolgokba.
Ezzel kapcsolatos főiskolai szakokat keresgélek, de nem tudom mi lenne nekem a legmegfelelőbb.
Mind ezt természetesen annak tudatában kellene megválasztanom, hogy az a jövőre nézve is ("ha egyáltalán beszélhetünk még jövőről") értékes ismeretekkel gyarapítson, tehát a munka, elhelyezkedésemet szemelőt tartva biztos egzisztenciám legyen.
Tehát, olyan szakot kellene választanom, ami jelenleg és későbbiekben is keresett lesz.
Van esetleg ötletetek, elképzelésetek milyen szakot válasszak?
Esti vagy levelezői lesz a megfelelő, hogy finanszírozni is tudjam a tanulmányaimat.Web programozásban már vannak ismereteim: HTML, CSS, PHP, SQL, JS...stb.
-
don_peter
senior tag
Srácok és lányok
Nem tartozik ide szorosan, de hátha nem köveztek meg egy ilyen kérdésért.
A lényeg, hogy C programozásban gondolkodom vagy is valószínűleg komolyabban is bele fogom ásni magam a dolgokba.
Ezzel kapcsolatos főiskolai szakokat keresgélek, de nem tudom mi lenne nekem a legmegfelelőbb.
Mind ezt természetesen annak tudatában kellene megválasztanom, hogy az a jövőre nézve is ("ha egyáltalán beszélhetünk még jövőről") értékes ismeretekkel gyarapítson, tehát a munka, elhelyezkedésemet szemelőt tartva biztos egzisztenciám legyen.
Tehát, olyan szakot kellene választanom, ami jelenleg és későbbiekben is keresett lesz.
Van esetleg ötletetek, elképzelésetek milyen szakot válasszak?
Esti vagy levelezői lesz a megfelelő, hogy finanszírozni is tudjam a tanulmányaimat.Web programozásban már vannak ismereteim: HTML, CSS, PHP, SQL, JS...stb.
-
"Allat ez a 2048,,, elcsesztem vele 2 orat"
Bocs
"azt mondjuk nem tudom, hogy hogyan lett ez 11ezer pont"
Minden egyesitesert annyi pontot kapsz, amilyen szam van az uj negyzeten, igy aztan egy 2^n kocka eloallitasaert osszesen (n-1)*2^n pontot kapsz, egy 1024-es 9216 pont, a 256 meg 1792, pont meg is van a 11k.
Koszi
Na ilyen nagyon osszeg osszegere nem gondoltam. Amugy jo, gyereknek majd odaadom hogy a fejebe menjenek ezek a szamok... -
Allat ez a 2048,,, elcsesztem vele 2 orat, es meg mindig csak az 1024+256 + hecsedli van meg (azt mondjuk nem tudom, hogy hogyan lett ez 11ezer pont)
"Allat ez a 2048,,, elcsesztem vele 2 orat"
Bocs
"azt mondjuk nem tudom, hogy hogyan lett ez 11ezer pont"
Minden egyesitesert annyi pontot kapsz, amilyen szam van az uj negyzeten, igy aztan egy 2^n kocka eloallitasaert osszesen (n-1)*2^n pontot kapsz, egy 1024-es 9216 pont, a 256 meg 1792, pont meg is van a 11k.
-
Igazabol oktalisat meg hexat a binarisbol eleg egyszeru atszamolni, mivel (a tizes szamrendszerrel szemben) egy-egy helyiertekre fix mennyisegu bit esik: oktalisnal harom bit ad ki egy oktalis szamjegyet, hexadecimalisnal meg negy.
Szoval ha van egy olyan szamod, hogy 10101101001011, akkor ki se kell szamolnod, hogy az mennyi is valojaban, hanem anelkul at tudod valtani.
Oktalisba harmasaval csoportositva (az elejere raktam plusz nullakat, hogy mindenhol meglegyen a harmas csoport):
010|101|101|001|011 = 25513Hexadecimalisba meg negyesevel:
0010|1011|0100|1011 = 2B4BDecimalisnal persze kenytelen vagy tenylegesen vegigszamolni (2048 jatekosok elonyben
):
10101101001011 = 1+2+8+64+256+512+2048+8192 = 11083 -
Persze. Nanoszekundumot a clock_gettime függvénnyel kapsz, ha a CLOCK_REALTIME órát adod neki paraméternek.
-
weiss
addikt
-
#include <stdio.h>
main()
{
int c;
int gyak[ 256 ] = { 0 }; /* az egész tömböt nullázza */
while ( ( c = getchar() ) != '@' )
++gyak[ c ];
for ( c = 0; c < 256; ++c )
if ( gyak[ c ] )
printf( "%c: %d\n", c, gyak[ c ] );
}Írjunk programot, amely a billentyűzetről látható karaktereket olvas mindaddig, amíg a @ karaktert meg nem kapja! A program határozza meg és írja képernyőre a beolvasott különböző karaktereket és azok gyakoriságát!
Ez egy megoldott feladat volt. Kérdésem lenne, hogy jól értem-e amit csinál.
míg a beütött karakter nem egyenlő @-val, addig folyamatosan tölti fel a tömböt, majd a for ciklus számolja a leütött karakterek számát és hogy melyikből mennyi van?(ezt itt nem teljesen vágom, hogyan számolja)
majd az if szerkezet kiírja?
Mellékesen megjegyzem, fájlvég esetén (EOF) ez csúnyán elhasal
![;]](//cdn.rios.hu/dl/s/v1.gif)
A ++gyak[ c ] helyett szerintem olvashatóbb a gyak[ c ] += 1. -
Ereshkigal
őstag
#include <stdio.h>
main()
{
int c;
int gyak[ 256 ] = { 0 }; /* az egész tömböt nullázza */
while ( ( c = getchar() ) != '@' )
++gyak[ c ];
for ( c = 0; c < 256; ++c )
if ( gyak[ c ] )
printf( "%c: %d\n", c, gyak[ c ] );
}Írjunk programot, amely a billentyűzetről látható karaktereket olvas mindaddig, amíg a @ karaktert meg nem kapja! A program határozza meg és írja képernyőre a beolvasott különböző karaktereket és azok gyakoriságát!
Ez egy megoldott feladat volt. Kérdésem lenne, hogy jól értem-e amit csinál.
míg a beütött karakter nem egyenlő @-val, addig folyamatosan tölti fel a tömböt, majd a for ciklus számolja a leütött karakterek számát és hogy melyikből mennyi van?(ezt itt nem teljesen vágom, hogyan számolja)
majd az if szerkezet kiírja?Megelőztek.
While ciklus: karaktereket olvas be, amíg nem ütsz entert úgy, hogy szerepel a @ karakter a begépelt szövegben. Közben a gyak-ban eltárolja, hogy az adott (ASCII kódú) karakterből mennyi darab volt.
For ciklus: végigfut az előzőleg feltöltött gyak-on. Ha az adott elem nem nulla (tehát volt olyan karakter beolvasáskor), akkor kiírja azt, illetve annak darabszámát. -
Nem jól érted, a beolvasott karaktereket (nagyon helyesen!) nem tárolja a program, csak a darabszámot gyűjti.
Nézd meg a ++gyak[ c ] sort jobban! Vedd figyelembe, hogy a [] operátor erősebb, mint a ++, illetve a tényt, hogy a gyak tömb 256 elemű. No meg nem árt az az ismeret hozzá, hogy a char típus nyolc bites, úgyhogy egy beolvasott karakter 256 különböző értéket vehet fel.
-
#include <stdio.h>
main()
{
int c;
int gyak[ 256 ] = { 0 }; /* az egész tömböt nullázza */
while ( ( c = getchar() ) != '@' )
++gyak[ c ];
for ( c = 0; c < 256; ++c )
if ( gyak[ c ] )
printf( "%c: %d\n", c, gyak[ c ] );
}Írjunk programot, amely a billentyűzetről látható karaktereket olvas mindaddig, amíg a @ karaktert meg nem kapja! A program határozza meg és írja képernyőre a beolvasott különböző karaktereket és azok gyakoriságát!
Ez egy megoldott feladat volt. Kérdésem lenne, hogy jól értem-e amit csinál.
míg a beütött karakter nem egyenlő @-val, addig folyamatosan tölti fel a tömböt, majd a for ciklus számolja a leütött karakterek számát és hogy melyikből mennyi van?(ezt itt nem teljesen vágom, hogyan számolja)
majd az if szerkezet kiírja? -
cellpeti
nagyúr
#include <stdio.h>
main()
{
int c;
int gyak[ 256 ] = { 0 }; /* az egész tömböt nullázza */
while ( ( c = getchar() ) != '@' )
++gyak[ c ];
for ( c = 0; c < 256; ++c )
if ( gyak[ c ] )
printf( "%c: %d\n", c, gyak[ c ] );
}Írjunk programot, amely a billentyűzetről látható karaktereket olvas mindaddig, amíg a @ karaktert meg nem kapja! A program határozza meg és írja képernyőre a beolvasott különböző karaktereket és azok gyakoriságát!
Ez egy megoldott feladat volt. Kérdésem lenne, hogy jól értem-e amit csinál.
míg a beütött karakter nem egyenlő @-val, addig folyamatosan tölti fel a tömböt, majd a for ciklus számolja a leütött karakterek számát és hogy melyikből mennyi van?(ezt itt nem teljesen vágom, hogyan számolja)
majd az if szerkezet kiírja? -
Igazabol oktalisat meg hexat a binarisbol eleg egyszeru atszamolni, mivel (a tizes szamrendszerrel szemben) egy-egy helyiertekre fix mennyisegu bit esik: oktalisnal harom bit ad ki egy oktalis szamjegyet, hexadecimalisnal meg negy.
Szoval ha van egy olyan szamod, hogy 10101101001011, akkor ki se kell szamolnod, hogy az mennyi is valojaban, hanem anelkul at tudod valtani.
Oktalisba harmasaval csoportositva (az elejere raktam plusz nullakat, hogy mindenhol meglegyen a harmas csoport):
010|101|101|001|011 = 25513Hexadecimalisba meg negyesevel:
0010|1011|0100|1011 = 2B4BDecimalisnal persze kenytelen vagy tenylegesen vegigszamolni (2048 jatekosok elonyben
):
10101101001011 = 1+2+8+64+256+512+2048+8192 = 11083 -
Pfff ez az egész kusza kicsit.
Találtam közben ezt, de valamiért túl sok nekem egyszerre. [link]
Tömör és nem értem mit hogyan...
Amit értek:
Mi 10-es számrendszerben számolunk mindent, vagy is ez az alap számunkra.
Ez eddig stimmel?A 2-es számrendszerbe átszámolni valamit, mondjuk 8bit-et a példa kedvéért:
2 a 7.-en, 2 a 6.-on, 2 az 5.-en ... 2 a 0.-on.
Ez bináris példában: 0000 1100 = 8 + 4 == 12
Ez eddig stimmel?Ha stimmel akkor eddig értem a dolgot.
De a többi egyelőre homály.
Szeretném én úgy megérteni, hogy ne keljen táblázatból lesnem az értékeket.ui: a srácok jelző lehet idősebb is mint pl én és lehet ezért is nem fog már rendesen az agyam
Azt most már tudom, hogy melyik milyen számrendszerben van.
Bináris (2-es)
Oktális (8-as)
Decimális (10-es)
Hexadecimális (16-os)10bit 2-es hatványát kell venni nem? Mármint 10-esből 2-esbe átszámolásnál.
Persze csak, ha binárisban van a szám.
Lehet, hogy ez sem tusom..
Rendet kellene tennem az agyban ezekkel kapcsolatban mert enélkül nem léphetek tovább.Igazabol oktalisat meg hexat a binarisbol eleg egyszeru atszamolni, mivel (a tizes szamrendszerrel szemben) egy-egy helyiertekre fix mennyisegu bit esik: oktalisnal harom bit ad ki egy oktalis szamjegyet, hexadecimalisnal meg negy.
Szoval ha van egy olyan szamod, hogy 10101101001011, akkor ki se kell szamolnod, hogy az mennyi is valojaban, hanem anelkul at tudod valtani.
Oktalisba harmasaval csoportositva (az elejere raktam plusz nullakat, hogy mindenhol meglegyen a harmas csoport):
010|101|101|001|011 = 25513Hexadecimalisba meg negyesevel:
0010|1011|0100|1011 = 2B4BDecimalisnal persze kenytelen vagy tenylegesen vegigszamolni (2048 jatekosok elonyben
):
10101101001011 = 1+2+8+64+256+512+2048+8192 = 11083 -
Azt mar 40+
mar ha ebben a korban nem venasszonyoztok me'g le a lany helyett 
De itt a lany/no" + programozas volt a kerdes - bar teny, az se pontos datumilag. Mar 7. altalanosban jartam a titbe tanfolyamra, hogy progizni tanuljam a zx spectrumot basicben. Ha meg ugy nezem, az egyetem elejen "csak" mat.kus voltam, 4. evtol vettem fel a progmatot, bar ezt nem annyira tevedes osszemosni, a matkus szak + no" is kello csodalkozast/hitetlenkedest valtott ki...
De kit erdekelnek mar a tobb evtizedes sztoriban az ilyen reszletek. -
-
Elnézésed kérem, nem mertem feltételezni, hogy nő is lehet egy programozói fórumon.
És ezt nem negatív értelemeben értem, csak fúra számomra
Örülök természetesen...Semmi gond, az egyetem kezdete ota elmult 20+ ev adott ra idot hogy megszokjam
Amugy orulok, hogy megtalaltad a kulcsot (ilyenkor a legnehezebb _jol_ segiteni, ha nem tudni hogy mi nincs meg nalad a szukseges informaciokbol). -
Nem (csak) eletkor, hanem nembeli elteres is van
Viszont nem lenne jobb ezt a matek topikban? Itt joggal kineznek minket, akik szakmai beszelgetest varnak, es ez netto matek.
(Es holnap, nekem mara ennyi volt.)Elnézésed kérem, nem mertem feltételezni, hogy nő is lehet egy programozói fórumon.
És ezt nem negatív értelemeben értem, csak fúra számomra
Örülök természetesen... -
Bináris->oktális pofon egyszerű, mivel 3 bit 1 oktális számjegyet kódol. Simán a legkisebb helyiérték felől 3 bitenként leírsz egy oktális számjegyet és kész. Feltételezem 3 bitet tudsz konvertálni, de ha nem akkor ugye a helyiértékek 4,2,1.
Bináris->hexa hasonlóan csak ott 4 bitenként haladsz.
A tízes számrendszer már külön állatfaj mivel nem kettő hatvány. Ott az általános átváltási módszert kell használni.
Igen ez megvan, (Bináris->oktális) hogy 3bit = 1 oktális számjegy.
Viszont a helyi értékek kimaradtak és ennek tudatában egyből, villámcsapásként értelmet adott az egésznek
Köszi a rávilágítást. Most már tudok majd aludni -
Srácok kérnék egy kis segítséget, hogy megértsek valamit.
Tanulom ezt a C nyelvet és elakadtam a bináris és oktális átszámolásnál.
Nem értem ezeket:Bináris = oktális
... 000 011 = 03
... 000 110 = 06
... 001 100 = 014A bináris ábrázolások 32bit-en kell elképzelni és nem értem miként jönnek ki az oktális eredmények.
Valaki elmagyarázná?
A könyv nem ad számomra elégséges magyarázatot az átszámolására.
Előre is köszi. -
Pfff ez az egész kusza kicsit.
Találtam közben ezt, de valamiért túl sok nekem egyszerre. [link]
Tömör és nem értem mit hogyan...
Amit értek:
Mi 10-es számrendszerben számolunk mindent, vagy is ez az alap számunkra.
Ez eddig stimmel?A 2-es számrendszerbe átszámolni valamit, mondjuk 8bit-et a példa kedvéért:
2 a 7.-en, 2 a 6.-on, 2 az 5.-en ... 2 a 0.-on.
Ez bináris példában: 0000 1100 = 8 + 4 == 12
Ez eddig stimmel?Ha stimmel akkor eddig értem a dolgot.
De a többi egyelőre homály.
Szeretném én úgy megérteni, hogy ne keljen táblázatból lesnem az értékeket.ui: a srácok jelző lehet idősebb is mint pl én és lehet ezért is nem fog már rendesen az agyam
Azt most már tudom, hogy melyik milyen számrendszerben van.
Bináris (2-es)
Oktális (8-as)
Decimális (10-es)
Hexadecimális (16-os)10bit 2-es hatványát kell venni nem? Mármint 10-esből 2-esbe átszámolásnál.
Persze csak, ha binárisban van a szám.
Lehet, hogy ez sem tusom..
Rendet kellene tennem az agyban ezekkel kapcsolatban mert enélkül nem léphetek tovább.Nem (csak) eletkor, hanem nembeli elteres is van
Viszont nem lenne jobb ezt a matek topikban? Itt joggal kineznek minket, akik szakmai beszelgetest varnak, es ez netto matek.
(Es holnap, nekem mara ennyi volt.)
Szerintem nem jó ez a megoldás. Mert pl. nem lép ki ha az első lépésben 2-es a visszatérési érték.
. Illetve néhány oldallal ezelőtt volt az a másik windowsos IDE, az is megérhet egy említést.
), vegulis a * es a [] "valahol" egyenertekuek, lehet hogy csak tolem idegen szokas.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Ú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!
- Samsung Galaxy A56 - megbízható középszerűség
- Asztalos klub
- Parfüm topik
- Ubuntu Linux
- EA Sports WRC '23
- Telekom mobilszolgáltatások
- Elképesztő rajt a Forza Horizon 6-nál - Steamen már most népszerűbb elődjénél
- One otthoni szolgáltatások (TV, internet, telefon)
- HiFi műszaki szemmel - sztereó hangrendszerek
- Star Citizen
- További aktív témák...
- Akció!!! Sosemhasznált! HP OmniBook 5 i7-1355U 16GB 1TB 16" FHD+ Gar.: 1 év
- AMD FX-6300 CPU + ASUS M5A97 EVO R2.0 + GeForce GTX 1060 3GB
- Új - MacBook Pro M5 Pro Chip 14" 15C / 16C / 24 GB RAM / 1TB SSD / Silver / Black - 27% Áfás
- Dell Precision 5560 i5 11500H 16GB 256GB SSD 1920x1200 Matt IPS
- Új - MacBook Pro M5 Chip 14" 10C / 10C / 16 GB RAM / 512 SSD / Silver / Black - 27% Áfás
- SZÁLCSISZOLT FÉM HATÁSÚ Dell Latitude 5420 14" Touchscreen i5-1135G7 16GB 512GB 1 év gar, LTE OPCIÓ
- Telefon felvásárlás!! iPhone 13 Mini/iPhone 13/iPhone 13 Pro/iPhone 13 Pro Max
- HIBÁTLAN iPhone 14 Pro Max 128GB Gold -2 ÉV GARANCIA - Kártyafüggetlen, MS5211
- Keresünk Galaxy S23/S23+/S23 Ultra/S23 Fe
- BESZÁMÍTÁS! 8TB WD RED WD80EFAX HDD meghajtó garanciával hibátlan működéssel
Állásajánlatok
Cég: Laptopműhely Bt.
Város: Budapest