Nem hinnem, hogy butasag. Eddig nem gondoltal erre, mostmar tudod. Ez a tanulas. Vagy magadtol jossz ra mindenre (rengeteg idobe telik), vagy megtudod masoktol.

Mi eddig kb. 50-60 darab DS18B20-at használtunk el hőpumpavezérléshez, eddig ha gond volt velük, mindig a csatlakozó volt a hibás, egy kivétellel, amit még nem néztem meg, de szerintem ott is a krimpelt csatlakozó lesz a hibás.

Én részemről, még a mellékzöngék mellett is érdekes vitának tartom az eddigieket. Látszik, hogy egyikőtök sem most jött le a falvédőről és érdekes a dolog, amit a kétszeres áttöltésről fejtegettél, valóban, minek, ha az első dolog úgy is a paraméter átadása. Naszóval köszi és béke veletek!

Átraktam a főciklusba (meg kicsit átszerveztem ezt-azt), és bár nem akarom elkiabálni, de úgy néz ki hatékonyabb lett egy fokkal a program.

Miért a a "kénytelen menteni a C fordító által paraméter átadáshoz használt regisztereit"szerepel a C18 fordítós megszakításos hozzászólásomban a "paramétereket a stack -re (FSR2 indirekten) kell másolnia" helyett.
Amit már a stack -re pakolt a program a megszakítás beérkezése előtt, azt nem kell még egyszer menteni. Csak a regiszterekben levő (pl a visszatérési érték dedikált regiszterei) adatokat kell menteni.
Jó, hogy leírtad, hogy a modern fordítók, hogyan kezelik a paramétereket.
Béke mindenkinek.

Tudtad, hogy ha egy eljárást a megszakítási rutin is meghív, akkor (bizonyos esteben) a C18, XC8 kétszer fogja befordítani a pogramba.

Ha ez kérdés volt, akkor a válaszom nem, de most már igen.

Bocsi ha megbántottalak...természetesen a nick nevedre értettem. Erről remélem nem nyitunk vitát. Nem a hozzászólásod tartalma volt a baj, inkább a stílusa volt kicsit lenéző. Itt azért nem vérprofik vannak. Én kb. 10 éve nyomulok PIC ügyben és mindig van mit tanulni, különösen ha új dolgot csinálok. Ebben nagyon sok segítséget kaptam a különböző topikokban.

Nem bantottal meg, csak felbosszantottal A nick-em az meg 1996-bol szarmazik, bilgécre utal es valoban a gyilkolasi vagyat tukrozi. A stilusom meg sajnos ilyen, de probalok en is valtozni, csak az nem megy olyan konnyen faluhelyen.

Sziasztok!
Szeretnék érdeklődni, hogy szerintetek melyik az "elegánsabb" eljárás egy függvénynél.
A deklaráció:

Itt a hőmérséklet eredményét a hom nevű változóba mentem indirekt módon:
vagy
A deklaráció:
s16 read_after_getstartalldev(BYTE pin, BYTE device);
Itt pedig a visszatérési értéket mentem majd el egy hom nevű változóba:

Melyiket érdemes használni?

A függvénynél az a "normális", ha visszatérési értéke van (nálad a második verzió).

Vannak azonban olyan esetek, amikor ez nem járható út, mert pl. egynél több adatot kell visszaadnia, ilyenkor az első változatot kell használni.

Köszönöm szépen. Azért érdekelne a dolog, mert fel szeretném "darabolni" a projektemet különböző forrásállományokra és picit gondban vagyok azokkal a változókkal, amik eddig lokálisak voltak állományokra nézve. Ezeket a darabolás miatt más állományokban is el kell tudni érni, esetleg módosítani, így gondoltam arra, hogy indirekt módon érem el a változókat a függvényekkel. Vagy maradna az módosító jelző a használni kívánt változó elé, amiket minden állományban deklarálnék, jelezvén a fordítónak, hogy ez a változó máshol lett deklarálva. Csak utóbbitól félek picit, mert eléggé átláthatatlanná teszi a programot.

Nem teszi átláthatatlanná az extern, ha jól használod. Jobb, mint a függvényezés. Nézd meg ezt a két hozzászólást: Link1 és Link2

Értem. És ha a main-ben van deklarálva és definiálva is a változó és ezt szeretném elérni egy másik állományban, akkor az extern módosító jelzős deklarációt hová tegyem?
Mert hogy main.h nincs, amit be tudok include-olni a forrásállományba. Vagy akkor mehet pl. a Modbus.c-be? Vagy menjen a Modbus.h-ba úgy, hogy a Modbus.h be lesz include-olva a main.c- be?

Ott valamit rosszul csinálsz, ha neked a main függvényen belül definiált változót kellene elérned másik forrásállományból. Akkor annak a változónak globálisnak kell lennie, így igen, egyik lehetséges megoldás az, hogy a modbus.c-ben definiálod a változót, a modbus.h-ben deklarálálod (extern ....), és a modbus.h fájlt includolod be a main.c-be. Vagy a másik lehetőség, hogy függvényekkel viszed oda-vissza az értékét, amikor szükség van rá, akkor kihagyod az externes deklarációt a modbus.h-ból. Pl. ha ez egy belső változója a modbus stack-nek, és nem akarod, hogy kívülről átírható legyen, de olvashatónak kellene lennie kívülről is, akkor csinálsz egy függvényt a modbus stack-be, ami visszaadja az értékét.

