Nem tudom, nem ismerem.
Ha nekem kellene olcsó programozó, akkor vennék egy Arduino Micro klónt 3 dollártért, és rátölteném az AVRISP mkII firmware-t. Az biztosan működik több szoftverrel is. Próbáltam.
Bővebben: Link

Nekem is van, tudtam használni avrdude-dal.

ATTinyUSB alapú programozóm van, teljesen jól működik. De nem pont ilyen, hanem ez: https://www.sparkfun.com/products/9825 Ezen van egy "buffer" meghajtó, amitől kicsit jobban védett az áramkör. Illetve alkalmas más feszültségeken működő AVR programozására is, mert a kimenet alkalmazkodik a rákötött VCC-hez, ha power off-ra van kapcsolva. (Méréseim szerint rátáplál egy kis áramot egy 3V-os áramkörre például, úgyhogy ezzel is csínján kell bánni.) avrdude kezeli ezt a típust https://learn.adafruit.com/usbtinyisp/avrdude

Hogy az általad linkelt típus működőképes-e, arról fogalmam sincsen, de nem tartom kizártnak. Viszont csak 5V-os áramkörben használható, az biztos.

Ezeknek az AVR-eknek programozása lényegében SPI protokollon keresztül történik (az új sorozatú seriesX processzorok már máshogy működnek, azokat egyetlen soros vonalon lehet programozni). Ezért ha csak néhányszor kell, akkor akár egy Arduino-val is lehet őket programozni. A programozó Arduino-ra rá kell tölteni az ArduinoISP programot, amit az AVRDude ismer, és ezen keresztül bármelyik SPI programozható AVR csippet lehet programozni. Itt van egy videó róla: https://www.youtube.com/watch?v=muP1dp73Mdg

Csak azért írom, hogy ha csak 1-1-szer kell, és van olyan Arduinod is, amin már fenn van a bootloader és USB-n keresztül csatlakoztatva van, (tehát pl egy bármilyen UNO) akkor nem kell a kütyüre várni, meg lehet csinálni vele a melót egyből. Persze ha sokszor tervezel programozni, akkor megéri megvenni egy dedikált programozó áramkört.

Üdv!

Float számot szeretnék karatkertömbbé konvertálni.
2 mód tűnik elfogadhatónak, de nem tudom melyik a jobb (memória és hasonlók szempontjából).
Mellékinfo: ESP8266 NodeMCU-n fog futni.

-Az egyik, hogy az egész és a tizedes számokat külön-külön int-ként kezelem, átkonvertálom őket itoa-val majd összefűzöm strcat-al.
-A másik, hogy a teljes float értéket átkonvertálom a dtostrf-al.

E téren nálam okosabbak ne fogják vissza magukat a véleményükkel

Ezt jó tudni! A String használata mennyire eszi a cpu-időt?

A micros() a jó, az eredmény 116.

Arduino nano-nál 116 milliomod másodperc.

Köszönöm!

A string-et kerülném. Állítólag problémás, de köszönöm a válaszod.

Nem problémás, csak erőforrásigényes, legalábbis a "sima" típusokkal történő dolgokhoz képest. De ha belefér, akkor használd nyugodtan.

Az ESP sokkal magasabb frekvencián (talán 5-szörös) fut és nem tartom valószínűnek, hogy ugyanezt rövidebb programmal, kevesebb futásidővel, kevesebb munkával meg lehet oldani.
De ha van rá idő, energia, kipróbálsz több lehetőséget és lehet választani.
Ha a sebesség kritikus, azt asm-ben célszerű megírni.

Azt olvastam, hogy a String dinamikusan foglal memóriát, ez lehet amiért nem szeretik használni.

Szokszor úgy szokás mikrovezérlőket programozni, hogy nem használunk dinamikus memóriafoglalást. Ennek előnye, hogy a dinamikus memóriakezelésből adódó egész hibaosztályt elkerüljük.

ATMega328-on azért elég könnyen összeér a heap és a stack, lásd: https://www.nongnu.org/avr-libc/user-manual/malloc.html

De ha pontosan tudjuk, hogy maximum hány bájtot foglalunk, és nincs leak illetve töredezettség veszély, akkor ott sem lenne gond.

Ezen az ESP8266-on ha nincs leak, akkor jó sokáig kitart a 80kB RAM.

Értem. Kipróbálom.
Mindenkinek köszönöm a felvilágosítást.

