Nem ragoznám túl, a dabadab által leírt megoldás helyes, de érdekelne, hogy ilyet hol találtál...

Same rules apply!

Köszönöm, én is erre kanyarodtam, már mint, hogy kétdimenziós tömb és valamilyen adatszerkezet vagy struktúra..
Kérhetnék tőled egy kis példát miképpen oldanád meg ezt a 2db struct-ot?

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Tulajdonképpen egy program generálja le ezt a definíciót, amellyel aztán egy chip felkonfigurálását lehet megoldani.
Az adatszerkezetet eddig nem önmagában, hanem lebontva használtam fel, de szeretném kicsit felgyorsítani a tesztelést, így gondoltam a legenerált definíciót felhasználva gyorsítanám meg a dolgot..

Ebből a definícióból csak a hosszabb sorok az értékes adatok, ezeket az adatsorokat egymás után kell elküldenem így a külön álló 0x00-ák nem lehetnek közöttük..

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Köszönöm srácok a segítséget.
Végül így oldottam meg:

const struct setup_t {
char dummy;
char command[32];
} valami[] = SETUP_MESSAGES_CONTENT;

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Köszi, közben persze rájöttem, hogy nekem ez nem jó mert elég rugalmatlan.
A tömbösített jobb mert könnyebben tudom bejárni..
Azért köszi a rávezetést, sokat segített.

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Nem olyan bonyolult azért írni egy fv.-t, ami szerializálja, ha mindenképp bejárni szeretnéd valahogy.

Same rules apply!

Ezt at lehet alakitani rekurzio nelkulire, ha ugy tartja kedved.

Igen, úgy tartja kedvem, csak nem tudom hogyan lehetne megcsinálni.

Valaki tud segíteni, hogyan sikerülhetne ezt átalakítani?

Te kell karban tarts egy vektort, amit veremnek hasznalsz, vagy egy valtozot ahol visszafele lepeskor is adminisztralod a valtozast, vagy lehet akar minden elorefele lepesnel megszamolni...
Az algobol eleve kiesik egy info, eleg az a-kat szamolni, mert (ha jol vettem ki) x=y+z igy b kovetkezik, sot a koztes lepeseknel is tudod, mert egy index ugyis kell hogy hol tartasz a veremben, az pont jelzi az aktualis hosszt.
De ezt en nem feltetlen igy csinalnam... ha a kerdes algoritmikus es nem programozastechnikai. Eloszor is kevesebb lepes, ha a run-length kodolas alapjan me'sz (minden lepesben nem 1 db valamelyik karaktert teszel le, hanem 1-tol az adott betubol visszalevoig barmennyit a betuket valtogatva, a legelejen megengedheto de cask ott a 0 db).
Masreszt ez az n alatt a k tipikus esete (x alatt az y), es mivel iszonyat gyorsan nonek ezek a szamok, igy ha ki kell iratni, akar arra is lehet tamaszkodni, hogy bele fog ferni egy nagyobbacska int-be a bitenkenti abrazolassal... az int-ben meg tudod szamolni - persze csak ciklusban de a stringnel joval gyorsabban - a bitek szamat, es csak ami jo azt konvertalod a-b-re.)
Valamelyik pszeudot osszedobhatom, ha gondolod, de mindet inkabb nem.

Köszönöm szépen a leírásod, de az utolsó módszerhez hasonlóan már megy. Növelek egy számot és bitenkénti ábrázolása megnézem, benne az 1 és 0-ák számát. és ami megfelel azzal dolgozok.

Kedves kollégák,

Egy olyan algoritmust kérnék tőletek amely egy 8bit-es vagy is 1 byte-ot fordít meg.
Pl: ből - re
00000011 - 11000000
A lényeg, hogy a lehető legkevesebb erőforrást igényeljen a bitművelet.
Egy olyan rutin kellene ami nagyon gyorsan és pontosan illetve rugalmasan dolgozik mert nagyon sok különböző adatot kell felcserélni..
(Azért nem én álltam neki megírni a rutint, mert, itt kevés az, hogy jól működik, itt sokat számít, hogy a lehető leggyorsabb és legkevesebb erőforrást igényelve cserélje fel a bitsorozatot.)
Előre is köszi... (egyébként egy makró vagy struktúra is jó lehet, ha az gyorsabb)

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Azt hogy kell megvalósítani?
Tán ami itt van az jó lehet: [link]

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Igen, az tökéletes. Főleg, hogy Neked csak egy bájtra kell.
Nemes egyszerűséggel indexeled vele a lookup tablet (erre van gyártva), és kész vagy.

