- iPhone topik
- Apple Watch
- A hagyományos (nem okos-) telefonok jelene és jövője
- Samsung Galaxy S25 Ultra - titán keret, acélos teljesítmény
- Fotók, videók mobillal
- Samsung Galaxy Watch (Tizen és Wear OS) ingyenes számlapok, kupon kódok
- Samsung Galaxy S24 Ultra - ha működik, ne változtass!
- Android alkalmazások - szoftver kibeszélő topik
- VoLTE/VoWiFi
- Samsung Galaxy S23 és S23+ - ami belül van, az számít igazán
Új hozzászólás Aktív témák
-
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
) -
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.
-
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
-
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.
-
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. -
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]); -
alapz@j
tag
-
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'. -
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... -
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.
-
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 = 11083 -
-
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.
-
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. -
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.
-
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
#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.
-
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.
-
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.
-
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.) -
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. -
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á? -
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 -
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...
-
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. -
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?
-
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... -
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?
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á?
Ú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!
- REFURBISHED - DELL Thunderbolt Dock WD19TBS docking station (210-AZBV)
- Bomba ár! Dell Latitude 3590 - i5-8GEN I 8GB I 256SSD I HDMI I 15,6" FHD I Cam I W11 I Garancia!
- ÚJ- Lenovo ThinkVision T24i-10 - 24" monitor - Számla, garancia
- AKCIÓ! Gigabyte B85-HD3 B85 chipset alaplap garanciával hibátlan működéssel
- KIÁRUSÍTÁS - REFURBISHED és ÚJ - Lenovo ThinkPad Ultra Docking Station (40AJ)
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: PC Trade Systems Kft.
Város: Szeged