- Google Pixel topik
- Fotók, videók mobillal
- iPhone topik
- Samsung Galaxy Watch (Tizen és Wear OS) ingyenes számlapok, kupon kódok
- Okosóra és okoskiegészítő topik
- Milyen GPS-t vegyek?
- Mobil flották
- Hónap végén érkezik a Xiaomi Band 10, ára is van
- Netfone
- Az Oppo Find X8 Ultra lett a legvékonyabb kameramobil
-
Mobilarena
Arduino hardverrel és szoftverrel foglakozó téma. Minden mikrovezérlő ami arduinoval programozható, és minden arduino program, board, és hardverrel kapcsolatos kérdések helye.
Új hozzászólás Aktív témák
-
Teasüti
nagyúr
válasz
Tankblock
#7753
üzenetére
Jah bocs. Épp csak említetted, nem voltam alapos.
Nem értem hogy jön ide a reset. Nekem arra a funkcióra eddig éles használatban soha nem volt szükségem. Boot nálam bekapcsoláskor van. Amúgy meg a bootstrap lábakkal ESP32-nél nem tudsz reset-elni, arra az EN való.
Boot alatt nem kell buzerálni a gépet és elvileg mindennek mennie kell. -
Teasüti
nagyúr
válasz
Tankblock
#7751
üzenetére
Miért ne lehetne használni ezeket? Csak oda kell figyelni az alapértelmezett jelszintjükre boot alatt.
Nálam pl. az IO2 bemenetként funkcionál, ami alapállásban magas impedanciájú (nyitott áramkör, pl nyomógomb húzza földre) és így oda húzza a kontroller ahova akarja. Persze boot alatt nem nyomogatom.
IO15 nálam egy tranyó bázisára kapcsolódik, tökmindegy hova húzza, max felkapcsolja az adott áramkört arra az egy másodpercre.
IO12 meg egy MPU-6050 interrupt pin-re van kötve, nos ez meg elvileg semmit nem csinál, amíg fel nem ébresztik az I2C csatornán a modult. Bár nem tudom ez a port alapból lebeg-e a modulon, ezt még ki kell nyomoznom.)
IO0 meg egy kimenet lesz hasonlóan egy tranyóval, mindegy milyen szintet vesz fel boot-kor.
És ezzel lefoglalva az összes elérhető IO port az ESP32-n.
Kivéve persze a flash portjai, nem is értem azok miért vannak kivezetve.Szerintem nem kell félni ezektől, elég csak egy kis körültekintés.
A "leghülyebiztosabb", ha egy NO kapcsolóval bemenetként használjuk őket. -
Teasüti
nagyúr
Gyors kérdés; mindig elbizonytalanodom, mikor kell közösíteni a földet.
Ha egy jármű teljes elektromos rendszere egy tápról megy (akku/generátor), akkor kell nekem közösíteni a különböző fogyasztók jelszintje között? Pl fesz. osztóval akku feszültséget mérek. Az mcu egy dc/dc konverteren van betáplálva. Rá kell-e kötnöm az MCU GND-jét a negatív ágra, vagy ugyanaz a földpotenciál a különböző konverterek előtt és után?Úgy magyarázták nekem annó, hogy egy hálózaton lévő földpotenciál mindig azonos.
Pl a ház elektromos hálózata mikor egy konnektorról ment a 12V-os dugaljtáp és a laptop, de mégis közösíteni kellett az USB szkóp és az MCU/táp között, ha értelmes mérést akartam. -
#7695
Teasüti
nagyúr
kormoskandur
#7694
Teasüti
nagyúr
válasz
kormoskandur
#7694
üzenetére
Tök érdekes!
De mire jó ez a random zaj?
(Zenei analfabéta.)A kapcsolótábla bekötése nem egy nagy mutatvány, alap tanulófeladat kezdőknek.
Az LCD kezelése se annyira, van rá tutorial is nem kevés. De ott azért lehetnek tárhely gondok, ha komplex menüt szeretnél 8 bites cpu-n.Ami kihívás az a kód.
Azt se tudom mit kéne programozni. -
Teasüti
nagyúr
válasz
Janos250
#7616
üzenetére
Tapasztaltál a hibás pixel után jel torzulást a lánc többi elemén?
Azt gyanítom, hogy a pwm vezérlők halnak le és a továbbítandó adat is csorbul, amit a következő pixel átvesz és onnantól hibásan utazik tovább. Az érdekes az, hogy a jel mindig ugyanúgy torzul így lehet csak egy-egy színcsatorna érintett. Érdekelne hogy működik a vezérlője.
Én sajnos nem tudtam ránézni a hibás szalagra, nem volt a helyszínen mini usb kábel a Nano-hoz... -
Teasüti
nagyúr
Láttam már ezt boltban, de nem olvastam utána mi is ez a Micro:bit egész pontosan. Ez az Arduino gyerek kiadásban és a "programozás" szép színes blokkdiagrammal készül?
Szerk: nem egészen, az a képernyőmentés engem az Android App Inventor-ra emlékeztet, bár azt se láttam még testközelből. -
Teasüti
nagyúr
válasz
Janos250
#7547
üzenetére
Felcímkézik a csomagolást. Kibontás után meg beépítésre kerül. A maradékot meg visszateszem a csomagolásba.
Amúgy nem rendelek olyan sokat, hogy ne tudjam követni mi micsoda.
Van, hogy az Aliexpress rendeléseim között keresgélek leírások után hónapokkal később is.Egyébként nem is nagyon érdekelt még a kérdés. Eddig azt hittem mindegyik ugyanolyan protokollt használ, azt hittem csak a szín sorrendben van különbség (GRB vs RGB, WRGB, stb.).
Belenéztem a könyvtárba és valóban van némi differencia mondjuk egy ws2812 és sk6812 között, de nem egyeztettem a doksikat így lehet csak a könyvtár alkotója okoskodott (ws2812 el is van szúrva nálam, ahogy nézem). Most ha nem megy elsőre, akkor majd megy másodikra... -
Teasüti
nagyúr
válasz
Janos250
#7528
üzenetére
Ezt olvastad egyébként?
Meg ezt.
Ez utóbbi tárgyalja a láncba fűzött ledek közti kommunikációt.
Még egy bejegyzés.
Hmm, ha pixelenként változik a T0H és T1H hossza, és a TxL hossza meg az a szünet lesz, ami két TxH között van, akkor tényleg nem nehéz elképzelni hibázó pixeleket, amik némi módosítással beleesnek a specifikációba, ha az előttük lévő pixelnek más az ideális jelhossza. -
Teasüti
nagyúr
válasz
Janos250
#7517
üzenetére
Érdekes a smart home integráció.
Még nem láttam ilyen alkalmazást, bár adja magát.
Legalább lehetne vmi értelmet adni ezeknek az asszisztenseknek a világításon kívül.(#7518) vargalex
Aliexpress. A minőség elég vegyes. Gyakori a pixelhiba, azt ki kell vágni belőle.
Ha szerencsés vagy, akkor üzembiztos lesz. Ha nem, akkor sorra jönnek elő a pixelhibák aktív használat közben.
Ledek száma attól függ mit szeretnél. 60 led/m még megfizethető, a 120-as már túl van árazva a többihez képest és nincs is belőle csak egy-két méteres. Mondjuk ez érthető, már a 60-ason is jelentős feszültségesés van 5 méteren.
Ha ws2812b-ben gondolkodsz, akkor megfontolnám a ws2813-at helyette. -
Teasüti
nagyúr
Nem volna egyszerűbb venni egy működő fejegységet a gyári helyére, ha ez beszart?
Ilyen fapados cuccok már kaphatók alig pár ezerrel többért, mint amibe ez a projekt kerül egy igényesebb kivitelezésben. Az időráfordítást nem számolva. A véletleneket meg meg se említsük... -
Teasüti
nagyúr
válasz
pigster
#7493
üzenetére
A TX led lehet az időszakos Serial.print-ek miatt, ha kiíratsz vmit.
RX led meg ha nincs adatfogadás, akkor lehet zajt szed össze. Bár ha mondjuk egy bread board-on van minden, akkor ezt hagyjuk. Pár centi vezetéken nem szed az össze semmit. Felhúzni nem szükséges, boot után push-pull módban működik.
3,3V-os szintillesztést hogy oldottad meg?
RX irányban jó a 3,3V amit a modul ad, az még simán magas érték. De a modul nem 5V toleráns, szóval TX irányban fesz. osztót kell használni.Amúgy még nem jött fel a szoftveres hiba lehetősége, engem a programod érdekelne.
Könnyen előfordulhat ugyanis, hogy akár a megszakításkezelés és/vagy program blokkolás miatt csúszol le a beérkező adatokról.
Ha küldeni tud gond nélkül az mcu, csak fogadni nem, akkor valószínűleg ez lesz a gond.
De ezt könnyen kipróbálhatod USB-ről is.
Ha azon flottul megy minden, akkor lehet kijelenteni, hogy a BT-vel van gond. -
Teasüti
nagyúr
válasz
ngabor2
#7476
üzenetére
Ha megnézed a relé adatlapját, azon rajta lesz milyen áram kell a tekercs stabil behúzásához.
Songle esetén pl. az 5V-oshoz 3,7V kell minimum. De Songle-ből van 3V-os is.
Viszont ezekhez az alacsony feszültségűekhez rendre 70 és 120 mA áram kell, szóval sehogy se ajánlott közvetlen az ESP lábára kötni őket. Tranzisztorral kell meghajtani és védődiódát kell berakni! -
-
Teasüti
nagyúr
Nagy overhead a ram és rom méreteket illetően, bár van hely bőven így ez nem akkora probléma.
Emiatt ugye a számítási teljesítmény egy része is elúszik. Bár így is 100x gyorsabb egy UNO-nál, szóval mindegy is.
Egyfajta virtualizációhoz lehetne hasonlítani.Mondjuk nem hiszem, hogy nálam összetettebb felhasználása volna itt még vkinek (73 KB-os forráskód +könyvtárak, amiből a BLE megeszi a rom a közel 70%-át) és jómagam sem futottam még bele se teljesítmény se tárterület problémába. Mondjuk még szeretném majd kipróbálni az OTA programfeltöltést. Arra számítok, hogy az még egy jelentősebb szeletet elvesz a tárból.
A wifi azt hiszem teljes támogatottságot élvez, a BLE már működőképes, de még "béta" állapotú és így nem fejleszt rá egyetlen 3rd party sem. Ez azt jelenti, hogy a valós alkalmazásokban sok mindent magadnak kell megoldani.
A perifériák közül eddig én egyedül csak az RMT-t használtam, így a többiről nem tudok nyilatkozni.
Az Arduino függvények úgy tudom működnek mind, illetve nem tudok példát hozni az ellenkezőjére.
Nekem az UNO-ra írt programom egy az egyben lefordult ESP32-re is (az Atmel-re írt könyvtárak nélkül természetesen), így ez teljes értékűnek tekinthető szerintem.Nálam is tervben volt az IDF megismerése és az alacsonyabb C nyelv tanulgatása, de így hogy megy amit akartam Arduino-ban is, így nekem nem is fontos.
Meg a mai világban már nem divat a nehezebb úton menni és szopatni magad a hardver specifikus utasításkészlettel és telefonkönyv módszerrel regisztereket programozni, amikor némi overhead árán, de pár absztrakciós réteggel feljebb is meg lehet oldani a problémát könnyen és gyorsan, specializált tudás nélkül.
Persze nem is lesz olyan hatékony a kód, de ki nem szarja le, érted... Ez nem a Crysis, hogy ultra grafikán kisajtoljak minden fps-t a vasból.
Senkit nem érdekel mit csinál a digitalRead(), amíg megvan az eredmény.
Példánál maradva:extern int IRAM_ATTR __digitalRead(uint8_t pin)
{
if(pin < 32) {
return (GPIO.in >> pin) & 0x1;
} else if(pin < 40) {
return (GPIO.in1.val >> (pin - 32)) & 0x1;
}
return 0;
}Na most e szerint az sem mindegy melyik lábat olvasom. Programozzon így az, akinek két anyja van!
Én inkább beírom, hogy digitalRead() és együtt élek az overhead-del. -
-
Teasüti
nagyúr
válasz
CHIPman
#7362
üzenetére
Semminek, hisz adat nélkül nem kapcsol be. Viszont ha adsz az adatbusznak egy kis interferenciát (vagy töltést az ujjaddal), akkor lehet felvillan néhány led.
Ezekhez kell egy adatfolyam, ami pixelenként 24 bitből áll (ugye három színkomponens 8 biten), és egy bit a szalag protokollja szerint egy magas és egy alacsony logikai jelszint adott időzítéssel. Szóval ezt te nem fogod úgy vezérelni, mint egy analóg szalagot, vagy egy ledet.
Ezekhez alapesetben egy könyvtárat szokás használni, amit a mikrovezérlődhöz választasz. Mint pl az Adafruit féle Neopixel, ami azt hiszem működik ESP-vel is.
Ezekben találsz példákat az animációkra.
Szóval itt animációt programozunk, jobban mondva egyenként ki kell számolni a pixelek színeit és berakni egy uint8_t tömbbe, majd ezt küldi ki a szalagra a könyvtár megfelelő függvénye. -
Teasüti
nagyúr
válasz
CHIPman
#7352
üzenetére
Hogyne lenne róla leírás, ne viccelj!
WS2812b a leánykori neve, több száz oldal foglalkozik a témával. Hozzádobod, h ESP és garantálom lesz rá találat.
Annyit fűznék hozzá, hogy ha komolyabb projekten dolgozol, ahol a szalag meghajtásán kívül mást is kéne csinálni, akkor tudni kell, hogy jelenleg az ESP32-n kívül minden más szoftveresen kezeli a szalagot és az adatküldés blokkolja a programot. Tehát nem lehetnek megszakítások és így arra a rövidke időre megszűnik a beérkező adatok fogadása.
-
Teasüti
nagyúr
válasz
Tankblock
#7341
üzenetére
Az RMT-hez kapcsolódó ws2812b könyvtárat már rég beüzemeltem.
A fenti led(on) példa a valóságban egy ledcWrite() függvény, így az RMT nem játszik.
Az a delay()-re volt kihegyezve, hogy azt te nem rakod össze ennél egyszerűbben.
És a kernel meg megoldja ahogy akarja (és meg is oldja).
Multitask rendszerben nem blokkol a delay(), semmi fennakadást nem okoz. -
Teasüti
nagyúr
válasz
Tankblock
#7328
üzenetére
Köszönöm a választ. Akkor nincs semmilyen ütközés kezelés FreeRTOS-nál?
Ha meghívom 1000x, akkor ki is fagy a kernel memóriahiány miatt.Vagy Taskot suspendedbe tenni és felkelteni amikor kell....
A delay() elvileg pont ezt csinálja az Arduino Core-ban:void delay(uint32_t ms)
{
vTaskDelay(ms / portTICK_PERIOD_MS);
}Azért, mert így jóval egyszerűbb programozni - mondjuk led villogás mintákat** (ez a feladat kifejezetten komplex és így szükségtelenül bonyolult volna a millis() módszerrel, valamint az adott folyamatot se muszáj pörgetni addig mivel önálló task-ról lévén szó) - és a kernel megoldja magának a váltást, ahogy akarja.
Ebben a környezetben a delay() nem kerülendő, hanem bátran használható.**Példa:
led(on);
delay(150);
led(off);
delay(100);
kettőször ismétel;
led(on); // És bekapcsolva marad, ha villant hármat.A prell-lel nem kívánok itt foglalkozni, a kérdésem megválaszolásra került, ennyi most elég.
Erre magam is ismerem a lehetséges megoldásokat.
Mondjuk esetemben inkább zavarszűrésről lesz szó, csak egyszer rá kéne néznem milyen jel jön a kapcsoló felől (vagy a tápegység felől, passz), mikor folyamatosan vibrál. Érdekes, álló motornál egyenletesen világít, járó motornál meg-megszakad a jel és véletlenszerű vibrálást okoz. -
Teasüti
nagyúr
válasz
Janos250
#7321
üzenetére
És a bit bang módszerrel el is érkeztünk az egyetlen okához, hogy miért nem jó szoftveresen kezelni a ws2812 szalagokat. Atmel-en is ilyenkor kötelezően ki kell kapcsolni a megszakításokat.
Amúgy a semaphore kapcsán láttam rá utasításokat, hogy addig nem adja át a stafétabotot az adott folyamat, amíg erre utasítást nem adsz. Így lehet utánozni az Arduino féle noInterrupts() függvényt szerintem. Bár nem próbáltam, nekem megfelel az RTM-et kiaknázó könyvtár is.
Amúgy az RTM valóban iszonyú precíz. A 48 Mhz-es szkópom mérése szerint a periódus idő az halál pontosan annyi volt, ami be van állítva.(#7322) Janos250
Ezt úgy értettem, hogy nem muszáj freertos-t se használni, ugye? Ebben az alkalmazásban, ha minden egyes ciklusidő számít, akkor le kell menni gépi kódba. A kernelt meg ki kell dobni. -
Teasüti
nagyúr
válasz
gyapo11
#7316
üzenetére
Ez esetben gondolom néhány absztrakciós réteggel lejjebb kell menni. Assembly-ben számolható minden egyes utasítás.
(#7319) Sokimm
Hardveres perifériák. A hardveres azt jelenti, hogy elég a programban csak bekapcsolni és átadni a paramétereket, utána el lehet felejteni. Nem igényelnek cpu időt a működéshez. -
Teasüti
nagyúr
Üdv!
ESP32 és az RTOS task indítás érdekelne, ha van ezzel tapasztalat.
A kérdésem pedig, hogy milyen módon kezeli a kernel az éppen futó folyamatok újbóli meghívását?
xTaskCreate() függvény hívása, miközben már fut belőle egy példány.
Ilyenkor megszakítja az első példányt, el se indítja a második példányt, vagy párhuzamosan fut a kettő (vagy több)?
Egy ISR alapú meghíváson filózok, amit egy gombra kötött CHANGE állapotváltozás figyel. És itt jön a képbe a prell jelensége. (Illetve vmi vibráció, vmi zavar amivel szembesülök járó motornál a féklámpa kapcsoló felől, de eddig lusta voltam megnézni szkóppal.) És mivel delay()-ek vannak a folyamatban, ezért könnyen előfordulhat, hogy újból meghívásra kerül a folyamat annak végezte előtt.szerk: az RTOS kérdés az érdekes most, nem a jel szűrése.
Köszönöm! -
#7306
Teasüti
nagyúr
kormoskandur
#7305
Teasüti
nagyúr
válasz
kormoskandur
#7305
üzenetére
Hát ez elég rövidke ismeretség volt.
"200db 220 ohmos ellenállás" biztos ami biztos, ez nem fog kifogyni.
-
Teasüti
nagyúr
válasz
Victoryus
#7282
üzenetére
Ez pont úgy működik, mint az általam használt pfodApp.
Arduino tárolja le vmi nagyon lényegre törő pár bájtos protokollal, hogy mit kell megjeleníteni, és ezek alapján készíti el a mobilos app, amit kell on-the-fly.
Gondolom van hozzá egy kód generátor is, amiben megszerkesztheted amit szeretnél látni.
Kár, hogy nem tud BLE-t, különben már telepíteném is.
Fejlettebbnek tűnik a pfodApp-nál.
Bár ahogy nézem Serial-on kommunikál, meg lehetne hack-elni a library-t, hogy menjen a BLE is.
Pont ezt tettem a pfodApp-pal is. Hmm... -
-
Teasüti
nagyúr
válasz
Janos250
#7274
üzenetére
Pedig elég jó keresője van az oldalnak. A részletes keresőben még felhasználóra is lehet szűrni.
Az asztali verziót használod vagy a mobilt? A mobil verzió viszont botrányosan gagyi. Utóbbi topikon belül nem is tud keresni.
Olvasáson kívül semmire nem való a mobil verzió.
Jah amúgy meg köszi szépen a hozzájárulásodat az lapcsalád csődbe viteléhez.
-
Teasüti
nagyúr
válasz
Teasüti
#7268
üzenetére
Mi a dolga ebben egy mikrovezérlőnek?
Mihez kell itt számítási kapacitás?
(A kérdésedből amúgy látszik, hogy helyre kellene tenni a mikrovezérlő definicióját is.)Ez egy analóg rendszer, esetleg van benne egy DAC is, ha van optika rajta.
Megkapja a bemeneten a hangot, azt erősíti, majd meghajtja a hangszóró(ka)t.
Van rajta egy analóg hangerőszabályzás, meg van benne egy tápegység.Ha ez tönkrement, akkor garancia, szerviz, vagy kuka.
Ezt a szerepet nem fogja betölteni egy mikrovezérlő.
Ellenben lehet kapni külön DIY erősítő modulokat, ha át akarod alakítani.
(Viszont ezt én nem ajánlanám a témában való jártasságodat figyelembe véve. Esetleg a Hobbi elektronika nevű topikban kérnék segítséget, hátha van egy hozzáértő a közeledben, aki elvállalná a javítást, vagy átalakítást. Már ha ér annyit egyáltalán az eszköz.) -
#7268
Teasüti
nagyúr
jrdani2001
#7267
Teasüti
nagyúr
válasz
jrdani2001
#7267
üzenetére
Nem a megfelelő kérdésekre válaszoltál.
-
#7266
Teasüti
nagyúr
jrdani2001
#7265
Teasüti
nagyúr
válasz
jrdani2001
#7265
üzenetére
Ez egy aktív hangszóró volna? Erősítő fokozattal, tápegységgel meg minden?
Ez több kérdést is felvet, de a legelső mindjárt az, hogy mi szerepe is volna egy mikrovezérlőnek egy hangszóróban? Mit kell itt vezérelni? -
Teasüti
nagyúr
Félre értesz. A nagy hatótávú jelátvitel két Arduino között történik. A wifi AP az egyik Arduino és az Android közé kell.
Lehetne szórakozni wifi repeater módban is más eszközökkel, de kétlem hogy olcsóbbak lennének két HC-12 modulnál. Eleve az egy nagyságrenddel kisebb frekvencia jobb választás erre a felhasználásra. Ugye itt nincsen különösebb sávszél. igény, pár vezérlőbájtot kell csak átvinni. -
Teasüti
nagyúr
Akkor ez eldöntetett. BLE nem a legideálisabb a valós idejű alkalmazásra. A klasszik BT még talán ahol aktív kapcsolat épül fel, de a BLE teljesen más elven működik.
A hatótáv se lesz elég neked.
Az még a Class 1 BT-nek is túlzás.Egyébként csak úgy szólok, hogy a telefonod (és egyéb mobil eszközeid) nem fog(nak) áthidalni több száz méteres távolságot.
Erre esetleg azt tudnám kitalálni, hogy legyen egy szerver wifi AP-vel a közeledben ahol tartózkodsz, és egy másik modul kihelyezve ahova kell. Két Arduino, amik kommunikálhatnak vmi egyéb nagy hatótávú csatornán. Pl. HC-12 modulokkal.
Sima soros porton történik az átvitel, nagyon egyszerű programozni. -
Teasüti
nagyúr
válasz
Spuri2000
#7252
üzenetére
Nem bonyolult, csak ránéztem és elszörnyedtem. Egy igazi kódhuszár erre köp egyet és tovább lapoz.
Tényleg hasznos az a "programkód" szövegformázás, így behúzza a sorokat a struktúrának megfelelően a fórum motor. Én pl már ott ráncoltam a szemöldököm, hogy három kapcsos zárójel egymás után.
Ami azonnal átlátható megfelelő formázással, de így meg át kell nyálazni, hogy melyik hova tartozik, ki kivel van.(#7250) dzz
Hát ha a karórámból indulok ki, ami BLE-vel kapcsolódik, akkor nem sok.
Két falon keresztül már megszakad a jel (mondjuk kimegyek a fürdőbe egyazon emeleten és hisztizik az óra, hogy megszakadt a kapcsolat). Néha a saját testemmel le tudom árnyékolni, mikor pl összefonom a karjaim. De hát ugye okkal az a neve, hogy Bluetooth Low Power.
A klasszik BT ugyan erősebb, de az nincs implementálva még az ESP-IDF-ben se, nem hogy Arduino vonalon.
Én azt mondanám jó, ha megvan a 10-20 méter szabad rálátás esetén.
Viselhető eszközökhöz és kis hatósugarú mesh hálózatokhoz van kitalálva, nem arra, hogy kirakjunk egy állomást a semmi közepére. Persze ha kimész a helyszínre kiolvasni az adatokat, ahhoz amúgy megfelelő, mert viszont jó választás az akkumulátoros üzemhez. Sőt, akkus üzemhez én eleve nem is gondolkodnék másban. Állítólag megfelelő alkalmazásban a BLE kevesebbet fogyaszt, mint az elem önkisüléséből eredő merülés. A wifi-nek nem lesz hosszú üzemideje e szempontból. -
Teasüti
nagyúr
Terepen szerintem a BLE lesz a nyerő, hacsak nem akarsz a mobilnettel b@szakodni.
Ugye vagy a telón csinálsz egy hotspot-ot amihez az ESP tud kapcsolódni (és akkor a hotspot adatait gondolom FW-be kéne rakni, aztán másik setup-pal nem lesz működőképes), vagy az ESP-n wifi AP-t (ha lehet ilyet egyáltalán, Janos250 biztos tud rá mondani vmit), amihez a teló csatlakozik és lőttek a mobilnetnek a telón. -
Teasüti
nagyúr
válasz
Spuri2000
#7245
üzenetére
Ha szeretnél érdemi segítséget kapni, akkor:
1. használd az auto formázást az IDE-ben és a szerint írd a programod (CTRL+T),
2. a fórumon használd kérlek a "program kód" szövegformázási lehetőséget!
Ez így egy katyvasz, ami nem átlátható.
A sorok behúzása rengeteget javít a kód olvashatóságán. Sztem nem túlzok nagyot, hogy senkitől nem lehet elvárni, hogy átrágja magát ezen - mire meglátja benne a struktúrát - és több időt szánjon rá a szabadidejéből, mint ami indokolt lenne. -
Teasüti
nagyúr
válasz
Victoryus
#7222
üzenetére
Igen, a get.exe-re való tekintettel külön leírtam a megoldást:
"Ezt én cmd-ből indítottam, mert rákattintva semmit nem csinált.".
Örülök, hogy sikerült!(#7223) Victoryus
Ez csak az erőforrásoktól függ. Mondjuk én soha nem használtam még Shield-eket, jó ötlet, hogy moduláris meg minden, de jobb szeretem magam kiosztani a használni kívánt lábakat. Így emiatt nem is lehet rávágni, hogy menni fog-e vagy sem, mert melyik Shield melyik lábra van bekötve és vannak-e átfedések?
Amúgy technikailag mi kell hozzá? A soros port a BT-hez, és elegendő számú GPIO minden másra.
A használni kívánt library-k méretétől függően a memória vagy elég lesz, vagy nem... -
Teasüti
nagyúr
válasz
Victoryus
#7214
üzenetére
Nem tudom milyen tutorial az, de nem kellett python-t telepíteni.
Én e szerint raktam fel.
De a Git Gui-s részt kihagytam, mert nekem nem működött. De ugyanazt teszi, mintha magad töltenéd le innen zip-ben az Arduino Core-t. Szóval baromira felesleges.
Aztán ha kicsomagoltad ahova kell, akkor jöhet a get.exe.
Ezt én cmd-ből indítottam, mert rákattintva semmit nem csinált.Ennyi az egész.
-
Teasüti
nagyúr
válasz
Janos250
#7209
üzenetére
Jobb híján én is akkor hívom a folyamatot, mikor kell és törlöm ha végzett. Elég elegáns megoldásnak tűnik (hála az isteneknek egy ciklusból csinál mindent). Nem úgy a fix delay, ha kell ha nem.
Kíváncsi lennék hogy melyik scheduler van beállítva, itt azt írják elvileg az, amelyiknek kéne váltania a folyamatok között az idő elteltével.Arra van vmi módszer, hogy monitorozzuk az üresjárati időt? Mint Windows-on a cpu terhelés a Feladatkezelőben.
Jól jönne a mag választásnál a folyamatokhoz. -
Teasüti
nagyúr
Janos250 és aki ESP-zik:
történt már veletek, hogy a watchdog reboot-ol, mert nincs etetve a Core 0-n?
Task watchdog got triggered. The following tasks did not feed the watchdog in time...
És akkor mutatja mely folyamatok futottak éppen.
Végtelen ciklusban megy egy, ami 100%-ra hajtja valószínűleg az első magot.
Beraktam egy delay(100)-at és most működik.Hogy kellene optimalizálni ezt a folyamatot?
Én eddig azt hittem az RTOS fel is tudja függeszteni az adott folyamatot, hogy cpu időt adjon a többi folyamatnak. Így nem voltam rest bedobálni több folyamatot is ide-oda, bár igaz mindegyik másikban van egy kicsi delay(), még ha mikroszekundumokban mérhető is.
Vagy etetni kéne a watchdog-ot?
Amúgy nem gáz, hogy ezeket itt tárgyaljuk ki? Engem nem zavar, de nem tudom azoknak zavaró-e, akik a vanilla Arduino-n dolgoznak.
-
Teasüti
nagyúr
Basic? Viccelsz? C++ és Java jobban megy (a nullához képest jobb
), akkor már neki állhatnék a natív Android-nak is.
Még nem tudom mi fog kisülni ebből a pfod-ból (várom a postást, hogy hozza már a második ESP32-met, mert az első már be van építve és én le nem mászok a garázsba ilyen hidegben laptoppal a hónom alatt), de tetszik ez a megközelítés, hogy mikroböngészőbe küldünk pár bájtos oldalakat. Persze BLE-n keresztül, Janos250 bevett.módszere túl könnyű lenne.
-
Teasüti
nagyúr
válasz
Janos250
#7192
üzenetére
Neeem, bár nem vagyok biztos melyik problémára célzol.
Amivel most küzdök, az egy BLE alkalmazás telefonra.
Mivel nem szeretnék megtanulni Android alkalmazást fejleszteni - nyilvánvaló okokból -, ezért a Play-en keresgélek vmi használható után. A Blynk egy egész ügyes kis alkalmazás lehetne, de nincs kész BLE támogatás egyetlen Espressif MCU-hoz se, hát még az ESP32-höz.
Az UART programok szépen működnek, de nem parancssorból szeretném vezérelni a cuccot.
Most vmi pfodApp nevezetűt próbálgatok.
Ennek sincs ESP32 támogatása - nem meglepő módon -, viszont az általa használt library pofon egyszerű (na jó azért kezdőként kell némi idő míg visszafejti az ember) és a meglévő BLE modulokhoz való UART porton kommunikál. Ezt a library-t akarom módosítani úgy, hogy ne a Serial stream-re tolja ki az adatokat, hanem a Kolban féle BLE UART függvényekbe. Elméletileg nem egy nagy munka átírni a library-t.
Csak mikor megláttam, hogy a Serial-t példányosítja és annak a print függvényeit használja, akkor hirtelen azt hittem elég volna copy&paste módon bedobálni a BLE notify() függvénybe mindent, ami ott megy át.
Persze aztán rájöttem ez se nem praktikus, se nem egyszerűen kivitelezhető.Amúgy okkal csináltam egy topikot ezeknek a témáknak, mert itt mindezt off-ba rakja a nép vmi oknál fogva.
-
#7184
Teasüti
nagyúr
hodostamas
#7183
Teasüti
nagyúr
válasz
hodostamas
#7183
üzenetére
Ha nem jutsz dűlőre, akkor még a fenti library-vel lehet matekozni is stack méretet. Ugye az előre lefoglalt memória a ram elején van, a dinamikus memória vagy az úgynevezett stack meg a ram végén. Ha a kettő "összenő", na akkor futsz ki a ram-ból. Ha a stack pozíciója lejjebb van, mint a lefoglalt terület vége, akkor van baj.
-
#7182
Teasüti
nagyúr
hodostamas
#7179
Teasüti
nagyúr
válasz
hodostamas
#7179
üzenetére
Erre mi mutat?
Serial.println(freeMemory(), DEC); // print how much RAM is available.
Persze menet közben monitorozva. (Nem próbáltam ki.)Illetve ha esetleg a program hibázik, akkor kipróbálnám az ArduinoCrashMonitor library-t is.
Ha mindig ugyanannál a sornál fagy le, akkor program hiba.
Velem fordult már elő, hogy a használt library volt a ludas.
Pl régebben a gyári I2C library nekem instabil volt és mindig megszűnt kommunikálni. -
Teasüti
nagyúr
Az előző motoromra is készítettem ledet, bár az analóg 12V volt.
A beázással nem volt gond, még az olaj lerakódás se hatotta meg, de még a motor hőjét is tűrte.
Ettől nem is tartok, elég igényesen összeraktam. Ragasztó + zsugorcső az egyik végén, ragaszó + szilikon végzáró a másik végén. Zsugorcső + szilikonzsír a vezetékek összekötésekor. Vízálló csatlakozók.
Nem tudom viszont a digitális szalag mennyire lesz megbízható. Konyhában pultvilágításra már szereltem fel ilyen szalagot, de az nagyon hamar pixelhibás lett. Többször is kellett pixelt cserélnem azon. Remélem csak egy selejtes tekercs volt...(#7163) gyapo11
Köszönöm!
Népszerű leszek a tinik körében, ez azzz!!
Egy igazi nő viszont max megmosolyog.![;]](//cdn.rios.hu/dl/s/v1.gif)
Ezt a magam szórakoztatására készítettem. -
Teasüti
nagyúr
Szeretném megköszönni ezúton is a rengeteg segítséget!
Igazán leköteleztek.
Alább látható az ESP32 vezéreltre ws2812 projektem.
Idővel szeretném interaktívvá tenni, a tacho és speed jelek kiolvasásával, meg épp készülőben van egy saját tervezésű féklámpa is 5730-as ledek felhasználásával (nagyon durvák ezek a fél wattos ledek, 5 db-ot próbáltam ki a prototípuson, de még 8%-on is bántja a szemem. 100%-on meg mintha napba néznék, instant vakufoltok.
Na ezt egy kicsit túllőttem 95 db ilyen leddel...).
Szóval egy szó mint száz, még keresem a bajt így sűrűn fogtok hallani felőlem. :] -
Teasüti
nagyúr
válasz
Janos250
#7146
üzenetére
Megcsináltam, működik. Fasza. Azóta életre keltettem a BLE UART-ot is, ami notify() és write() funkciókkal tud csak működni, ami a klasszikus BT-re hajaz, de a fogyasztás nem szempont.
Igazából a hardver több fejfájást okozott, mint a dokumentáció nélküli library.
Ha követed a hobbi elektronika topikot, akkor láthattad mekkorát sz.ptam a szalagok vezérlésével és az állandó boot loop-pal. -
Teasüti
nagyúr
-
Teasüti
nagyúr
válasz
Teasüti
#7139
üzenetére
Hmm úgy néz ki itt vmi típushiba van, ahol ezt alkalmazni szerettem volna.
Más helyen aSTRANDS[i].numPixelsszintaktika működik.
Viszont változó deklarációnál nem veszi be:byte buffer1[(int)STRANDS[0].numPixels * 3] = {};Erre dobja a hibát:
array bound is not an integer constant before ']' token -
-
Teasüti
nagyúr
válasz
Tankblock
#7129
üzenetére
Őőő kicsit el vagyok tévedve. Még mindig nem fog menni.
Már az sem megy, hogy hogy tudom lekérni ennek a STRANDS[] tömbnek az egyik elemét.
Hibát dob a compiler ezek mindegyikére:STRANDS[0].numPixels;
&STRANDS[0].numPixels;
&STRANDS[0]->numPixels
És a maradék kombinációra.Próbáltam így is:
strand_t * strands [] = { &STRANDS[0] };
strands->numPixels;
Így se jó.
Kezdek ideges lenni...
Keresnék a neten, de azt se tudom ez melyik témakör, vagy mit keressek.
Object array-ra kicsit más találatok jönnek ki, vagyis többnyire olyan példák, amiben a tömb elemeinek csak egyetlen paramétere van.A demo1-ben ami alapján próbálkozom meg rohadt nehéz átlátni, hogy az függvények miket adnak át egymásnak: pointer-t, objektum tömböt, pointer-ből álló tömböt, stb.
-
Teasüti
nagyúr
Próbálom visszakövetni a forráskódot hol lehetnek a pixelek eltárolva.
Ha megnézem a
digitalLeds_updatePixels(strand_t * pStrand)kódját a .cpp fájlban, akkor ebből apState->buf_data[0 + i * 3] = pStrand->pixels[i].g;
pState->buf_data[1 + i * 3] = pStrand->pixels[i].r;
pState->buf_data[2 + i * 3] = pStrand->pixels[i].b;
rész érdekes nekem. Az itt lévőpixels[]az lesz, ami a STRANDS[] objektumban van definiálva.Aztán ott van egyszer a szalag definíció a programban:
strand_t STRANDS[] = { // Avoid using any of the strapping pins on the ESP32
{.rmtChannel = 1, .gpioNum = 17, .ledType = LED_WS2812B_V3, .brightLimit = 32, .numPixels = 93,
.pixels = nullptr, ._stateVars = nullptr},Csak tippelek, de a
.pixelsaz az ami érdekes lehet nekem.Ez a .h fájlban így néz ki:
typedef struct {
int rmtChannel;
int gpioNum;
int ledType;
int brightLimit;
int numPixels;
pixelColor_t * pixels;
void * _stateVars;
} strand_t;Itt a
pixelColor_t * pixels;amit keresnem kell.
Felette meg is vannak az egyes komponensei a pixeleknek:inline pixelColor_t pixelFromRGB(uint8_t r, uint8_t g, uint8_t b)
{
pixelColor_t v;
v.r = r;
v.g = g;
v.b = b;
v.w = 0;
return v;
}Már csak a pStrand maradt hátra az egyedüli elemeként a puzzle-nak, amit még nem egészen tudtam lekövetni, mi hogy mikor és hol kerül meghívásra.
Jelenleg úgy sejtem a*pStrandaz lényegében egy&STRANDS[i]lesz. Na megyek alámerülni megint...szerk: oh ba.meg MEGVAN! Hisz ezzel indul a függvény meghívás a loop()-ban.
for (int i = 0; i < STRANDCNT; i++) {
strand_t * pStrand = &STRANDS[i];
rainbow(pStrand, 0, 2000);
scanner(pStrand, 0, 2000);
digitalLeds_resetPixels(pStrand);
}
Azt hittem ez globális lesz, mert mindenhol előfordul ez a név.
Közben meg ha jól értem, akkor a loop() deklarálja és innen kerül átadásra a függvényeknek, ahol meg újra lesz deklarálva helyi változóként minden egyes függvényben külön-külön.Akkor azt hiszem ezzel a helyére került minden eleme a puzzle-nak.
Elméletben. Jöhet a gyakorlat... -
Teasüti
nagyúr
válasz
Janos250
#7127
üzenetére
Idáig már magam is visszafejtettem a demót.
Amit pillanatnyilag nem értek, az a pStrand használata:digitalLeds_updatePixels(pStrand)
Azt próbálom kisilabizálni, hogy ez egészen pontosan mire is hivatkozik és vhogy át kéne neki adnom a saját byte tömbömet, amiben a pixeleket tárolom globális változóként.
Nem szeretném a demóban lévő rainbow-t használni, az csak példa értékű.
A saját függvényeimet kell átírnom, hogy pointer-t használjanak, vagy pedig kell egy apró függvény, ami az általam alkalmazott byte tömbből csinál mutatót, amit át tudok adni adigitalLeds_updatePixels()függvénynek.
Ha egyáltalán így működik a pStrand. Amíg nem tudom mire mutat... Egy tömbre? Vagy egy objektumra a STRANDS[] elemei közül? Vagy hogy tudom elérni közvetlenül az egyes pixeleket, amire mutat? -
Teasüti
nagyúr
válasz
Tankblock
#7121
üzenetére
Mi a különbség ez:
while (true) {
for (int i = 0; i < STRANDCNT; i++) {
strand_t * pStrand = &STRANDS[i];
rainbow(pStrand, 0, 2000);
digitalLeds_resetPixels(pStrand);
}
}...és ez között?
while (true) {
for (int i = 0; i < STRANDCNT; i++) {
rainbow(&STRANDS[i], 0, 2000);
digitalLeds_resetPixels(&STRANDS[i]);
}
}
szerk: semmi... Eredetileg jelölő nélkül értettem, hogy aztán leesett, hogy mint változó értelmetlen volna aSTRANDS[i]. Azt leszámítva, hogy jelölőket kell átadni a függvényeknek.Miközben írtam a válaszom jött egy felismerés:
két példány létrehozásához jön jól egy objektumnál, ha a teljesen azonos paramétereknek két eltérő memóriaterületet tudunk linkelni. Szóval a régi dilemmámat lehet feloldani így ha jól értem, amikor változókból próbáltam létrehozni több példányt: pl buffer1[], buffer2[] és e helyett lehet ugyanazt a buffer[] változónevet használni pointer-ként, egy amolyan shift register módon. Ez a gondolatmenet nagyjából köszönőviszonyban van a valósággal?
Vmint az RMT külön lefoglalt ram területekről dolgozik. Értem. Ha erre céloztál. Ez lesz a puffer szerintem, az viszont külön téma a library-ben:
// Pack pixels into transmission buffer
if (ledParams.bytesPerPixel == 3) {
for (uint16_t i = 0; i < pStrand->numPixels; i++) {
// Color order is translated from RGB to GRB
pState->buf_data[0 + i * 3] = pStrand->pixels[i].g;
pState->buf_data[1 + i * 3] = pStrand->pixels[i].r;
pState->buf_data[2 + i * 3] = pStrand->pixels[i].b; -
Teasüti
nagyúr
válasz
Tankblock
#7119
üzenetére
Van demo2 is?
Most próbálm kiollózni a minimálisan szükséges részeket a demóból.
De köszönöm a segítséget, két ember is ugyanezen dolgozik épp... Igazán megtisztelő.
Majd mondjátok mivel tartozom ha ezt tető alá tudjuk hozni!Amúgy egyáltalán nem értem miért kell ennyi pointer ide. Amit beillesztettél ciklus is szerintem pont ugyanazt adná pointer nélkül is közönséges változókkal.
-
Teasüti
nagyúr
Ez a Neil Kolban nagy guru lehet.
Most nézem, hogy van BLE library Arduino alá, és nem a SimpleBLE-ről van szó, hanem rendes implementációnak tűnik első blikkre.
Épp az UART Service példát nézegetem... (Bakker, nem kéne elkalandoznom a feladatról. ) -
Teasüti
nagyúr
válasz
Tankblock
#7113
üzenetére
Szia!
Erről volna szó:
[link]
Arduino IDE alatt. Jövő héten működésre szeretnék bírni egy projektet, így a megszokott környezetben szeretném berúgni a vasat. Az ESP-IDF-fel való ismerkedés inkább hosszabb távon realizálható.
De megvettem hozzá Kolban könyvét, szóval talán lesz egy épkézláb tananyagom hozzá. -
Teasüti
nagyúr
válasz
Janos250
#7111
üzenetére
Elnézést ha túl sok gondot okozok, nem akarlak feltartani a saját munkáddal!
Csak nem tudom hirtelen hová forduljak segítségért, próbáltam keresgélni az adott library-vel kapcsolatban, de semmit nem találtam még a github-os repo-n kívül, meg egy fórum bejegyzésen kívül, ahol a készítő maga kérdezett vmit.Nekem úgy tűnik, hogy a demóban ez volna talán a deklaráció:
strand_t STRANDS[] = { // Avoid using any of the strapping pins on the ESP32
{.rmtChannel = 1, .gpioNum = 17, .ledType = LED_WS2812B_V3, .brightLimit = 32, .numPixels = 93,
.pixels = nullptr, ._stateVars = nullptr},
};
int STRANDCNT = sizeof(STRANDS)/sizeof(STRANDS[0]);Viszont a programozási ismereteim idáig nem terjednek, így nem tudom mi ez:
strand_t STRANDS[]. Ez egy objektumként deklarált tömb volna? Az object array leírások nem igazán hasonlítanak erre a kódra. A kapcsos zárójelben lévő elemek is elég furák, mi az a pont minden egyes paraméter előtt? Meg hol van melyik változó milyen típus?És ha jól látom, akkor a frissítés az már a rainbow és a scanner függvényekből történik, vagyis eredendően más megközelítést használ mint én eddig. Én ram-ba írtam az eredményt és azt dolgoztam fel, mielőtt burst write-tal kiment a szalagra - és tulajdonképpen az egész library-ből csak annyit használtam, hogy tolja ki a szalagra az általam felállított byte tömböt.
Ha ennyit el tudnék érni ezzel az ESP-n, hogy írja ki a saját byte tömbömet a szalagra, annyi nekem bőven elég lenne. Nem kell semmi más funkció.Ha megnézem a Scanner osztályát (a class használata nekem kicsit magas, régen sem találtam elég bő lére eresztett leírást a szintaktikájáról, a spéci szimbólumok magyarázatáról), akkor ott látok pár parancsot, ami nekem kell ide, mint a
digitalLeds_updatePixels(pStrand);valamint adigitalLeds_resetPixels(strands[i]);parancsok. Viszont nem látom, hogy a pStrand az minek van deklarálva. Az egy tömb lenne?MÁS
Mi a probléma a kapcsoló üzemű táppal?
Stabilizált a táp ill. vannak bypass kondik a lap előtt?
Valószínűleg nem ide tartozik, de én PC táppal tapasztaltam hasonló problémákat, amit meg egy a közelében lévő másik fogyasztó csap le állandóan. A táp egy gőzelszívó ventilátor felett helyezkedik el és valahányszor kikapcsolják a ventilátort, a PC táp reset-el vmiért. Először azt hittem a Nano hülyül meg, televágtam bypass kondikkal, meg ESD védelemmel és még alufóliával árnyékoltam.
De még így is levágta, aztán rájöttem, hogy nem a Nano reset-el (készenléti áramról kapja a tápot), hanem a táp maga kapcsol ki. -
Teasüti
nagyúr
válasz
Janos250
#6642
üzenetére
Szia!
Kérhetnék egy kis segítséget ahhoz a led library-hez?
Nézegetem a demo1 példát, ami jár mellé, de nem igazán tudom értelmezni.
Nagyon gyenge vagyok a hardver közeli parancsokból, alacsony szinten nem is tudok programozni.
Azt se igazán tudom kisilabizálni, hogy hogy tudok led szalagot definiálni.
Ez a demo inkább emlékeztet egy library struktúrájára a .h fájlokban (a mai napig nem tudok library-t írni, egyszerűen nem értem a szintaktikáját), semmint egy magas szintű példaprogramra. -
Teasüti
nagyúr
Megszakításnál pedig ez az alapeljárás - sok helyen külön felhívják rá a figyelmet, hogy legyen minél rövidebb, lehetőleg egyetlen parancs csupán -, hogy csak egy változót állítasz be (más néven flag-et, ahogy Tankblock hivatkozott rá). Így a lehető legrövidebb ideig tart a megszakítás a loop különösebb hátráltatása nélkül.
A flag elnevezés meg onnan ered, hogy ez az eljárás egy jelzést ad a loop-nak, amiben már szabadon azt csinálunk vele, amit akarunk. Majd ha bevégeztetett a feladat, akkor utána nullázod a flag-et.
Bizonyos feladatokban, mint mondjuk az input capture, ez a flag lehet számláló is és így nézne ki a dolog:void nyissz() {
piros++;
} -
Teasüti
nagyúr
válasz
Janos250
#6642
üzenetére
Köszönöm a segítséget!
Erre a válaszodra visszakanyarodva a ws2812 kapcsán:
az kézikönyvet olvasgatva nekem úgy tűnik az RMT és az Input Capture fejezetek ugyanarra a perifériára utalnak, vagyis ugyanazt a hardvert használja mindkét funkció?
Ugye van 8 csatornám, amit az infrán kívül be lehet fogni többek közt led vezérlésre is, viszont én szeretnék használni input capture-t is. Szerinted megoldható volna párhuzamosan a két különböző feladat?
Természetesen más-más csatornákon.Más: a cpu sebességet nekem kéne állítani, vagy az hardveresen van belőve kristállyal? Nem tudom mi az a flash frequency, ami 80 Mhz-re van állítva, de említést tesznek, hogy a cpu is 80-240 Mhz között állítható.
-
Teasüti
nagyúr
válasz
Janos250
#7077
üzenetére
Szia!
ESP32 WROOM 38pin vezérlőm megérkezett a minap. Most raktam fel Arduino alá az alaplapi meghajtókat.
Viszont lett egy rakás új menüpont az Eszközök menüben. Ezeket te hogy állítottad be? Jó az alapbeállítás? El tudom rontani (téglásítani)?
Köszönöm!Illetve normális az ha melegszik a lap? Olyan 30-40 fokos lehet, pedig semmit nem csináltam még vele csak lóg az usb-n.
-
Teasüti
nagyúr
válasz
Teasüti
#7088
üzenetére
A gombok bolondbiztossá tételéhez meg: a fenti kódomban a várakozás után a piros gombhoz tartozó változónak hamis értéket kell adni valamint nullázni a számlálót. Így nem fog azonnal vágni, hisz mindkét feltételt hamisnak állítottuk be, tökmindegy mi történt míg szünetelt.
Fordított esetben meg a nyissz megtörténte után fog csak szünetelni, szóval az úgy korrekt.Ui: mondjuk ezért nem használok gombhoz megszakítást... Van amikor nem akarunk tudomást venni egy gombnyomásról. Mint itt amíg szünetel a gép.
-
Teasüti
nagyúr
válasz
Tankblock
#7087
üzenetére
Mármint vész stop. Nem lepődnék meg, ha emberünk jártas volna a gépek terén.
Hisz azzal dolgoznak és ő a boss ha jól emlékszem. Nem egy kisgyerekkel van dolgunk.A felvetés jogos. Volt már arról szó hogy illeszkedik a gépbe az arduino? Honnan kapja a tápot, amit vezérel az honnan kapja, az arduino az egy kiegészítése a meglévő vezérlésnek vagy inkább helyettesítése? Lehet a gépen lévő vész stop megállítja az egész hóbelevancot. Mondjuk én a pillanatálljt kapcsolóra raknám, nem gombra. Így a mikrovezérlő végtelen ciklusban várakozik. Utána nulláznám a számlálót és az azonnali szeletelés gombbal lőném be a kezdési pontot. Vagy különben a szünet után azonnal vág, ami váratlan lehet és így veszélyes. Persze nem ismerjük a gépet, így ezt neki kell eldönteni. Vagy a megbízott munkavédelmisnek, stb...
-
Teasüti
nagyúr
Unatkoztam, remélem nem haragszol meg érte ha esetleg ez volna a megoldás!
Nem igazán emlékszem a kapcsolási rajzodra, de a bemenetek alapból Vcc-re vannak húzva és GND-re kapcsolsz, ugye? Meg hardveres prell mentesítést használsz, ugye? Mielőtt interrupt özön keletkezik egy gombnyomásra.
Hosszú idő után ez az első programom, így lehetnek benne hibák. Pár dolgot ki kellett keresnem, mert nem emlékeztem rá.
Arra figyelj, hogy szünet után azonnal nyissz lesz, ha lejárt a ciklusidő!#define vido 19890 // EZ A LENYEG! Ez a vágási idő ciklus. kb 51 az 1 mm-t jelent. millisecundum egyébként.
unsigned long currentMillis, previousMillis;
bool piros;
void nyissz() {
piros = true;
}
void setup() {
pinMode(3, INPUT); //piros
pinMode(2, INPUT); //mikro
pinMode(13, OUTPUT); //led
pinMode(6, OUTPUT); //relé
Serial.begin(9600);
attachInterrupt(digitalPinToInterrupt(2), nyissz, LOW);
}
void loop() {
currentMillis = millis();
if (currentMillis - previousMillis >= vido || piros) {
digitalWrite(6, HIGH);
delay(100);
digitalWrite(6, LOW);
Serial.println("Vágtam, kövi.");
previousMillis = currentMillis;
piros = false;
}
if (digitalRead(2) == LOW) {
while (digitalRead(2) == LOW);
}
} -
Teasüti
nagyúr
válasz
Tankblock
#7076
üzenetére
Lehet kellene egy ESP32 ESP-IDF topic, hogy ezt ne offoljuk szét.
Az a maréknyi ember, aki ebben járatos mind ide jár.
Aki a legtöbbet ESP-zik, ő meg Arduino alatt programoz.
Aki meg más IDF-et használ, ő meg nem ESP-zik. Így hirtelen akik eszembe jutottak.
Esetleg lehetne egy Arduino komplementer topik. Aki Arduinózik az ne kapjon szívrohamot, ha betéved ide. Minden más platform meg mehetne külön.
Amúgy necces úgy topikot nyitni, hogy nem tudok hozzátenni semmit. -
Teasüti
nagyúr
válasz
Janos250
#6949
üzenetére
Tévedsz.
Atmel324p-vel én 300 db ws2812b ledet vezéreltem mindenféle gond nélkül.
A bonyolultabb effekteknél - mint mondjuk két eltérő effekt számolása + áttűnés a kettő között - az fps bezuhant kicsit, de így is értékelhető eredményt adott. Az egyszerűbb effekteknél, ahol nem kell sokat számolni, ott sok száz fps is elérhető volt. Maga a szalag frissítési ideje az nem akkora időszelet, hogy te szemmel bármilyen formában észrevedd, főleg magasabb fps-nél. Ekkor ugye nincs interrupt, szóval az idő számolása megáll arra a pár ms-ra, de nem vettem észre microstuttering-et az animációban. Pedig jó szemem van a kadenciahelyességhez.
Az meg hogy fizikailag több láncon vannak sorba fűzve a ledek, nem változtat semmit. A ledek számától függ az animáció sebessége, nem attól, hogy hány portra vannak szétszórva. Szép sorban végigmész a portokon a frissítés során. Egy kimenet helyett több kimenet van. Ennyi.
Több példányt kell csinálni abból az objektumból, amivel a led szalagot definiálod.
). Ehhez 3V3 GPIO esetén 330R bázisellenállás tökéletes.
), akkor már neki állhatnék a natív Android-nak is.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
De még így is levágta, aztán rájöttem, hogy nem a Nano reset-el (készenléti áramról kapja a tápot), hanem a táp maga kapcsol ki.
Új hozzászólás Aktív témák
Hirdetés
ekkold- Lakáshitel, lakásvásárlás
- Formula-1
- Nvidia GPU-k jövője - amit tudni vélünk
- One otthoni szolgáltatások (TV, internet, telefon)
- Kazy Computers - Fehérvár - Megbízható?
- Fejhallgató erősítő és DAC topik
- Google Pixel topik
- Tőzsde és gazdaság
- Ford topik
- D1Rect: Nagy "hülyétkapokazapróktól" topik
- További aktív témák...
- Bomba ár! HP ProBook 430 G8 - i5-1135G7 I 16GB I 256GB SSD I HDMI I 13,3" FHD I Cam I W11 I Gari!
- GYÁRI TÖLTŐK DELL LENOVO HP FUJITSU TOSHIBA Macbook---------- Budapest,/MPL/Foxpost
- Magyarország piacvezető szoftver webáruháza
- Bomba ár! Lenovo ThinkPad T480s - i7-8GEN I 16GB I 256GB I 14" WQHD I HDMI I Cam I W11 I Gari!
- ÁRGARANCIA!Épített KomPhone Ryzen 7 7700X 32/64GB RAM RX 9070 16GB GAMER PC termékbeszámítással
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: Liszt Ferenc Zeneművészeti Egyetem
Város: Budapest