Semmi osszefugges a ketto kozott. Az egyik egy eszkoz, a masik egy programozasi nyelv.

Ok, félreérthetően írtam, meg hát attól még hogy a Microchip rosszul írta meg a függvény(eke)t, attól nem a C a rossz nyelv.

Nem gondolom, hogy egy flag torlese automatikusan kell hogy kovesse a kiolvasast, nyelvtol fuggetlenul

Sziasztok!
Elakadtam egy projekt legelején egy látszólag nagyon egyszerű feladatnál:
A GP2 lábon érkező felfutó él megszakítást okozna, viszont az alábbi kódrészlet nem csinál semmit.
Ha a GP0_bit = ~GP0_bit; sort áthelyezem a megszakításba közvetlenül, akkor helyesen működik, viszont -ha nem tévedek-, oda célszerű a lehető legkevesebb utasítást írni.
PIC12F615, MCLR Disabled, INTOSCIO 8MHz.
Köszönöm előre is.

Kb. hetente előkerül, hogy azok a változók amiket megszakításból és a főprogramból is egyaránt felhasználsz, volatile-nek kellene lennie. Tehát a flagnak volatile char-nak kellene lennie (char is elég, felesleges a 16bites int, még egy bit is elegendő lenne).

Köszönöm a segítséget

Van egy másik kérdésem encoderek kezeléséval kapcsolatban:
Eddig így olvastam be az állapotokat:

Ha az encoder két lábát külön portra teszem, és az alábbi módon olvasom be, annak van valamilyen hátránya?

Milyen hatranyra gondolsz? Jol fog mukodni, csak pár assembly utasitassal hosszabb lesz a kod, mintha egy porton lennenek egymas mellett az enkoder jelek.

Uraim, lenne egy változóm amiben egy számolás eredményét kellene tárolnom.
A kérdésem az, hogy ezt hogy tudom megoldani,

...úgy hogy ha az eredménye 0 vagy negatív szám lenne akkor 0 értéket adjon vissza?
Most az eredménye 17992 unsigned, signed int típusokkal.

Ha az 514 előtti szám kisebb mint az amiből azt ki kell vonni akkor az eredményem 0-nak kellene lennie.

Van erre jó típus módosító?
Vagy több sorban tudom csak megvizsgálni az eredményt és aszerint eldönteni a folytatást?

Most egyelőre így oldottam meg, de ha van jobb megoldás azt szívesen veszem:

Az 5000\1024 értéke egész számok esetén 4 lesz...

Az nem baj, a számolás során lebegőpontosként kezelem, a végeredményt pedig egészként.
Ez itt most nem látszik.

Akkor 5000.0/1024.0-t kellett volna írnod, vagy ((float)5000)/((float)1024)-et.

Szia!
Igen, ehhez hasonló hátrányra gondoltam, köszönöm a válaszod.
Ezt gondolom a gyakorlatban nem igazán lehet észre venni.

Igen így volt, de nem ez volt a baj, hanem a végeredményt előjel nélkül kezeltem ezért volt gondom. Most már megoldódott ez a probléma.. Köszi azért.

Sziasztok egy kis segítséget szeretnék kérni.
Azt szeretném, ha az rc0-ra kötött nyomógomb megnyomásakor az adc beolvasná és konvertálná az an0 és an1 lévő potik helyzetét. A fordító hibát ír ki, de nem tudom mi a hiba.

Srácok, szeretném ezt egyszerűbb alakra hozni mert szerintem kicsit lassú a struktúrás megoldásom:

Valami olyasmire gondolok, hogy a biteket tologatnám jobbra és így adnám át egyesével az biteket D?-nek.
Valami ilyesmire:
Előre is köszi.

Köszönöm, az előzőre az volt a helyes válasz amit meg is adtam
Sajnos nem az volt a lassú, hanem a stiftregiszter meghajtásom.
Kérnék segítséget illetve tanácsot, hogy miképpen tudom gyorsítani a shift regiszter meghajtást.
Most ilyen:

A módszer jól működik, de több 100 ezres címzésnél már gyalázatosan lassú.
Hogy írhatnám meg ezt úgy, hogy akár drasztikusan is javítson a lefutáson?
Előre is köszönöm.

Milyen PIC, milyen sebeséggel hajtod?

18F442 @40MHz
C18-ban íródik a program.
3db shift regiszter van egymás után a linkelt kód az elsőt vezérli, 24bit-et kell kiléptetni.
A többi annyiban különbözik, hogy a ChipSelect elnevezése után számmal van jelölve: SR_CS, SR_CS2, SR_CS3.
Áhh linkelem az egészet, hogy lehessen látni a problémát:

Tehát ezt kellene kicsit hatékonyabbá tennem.
Mivel jelenleg fix a bekötés, nem állnék át SPI meghajtásra.

ui: Adat és órajel közös vezetéken fut.

helyett

Ez mennyiben fog gyorsítani a lefutáson?
A program működik rendben, csak nagyon lassú ha már 100e-s címzésről beszélünk.
260e címzést 6.5perc alatt léptet végig.

ui: amúgy köszi, és javítom.

Valoszinuleg attol ennyire lassu, mert minden egyes bitnel egy 32 bites szamot shiftelgetsz. Sokkal jobban jarnal, ha harom darab 8 bites szamra bontanad az adatot es azt is ugy shiftelned ki, hogy mindig csak egy bitet mozditasz rajta.


Hogy a ket shift_out() fuggvenybol melyik a gyorsabb, azt ki kell probalni.

Köszönöm, kipróbálom milyen eredményt hoznak.

A 23. sor hibas! Helyesen:

Igen közben erre én is rájöttem.
Köszi.
Tesztek:
1-es verzió gyorsabb 1 másodperccel: 7s és 2103 byte/s
2-es verzió: 8s és 1872 byte/s

A végeredmény az, hogy 3szor hatékonyabb ez a megoldás mint az enyém.
Köszönöm.

Nincs mit. Ha nem eleg okos a C forditod, akkor lehet, hogy meg egy kicsit gyorsitana rajta, ha igy irnad:

Ki fogom próbálni, bár szerintem ezt már nehéz lesz lemérni.
Még azzal gyorsítottam rajta 3 másodpercet, hogy a 3. kiléptetést csak akkor végeztetem el, ha cím nagyobb mint 65535.
Még ezt az időt is elvileg meg fogom tudni felezni, mivel most byte-onként léptetek, de tud a cucc 16bit-et, így annak használásával feleződni fog az idő.
Köszi még egyszer, most tesztelem ezerrel.

1. Bár kicsit terjedelmesebb lesz a program én nem raknám ciklusba a 24 bit küldését (a ciklus is sokat lassít).
2. olyan bitmezős struktúrát csinálnék, hogy mind a 24 bithez hozzáférjek.
3. ha nem szempont hogy az adatláb megbillen, akkor fixen kinulláznám az SR_ADAT -ot és csak akkor állítanám vissza 1-be ha szükséges

Véleményed szerint ez mennyiben gyorsítana még a programon?
1-2%-ot vagy többet?

ui: a struktúra felépítése lehetővé teszi, hogy minden bit-et külön tudjak kezelni.