Az is természetesen. Az a helyzet, hogy a megszakításban töltöm fel a bejövő pufferem, amit a main-ben deklaráltam (vagyis igazából még a a main() előtt így globális, de attól még abban az állományban van) és a modbus.c-ben kellene kielemeznem. Igazából a kimenő pufferem is hasonló...

Ja, azt hittem a main függvényen belüli változóra gondolsz. Akkor ez így jó, csak akkor pl. csinálnod kell egy main.h fájlt, amiben extern-el deklarálod a változót, és akkor azt beincludolod a modbus.c fájlba. Vagy átteszed a változódefiníciót a modbus.c fájlba, deklarációt a modbus.h fájlba, és azt includolod a main.c-be. Mindkét megoldás működik, C projekt felépítés szempontjából mindkettő megfelelő, hogy a te szempontodból melyik a logikus, az rajtad múlik.

Nagyon szépen köszönöm!

Ha extern változót szeretnék, annak készíteni szoktam egy külön extern.h állományt és a main.h-ba, vagy más közös *.h-ba, ami mindegyik *.c-be be van include-olva, így mindenhová bekerül. Ha hozzá kell adni új változókat, akkor csak ide kell bevezetni.

És azt hogy csináljam, ha pl. beírom a Modbus.c-be, hogy:

És ezt szeretném elérni, akár megváltoztatni a main.c-ben, vagy bármelyik forrásállományban?
Mert ha ezt beteszem pl. a Modbus.h-ba így:

és a Modbus.h-t meg beincludolom a main.c-be, akkor ezt a hibát kapom:
conflicting declarations for variable "bejovo_puffer"
16.16 type redeclared

Külön kell választani a típusdefiníciót és a változó definíciót. Modbus.h fájlba csinálsz ilyet:



A typedef létrehoz egy új típust, de nem foglal neki memóriát. Csak létezni fog a típus, mint ahogy létezik az int vagy a float. Az extern-el a szokásos módon jelzed a linkernek, hogy majd lesz egy kimeno_puffer_t típusú változó valahol.

Modbus.c fájlban pedig



Ezzel pedig lefoglalod a memóriát a struktúra számára.

Ezt sosem tudom megjegyezni, hogy hová kell írni

Ettol lesz egy struct xxx tipusod is, meg lesz a tipus_t is. A ketto ugyanaz. Csak a struct xxx-re mar a strukturan belul is tudsz hivatkozni.

De kette is lehet szedni:

Oké, úgy néz ki működik a dolog.
Köszönöm szépen!

Azt esetleg hogyan tudnám megcsinálni, hogy a függvényeknek, ahelyett, hogy külső globális változókat adnék át, átadnám indirekt módon a kimeno_puffert vagy a bejovo_puffert?

Nem egészen értem a kérdést, tudsz mutatni rá példát, hogy mire gondolsz?

Ritkán használom ezeket a szintaktikákat, és hiába jegyzem meg, előbb-utóbb úgyis elefeljetem. Azért úgy nagyjából emlékszem, fordító meg úgyis kiabál érte, ha rosszul használnám

Szóval a program úgy épül fel, hogy a megszakításban karakterenként egy bejovo.puffer.bejovo_adat nevű tömbbe mentem le a beérkezett karaktereket. Ha az első karakter megegyezik a PIC_ADDRESS-el, akkor innentől kezdve még vár 7 karaktert, amit ugyanugy lement a pufferba, majd ha bejött mind a 8 akkor beír egy flaget 1-be jelezvén a főprogramnak, hogy bejött egy stream.
A gond az hogy a megszakítás is külön forrásállományba van téve (Interrupt.c, Interrupt.h) így neki ismernie kell a bejovo_puffer nevű struktúra változót. Viszont a kiértékelés a main.c-ben van, ahol is megnézi, hogy helyes-e a bejött stream. De ezt viszont úgy, hogy a main-ben csak meghívja a Modbus.c-ben lévő függvényt, hogy vizsgálja meg. Ennek a függvénynek bemenő paramétere nincs, visszatérési értéke van csak. Vagyis itt valahogy tudomására kell juttatni, hogy mi az a bejovo_puffer. Ezért kellett a "globális változóvá tétel". De nekem az lenne szimpatikusabb, ha úgy adnám oda ennek a függvénynek a bejovo_puffert, hogy indirekt módon.
Pl_:
Vagy valami hasonló módon. így nem kellene mindenkinek ismernie a bejovo_puffert (megszakításnak sajnos igen, mivel neki nem tudok bemenő paramétert adni), csak indirekt módon átadnám a címét, ahonnan tetszés szerint változtatnám...

Amikor a függvényt hívnád meg, akkor egy & jelet tegyél a változó neve elé, ezzel nem az egész puffert adod át a függvénynek, hanem csak a címét, vagyis egy pointert. Tehát



A függvényen belül pedig vagy vagy pedig formában éred el a struktúra belső változóit. A kettő ugyanazt jelenti, utóbbi szerintem átláthatóbb.