A delayt csak a mainen belül használok, de amikor van megszakítás az egész elcsúszik mármint a megszakításbeli dolgok. A pic PWM-jével szinuszt állítok elő, de amikor az LCD-re is írok elcsúszik az egész. A delay fv nem tudom melyik számlálót használja, de olyan mintha valami összeakadna.

A megszakítási rutin lehet másik C fájlban is, de ha csak egy C forrásod van a projectben, akkor csak deklarálni kell a változót és olyan területre kell irányítani (access), ahol elérhető bármelyik bankból és mindig a helyén legyen írva (volatile near), ne valamilyen regiszterben, vagy gyorsító tárban, hogy a megszakításon kívül, ahol használod, az aktuális érték legyen olvasható belőle minden olvasáskor.

Használod a Delay1KTCYx függvényt a megsuakítási rutinban.
Próbáld meg úgy megírni, hogy kerüld el a használatát.

Megpróbálok egy másik megoldást úgy is gyomlálni akartam a programom, csak ehhez majd kell egy alacsony prioritású megszakítás, kíváncsi leszek annak a használata majd milyen problémákat szül.
Egyébként ha van magas és alacsony prioritású megszakításom, amíg az alacsony szintűben vagyok a magasabb szintű aktiválódhat?

Logikusan. Ha az alacsony szintűt meg kellene várnia a magasabb szintűnek, akkor mi értelme a prioritásnak?

Van egy egyszerű függvényem:

Ezt a függvényt, pontosabban ennek a visszatérési értékét szeretném feltételként használni, így:

De ha beírom ezt a feltételt akkor nem hajlandó lefordulni a program. Miért? Nem lehet egy függvény visszatérési értékét feltételként használni?
(XC16 a fordító.)

A bool-t írd át unsigned char-ra és hagyd el a static-et (A C úgy sem használ bites változót önmagától). Egyébként lehet így használni, nem szokott gond lenni.

Nem a bool-al van a probléma, de próbaképp átírtam és úgy sem fordult le. A static pedig nagyon fontos, kell ahhoz hogy csak ezen a fájlon belül látszódjon ez a kis függvény.
Kipróbáltam közben hogy egy sima konstanst adtam át neki:

Így jó. Viszont a helyzet picit bonyolultabb, így kellene ugyanis használni:

Na így már nem fordul le.

Mi a pontos hibauzenet? Mellesleg a 'c' miert const? Ennek itt semmi ertelme. A const-nak pointereknel van erteleme, amivel azt jelzed, hogy a fuggveny nem fogja modositani a pointer altal megcimzett memoriat.
Egyebkent a fuggvenyt hasznalhatod if() feltetelekent, azzal nincs semmi baj. Amugy ez a konyvtari isdigit() fuggveny. Es igy nezne ki a legegyszerubben:

int func(char c)
{
return (c >= '0' && c <= '9');
}

A const nem tudom már pontosan hogyan jött. Egyszer valahol azt olvastam hogy ha nem akarjuk hogy a függvény módosítani tudja akkor const kell elé. Persze tudom hogy eleve mivel nem mutatót adunk neki át így amúgy is képtelen lenne módosítani, ennek ellenére állítólag ezt akkor is így szokás.
Közben rájöttem, a függvény nevében a V-betűt a hívásokkor kicsi v-vel írtam.
Átírom erre az isdigit()-re, köszönöm a tippet!

Ez a fajta const-os dolog kicsit másképp, de inkább c++-ban szokás, hogy jelezzék, hogy a függvény nem módosít semmit csak egy konstanssal visszatér.

Normalisan a fuggvenyek bemeno valtozoi olyanok, mint a fuggveny lokal valtozok, csak fel vannak toltve a hivaskor atadott ertekkel. Ebbol kovetkezik, hogy a bemeno valtozo erteket is modosithatod a fuggvenyen belul:


Ha const-nak deklaralod, akkor nem lehet modositani. Hogy ez pontosan mire jo, azt viszont nem tudom, talalgatni meg nem akarok.

