Új hozzászólás Aktív témák
-
Peter789
senior tag
válasz don_peter #4369 üzenetére
MPLAB-al zeró a tapasztalatom, a mikroe IDE-ket viszont nagyon tudom ajánlani! Van C, Pascal, Basic alapú is 8/16/32 bites PIC, AVR, 8051 és ARM procikhoz egyaránt. Maguk az IDE-k is tele vannak hasznos függvénykönyvtárakkal, valamint a libstock rendszerében is már rengeteg plussz anyagot töltöttek fel a lelkes felhasználók. A VisualTFT / VisualGLCD segítségével pedig egészen látványos grafikákat is össze lehet kalapálni viszonylag kevés tudással - jobban mondva segít elindulni, kitanulni az alapokat - később már nyilván egyre kevesebb dolognál fogja használni az ember a kész/félkész megoldásokat és egyre többet farag sajátokat...
Igazából nem tudom hogy mennyire fér bele az általános C programozásba az ilyen téma, de azért leírhatnád hogy egyáltalán meddig jutottál el az élesztéssel, teszteléssel... Megy már valami csak bugos és nem tudsz úrrá lenni rajta, vagy már a PIC élesztéséig sem jutottál el?
[ Szerkesztve ]
----------------------------------------------------------------------------------------------------------------- AquAgorA ...Pál apostol nyomában: http://fleettracker.eu/index.php/component/aquagora
-
Peter789
senior tag
válasz don_peter #4371 üzenetére
Az hogy deklarálva van minden, még nem feltétlenül jelenti azt hogy nincsen valami félredeklarálva
Az elakadás az analógnál mit jelent? Valami fix fals értéket sikerül olvasni róla, vagy le se tudod fordítani a programot?
"az a programozó vagyok aki a kódokat szereti látni és megtanulni őket leírni" - dehát itt használod a már kész ADC és egyéb függvényeket, nem magad piszkálod a regisztereket, tehát "csalsz" Amivel persze semmi gond egészen addig amíg a kész függvények megfelelnek a céljaidnak. Elször én is a mikroe rendszer beépített UART olvasó függvényeit használtam pl, de hamar rájöttem hogy sokkal többre képes a vas és utánatúrtam hogy hogyan tudok saját IRQ alapú feldolgozást írni. De pont ez tetszik a mikroe-ben hogy tengernyi a példa és kész/félkész megoldás, lelkes a közösség, így könnyű elindulni és fejlődni...
----------------------------------------------------------------------------------------------------------------- AquAgorA ...Pál apostol nyomában: http://fleettracker.eu/index.php/component/aquagora
-
Peter789
senior tag
válasz don_peter #4373 üzenetére
A drag-and-drop csak a visual tft / glcd-re igaz - de így nagyon látványos kis GUI-t lehet hamar összeszórni egy kis LCD-re. Természetesen a lényegi funkcionalitáshoz már az alá is ugyanúgy kell programozni, ez csak a megjelenítés amit máshol is használsz (write parancs), legfeljebb kevésbé látványos az eredmény vagy sokkal többet kell érte izzadni. Az alap mikroe IDE-k rendes programozós környezetet adnak, csak sok az alapból beépített függvény (és az addon-ként elérhető plussz) aminek köszönhetően nem kell egyből a lowlevel hardver eléréssel bajlódni, ami hamar elriasztaná a kezdő érdeklődőt
Rámértél a lábra hogy valóban változik e rajta a feszosztó arányának megfelelően az érték? Ha nem, akkor félrekonfigolás miatt lehet erőszakkal lehúzza a lábat a földre... Ha ilyen gond nincsen, akkor próbáltál már az adc read helyett konkrét értéket adni a változódnak és azt kiiratni, hogy hátha ott a hiba?
A PORTA lábainak semmi extra konfig nem kell (mint a PBADEN a PORTB-n), elég csak analógnak és bemenetnek konfigolni. Viszont nem ismerem az adott IDE függvényeinek működését - lehet neked kell előre bekapcsolni az AD konvertert és kiválasztani a csatornát az ADCON0 regiszterben?
----------------------------------------------------------------------------------------------------------------- AquAgorA ...Pál apostol nyomában: http://fleettracker.eu/index.php/component/aquagora
-
don_peter
senior tag
válasz don_peter #4375 üzenetére
Bocs, de most meg a kijelző nem akart menni
Azt beizzítottam szóval le próbáltam a dolgot.
1K ellenállással rávittem az 5v-ot a PIC A0-ás lábára.
Analógra és bemenetre van állítva ezt lecsekkoltam szóval elvileg működnie kellene, de az érték 0 marad és nem változik ha rárakom és, ha leveszem akkor sem.----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----
-
Peter789
senior tag
válasz don_peter #4376 üzenetére
sajnos így most nincsen több ötletem mert nagyon nem ismerem az MPLAB IDE-t és fordítóját... akkor ugye az esetleges kiiratásnál történő konvertálási, formázási hibát próbálgatással kizártad, nem lehet hogy ott válik 0-vá az akármilyen érték?
a hobbyelektronika fórumán biztosan találsz releváns témát, ott valószínűleg kapsz rá megoldást...
----------------------------------------------------------------------------------------------------------------- AquAgorA ...Pál apostol nyomában: http://fleettracker.eu/index.php/component/aquagora
-
don_peter
senior tag
válasz don_peter #4444 üzenetére
Ezzel a tömbös megoldással megoldottam, de itt még nem kellene járnom szóval egyszerűbb megoldás létezhet a dologra?
És itt még felmerül a kérdés, hogy tudom megnézni egy adott változóban mennyi karakter vagy számjegy van.
Szóval a = 123;
Akkor ennek a karakter hossza 3db.
Ezt PHP-ben strlen() függvénnyel szépen le lehet kérni.
Itt is van ilyesmi?
Mert a tömbömnek meg kellene adni mekkora legyen és így automatizált lehetne a dolog.
Bár lehet rosszúl gondolkodom, de PHP-nél ez kézenfekvő volt.int number, right_digit[5], i = 0, mennyi = 0;
printf("Adj meg egy számsort: ");
scanf("%i", &number);
while(number != 0) {
right_digit[i] = number % 10;
printf("%i, ",right_digit[i]);
number = number / 10;
mennyi = i;
i++;
}
printf("\n");
for(i=mennyi; i>=0; i--){
printf("%i",right_digit[i]);
}
printf("\n");Illetve a 2. pontban lévő kérdésemet még mindig nem tudtam megoldani.
pl.: 1 2 3 4 = 1234[ Szerkesztve ]
----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----
-
Jester01
veterán
válasz don_peter #4445 üzenetére
C-ben is van strlen de csak akkor működik ha van egy lezáró 0 byte a karakterek után. Továbbá ez minden alkalommal végignézi a stringet, szóval nem valami gyors. Javasolt kézzel nyilvántartani a tömbbe rakott karakterek számát, ahogy te is tetted.
A másik probléma az gondolom a kávé hiányra vezethető vissza, mert óvodás matematika Ugye ha van egy abcd szám annak az értéke a*1000+b*100+c*10+d. Ennyi segítség már elég hozzá?
Jester
-
-
axioma
veterán
válasz don_peter #4455 üzenetére
Azt nem ertem a feladatban, hogy nem megforditani kell mint egesz szamot szamjegyek sorakent? Ha eleve ugy raktad le, hogy a 0. elem a 0. helyiertek, es utana a hossztol indulsz vissza, akkor siman osszerakod a szamot, nem forditva kapod meg, ez a futasi eredmenyeden is latszik. Raadasul ehhez (megforditott szam) a ciklus ugyanabban az iranyban menne felbontaskor es osszerakaskor, es igy osszevonhato, meg a tombben tarolas is teljesen kihagyhato belole, a hossz sem erdekel bar persze vezetheto, meg nem kene a tartomanyt se bekorlatozni.
Ha direkt az eredetit akartad osszerakni (de azt eleve beolvasod, tudnad a szetszedes elott menteni, ezert gondolnam hogy nem), akkor viszont nem szoltam.[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4458 üzenetére
Ez mar ugye mas, itt muszaj lesz megszamolni a hosszt, en eredetileg csak erre az osszevonasra gondoltam (poz. egesz szambol a megforditottja poz. egesz gyartasa, intbol int):
int input=...; // segedvaltozo legyen, mert szetbarmoljuk
int forditva=0;
while (input != 0) {
forditva=forditva*10+input%10;
input=input/10;
}Amit szeretnel, szerintem megkerulheto egy sprintf -fel (nyilvan memoriafoglalasra stb. kell akkor meg figyelni).
De ha matekos megoldast akarsz, akkor logikus megkeresni a legnagyobb helyierteket, es itt is lehet (kovethetobb) szamolni a hosszt:hossz=1;
helyiertek=1;
while (helyiertek<input) {
helyiertek*=10;
hossz++;
}
-- de akkor vigyazni kell arra, hogy az input pozitiv egesz (0 sem jo!) legyen (nyilvan itt ez gyors, de nagyon altalaban lehetne logaritmussal is szamolni, hoyg a 10 hanyadik hatvanya ez), es utana akkor erre felepitve mar a ciklusod:int szamjegy;
int osszerakva=0;
while (helyiertek>0) {
szamjegy=(input/helyiertek)%10;
printf("%d,",szamjegy);
osszerakva=osszerakva*10+szamjegy;
// vagy: osszerakva=osszerakva+szamjegy*helyiertek;
helyiertek/=10;
}Igy az inputodat se valtoztatod meg.
Ilyenre gondoltal? Bocs, a koritest (beolvasas, vegso kiiratas) kihagytam, az algoritmust ez a resz is mutatja.
(Amugy en java-s vagyok es nem is sokat szolok itt hozza, meg is lepett hogy pont hozzam intezted a kodirasi kerest.)[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4460 üzenetére
Csak az elso programreszlet a megforditasos, a masik ketto az mar a mostani problemadhoz kapcsolodo reszlet, a sima elolrol hatra felszeletelgetes. Es ta'rolasra nincs benne tomb.
Mondjuk egy hasonlo feladatot kaptam egyszer egy interju reszekent ugy, hogy csinaljam meg rekurzivan szamolgatas nelkul (balrazart kiiratast ott igazabol), az kodsorban joval kevesebb, de megintcsak nem tanultatok:void egyesevel(int input) {
if (input>=10) {
egyesevel(input/10);
printf(",");
}
printf("%d",input%10);
}Ebben annyi a "beugrato", hogy csak akkor tudod megcsinalni, ha az aktualis korben elintezendo _elott_ hivod meg ugyanezt a fuggvenyt rekurzivan. Legtobbszor inkabb ugy csinaljuk, hogy elintezzuk az aktualisat, es a maradekot a rekurziv hivassal. Hiaba nincs erre semmi ok, ez az automatizmus, a rugalmassagot teszteltek vele.
[ Szerkesztve ]
-
Karma
félisten
válasz don_peter #4463 üzenetére
Például úgy, hogy nem számként olvasod be a scanf-fel, hanem szövegként (pl. az fgets függvénnyel).
A feladathoz szokás adattípusokat választani, nem pedig hangulatból.
Azt mondjuk nem tudom, hogy ha valóban és szigorúan egy szám a bemeneti adat, akkor osztogatni éri meg jobban, vagy egyszer átkonvertálni stringbe és azon futtatni a ciklust. A paraszti eszem szerint a string, mert sokkal olvashatóbb, hogy mit csinálsz.
[ Szerkesztve ]
“All nothings are not equal.”
-
Karma
félisten
válasz don_peter #4467 üzenetére
Lebegőpontos számot hány tizedesjegyig szeretnél számolgatni? A definíció szerinti pontatlanságon túl ez is egy fontos szempont.
Továbbra is fenntartom az állításomat, hogy ez nem egy számítási, hanem egy karakterkezelési feladat. A tizes számrendszer emberi fogyasztásra alkalmas csak egyébként is. Jó szórakozást hozzá, én kiszálltam.
[ Szerkesztve ]
“All nothings are not equal.”
-
axioma
veterán
válasz don_peter #4467 üzenetére
1. azert van a kettes duplazva, mert elfelejtetted a "nem tizedespont koveti" esetet kulon else agba rakni, igy a tizedes elotti is rafut arra is.
2. az if feltetel tul bonyolult, mert a tizedes nalad fixen 5 db lesz (me'g ha a vege nullakkal is van feltoltve), hiszen 100e-rel szoroztal (eleg lenne oda egy ilyen:for(i = mennyi; i >= 0; i--){
printf("%i", oszto_tomb[i]);
if (i==5) { // a 4-3-2-1-0 a tortresz
printf(".");
}
}
3. szerintem a tizedes nevu valtozoval pont az egeszresz hosszat "szamolod"... nem tul szerencses elnevezes, azt lehetne hinni, hogy a (hasznos) tizedeseket (mert pl. most ha az inputod 2.5, akkor azt fogja kiirni, hogy 2.50000)
4. a negativ szamokra sehol nem gondolsz, me'g egy arva hibauzenetet se dobsz
5. nem ertem a mennyi=i; i++; reszt sem: nem lenne egyszerubb, ha a ciklusban nem bantanad a mennyi-t, hanem a kilepes utan irnad, hogy mennyi=i-1 ? Vagy hatultesztelos ciklus (egy szamjegyet ugyis fogsz irni). -
Karma
félisten
válasz don_peter #4472 üzenetére
Nem lehet. Hasonló témában nemrég leírtam a lehetőségeket (tl;dr: char* a heapen, vagy paraméterben átadott célterület).
“All nothings are not equal.”
-
Karma
félisten
válasz don_peter #4483 üzenetére
Igen, pontosan erről írtam, hogy nem kéne így csinálni, ha nem muszáj. Márpedig desktop környezetben (szemben egy beágyazott rendszerrel) nem valószínű hogy ez fennállna.
A probléma a globális változókkal az, hogy a függvény újrafelhasználhatóságát és olvashatóságát is egyaránt rontja. Az előbbit azért, mert egy közös memóriaterületet piszkál amihez más függvény is hozzáfér és így elronthatják egymás dolgait. A másikat meg azért, mert a függvényen kívülre kerül az az adat, amivel dolgozik.
És végül azért is célszerű már most leszokni a globális változókról, hogy ne alakuljon ki rossz kódolási stílus mielőtt más nyelvekre mész tovább.
“All nothings are not equal.”
-
axioma
veterán
válasz don_peter #4498 üzenetére
Ha nem ragaszkodsz "srac"-hoz
Eloszor is a 0 azert van az elejen, mert az kodolja hogy oktalis. Tehat matekosan 100 011 (2) = 43 (8), ahol a zarojelben levo szamok kis karikazott szamok alul.
Masreszt azt tudod, hogy 10-es szamrendszerbol a 2-esbe hogyan megy? Tehat a 35 (10) = 43 (8) az stimmel, csak a kozvetlen atvaltas nem? Ha igy van, a 2-esbol 16-osba (hexa) az ertheto, csak az oktalis nem?
Ha behatarolod, hogy hol nem ertheto, egyszerubb lesz segiteni. -
Jester01
veterán
válasz don_peter #4498 üzenetére
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.
Jester
-
-
dabadab
titán
válasz don_peter #4500 üzenetére
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 = 11083DRM is theft
-
buherton
őstag
válasz don_peter #4524 üzenetére
Ha csak C, akkor villamosmérnöki -> beágyazott rendszerek vagy mérnök informatikus (erősen ajánlott az ÓE-NIK) -> beágyazott rendszerek, de itt már nem csak C lenne, hanem Java, C# is.
tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!
-
buherton
őstag
válasz don_peter #4532 üzenetére
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.
[ Szerkesztve ]
tely, baly, fojó, mennyél, mingyárt, telyföl, tolyás, malyd, kapú, egyenlőre, ejsd, jáccani, ahoz, fúj, hüje, muszály, alat, álok, lasan, fojtatás, ál, fontós, költsön, eggyüt, lyob (jobb?), mek, mongyak, milyért - !!! Tanúlyunk már meghejjessen irni... !!!
-
-
axioma
veterán
válasz don_peter #4544 üzenetére
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...[ Szerkesztve ]
-
axioma
veterán
válasz don_peter #4548 üzenetére
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'.
-
alapz@j
tag
-
alapz@j
tag
válasz don_peter #4560 üzenetére
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]);[ Szerkesztve ]
-
don_peter
senior tag
válasz don_peter #4567 üzenetére
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.[ Szerkesztve ]
----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----
-
dabadab
titán
válasz don_peter #4568 üzenetére
#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.
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz don_peter #4570 üzenetére
[ 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
[ Szerkesztve ]
DRM is theft
-
dabadab
titán
válasz don_peter #4577 üzenetére
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.
DRM is theft
-
dabadab
titán
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 )
DRM is theft
-
don_peter
senior tag
válasz don_peter #4607 üzenetére
Ígértem egy kis videót a programról amit írtam.
Még nem tökéletes, de rajta vagyok erősen
4x4 alfanumerikus matrix:
video link[ Szerkesztve ]
----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----
-
alapz@j
tag
válasz don_peter #4613 üzenetére
Pont tegnap próbáltam ki az alábbi kis szösszenetet, ami válasz a kérdésedre is:
#include <stdlib.h>
#include <intrin.h>
int main(void) {
unsigned char *test = (unsigned char*)malloc(100);
__stosb(test, 0, 100);
free(test);
return 0;
}X86 és X64 architektúrákra.
[ Szerkesztve ]
-
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
[ Szerkesztve ]
“All nothings are not equal.”
-
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.
“All nothings are not equal.”
Ú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!
- Otthonfelújítási program (2024.)
- 3D nyomtatás
- Milyen okostelefont vegyek?
- Új Beats fej- és fülhallgatók jelentek meg
- TCL LCD és LED TV-k
- Publikálta a Microsoft az MS-DOS 4.0 forráskódját
- Samsung Galaxy S21 Ultra - vákuumcsomagolás
- D1Rect: Nagy "hülyétkapokazapróktól" topik
- LEGO klub
- Vezetékes FÜLhallgatók
- További aktív témák...