Éljen a gugli-copy-paste pattern.

Same rules apply!

Igen ezt korábban is néztem már, de nem tudom PIC (mikrokontroller) esetében ez a megoldás mennyire lehet erőforrás kémillő megoldás... Vélemény?

És valaki el tudná magyarázni a működését?

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Hát józan paraszti ésszel nézve is 256byte-ot fogyaszt a lookup table, valamit egy indexelést hajtasz végre (ami ugye gyakorlatilag egy összeadás - tömb kezdetének címe+index).
Ez még egy kenyérpirítón is gyors lesz.

Működés: a tömbben minden indexen az adott byte megfordítottja van, csak nyilván hexában van leírva.
Tehát pl.
tömb[1] = 0b00000001 megfordítása = 0b10000000 = 0x80.
tömb[17] = 0b00010001 megfordítása = 0b10001000 = 0x88.

[ Szerkesztve ]

Same rules apply!

Ez a része nem világos:
// Option 1:
c = (BitReverseTable256[v & 0xff] << 24) |
(BitReverseTable256[(v >> 8) & 0xff] << 16) |
(BitReverseTable256[(v >> 16) & 0xff] << 8) |
(BitReverseTable256[(v >> 24) & 0xff]);
Itt 8bit-nél is ezt az egész sort kell használni?

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Ez arra kell, hogy az egész byteot megfordítsa, ha megnézed.
Egy bytehoz Neked csak a tömböt kell indexelni, semmi mást.

Same rules apply!

Huu basszus... Nem esett le, hogy megnézzem a tömb-ben felvett hexák értékét..
Köszi, most már értem.
1bájthoz csak indexelnem kell

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Hirtelen ez jutott eszembe, de biztos van gyorsabb módszer is:

unsigned char reverse_bits(unsigned char x)
{
unsigned char y=0;
y=y | ((x & 0x80) >> 7);
y=y | ((x & 0x40) >> 5);
y=y | ((x & 0x20) >> 3);
y=y | ((x & 0x10) >> 1);
y=y | ((x & 0x8) << 1);
y=y | ((x & 0x4) << 3);
y=y | ((x & 0x2) << 5);
y=y | ((x & 0x1) << 7);

return y;
}

„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár

Ez talán egyszerűbb és gyorsabb, ha a ciklust kigörgeted:

unsigned char reverse_bits(unsigned char x){
unsigned char y=0;
for(int i=0;i<8;++i){
y=y >> 1;
y=y | (x & 0x80);
x=x << 1;
}

return y;
}

„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár

Vagy a ciklus ilyen is lehet:

for(int i=0;i<8;++i){
y=y << 1;
y=y | (x & 1);
x=x >> 1;
}

„Kétségtelen, hogy nem tudjuk, mit tegyünk, de felkészültek és elszántak vagyunk.” - Olaf Scholz német kancellár

Köszönöm végül a táblás módszert választottam.

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

mivel a tábla az const ezért a flashben fog tárolódni, és nem a ramból vesz el 256byte-t.

Same rules apply!

ha const-al definiálsz akkor a fordító a flashben fogja tárolni és nem a ramban. MAP fájlban meg is lehet nézni pontosan hova rakta.

Azért ez így ebben a formában elég furán hangzik, gyakori használat mellett (és mondjuk ilyen beégetett tömböt simán csinálsz pont erre) eléggé szuboptimális lesz a dolog.

Same rules apply!

ROM ként tárolom vagy is a PIC program memóriájában.
CONST-ként nem engedélyezett a tárolása.

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Code::block-ban hol lehet beállítani, hogy az adott program csak 32mb ramot hasznaljon???