A const deklaráció arra jó, hogy a fordítónak szól, hogy erre figyeljen. Tehát, ha a programozó mégis olyan kódot ír, ami módosítaná, akkor hibaüzenetet kapjon miatta.
Illetve arra is jó, hogy ezzel egy mikrokontrollerben a programmemóriában tárolódjon az állandó (már a fordításkor értéket kap), ne foglaljon neki helyet a RAM-területen. Ugye ez nem szempont egy normál processzornál, mint ami mondjuk egy PC-ben van, mert ott nincs külön programmemória, mint a Harvard-architektúrás mikrokontrollereknél.

Igen, ez logikusan hangzik.
Attol, hogy const, meg erteket lehet neki atadni, hiszen a fuggveny bemeno valtozoja. Meg egyebkent is, egy bemeno valtozo altalaban regiszterben van, esetleg a stack-en, de semmikeppen nem a bss-ben.

Nem változó, hiszen konstans

Jó kérdés, hogy a fordító milyen kódot generál, mert lehet, hogy egy változóhoz képest más elhelyezést használ, tehát nem stack-et, sem regisztert. Minek is használna, hiszen konstans, értéke a fordításkor is adott, így a kód része lehet. Tehát ha mondjuk a w-regiszterbe tölti műveletvégzéshez (lehet egy értékadás bemenő adata, vagy egy matematikai/logikai műveleté), akkor egy kódterületről teszi meg.

Upd: megint megnéztem a Kopják-féle könyvben és ott szépen leírja, hogy a const mit is jelent a mikrokontrollereknél. Azt mondja, amit írtam. Az eredeti C nem tett különbséget a tároláskor (csak a kötelező kezdőértékadást és a megváltoztathatatlanságot jelentette, az előbbi elmulasztása és az utóbbi be nem tartása fordítási hibát okozott), de az mk-k esetében új jelentőséget kapott, az eltérő architektúra miatt.

Lehet, hogy te ezt viccesnek talalod, pedig baromira nem az. Gondold vegig! A fuggveny bemeno parametere nem konstans, hiszen minden meghivasnal mas es mas ertek lehet:

A const ebben az esetben annyit tesz, hogy a printa(const int a) fuggveny nem valtoztatja meg menet kozben az 'a' valtozo erteket. De attol az meg egy valtozo.
Nem ismerem a Kopjak fele konyvet, de C kerdesben kizarolag a K&R konyv mervado, meg a szabvany. Nincs olyan, hogy a "mikrokontrollereknel". Vannak olyan forditok (tipikusan PIC-ekhez), amik nem tartjak be a C szabvanyokat, de ezeket en nem neveznem C forditonak. Megaztan nem is minden mikrokontroller Harvard arhitekturas (last ARM Cortex-M0 alapuak). Viszont a von Neumann arhitekturas gepeken is lehet program es adat memoria, meg akkor is, ha mindketto RAM-ban van (pl. PC). Csak az OS gondoskodik rola MMU-val, hogy a program memoria (.text) R es X jogosultsagot kapjon, mig az adatmemoria (.data es .bss) R es W-t. Ennel kicsit bonyolultabb, de a lenyeg ez. Ezen felul az eredeti C nem is ismerte a const-ot. K&R konyv elso kiadas.

Ez csak nézőpont kérdése. Igazad van, bemenő érték változik, de a const a függvényen belülre vonatkozik, azaz ott már nem változó a változó, legalább is gyakorlatilag nem, annak ellenére, hogy RAM-ban lesz (egy regiszter is RAM). Tehát változó is de nem is.
De ez csak arra jó, hogy véletlenül se változzon meg a programozó hibájából se. Végül is nagy projectekben, ahol sokan dolgoznak együtt, hasznos lehet, feltéve, hogy tényleg nem engedi a fordító megváltoztatni!
A másik, hogy itt PIC-ekről beszélünk, azaz lehet, hogy nem szabványos, ezért nem mérvadó a standard, de csak kivételes esetekben, mint ez is.

Ha már ott tartunk, hogy mi nem változó, akkor ez az?