Úgy vélem, a dtostrf() nem dinamikus memóriafoglalást használ.

Igazad van. Nekem is jobb megoldásnak tűnik, mint a String objektumot használni már csak azért is, mert ezt legalább értem, hogy mit csinál, a Stringben nem vagyok egészen biztos, el kellene olvasnom a kódot. Meg mindig érdemes a függőségeket a lehető legszűkebben tartani.

De mégis az ördög ügyvédje voltam, mert sem program memória, sem RAM használat, sem CPU miatt nem indokolt egy ESP8266-on spórolni. Kivéve, ha nagyon sűrűn kell ilyen konverziót csinálni.

Remélhetőleg a posztoló most már kellően informált, el tudja dönteni, hogy melyik kell neki .

Na végül a dtostrf() lett a megoldás, de nem az erőforrás miatt, hanem a paraméterezhetőség miatt. A dtostrf()-ban megadhatom hány tizedesig akarom konvertálni, a string-nek nincs ilyen funkciója.

Az alábbi példában 3 tizedesre van állítva.

Arduino nanoval 16 MHz-en:

Most kezdtem el programozni Arduino IDE alatt ...
ESP modulokkal próbálkozom...
egy olyan problémába ütköztem hogy feltettem két függvény könyvtárat, de mindkettőben megtalálható ugyan az a fájl ... pl: WifiManager.h ... Emiatt a fordító hibát dob, és nem fordítja le a programot, ami egyébként korábban már működött. Ezt hogy lehet megoldani?

Ne használj ugyanolyan nevű lib-eket.

Felhasználónév/appdata/local/arduino/... alatt találhatók a telepített libek, onnét kitörlöd szerintem helyre áll.