Ez a kérdés hogyan merült fel?

Same rules apply!

Srácok ennek a BT chipnek a konfigurációs beállításához kellett a bitfordítós program: DPTP System - nRF8001 Bluetooth kapcsolat
Köszi még egyszer a segítséget.

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Versenyen volt ilyen feltétel, hogy ennyi memóriát használhat csak a program.

Sziasztok!

MPLAB X IDE v2.30-ben fejlesztek egy programot pic16f688-ra. DS1820-al szeretnék hőmérsékletet mérni. A program C-ben íródik. Találtam egy ilyen, már más által megvalósított kapcsolást és programot [link], de olyan parancsot használ (Ow_Reset, Ow_Read, Ow_Write), amit a fejlesztőkörnyezet nem ismer. Gondolom includeolni kéne egy header file-t, de itt elakadtam... Tudna valaki segíteni? Maga az includeolás az menne, azzal semmi probléma nincs, csak hogy mit honnan kell letölteni, hova kellene bemásolni, meg ilyenek.

Előre is köszönöm!

Ezek olyan függvények amelyek nincsenek benne a fórosban.
Gondolom egy külső fájlban írta meg és azt nem publikálta.
Használd ezt a forrást: [link]
Egyébként a DS1820-nak van adatlapja ott részletesen leírja miképpen kell vele kommunikálni.
Honnan szereztél ilyen szenzort?
Pont most akarok én is egy olyan projektet elkezdeni amihez ilyen szenzor fog kelleni.

[ Szerkesztve ]

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Köszönöm, vettem is gyorsan 2db-ot.

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