void PrintConstString(const unsigned char *c);
Ez sem az, mert ez egy pointer, ami változó, ami ugyan program területre mutat, ami nem változó, de csak olyan uC-nél, aminek a program területe nem RAM. Ebbe bele lehet kavarodni!

Hm, igazad van, főprogramból nézve változó. Kicsit fából vaskarika.


Sajnos ebben viszont nincs igazad, nekem megvan a könyv, leírja azt, amit a mikrokontrollerekkel - pontosabban a PIC-ekkel - kapcsolatban tudni kell, hiszen arról szól a könyv. A C sokat alakult az idők folyamán, amikor megalkották K&R-ék, akkor még nem voltak mikrokontrollerek, sőt, mikroprocik se nagyon. Az, hogy te mit nevezel C fordítónak, az a te dolgod, a népesség többi része viszont elfogadja, hogy C az, amit itt használ. A mereven elzárkózás hitvitává tenné a beszélgetést, nem is vezetne sehova.


A topic címe "PIC programozása C nyelven, C-Compiler". Lehet, hogy kicsit egyszerűsítve fogalmaztam, de maradjunk a topic témakörén belül, mint értelmezési tartomány, legalábbis nekem ez volt a szándékom.


A Neumann-felépítésnél fizikailag semmi sem választja el egymástól a két memóriatípust (ez a lényeg), ugyanazon címmezőn, elérési utakon (cím- és adatbusz) osztozkodnak. Sőt, az x86-os procik valós módjában nem is megy az MMU (ami a 286-osoknál jelent meg), akkor pláne kitűnik ez a tulajdonság - ha még emlékszel a jó öreg DOS-ra, mert nem volt mindig winfos mindenhol...
Viszont a Harvardnál fizikailag is külön van a kettő, nem ugyanazokon a vonalakon mozognak az adatok és az utasítások, címmezejük sem közös, a chipen is máshol vannak, nincs átfedés. És ez alapvető különbség. Ehhez alkalmazkodni kellett a fordítóknak is. Törődj bele

Magamat is korrigálom. Nem függ a memória típusától az, hogy egy változó constans, vagy sem, ezzel nem lehet indokolni. Ha a forrásban van érték adva neki és később nem akarjuk változtatni, akkor const lesz, függetlenül a kontroller felépítésétől. Tehát csak a szándéktól függ, amit jelzünk a fordítónak.

Na, ez a baj. Foprogramobol nezve. Meg fából vaskarika. Ilyen nincs. A valtozo az mindenhonnan nezve valtozo. Ezek programozasi kifejezesek, nem lehet oket maskepp ertelmezni, mint ahogy kitalaltak. Ezeket nem en talalom ki. Vitát lezarando, javaslom, olvasd el a C konyveket arrol, hogy mit jelentenek a valtozo es konstans kifejezesek, es mit a const kulcsszo a C nyelvben.
Valtozok:
int a; // sima int tipusu valtozo
const int a; // egy int tipusu valtozo,
de mivel const, erteket ketfele modon kaphat. deklaraciokor inicializalassal:
const int a = 3;
es fuggveny bemeno parameter eseten a fuggveny meghivasakor (a vitatott eset)

const char *p; // egy pointer tipusu valtozo
a p valtozo erteke modosithato, de a const qualifier miatt a pointert irasra nem lehet dereferencialni, azaz:
a = *p; olvasas lehetseges,
*p = a; de az iras mar hibauzenetet eredmenyez.

char * const p; // egy char-okra mutato const valtozo
Ennek erteket csak inicializalassal lehet adni vagy fuggveny bemeno valtozojakent kaphat erteket. Ezt a pointert irasra es olvasasra egyarant lehet hasznalni.

Konstansok:
12 // egy int tipusu konstans
'A' // egy int tipusu konstans
"alma" // egy const char * tipusu konstans (tehat egy pointer), ami inicializalva van, erteke az alma\0 szovegre mutat. Az, hogy a szoveg maga hol es milyen memoriaban lesz , az mar erosen fordito fuggo.