Egy uj feladat, hogyan lehetne ezt optimálisan kezelni?
Van 16 bemenetem és 16 kimenetem ( Arduino UNO + Port Extenderek)
A bemeneten csak nyomogombok vannak, amik aktiv helyzetben a GND-re kapcsolják az adott bementi bitet.
Az Arduino csak akkor értékeli az eredményt, ha a 16 bit közül legalább egy 0 (azaz egy gomb meg van nyomva).
Ezt az állapotot elmenti és kikeres hozzá egy bit kombináciot a kimeneten (16 Bit=1 word).
Ez az állapot addig marad a kimeneten, amig nem olvas be egy másik aktiv nyomogombot ( közben nincs megnyomva semmi, azaz a bemenetek #FF ( bytenként olvasom be a két 8 portot) amit a rendszer átugrik. Eddig többé kevésbé megy a dolog.

Most jön a gond
A bemeneti nyomogombok több csoportba vannak osztva ( szerencsére csak egy byten belül). Egy-egy csoportbol, csak egy kimenet keletkezhet.
Pl. nyomogombok 1,2,3 egy csoportban vannak azaz csak egy kombinácio jelenhet meg a kimeneten: LU1,LU2, LU3 -bol ( valamennyi kombinácio 1 bitet jelent a kimeneti oldalon).
A nyomogombok 4,5,6,7,8 egy másik halmazbol választanak egyet LU4,LU5,LU6,LU7 és LU8.
Azaz az adott 8 bites porton egyszerre csak 2 bit lehet aktiv. (Mindegy, hogy 0 vagy 1).
És igy tovább.
A problémám még az, hogy a fenti példában az elsö 3 bit az egyik csoportba tartozik a másik 5 meg a másikba. Azaz, ha megjelenik az elsö 3 biten valami - mondjuk 010, az nem változhat, ha a másik csoportban van változás ( azaz egy nyomogomb a 4-8 közül aktiv és kiválaszt egyet az LU4-8 közül, azaz mondjuk 01000. Az egész kimenet ilyenkor 0100 1000. Ha most megnyomom az elsö gombot akkor 1000 1000 kell a kimenetre küldeni (5. nyomogomb már nincs megnyomva), és igy tovább. Egyszerre csak egy nyomogombot kell beolvasni (nem tudom, hogy esetleg kezelni kell az esetet, ha több nyomogomb lenne megnyomva, ami majdnem kizárt a hardwaren).
Jelenleg azt meg tudom oldani, ha csak egy állapotot engedélyezek a 8-bol bytenként. Azaz a 8 nyomogomb egy csoportban van és egy kimeneti állapotot választ. Azaz egy uj nyomogomb átir minden korábbit az adott byteban.

Kösz az ötleteket!

Szerintem az a megoldás, hogy eltárolod az adott byte legutóbbi értékét, vagy egyben (LU1_8), vagy külön csoportonként (LU1_3 és LU4_8). Előbbi esetben gombnyomás esetén csak az adott csoportra vonatkozó részt változtatod meg úgy, hogy kimaszkolod a többit:

Mási kesetben pedig csak az adott csoportra vonatkozó változót állítod be, aztán a kimenetet beállítod a másik (vagy többi) változóval összebindzsizve


Problémás lehet még a prellezés, illetve ezzel kapcsolatban egy gomb beragadása is. Ezt valamilyen formában le kell kezelni, de ez most out of scope (és lehet, hogy már meg is csináltad).

Kösz, kifogom probálni.
A prellezést már kezelem , ott nincs akkora gond, mert bytenként olvasom be és csak többszörös beolvasás után fogadom el a bemenetet.
Valoban tehát ugy a bemenetet, mint a kimeneti byte szekvenseket (LU1_3 stb) el kell külön tárolnom, mert csak akkor kell valamit csinálni, ha változik a bemenet ( azaz nem az ami a régi) a kimeneten meg az adott szekvenst fog kelleni csak átirni a másikat hagyni ugy ahogy van.
Talán még azt meg fog kelleni oldani, hogy hibajelzést kapjak, ha több bemenet van egyszerre lenyomva ( ragad a gomb vagy hibás kezelés). De ezt majd meglátom, ha összeáll a program.

Sziasztok szerintetek kb olyan 50-60db ledet egymastol független hogyan tudnék működtetni egy arduinorol ?

Mit értesz működtetés alatt? Ha csak ki- és bekapcsolást, akkor egy Arduino Mega is jó választás lehet, van elég lába.

Esetleg egy MAX7219-is szóba jöhet, az mátrix üzemmódban hajtja a LED-eket, 64-et ki tud szolgálni.

Arduino mi?
Az uno/nano összesen huszonvalahány pin-nel rendelkezik, itt több i2c/spi portbővítő jöhet szóba. A mega-nak van egy csomó pin-je, ott mehet magáról a uC-ről.
De szerintem ennyi LED árama már meghaladja azt, amit a uC/portbővítő leadni képes, szóval javasolt LED-enként egy logikai N csatornás FET-tel kapcsolni.

Az egyik legegyszerűbb megoldás, ha shift regisztert használsz. Órajel és data láb kell hozzá, ezekkel "ki tudod shiftelni", hogy melyik LED van be és melyik ki állapotban, minden LED egy kishiftelt bit.

Amivel lehet fűszerezni:

* PWM meghajtást úgy lehet csinálni, ha van "output enable" bemenete a shift regisztereknek. (Ez plusz egy PWM kimenet a uC-ről)
* Pontosan egyszerre lehet frissíteni (és akkor nem kell a PWM-mel szinkronizálni a tökéletes meghajtáshoz) a kimenetet, ha van a shift regiszternek ugynevezett latch funkciója. Ezeknél a shift regiszter egy átmeneti tár, és a latch-en adott élre a shift regisztert a kimenetet vezérlő emlékezetbe másolja (Ez is plusz egy kimenet a uC-ről)
* Az áramot a shift regiszter kimenete adja, tehát nem lesz a mikrovezérlő túlterhelve függetlenül a LED-ek áramától és számától. A shift regisztert természetesen méretezni kell.
* A shift regisztereket a felépítésükből adódóan sorba lehet kötni, így akárhány LED meghajtható, plusz uC lában nélkül
* A bitek kishiftelését a mikrovezérlő SPI interfésze is meghajthatja, így még kevesebb CPU órajelet használ el a meghajtás. De a shiftelés logikája programban megírva is nagyon egyszerű és gyors.

(PWM és Latch-elt megoldás esetén tehát 5 láb kell hozzá: data, clock, input enable avagy "chip select", PWM, latch. A chip select lespórolható, ha nincs más eszköz ugyanerre a data/clock, avagy SPI vonalra.)

De van egy rakás egyéb megoldás is, például amiket a többiek írtak. Érdekes még az úgynevezett charlieplexing: https://en.wikipedia.org/wiki/Charlieplexing

Az másik legegyszerűbb megoldás, ha egyedi címezhető RGB LED-et használsz. Egy lábon akár (több) száz LED is lehet és mind más színű, fényerejű beállítással.