// if the file is available, write to it: if (dataFile) { dataFile.println(dataString); dataFile.close(); } // if the file isn't open, pop up an error: else { Serial.println("error opening datalog.txt"); }
Kezdő vagyok az Arduino programozásában, de szerintem az a gond, hogy nem főzöd össze a datastringet, ezért csak a legutolsó értékadást írja ki. Mindig felülírod! Ha jól látom akkor csak a százalékot írja ki nem?
if (dataFile) { dataFile.println(dataString); Itt csak a százalék íródik ki, mert fentebb csak ezt az értéket veszi fel dataFile.close(); }
Próbáld meg:
if (dataFile) { dataFile.println(String(LAKASFUTES));
dataFile.println(String(fusthofok));
.
.
.
dataFile.close(); }
Vagy fűzd össze egy stringbe az egészet,
dataString+= String(LAKASFUTES);
dataString+= String(fusthofok);
dataString+= String(T1);
.
.
.
dataString+= String(szazalek);
majd:
if (dataFile) { dataFile.println(dataString); dataFile.close(); }
Ennek az lesz a baja, hogy nem lesz elválasztó karakter közötte! Ezt kikerülheted, ha hozzáfűzöl még pl egy pontosvesszőt (rögtön csv lesz belőle, duplaklikk és máris az excel megnyitja)
dataString+= String(LAKASFUTES);
dataString+=";"
dataString+= String(fusthofok);
dataString+=";"
dataString+= String(T1);
dataString+=";"
.
.
dataString+= String(szazalek);
dataString+=";"
Nézz utána, hogy így lehet-e hozzáadni pontosvesszőt!
Hmm valoban, belegondoltam, a Malna PC ide feleslegesen overkill, tul sok... Lehetne hasznalni, de tul bonyolult, es valoban nem olyan stabil mint egy egyszeru modul (amugy azert stabil).
// if the file is available, write to it: if (dataFile) { dataFile.println(dataString); dataFile.close(); } // if the file isn't open, pop up an error: else { Serial.println("error opening datalog.txt");
SD kártyára kellene kiírni a String(LAKASFUTES);..... String(szazalek); adatokat,
Épp ezért nem is vágtam bele az arduinos projectnek (egyelőre), mert rögtön a sebesség problémába ütköztem. Tanulni, megérteni, eredményeket felmutatni azért azzal is lehet, mert a prototípus elkészültéig néhány biztosan megpörkölődik! :-)
Csak 4MHz az SPI az Arduinon? Azt hittem, hogy a beépített óra frekvenciájával képes meghajtani... Sebaj, megoldom másképpen.
Léteznek nagyon komoly de ennek ellenére még mindig olcsónak nevezhető AD konverterek (TI pl) amik nekem jók lennének, de azokban nincs , vagy csak kevés memória. A memória azért kellene, mert a mérés tényleg off line lenne, így sokkal gyorsabb mintavételezés érhető el, valamint nem kell annyit gondolkodni, hogy mennyi óraciklust visz el egy közbeiktatott kontroller. Ezek előnye továbbá, hogy több mintát tudok venni.
Az azonnali feldolgozás annyit jelent, hogy az adott számú minta után meg kell jeleníteni, FFT-vel szűrni stb a PC-n, majd ha minden ok, akkor mehet a következő mérés. Itt jön a képbe az idő...
"Ha feltétlen fontos az azonnali feldolgozás, akkor a legkézenfekvőbb valamilyen automatizmus futtatása a PC-n, egy külön USB port, aztán hajrá! Kis ügyekedéssel megoldható, hogy a mentett 256 kB-os csomag mass storage eszközként egyszerűen (és automatikusan) áthúzható legyen a PC-re."
Ez már tetszik!!!! :-)
Az egész ARDUINO ott jött csak a képbe, hogy az adatokat a PC felé annak segítségével küldeném, de ha nem szükséges, az még jobb!
Már sokat segítettetek! Köszönöm! Ha van még javaslatotok, akkor ne kíméljetek! :-)
Málna PC-azért nem szimpi eddig, mert ott meg Linux fut, nem tudom mennyire gyorsan boot-ol, mennyire stabil, stb.
Azonban, ha megoldható egy cél gép megalkotása, akkor ok! :-)
Oké, vegyük az „alját”, 10 kHz-en mintavételezel 24 biten egy analóg jelet. Ezt oldd meg azzal, ami bevált, a végén alighanem valami átmeneti tárba kiírja ezt a 256K-t, amit te onnan ki szeretnél olvasni és automatikusan egy PC-re írni.
Mindenekelőtt én megnézném, hogy van-e erre kész eszköz (szinte mindenre van). Ha nincs, akkor kell tovább agyalni.
Ha az egész projektből SEMMI nincs meg, akkor -- szerintem -- nagyjából most lenne érdemes felhagyni vele, mert nagyon-nagyon mélyre kell ásni a mérnöki tudományokban, hogy működő, megbízható és többé-kevésbé (az elvárásoknak megfelelően) hiteles méréseid legyenek (egyébként nem sok értelme van).
A nagyon nagy kérdés, hogy neked mennyi idő a „MINÉL gyorsabban”? Ha a mérés lehet off-line is, akkor én egyszerűen betennék egy nagyobb (2 GB) memóriakártyát, hogy írja arra. Ez pont 8000 méresre elég, ha jól számolom (de lehet hogy nem, ez esetben bocsánatot kérek). Mindegyik külön címkézett fájlba.
Ha feltétlen fontos az azonnali feldolgozás, akkor a legkézenfekvőbb valamilyen automatizmus futtatása a PC-n, egy külön USB port, aztán hajrá! Kis ügyekedéssel megoldható, hogy a mentett 256 kB-os csomag mass storage eszközként egyszerűen (és automatikusan) áthúzható legyen a PC-re. Ez gyakorlatilag 1-2 másodperc maximum.
Az SPI erre (elvben) alkalmas, de a végponti eszközök (master és slave) minőségén, felépítésén, tulajdonságain és a megírt szoftveren múlik, hogy végül működik-e (és elég gyorsan). Az Arduino maximum SPI sebessége viszont gyászos 4 MHz-es órajelen mehet csak, amiből jó esetben a fele hasznos. Ezzel még nincs veszve minden fejsze, de én inkább felfelé kacsintgatnék (ARM mbed), a nagyon gyors Arduinok esetében több lesz a szívás szerintem.
Túrj külföldi fórumokat a kulcsszavakat (24 bit 10 kHz AD logger windows stb.) keresve.
Egyelőre csak tervezgetek, nem állt össze semmi, mert ha az ARDUINO nem elég a tervemhez, akkor más kell. Keresgéltem és láttam, hogy van olyan ARDUINO ami 72 vagy 84MHz órajellel megy.
A terv az lenne, hogy egy AD (24bit 10-20KHz Sample rate) konverter adatait küldeném egy Flash memóriába (256K) egy triggerrel (Itt nem lenne az Arduino, mert ahhoz lassú), majd ha a mérés lement akkor az adatokat elküldeném a pc-re feldolgozásra. Az Arduino épp arra kellene, hogy adjon órajelet az AD konverternek és a memóriának (Persze lehetne külső, stabil órát is rákötni később), valamint az Ethernet Shield segítségével elérném az adatokat a memóriában, valamint az AD konvertert is ezen keresztöl érném el(programozható Gain, stb). Természetesen itt kellene az SPI, mert az gyorsabb mint az i2C. Arduino SPI-n keresztül kapcsolatba lép a memóriával, átküldi az ethernetre stb.
Az Arduinonak annyi lenne a dolga, hogy mikor lezajlott a mérés akkor ezt a 256K adatot tolja a PC felé, de MINÉL gyorsabban. Erre a serial nem elég 9600baud siralmasan kevés, a többi meg csak vakítás, de még azok is kevésnek bizonyulnak.
Ha jobb ötletetek van, azt is szívesen venném! Lehet nem is kellene ide ARDUINO, de nem értek annyira ehhez.
Annyit kibogarásztam, hogy ha Dual Quad módon van összekötve a két eszköz, akkor pár bájt ide oda tologatása után szinte egy bit per óraciklus.(nagy adatoknál), De nem vagyok benne biztos, éppen ezt szeretném tisztázni.
Milyen memóriát? Milyen adatokkal? Hogy jön a képbe a PC?
A Shield vezérlője (W5100) tudja, de ez csak az alap átviteli sebesség, a szűk keresztmetszetet az fogja adni, hogy az Arduino hogyan tudja kezelni az adatcsomagokat (és elég lassan, legalábbis ehhez képest).
Azt tervezem, hogy az arduino és egyéb ic-k segítségével memóriát töltök fel adatokkal. pl.256Kbyte-ot. A problémám az, hogy az I2C protokollal lassan tudnám küldeni az adatokat a PC felé. Arra gondoltam, hogy egy Ethernet Shield segítségével oldanám meg a dolgot, mégpedig úgy, hogy az ARDUINO közbeiktatásával olvasnám ki az adatokat a memóriából az Ethernet Shielden keresztül SPI összeköttetésével.
Arra lennék kíváncsi, hogy mekkora adatátviteli sebességet érhetek el ezzel? A Shield tudja a 10MBit/s-ot, de a kérdés, hogy ilyen felállással tudni fogja az ARDUINO is kiszolgálni? A memóriát úgy választanám meg, hogy az 16MHz feletti legyen.
Azt javallom, hogy a saját munkád egyszerűbbé tétele végett a változókat globálisként deklaráld (a void.setup() előtt), és mindegyikhez írd meg, hogy mire való (// és a szöveg a sor végére). Nekem vannak 300-400 soros kódjaim, amin enélkül, pláne egy-két hónap kihagyás után pokoli nehéz lenne kiigazodni.
Minek a key változót átírni egy BE változóba? (A char-t meg úgy „konvertálni” int-té, hogy ' - 48' elég meredek.)
Ennyi if{} helyett messze csinosabb lenne szerintem egy 'switch / case' vizsgálat. A külön függvény a kiírásra nem rossz megoldás, ha máshonnan is hívva van (hívva lesz?).
Köszönöm. Működik amit szerettem volna. A 3x4-es padról beolvasok egy billentyűt és azt a hétszegmenses kijelzi. Ez alapja lesz egy mozdony fordítókorongnak. A következő rész a léptetőmotor meghajtása lesz.
Ez egy lábba bezavarhat, de a többibe nem. Pislogni fog neki kegyetlenül és/vagy nem fog rendesen menni a Monitor, de a többire akkor sem lesz hatással.
Én kezdetnek javasolnék egy filléres shift-registert, mondjuk egy SN74HC595. A megjelenítést ezzel összehasonlíthatatlanul leegyszerűsíted.
A megoldás az if() rész alatt van elrejtve, nevezetesen pont előtte a key változót 'char' típusú változóként definiáltad, utána viszont a switch részben már mint sima 'unsigned int' változóként hasonlítod össze. Próbáld meg úgy, hogy a case után a számokat ' ' jelek közé teszed!
Nem tudom, mi lesz a projekt, egyáltalán van-e terved, vagy csak teljesen kezdőként mennél bele. A Leonardo nagyjából egyetlen „előnye”, hogy az USB-n egyből magát a mikrokontrollert látod (ez erős túlzás műszakilag, de nagyjából erről van szó), míg általában a többi Arduinora az jellemző, hogy a mikrokontroller és az USB között van egy soros--usb átalakító. Ennek kezdőként nagyon nem fogod hasznát látni.
Ha nulláról indulsz, akkor (szerintem) Nano, 328. Kínából iszonyú olcsó (2-5 dollár attól függően, hogy mit fogsz ki). Ugyanazt tudja, mint az Uno, közvetlenül rárakhatod a próbapanelre, később nagyon egyszerűen lehet belőle üzembiztos (forrasztott) protót csinálni úgy, hogy ettől még egyszerűen cserélhető/fejleszthető marad, nem utolsó sorban baromi picike. Hátránya, hogy semmilyen shield-et nem tudsz rárakni. Ha ez fontos (szerintem az ilyen panelek zöme csak nagyon kis mértékben javítja a fejlesztés hatékonyságát, ha egyáltalán), akkor inkább Mega (milliárd ki- és bemenet, jóval több memória, bár maga a kontroller ugyanakkora órajellel ketyeg).
Kb. ennyi.
Ha most kezdeném, valószínűleg nem az Arduino mellett döntenék, hanem kevéssel több pénzért mbed (maga a panel jóval olcsóbb, mint a gyári Arduino [bocsánat, Genuino], de a kiegészítők messze nem szerezhetők be annyira könnyen és olcsón, mint az Arduinóhoz, ráadásul az eltérő jelszint miatt sok olyan eszköz, ami Arduino környezetben vígan megy, itt illesztést kíván -- pl. MAX7221). De ez kicsit túlmutat a kérdésen.