A tobbirol nem kivanok itt vitazni.
MS-DOS... Tudod, en '87-ben mar sajat tervezesu, epitesu z80-as gepen kerestem a penzem C programozassal, kesobb CP/M felulrol kompatibilis oprendszert irtam a gepre (tobbet is), meg assemblert, linkert, editort, C forditot, debuggert, pm klont es hasonlokat. Azota rengeteg szamitogepet terveztem, irtam tomerdek programot, kicsit is, nagyot is. Elhiheted, hogy tisztaban vagyok az arhitekturakkal es a C nyelv alapjaival. Ja, es ezeket meg is tudom mutatni, nem csak a levegobe beszelek. En itt altalaban segiteni szoktam es amolyan onkentes szakmai moderator modjara kijavitani az ilyen teves dolgokat, mint ez a konstans/valtozo kerdes. Itt, ha valamit kozzeteszel, abbol masok tanulhatnak, ezert erdemes hiteles dolgokat allitani. Ha valamit nem tudok, akkor azt nem magyarazom el masoknak. Ezert irtam en is az elso post-ban, hogy nem tudom, hogy mire jo ebben az esetben a const, es talalgatni nem akarok.

Nem, nem nezopont kerdese, hanem definicio kerdese. Ez nem irodalmi szakkor, hanem programozas.
Igen, tulkepp en is erre jutottam, mert mas ertelme nincs.Egy szabvanyos C fordito nem engedi, az biztos.Ez egy pointer es ez a const itt egy szabvanyos C eseten csak azt mondja a forditonak, hogy csak olvasasra lehet hasznalni. Egyes PIC-ek eseteben, a Harvard es a keves RAM miatt tobbet is mond a forditonak, de pont ezzel durvan megserti a C szabvanyt. A const es nem const teruletre mutato pointer ugyanaz kellene legyen, de egyes PIC forditoknal egeszen maskepp kezeli a const pointereket, mivel azok a FLASH-be mutatnak, nem RAM-ba. Ez egy kenyszermegoldas, ez van. Pl. az AVR-eknel, ami szinten Harvard arhitekturas, ott ezt ugy oldottak meg, hogy minden const adat RAM-ban van, igy nincs kulonbseg az eleresuk kozott. Tobb RAM-ot hasznal, viszont C a C, tehat, aki nem PIC-ul programozik, hanem C-ben, azt nem erik rettento meglepetesek.

Ebbe ne menjünk bele. Ha akarod érted mire gondoltam itt.

Szerintem nem sért semmit, csak kibővíti. Változtatni kellett, mert így logikus.

Ha neked fontos, hogy egy nem változtatható értékű állandót változónak nevezz, akkor rendben, engem nem zavar, de nekem állandó az, ami nem változik, függetlenül attól milyen memóriában van tárolva. Ha azt mondom a fordítónak const, akkor az nekem nem egy változót jelent a szó valós értelmében. Ebben az se zavar, ha a C ezt másképpen értelmezi, mert nem okoz problémát a munkám során...

Tehát szerinted egy const létrehoz egy olyan változót, ami nem változik? (azaz egy állandót?) Jól kitalálták!

Ne menjunk bele. Nekem mindegy, en tudom, hogy mi mit jelent. Sajnos nem tudok segiteni. Ha te maskepp hivod a dolgokat az a te maganugyed, csak ne vezess felre masokat. A 12 az konstans, az mindig 12. De eppen a const-nak deklaralt fuggvenyparameter a pelda ra, hogy minden hivaskor mas es mas ertekre van inicializalva, tehat nem allando. Ezt nem lehet vitatni, legfeljebb nem tudni.
En mondjuk nem ezt mondtam, de lenyegeben igen. A const elotag egy valtozo deklaraciojakor azt jelenti, hogy a valtozo erteket a program futasa soran nem lehet megvaltoztatni, csak inicializalassal lehet neki erteket adni. Ezen felul az igy deklaralt nem auto valtozok forditotol es kornyezettol fuggoen lehet, hogy mas memoria szegmensbe lesznek elhelyezve, mint a nem const valtozok. De a programozas mar csak ilyen, vannak benne ilyen elsore erthetetlen, logikatlannak tunu dolgok, de a legtobb esetben a melyebb reszletekbol kiderul, hogy ennek mi az oka. Az egyetlen dolog, amibe itt mindharmunknak bele kell torodni (en mar tul vagyok rajta), az az, hogy ezt nalunk sokkal okosabb emberek talaltak ki, es ok tudjak, hogy ez miert van igy. Most nem a mikrocsip programozoira gondolok, akik a gcc-bol zombit csinaltak, hanem az igazi nagy agyakra, mint Kernigham és tarsai. Azt pl. tudtad, hogy C-ben az ertekado operatoroknak csak egy mellekhatasa (side effect), hogy az egyenlosegjel bal oldalan allo objektum felveszi az operator eredmenyenek erteket? Kicsit jobban elmelyulsz a C nyelv elmeleteben akkor meg is erted, hogy miert van igy. Ertelmetlennek hangzik, pedig igy van.

