Keress olyan kijelzőt, aminek a beépített karakterkészletében van fok jel. Vagy ha nincs, csinálj egy karakterkészletet (vagy csak egy karaktert), ami akként működik, és hívd azt.
ez a furcsa a többinél. tegnap kipróbáltam úgy 15 különféle soros teminálprogramot és soros kontrollert (mint amilyen ez is).
előbb feltettem a CH341 driverét. Namármost a 15-ből 4 tökéletesen működött, az eszköz cstlakoztatásakor a rendszer rákérdez, mivel akarom összepakcsolni (melyik programmal). Ezek a programok egyébként az elindításukkor is rákérdeznek, melyik portot olvasnám, és elfogadják ezt a ch341-es virtuális com-ot. A maradék 11 viszont nem.
Egyébként az Androidnál van valami beépített alkalmazás, amivel meg tudom nézni az aktív perifériákat, mint a windowsban? van egyáltalán ilyen COM1 stb kiosztás?
Amit belinkeltél, az viszont, ha működik, pont azt tudja, amit szeretnék. Csak most estig kell várnom.
van valakinek valami KIPRÓBÁLT megoldása, amivel egy Arduinot (klónozott kínai szart, CH340-es USB interfésszel) egy Androidos tabletről lehetne USB-n keresztül vezérelni? Valami nagyon egyszerű felület kellene, néhány megjelenített számérték, néhány kapcsoló, beviteli mező. Kérlek, ne a LabViewt ajánljátok (már ha van Androidra), hanem valami egyszeűbbet . Nem baj, ha pénzbe kerül, csak ne legyen megfizethetetlen. Odáig már eljutottam, hogy az androidra fel tudtam tenni a drivert, találtam a CH341-gyel együttműködő soros port terminált. csak éppen a programok nem akarják látni az usb-n lévő áramkört.
Köszönöm , hogy ilyen kimerítően válaszoltál . Ha nem is válaszoltam , azért edzek rá .
Most még sokat puskázok és kis számokkal próbálgatok ciklusokat irkálni , hogy véremmé váljon .
A túlcsordulás nálam is megtörtént a göngyöltnél negatívvá vált , majd logikusan a következő túlcsordulásnál újból pozitívvá vált . Lassan haladok , mindig vissza kell olvasnom a Tavir elejére.
Alapvetően rengeteg olyan "bevált" módszer van, amivel ilyen és ehhez hasonló lehetetlen megoldásokat össze lehet hozni, aztán (ad abszurdum) debug helyett release fordítással meg előjön egy hiba és fingod sincs, hogy hol és mitől van.
Ha van nagyon időd, a Sololearn android (iOS?) alkalmazás C++ tesztfeladatait megnézni úgy level 2 és 7 között. Zokogok (pontot lehet kapni feladatok gyártásáért), úgyhogy olyan logikai feladatokat rittyentettek, hogy csak lestem. És a fenti hibából vagy annak valamely válfajából (operátor hatáskör-sokszorozás) minden második feladatban van. Írtam nekik párszor, a negyedik filmes screen capcure után abbahagyták a választ és csak annyit írtak, hogy "dehát senki más sem jelentette, biztos úgy jó". Valaki meg a fórumban feltette a kérdést, hogy az on-line szertifikáttal mehet-e c++ fejlesztőnek állásinterjúra. :-D
Visszatérve. Az Arduino IDE elvileg konzisztensen fordítja, legalábbis amíg a fordítót ki nem cserélik vagy nem frissítik benne.
megint egy olyan dolog, amit kerülni kellene, mert NEM az elvárt eredményt fogja adni.
Ismét C++ alapelv: a ++ operátor (incremental operator) eggyel növeli a mögötte vagy előtte lévő változó értékét, de nagyon faramuci módon.
int a = 1;
int b = a++; // b = 1, a = 2
int c = ++a; // c = 3, a = 3
Ha az operátor a változó előtt van, akkor előbb végrehajtódik a változón az érték növelése eggyel, majd felhasználásra kerül a változó a műveleti sorrend szerint. Ha a változó után van az operátor, akkor előbb felhasználja a művelethez a változót annak aktuális értékén, majd hozzáad az érintett változó értékéhez 1-et.
A forgo = forgo++; egyetlen műveletben kettő műveletet végez el, méghozzá úgy, hogy az logikailag kicsit önmagával mond ellent, pontosabban ugyanarra a változóra egyetlen műveleten belül két egymástól független műveletet végez el. A nehézség az a dologban, hogy ahány fordító, annyi féle lehetséges kimenete van ennek, emiatt c++-ban ez kifejezetten ellenjavallt eljárás (az Arduino alighanem következetesen fordítja, de ettől még nem igazolja a logika jóságát).
Talán könnyebb megérteni ezzel a példával:
int a = 1;
int b = 0;
int b = b - a--; // Mi lesz az eredmény? nagy valószínűséggel változó tulcsordulás, mert 0 - 1 sima int esetén nem -1 (mínusz 1), hanem 32766 lesz.
Igazából az eddig általam látott arduinós oktatási anyagok zöme sajnos nem éritett jól két alapvető fontosságú kérdéskört, a változó-érvényességet és a függvényeket. A függvények kezelésével is van némi következetlenséged, de legalább vannak, a változókkal van gond. Előbb nézzük a kérdéseidet:
> Ha a void setup elött valamit magadok ugye az globális?
Nem csak az a lényeg, hogy HOL, hanem hogy hogyan. Minden változó globális, amit függvényen KÍVÜL deklarálsz (vagyis nincs benne sem a void setup()-ban, sem a void main()-ben, sem más hasonlóan elnevezett függvényben.
Ezen kívül alap esetben lokálisnak tekintendő minden változó, amely bármely okból olyan szakaszon belül van, amelyet kapcsos zárójelek zárnak közre, az érvényessége pedig (persze kivételekkel) a kapcsos zárójelen belül fog tartani.
> Ha oda figyelek és minden globális, abból nem lehet nagy baj , csak ne használjam két alprogramban ugyanazt?
Ha valami globális, akkor a nevéből adódóan az összes alprogramban (nevezzük inkább függvénynek) érvényes lesz, mi több, az értékét is hozza magával és -- hacsak máshogy külön nem jelölöd -- az értéket meg is tudod változtatni úgy, hogy a teljes programon belül mindenütt az új érték lesz érvényes.
Mivel nem megy a deklarálás, nézzük a kódban lévő bajokat.
Először, a változó deklarálásának (és egyben definiálásának) formája: int valtozonev = 0;
ahol
int -- a változó típusa (lehet unsigned int, byte, const char, stb.)
valtozonev -- a változó neve, amellyel hivatkozunk rá
= 0 -- a változónak adott első (kiinduló) érték, vagyis a változó definiálása. A definíció elvileg elmaradhat, de több okból kifolyólag praktikus a deklaráláskor megtenni -- ebbe nem megyek bele külön.
; -- az elemi kódsort lezáró karakter.
Namost, nálad az a helyzet, hogy a változó MINDEN előfordulásakor kiteszed a változó elé az int jelzést, ezért nem értéket adsz (hozzárendelsz, definiálsz stb.), hanem új változót deklarálsz egy új értékkel. Az előző levelemben írtam, hogy erre (elvben, C++11 után) van mód, de rengeteg okból kerülendő. Ez egy potenciális hibaforrás runtime-errorokhoz, amiket nyilván a legnehezebb megfejteni. Erről mindenképp szokj le! Bár nem vagyok mérvadó, de még nem találkoztam olyan programozási nyelvvel, ami ezt szükségessé tette volna, és nem igazán tudok elképzelni olyan magyarázatot, ami indokolná ezt.
> Jó esetben a göngyölt változó is biztonsággal elégnek kellene lennie ,mert max 20 mérés összege is 20 x 1,023 Kbyte = még csak 20 Kbyte.
Ezzel itt van némi gond. Egyrészt, a Kbyte memóriaméret, az 1023 (ne vesszőzz, mert rettentően zavaró és egyenes út sok-sok különböző hibához) a beolvasható maximális érték (ez hardverspecifikus). 20 × 1023 = 20460, ami a változó által felvehető maximális elvárt érték, az int típusú változó pedig 32767. Ezzel tehát nincs gond.
A változó valóban foglal valamennyi memóriát, de ez nem az értéktől függ, hanem a változó típusától és az architektúrától.
> int forgo = 0 ; ez ugye értékadás , és a programban megváltoztathatom?
Ez deklaráció és definíció, vagyis létrehozás és értékadás egyszerre.
> int forgo = forgo * 5;
> int forgo = forgo++;
> int forgo = x;
Ha kihagyod előlük az int-et, akkor mind megfelelő. a forgo = forgo++; megfelel a forgo++;-nak.
Ha az int előtte van, akkor deklaráció lesz, és ha abban a szakaszban még nem volt deklarálva forgo nevű változó, akkor létre fog hozni (nested variable). Ez mindenáron kerülendő!
> int forgo (); ez mi ? mikor kell ez két zárójel ?
Ez egy függvény-deklaráció, definíció nélkül.
void setup() {}
void loop() {}
int forgo() {}
Ezek mind függvénydefiníciók, logika alapján:
void/int -- a függvény által visszaadott változó típusa (a void ún 'üres' változó, sem memóriafoglalása, sem felvehető értéke nincs),
setup / loop / forgo -- a függvény elnevezése, amellyel hivatkozunk rá (mint a változóra),
() -- a függvény paramétereinek helye, amelyet a hívásnál adunk át,
{} -- a függvény teste, lényegében utasítások sorozata.
A paraméterek helye lehet üres, illetve a test is lehet üres. A
void setup()
{ int x = 0; }
void loop() {}
egy érvényes, leforduló, bár alapvetően haszontalan Arduino kód.
Mint írtam a 60 napos arduino tanfolyam felénél járok .
A tanfolyamon még nem említettük a globális és lokális változókat.
Sajnos a turbo csak hasonló az arduinohoz.
Turboban a globális változókat a programfejben deklaráltuk
a lokálisakat pedig az procedurákban „ alprogramokban " .
Valójában kicsit előreszaladtam : valaki egy S O S ledes programot nem lefutó formában , hanem procedurásan oldott meg és ezt koppinthattam rosszul.
Program hossz 32 Kbyte lehet , csak gyakorlásképpen próbáltam rövidíteni.
Az byte mehet 255-ig , ciklusokra feltétlen elég kellene lennie, de nem fordította le.
Ide azért int.- et választottam.
Jó esetben a göngyölt változó is biztonsággal elégnek kellene lennie ,mert max 20 mérés összege is 20 x 1,023 Kbyte = még csak 20 Kbyte . Persze csak akkor ha mindig jól nullázom a változót. De itt már az NTK ellenállása 0 ohm lenne. Ha pákával melegítettem az NTK-t akkor ment fel 900 ig . Szobahőmérsékleten 400-450 volt.
Elfogadom, praktikusabb long.- változót használni . Csak a logikám szerint arra gondolta ez még belefér.
Az átlagnak turboból maradt szokás , ott az osztás eredménye „ még a 10/2 „ is csak real lehet , ami megfelel a float.-nak. Attól tartottam , hogy az átlag-ot nem fogja lefordítani int.-ben.
Mint írtam , ez csak edzés a feladat megoldásához, azért írattam ki a ciklus minden lépésénél az átlagot, hogy lássam a lépéseket. Én is arra gondoltam , hogy egyszer végzem el az osztást az utolsó ciklusnál és a göngyölteket osztom a ciklusok számával . Számtanilag értem ,de programot rosszul fogalmaztam .
Most még alaposan hozzá olvasok és számítok rátok, de szeretnék majd pontosabban kérdezni .
Csak még annyit , csodáltad , hogy lefordította a programot. NEM FORDÍTOTTA LE !! Nagyon sokadikra fordította le. És ,hogy szintaktikailag jó legyen mindig beleváltoztattam és logikailag vágtam agyon.
Légy szí , most csak erre válaszolj !
- Ha a void setup elött valamit magadok ugye az globális ?
- Ha oda figyelek és minden globális, abból nem lehet nagy baj , csak ne használjam két alprogramban ugyanazt ?
- Még bajban vagyok a deklarációkkal .
int forgo = 0 ; ez ugye értékadás , és a programban megváltoztathatom ?
int forgo = forgo * 5 ; int forgo = forgo++ ; int forgo = x ;
int forgo () ; ez mi ? mikor kell ez két zárójel ?
Bocs , hogy ennyire alapdolgokat kérdezek , én még az elektroncsővel kezdtem 1971-ben és még volt mágneses erősítő is abban a korban!
kicsit utánanolvastam, maga a chip 3,3 voltos, a panelon van egy stab IC, ami a tápfeszt leviszi 3,3-ra. ettől függetlenül, a külső tápfesz nélkül működik rosszul. írtama forgalmazónak, kíváncsi vagyok, mit lépnek. mindenki csak jót írt a termékről.
Kódmegosztáshoz javaslom valamelyik kódmegosztó oldalra feltenni a forrást (copy + paste) és csak a linket mellékelni. Pl. codeshare.
Rengeteg logikai és szintaktikai bukfenc van a kódodban, sorolom.
int forgo () ; // globalis valtozo , hanyszor fordult korbe a teljes forciklus
Nem. Ez egy függvénydeklaráció. Helyesen:
int forgo = 0;
A zárójeles megoldás a függvény paramétereit tartalmazza, ez esetben ez egy int típusú változót visszaadó függvény deklarációja. Az IDE biztos szólt miatta.
A deklaráció során egyből definiáltad is a változót kezdő értékre. Ezt javasolt minden változómegadásnál megtenni!
A for ciklus anomáliájára önállóan rájöttél, ez kafa.
void megresz() függvényben rossz az átlagolás logikája. Mint régen matekból: (1) összeadjuk az értékeket (2) az összeget elosztjuk az egyedi értékek darabszámával. Vagyis a for ciklus körbemegy az elvárt számú alkalommal, majd a szamgongyolve változó értékét elosztod az iterálások számával (ami 9 lesz, ha a for ciklus indexét ciklus < 10 limittel adod meg).
Itt van több további bukfenc is. Egyrészt kellően nagy szam valtozó esetén vagy kellően nagy számú iterációnál simán előfordulhat, hogy a szamgongyolve valtozó értéke túlfut a maximumán, ami 32737. Ennek elkerülésére az a mód, hogy az int típusú változó helyett jóval nagyobbat választunk, mondjuk egy long-ot vagy unsigned long-ot (előbbi 2, utóbbi 4 milliárdig nyerő, cserébe többet foglal a memóriából) -- a kettő között azért van átjárás.
A függvényen belül újra definiáltad a szam és a forgo változókat, ez elég rossz ötlet. Simán szedd ki előlük az int utasítást.
Serial.println (" ") ; felesleges, elég a Serial.println();
A delay(2000); most még jó, de elég gyorsan el kellene felejteni.
Később: előző mérés + új mérés / aktuális ciklus = átlag ez így teljesen rossz, ez nem átlag és így nem is lehet átlagot számolni, mert az utolsó mérés súlya mindig exponenciálisan nagyobb lesz, mint az összes korábbi mérésé.
Az atlag is lehet nyugodtan int. Felesleges a tizedesekkel bajlódni (pontosítani persze lehet, de kérdés, hogy érdemes-e ezen a szinten).
A felvetésed, hogy a szamgongyolve változó miért nem nullázódik egy kicsit hosszabb leírást szorgalmaz.
Nyitásra az, hogy függvényeket (procedúrákat) használsz, dícséretes, viszont egy nagyon fontos dolgot figyelmen kívül hagysz, ez pedig a változók hatóköre. A program elején deklarálod a szamgongyolve változót int típusúként (illetve valójában nem, mert egy függvényt deklarálsz csak, csodálom, hogy nem kajabál az IDE, hogy rossz az egész). Ez globális változó lesz (lenne). Ezt követően mind a nullazo() mind a megresz() függvényben újra deklarálod őket (a változó neve elé kiteszed a változó típusát jelző int utasítást). Ezt beágyazott változókezelésnek hívják, és bár logikailag/szintaktikailag működik, programozástechnikailag a taposóakna megfelelője, ezért kerülendő.
A dolog úgy javítható egyszerűen, hogy a fentieket is követve csak és kizárólag a program elején (vagy a változó első előfordulásakor) használod a változódeklarálást jelző utasítást (gyakorlatilag a változó típusának jelölését).
Végül. Az egész program logikája sok ponton hibás. A függvények egymás után futtatásával (különösen az összehasonlito() fügvény esetén) biztosan nem az elvárt eredményt fogod kapni (ez a nevesített ugyanis minden futtatásakor PONTOSAN ugyanazt az eredményt fogja adni, és nem csak azért, mert a vizsgálat hibás -- == helyett = van --, hanem azért is, mert mindig ugyanazzal a szam változó-értékkel fog elindulni.
30 mp-es mintavételeknél azt javaslom, hogy 2 mp-es mintavételezést használj 14 mintavételt átlagolj a két-két szélsőérték (maximum és minimum) eldobásával és ezt rögzítsd. Ezzel jó szerencsével minden külső tényezőt ki tudsz szűrni.
A linkelt oldalon nem találtam meg, de ha beküldöd itt vagy e-mailben, szívesen ránézek. De ismerve a kínai cuccok minőségét, valószínűnek tartom, hogy nem benned van a hiba.
Teljesen egy véleményen vagyunk, jövőhéten veszek egy marék kondit. Ha működik a dolog, akkor pedig a vezetéket árnyékoltra cserélem . Kondiból több kisebb kerámiát teszek rá, azok jól szűrnek.
Közben egy hibát már találtam a for ciklus első sorában :
Most , hogy írod ezen valóban el kell gondolkodnom . Ha egymásután mérek 20-at és várok egy másodpercet akkor valóban lehet , hogy a görbe egy pontját mérem hússzor. De ha egyenlő időközönként mérek 20 szor és annak veszem az átlagát , akkor a valószínűsége nagyobb , hogy tényleg átlagot mértem. Minden képen megkondizom és átlagolom is. Gondoltam rá ha 1 Kohm NTK és 1 Kohm ellenállással jobban söntölődik a jel , de jobban melegszik is az NTK és többet mutatna. Ha beáll , akkor kalibrálom is . de ez még csak indikálás. Ha részletek összeálltak , biztos kell segítséget kérnem a mentéshez.
Amit itt írtam , az még nem a feladat. Ez csak tréning , hogy jól begyakorolni a lépéseket . Én nyugdíjas elektroműszerész vagyok és két hónapja játszom az arduinoval . csak hobbiból foglalkoztam a turbopascallal , amihez voltak nagyon jó magyar nyelvű könyvek . Ott láttam rengeteg példaprogramot . Itt csak a for ciklust akartam gyakorolni. Régebben csináltam is AT számítógépre A/D átalakítót 3 csatornára 16 bites felbontásra . Nagyon szépen működött és el tudtam menteni „csv” fájlba . Most két hónapja kaptam 2 db arduino uno.-t és jól eljátszom vele a konyhában . Az asztali számítógépes nagyon terjedelmes volt és nem fértem el a konyhában.
A TAVIR távoktatásának a felénél járok és szoktam nézni a YouTube.-n . Mindig kicsit átalakítom a programot és így gyakorlok.
Megcsináltam az ultrahangos távolságmérőt és a DHT11 –el a hőmérséklet és páratartalommérőt. Az távolságmérő az nagyon jó , de a DHT11 nagyon pontatlan .
Amit itt a képen láttok , ez csak egy pikk-pakk próba .volt 5 db NTK és 5 db ellenállásom. Minden 100 Kohmos. A vezetékek nem árnyékoltak és nem is sodrottak. Szkópom az van kettő is , de gondoltam én is , hogy zajos lesz , de nem ennyire. Még szkóppal nem néztem .
A padláson csináltam :
- kék vonal 400-nál padlás hőmérséklete, itt nincs vezeték
- piros a szobába belógattam az ajtórésen át
- lila alul, kilógatott vezeték az udvarra 6-7 méter itt szakadás lehetett ezt ne vegyük figyelembe
- zöld a cirkó előremenő vezetéke
- sárga a cirkó visszatérő vezetéke
Este bekapcsoltam és 200 másodpercenként vette a jeleket másnap délelőttig , sűrűbbre nem vehetem , mert 500 lépés után betelik a képernyő.
Ide kellene 1-2 mikrofarádos kondi. Még vennem kell .
A kék vonal a padlás hőmérsékletén elég jól követhető a tendencia , látszik hogy éjszaka hűlt a levegő .
Reggel és délelőtt négyszer kapcsolt a cirkó .A cirkó csövére csak rá van szigszalagozva az NTK .
A mintavételezési időt későbbiekben szeretném kb 30 másodpercre csökkenteni, de ehhez majd meg kell oldani a csv fájlba mentést vagy memóriakártyára. Ehhez még Hajnalka vagyok.
Most lefuttatom a programot és ezt kapom :
Nekem úgy tűnik , nem ugrik ki a ciklusból , a " forgo " nak minden ciklus után kellene 1-el nőnie.
leírnád, hogy pontosan milyen időközönként szeretnéd megjeleníteni a végeredményt? Hőmérsékletről lévén szó, az biztosan nem változik túl gyorsan.
Illetve, hogy milyen frekvenciával zajos az a jel? Szkópon nézted már? Ha a jelzajt szeretnéd kiszűrni, akkor ott - legalábbis én úgy gondolom - nagyon is fontos lenne a mintavételezés és a zajfrekvencia összehangolása (mondjuk a zaj egyetlen feltételezett periódusára jusson vagy 20 mérés , másként ha véletlenül azonos frekvenciával történnek, előfordulhat, hogy pl csak a csúcsértékeket átlagolod.
Az összegek tárolására elég e az int számtartománya, mert ha túlcsordúl, lehet galiba. Az if összehasonlító jele a (==) és nem a (=), ez értékadás. Az átlagot nem lenne célszerűbb a for cikluson kívül kiszámolni, mikor a teljes összeg rendelkezésre áll? A program igen rondán van tördelve, ember legyen a talpán aki kiigazodik rajta.