Free sample-ként rendeltem még régebben valamelyik gyártótól vagy összesen 5 db-ot. aztán onnan maradt meg. De ezt (#5188) zka67 én is megjegyzem.. Köszi!

A leírását tanulmányoztam, egy egész délután játszottam az időzítésekkel, meg mindennel. Átírtam mindent, ötször megnéztem, de nem akarja az igazságot.
Ez amit belinkeltél meg nekem sajnos nem jó, az MPLAB X egy rakás hibaüzenetet küld, hogy ez nem jó meg az nem jó. De ahogy elnézem, nem véletlen. "(CCS Compiler, Microchip C18 Compiler)".
Tudom, ajándék csónak ne nézd a lapát, de... Valami ötlet?

[ Szerkesztve ]

Igazából nem azért linkeltem, hogy úgy ahogy van másold és használd
A lényeg benne van csak észre kell vedd..

Ha a gyártó által megadott időzítéseket használod, akkor mennie kell, max az lehet a gond, hogy a késleltető függvényed nem jó mert a PIC nincs jól beállítva, de ez már egy másik topik..

----== Neo Geo és Arcade Fórum : www.neo-geo.hu ==----

már időközben találtam valamit! köszi a segítséget!

Szia, itt az általam használt modul. A gpio.h-t cseréld le a PIC io moduljára, és a gpio funkciókat is írd át a megfelelőkre, értelemszerűen (Ez a program a 2.5-ös portot használja, természetesen ez szabadon választható). A temp_delay értékeket át kell számolnod, hogy a megfelelő időzítéseket megkapd.

Először olvasd ki az értket a chip-ből a temp_get()-tel, utána indítsd el a következő konverziót a temp_start_conv()-val, és a következő kiolvasásig várj 1mp-et. A program az alapértelmezett felbontást használja (12 bit), a konverzió ideje 750ms. Ezalatt csinálhatsz mást, sűrűbben kiolvasni nincs értelme és egyébként is hibás adatot kapnál.

Remélem így már boldogulni fogsz

#include "core/gpio/gpio.h"

void temp_delay(int delay) {
do { ; } while(--delay);
}

void DQ_LOW(void) {
gpioSetDir(2, 5, gpioDirection_Output);
gpioSetValue(2, 5, 0);
}

void DQ_HIGH(void) {
gpioSetValue(2, 5, 1);
gpioSetDir(2, 5, gpioDirection_Input);
}

uint32_t DQ(void) {
return gpioGetValue(2, 5);
}

void temp_reset(void) {
char presence = 1;
while (presence) {
DQ_LOW() ;
temp_delay(9055); // 503us
DQ_HIGH();
temp_delay(1260); // 70us
presence = DQ();
temp_delay(7740); // 430us
}
}

void temp_write_byte(uint8_t val) {
uint32_t i;
uint8_t temp;
for (i=8; i>0; i--) {
temp = val & 0x01;
DQ_LOW();
temp_delay(90); // 5us
if (temp) DQ_HIGH();
temp_delay(1134); // 63us
DQ_HIGH();
temp_delay(36); // 2us
val = val >> 1;
}
}

uint8_t temp_read_byte(void) {
uint32_t i;
uint8_t value = 0;
for (i=8; i>0; i--) {
value >>= 1;
DQ_LOW();
temp_delay(108); // 6us
DQ_HIGH();
temp_delay(72); // 4us
if (DQ()) value |= 0x80;
temp_delay(1134); // 63us
}
return(value);
}

void temp_start_conv(void) {
DQ_HIGH();
temp_reset();
temp_write_byte(0XCC); // skip rom
temp_write_byte(0X44); // start conversion
}

uint32_t temp_get(void) {
uint32_t tlv, thv;
temp_reset();
temp_write_byte(0XCC); // skip rom
temp_write_byte(0XBE); // read scratchpad
tlv = temp_read_byte();
thv = temp_read_byte();
DQ_HIGH();
return tlv | (thv << 8);
}

Isten vagy, köszönöm!

Üdv!
Kezdő programozó vagyok és lenne nekem egy példám..
A példa így szól:
Ird meg a C nyelvű függvényt mátrix transzponálására(az oszlopok és a sorok helyet cserélnek).Ird meg a főprogramot,amely bemutatja a függvény működését.
Nos,a mátrix kiírása/beolvasása sikerült viszont a transzponálás már nem megy annyira.Van pár ötletem de azért meghallgatnák pár tapasztaltabb embert,hogy mit javasol.
Köszönöm

Attól függ mi a feladat pontosan. Mert ha a transzponált mátrixot oda kell adni valami másik függvénynek az boldogtalan lesz ha nem transzponálod ténylegesen mert nem tudja, hogy fel kell cserélni a koordinátákat. Persze ha van valami társított flag ami mutatja és ezt minden tudja is kezelni, akkor jó megoldás.

A kérdésre válaszolva: végig kell iterálni az alsó vagy a felső hárömszögön és cserélgetni. Már ha nem kell új helyre másolni, mert akkor az egészen végig kell menni és felcserélve kiírni.

[ Szerkesztve ]

Jester

Troll megoldas: a transzpnalo fuggvenyed csak egy func pointert ad vissza, amin keresztul az eredeti mx indexelheto. C++-ban megszebb ugyanezt visszaadott iteratorrral megoldani.

Same rules apply!

Viszont ez minden elem elérésnél egy indirekt függvényhívás amit nem tud a fordító inline beágyazni. Bizonyos mennyiség fölött garantáltan sokkal lassabb lesz, mintha ténylegesen transzponáltad volna.

A másik, hogy a cache hatékonyságát nagyban befolyásolja a bejárás. Egy sorfolytonos bejárás sokkal gyorsabb lehet mint egy oszlopok szerinti. Az algoritmust ennek megfelelően választhattad meg, de ha a hívó egy függvénypointeresen transzponált mátrixot ad be, akkor amire a kód azt hiszi, hogy hatékony sorfolytonos az valójában nem az. Ugye bizonyos műveleteknél ezért éri meg ténylegesen transzponálni a mátrixot, a bejárás megváltoztatása helyett, még akkor is ha amúgy nincs függvénypointeres trükközés. Lásd még What every programmer should know about memory: "Through the simple transformation of the matrix we can achieve a 76.6% speed-up! The copy operation is more than made up. The 1000 non-sequential accesses really hurt. "

Virtuális mátrixokhoz viszont kétségkívül jó megoldás lehet.

Jester