Szóval értelmetlen neve van, ha tényleg így gondolták a kitalálói, de szerintem nem így gondolták, csak te így értelmezed és szerinted másnak is így kéne, de én ezt nem eszem meg, mert logikátlan! Azzal egyetértek, hogy több eszük volt, de a bibliát is sokféleképpen értelmezik...


Tévedsz! A függvény paraméterének érvényességi (értelmezési) tartománya a függvényen belülre korlátozódik, azaz a függvényen belül ez egy állandó. Ha globálisan deklarálod, akkor globálisan lesz állandó. A függvényen kívül ez az állandó nem is létezik, a függvény hívásakor jön létre és kap értéket, utána felszabadul a hely. Tehát a const a saját értelemzési tartományában pontosan azt jelenti, amit jelent. Hiba lenne kiemelni és más tartományba értelmezni egy ott nem létező valamit.

logikatlan neked, de nem nekem. Akkor ki esz meg mit? Pont ez a lenyeg, hogy ez nem szubjektiv dolog (nem irodalmi szakkor, senem Biblia), nem azon mulik, hogy szerinted vagy szerintem mi mit jelent. De talan a leglenyegesebb kulonbsegre hadd hivjam fel a figyelmed: Egy C valtozonak van neve, tipusa, ervenyessegi tartomanya, tarolasi osztalya. Ezzel szemben a konstans vagy allando a C-ben egy olyan kifejezes, aminek a tipusa es erteke mar forditaskor ismert, de nincs neve, nincs ervenyessegi tartomanya es nincs neki tarolasi osztalya sem. A ket dolog teljesen mas.

Idézet:
„Akkor ki esz meg mit?”

Amit főzött.

Had kérdezzek valami, hátha tudsz segíteni! Mit jelenthet az xc32-gcc beállításainál a Isolate each function in a section beállítás (csatoltam egy képet) ? Ha nem pipálom ki, 700k-s lesz a program, he igen, 472k.

Ha jol ertem a leirast, akkor azt jelenti, hogy minden fuggvenyt kulon szegmensbe tesz a fordito. Normalisan a gcc a .text szegmensbe teszi a fuggvenyeket, ha kulon mast nem kersz. Ha megkapja a -ffunction-sections opciot (bepipalod az Isolate...-t), akkor minden fuggvenyt egy .text.fuggvenynev szegmensbe tesz. Ez linkeleskor jol johet, mert nem egyetlen nagy kod lesz, hanem rengeteg kicsi, amit a linker tobb teruletre szet tud osztani. De, hogy ettol miert lesz kozel a fele a kod, azt el nem tudom kepzelni.

Kozben megtalaltam a megoldast. Az Isolate.. bepipalasa a linkernek is atad egy opciot: --gc-sections. Azert lesz rovidebb a kod, mert ha minden fugveny kulon szegmensben van, akkor a linker ki tudja hagyni azokat a fuggvenyeket a vegen, amikre senki nem hivatkozik. Feltetelezem, hogy hasznalsz valami gyari mikrocsip cuccot, USB, SD, FAT, TCP/IP, ami tartalmaz rengeteg fuggvenyt, aminek csak egy reszet hasznalod.