-
PROHARDVER!
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
-
-
Janos250
őstag
válasz
tibi-d
#17055
üzenetére
Sok jelentősége nincs. ha a default pineket használod, akkor talán 1-2 ns-sel gyorsabb.
Ha nem azt használod, akkor meg teljesen mindegy, ugyanis van egy hardware mátrix - olyasmi mint a fóliás billentyűzetekben - azon keresztül megy. A mátrix egyik oldalához vannak kötve a perifáriák, a másikhoz meg a pinek, és amikor összerendeled őket, akkor egy adott sort összekötsz egy adott oszloppal.
Az analogokat a defaultból válaszd. Az UART1-nek is van default, de az nem jó, mert azt a memória kezeléshez használja, a lapok többségén ki sincs vezetve.
Én az I2C-t, és az SPI-t (VSPI) az alapértelmezetthez szoktam kötni, de csak megszokásból. Itt elég jól fel vannak tüntetve:
https://i2.wp.com/randomnerdtutorials.com/wp-content/uploads/2018/08/ESP32-DOIT-DEVKIT-V1-Board-Pinout-36-GPIOs-updated.jpg
Meg itt is:
https://i0.wp.com/randomnerdtutorials.com/wp-content/uploads/2018/08/esp32-pinout-chip-ESP-WROOM-32.pngVagy ez:
#ifndef Pins_Arduino_h
#define Pins_Arduino_h
#include <stdint.h>
#define EXTERNAL_NUM_INTERRUPTS 16
#define NUM_DIGITAL_PINS 40
#define NUM_ANALOG_INPUTS 16
#define analogInputToDigitalPin(p) (((p)<20)?(esp32_adc2gpio[(p)]):-1)
#define digitalPinToInterrupt(p) (((p)<40)?(p):-1)
#define digitalPinHasPWM(p) (p < 34)
static const uint8_t LED_BUILTIN = 2;
#define BUILTIN_LED LED_BUILTIN // backward compatibility
#define LED_BUILTIN LED_BUILTIN
static const uint8_t TX = 1;
static const uint8_t RX = 3;
static const uint8_t SDA = 21;
static const uint8_t SCL = 22;
static const uint8_t SS = 5;
static const uint8_t MOSI = 23;
static const uint8_t MISO = 19;
static const uint8_t SCK = 18;
static const uint8_t A0 = 36;
static const uint8_t A3 = 39;
static const uint8_t A4 = 32;
static const uint8_t A5 = 33;
static const uint8_t A6 = 34;
static const uint8_t A7 = 35;
static const uint8_t A10 = 4;
static const uint8_t A11 = 0;
static const uint8_t A12 = 2;
static const uint8_t A13 = 15;
static const uint8_t A14 = 13;
static const uint8_t A15 = 12;
static const uint8_t A16 = 14;
static const uint8_t A17 = 27;
static const uint8_t A18 = 25;
static const uint8_t A19 = 26;
static const uint8_t T0 = 4;
static const uint8_t T1 = 0;
static const uint8_t T2 = 2;
static const uint8_t T3 = 15;
static const uint8_t T4 = 13;
static const uint8_t T5 = 12;
static const uint8_t T6 = 14;
static const uint8_t T7 = 27;
static const uint8_t T8 = 33;
static const uint8_t T9 = 32;
static const uint8_t DAC1 = 25;
static const uint8_t DAC2 = 26;
// PWM Driver pins for PWM Driver board
static const uint8_t PWM0 = 12;
static const uint8_t PWM1 = 13;
static const uint8_t PWM2 = 14;
static const uint8_t PWM3 = 15;
static const uint8_t PWM4 = 16;
static const uint8_t PWM5 = 17;
static const uint8_t PWM6 = 18;
static const uint8_t PWM7 = 19;
#endif /* Pins_Arduino_h */Apropó!
Szerintetek ennek a sornak mi az értelme:#define LED_BUILTIN LED_BUILTIN -
-
Janos250
őstag
válasz
Sebiferi
#17047
üzenetére
Erre én is kíváncsi lennék, mert irreálisan alacsonyak az árak. pl. ESP32CAM 1100 Ft.
Lehet, arra játszanak, hogy nem küldik, és mivel hosszú a szállítási határidő, és az nem is a rendelés napjától, hanem attól a naptól számít, amikor ők postára adták, így aki nagyon erősködik annak visszautálják, de sokan addigra el is felejtik, és az a hasznuk. -
#17040
Aryes
nagyúr
Killer man
#17039
válasz
Killer man
#17039
üzenetére
Sosem hallottam még ilyen nevű eszközről. Milyen uC van rajta?
Látatlanban azt mondom, hogy nem bír el 40mA-t. Az AVR-ek talán bírnak ennyit, de inkább sink módban, push módban asszem 27mA a max. Az esp-k még ennyit se, ott talán 17mA a max áram. -
Janos250
őstag
válasz
Ton-ton
#16973
üzenetére
A Ramp az jó, bár Megaval megy, de nem tudok olyan, nagy szériában gyártott panelről, ami korszerűbb procival (STM, ESP) megy. Utólag szokták hozzá mókolni az ESP8266-ot, akinek kell.
A programodat hova akarod tenni? A RAMP Megájába? Vagy külön panel lesz rá?
USB ügyben elég gyenge vagyok.
"Esetleg tudnál compilert javasolni?"
Ha az Arduino IDE-t letöltöd, abban minden benne van, szőrötül-bőröstül.
Megnyomot a feltöltés menüt, és mindent elintéz.
Van olyan IDE, ami régebbi fordítót tartalmaz, de pl. az ESP32-höz ami van, az már tudja a C++11-et, bár az alapesetben nem szükséges. -
válasz
sisi22
#16965
üzenetére
Ez a soros port nem az a soros port, amire te gondolsz, ez usb-n keresztüli (virtuális) soros port emuláció. Vagyis usb-vel rádugod a gépre, csak kell valami, ami tudja kezelni. Valószínűleg a legjobb megoldás Janos250 javaslata alapján egy esp32, ami egy önálló webszervert képes megvalósítani. Felkapcsolódva vele az otthoni wifi hálózatra, gépről rá tudsz kapcsolódni és megnézni rajta az adatokat.
20 forintos kérdés: Arkagyij Rajkin
Jó lenne, ha megmásznád ezt a spanyol hegyet, különben kell valaki, aki megmássza helyetted.
Lehet önálló kütyü is, van mindenféle kijelző, karakteres vagy grafikus, pénz kérdése.
-
vegyszer
addikt
válasz
Dißnäëß
#16944
üzenetére
Azt láttam, hogy ESP32, illetve ESP8266 esetén van MicroPython használati lehetőség.
Getting started with MicroPython on the ESP8266De hogy ez azt az érzést, élményt hozza, amit te szeretnél, azt már nem tudom. Én megragadtam a kapott kódok alantas igényeimre formálásának a szintjén.
![;]](//cdn.rios.hu/dl/s/v1.gif)
-
Dißnäëß
nagyúr
Urak !
Van ez az Arduino IDE ugyebár. Most egy nagyon fura kérdést hoznék, nem ér kiröhögni
Szóval: jó ez a C++, de én amúgy így egyébként udemy-ről meg innen-onnan python-t tanulok épp.Van rá lehetőségem, IDE, akármi, hogy python-ban fejlesszek a kütyükre ? Gondolok a Leonardo-imra arra a kettőre, meg az ESP8266-omra.
Nem is maga a nyelv érdekel, hanem a library-k széles választéka. Gondolom, C++ -ra van a legtöbb, nem ? (Van ugye az OLED kijelzőm). Végülis tök jó nekem a C++ mert nem egy világvége, de ha már amúgy egyébként python-ozok, miért ne használjam itt is azt.
Csak elfilóztam, nem nagy dolog. Köszi.
-
#16910
Janos250
őstag
tonermagus
#16908
Janos250
őstag
válasz
tonermagus
#16908
üzenetére
Én ajánlani már semmit senkinek nem ajánlok, csak azt mondom el, én hogyan csinálom/csinálnám.
Én az IRLB4030-at használom, ez nagyon jól bevált, kivétel, amikor az Aliról használhatatlan példányokat kaptam.
Gyakorlatilag tökéletesen nyit, zár, nem melegszik, nagyon kicsi az ellenállása az ESP32 kimenetével hajtva a gate-et.
A vásárolt példányoknak kb. a fele rossz volt, nem nyitott ki teljesen, és nagyon melegedett.
Amit megbízhatóbb eladótól vettem az mind jó, de volt 2 olyan rendelésem is, hogy mind rossz volt. Kénytelen voltam az összes példányt lemérni, és a rosszakat kidobni.
Részlet, hogy én hogyan használom: (Csak a FET-eket és az ESP32-t nézd, mert van ami el van rontva, de nem találom a javítottat)
-
Tomika86
senior tag
Sziasztok
Pár kérdésem lenne:
1. Fordítaskor kiírja az arduino ide hogy az egyik library nem kompatibilis esp32 platforma, működik, de esetleg okozhat gondot?
2. Nagyon lassan fordít le, ha másodszor is fordítom már sokkal gyorsabb
3. Reset és gpio0 10kohm-al felhúzva 3,3vra. Ha a kapcsolóhoz kondenzátort teszek akkor boot módba lép tápfeszültség megjelenésekor, 100nF és 1uFal is próbáltam, kisebb kell? 1nF?
Usbs újraindítás nincs, csak a kettő gomb.Köszönöm
-
Janos250
őstag
válasz
JozsBiker
#16879
üzenetére
Az ESP32-nek van saját time.h-ja, az jól működik, ahogy weiss is írta.
Itt jobban kirészletezve:
https://lastminuteengineers.com/esp32-ntp-server-date-time-tutorial/Vagy maga a program:
#include <WiFi.h>
#include "time.h"
const char* ssid = "xxxxx";
const char* password = "xxxxxxxx";
const char* ntpServer = "pool.ntp.org";
const long gmtOffset_sec = 3600;
const int daylightOffset_sec = 3600;
void printLocalTime()
{
struct tm timeinfo;
if(!getLocalTime(&timeinfo)){
Serial.println("Failed to obtain time");
return;
}
Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
}
void setup()
{
Serial.begin(115200);
//connect to WiFi
Serial.printf("Connecting to %s ", ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println(" CONNECTED");
//init and get the time
configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
printLocalTime();
}
void loop()
{
delay(1000);
printLocalTime();
} -
JozsBiker
aktív tag
Sziasztok !
Ennek szerintetek kellene működni ESP32 -n ?
/**************************************************************
* Local Time Stamp with ESP32
* Developed by Marcelo Rovai - 8 September 2017
**************************************************************/
#include <NTPClient.h>
#include <WiFi.h>
#include <WiFiUdp.h>
#define NTP_OFFSET -3 * 60 * 60 // In seconds
#define NTP_INTERVAL 60 * 1000 // In miliseconds
#define NTP_ADDRESS "0.europe.pool.ntp.org"
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, NTP_ADDRESS, NTP_OFFSET, NTP_INTERVAL);
void setup()
{
Serial.begin(115200);
timeClient.begin();
}
void loop()
{
timeClient.update();
String formattedTime = timeClient.getFormattedTime();
Serial.println(formattedTime);
delay(1000);
} -
#16843
razorbenke92
őstag
Sebiferi
#16835
válasz
Sebiferi
#16835
üzenetére
Az áramváltós és a hall-effektes mérők tudtommal nem tudnak ilyen kis áramokat mérni.
Ez igaz, de sokkal könnyebben meg tudod emelni a rajtuk keresztül folyó áramot, mint hinnéd.
Mondok egy példát:
Veszel egy 5A-es lakatot ami 5mA-re vált. Teszel rá egy terhelőt, ami az 5mA-ből 5V-ot csinál (1kOhm).
Ezt az 5V-ot 1024 felé tudod bontani, azaz az 5A-t is. Az már 4,8mA felbontás.
Ha viszont a vezetékedet 4x viszed át a hurokban (ügyelve az azonos áramirányra) akkor 4x olyan érzékeny lesz, azaz 1,2mA felbontást kapsz.
Ezekben az áramváltókban a vasmag szaturációja a névleges értékre van belőve, afölött nem - vagy nem sokkal nagyobb - feszültség/áram nyerhető belőlük, így amikor a valós 10 amperes fogyasztás megérkezik, nem fog túlfeszültséget okozni a mérő oldalon. (Illetve amit okoz, azt simán elviszed egy ellenirányú 5V-os zenerrel).
A közös nullpont azt hiszem nem lesz gond, ennek (is) utánajártam. Pl. a sonoff cuccok is ilyenek és jól működnek.
A Sonoff cuccokban az ESP-k nem az AC vonallal közösítenek nullát, hanem a dedikált energiamonitorozó chippel (HLW8012). A schematicon ne keverd össze az Earth és a GND pontokat, mert azok nincsenek közösítve. -
Tankblock
aktív tag
válasz
Dißnäëß
#16797
üzenetére
Szia,
Van másik út is ha ,egengedik a követelmények. RTC memóriájába írod a ESP-nek, majd deep sleep, és csak a deep sleep currentet kell megtartani 20 µA ami nem sok, ha csak pár percig kell, vagy egy szép LiPo akksit/ CR2032/Alkaline elemx2 teszel rá, backupnak attól függ hányszor jön elő.
Ha visszajön a tápfesz kiírod.
-
Dißnäëß
nagyúr
Három számot kellene beleírnom, üzemóra. Amit szerintem percekben tartanék nyilván, és a maximum az 10.000 (legyen 20.000 de 10.000 óránál jelezne). Ez 60-al felszorozva 600.000.
Szóval 3db értéket update-elnék mindig, mindegyik maximum 600.000-ig menne, de főleg sokkal korábban már reset-elném egy külön nyomógombbal. (1 nyomás egyiket, 2 nyomás másikat, 3 nyomás harmadikat).
Nem percenként írnék bele, hanem csak kikapcsoláskor és/vagy áramszünetkor. Ez szobai erősítő, ergo egyetlen bekapcsolással elmegy 1-4 órát, mikor milyen kedvem van, szóval az írás gyakorisága nagyon kicsi szerintem. Amíg működik, nem tárolnám le benne mindig az újabb +1 percet.
@ekkold, a modul már megvan, lásd korábbi hsz-em. Ezzel kell élnem, egy RTC és egy EEPROM.
@razorbenke92 értem, nagyon jó gondolatmenet, én is ilyen biztonsági játékos volnék inkább. Köszönöm, megnézem a linkeket is. Táp: 6V AC a szekundere a kis nyáktrafónak, tehát olyan ~8.5V DC-re érkezek vele egyenirányítás után, és akkor innen ketté válnék:
1. direktben odaadnám ezt a feszt az ESP-nek, Vin elbírja és 3.3V-ra belsőleg stabizza
Vin is the NodeMcu's voltage input that is connected to its internal voltage regulator allowing an input voltage range of 4.75V to 10V. It will be regulated to 3.3V. Alternatively an external voltage source of 3.3V can be directly connected to the NodeMcu's 3V3 pins. The 3V3 pin can be also a voltage source to other components such as LEDs. GND is the common ground of the board.
2. minden egyéb kütyüt az LM317T-vel lestabizva 3.3V-ra, tudok külön táp-ágra tenniMivel így még mindig ugyanabból a pufferkondiból ennének, nem kerül semmibe 4 plussz kis diódával két híddal mennem, a trafó elbírja ezek minimális többletáramát, és akkor egyik táp ág ESP nagykondival stabilizálatlanul (azaz a sajátjával), másik táp ág egy átlag kondiértékkel az összes egyéb periféria 3.3V-ra stabizva.
Ez a nagy ötlet.
Hát azt hiszem, az órát, percek beleírását stb. még olvasnom kell, úgyhogy "elhallgatok" egy kis időre.
Ja és próbálok KiCAD-et tanulni, lehet ennek csináltatnék egy pici nyákot, úhh. Ez se holnap lesz kész... 
-
#16795
razorbenke92
őstag
Aryes
#16793
Teljesen jogos a kérdés, bennem is megfordult már, amikor láttam a 10másodperces áthidalási igényt korábban.
Dißnäëß
Egy Arduino 3.3ms alatt ír egy bájtot. Tegyük fel, hogy ennyi kell egy ESP-nek is (úgy gondolom, az gyorsabb, de számoljunk a legrosszabb esettel).
Legyen szükséged 8 bájtra, az 26,4 ms.
Az ESP8266 tombolás közben 400mA-t tud fogyasztani - ez megint a legrosszabb eset. Idleben, bekapcsolt rádióval is 80mA körül eszik csak.
Számoljunk 5V-os táppal - bár az ESP 3.3V-al megy, de gondolom a modulon LDO van, ami veszteséggel konvertál, így marad az 5V.5V-on 0,4A az 2W
2W-ot 26,4ms-ig fenntartani kell 0.0528J energia.
0.0528J energiát egy 5V-os kondenzátorban 4224uF-al tudsz tárolni.
Persze a kondenzátor feszültsége folyamatosan esik energia leadása közben, az akksikkal ellentétben egészen nulláig. Az LDO miatt pedig ez azt jelenti, hogy kb. 25%-át tudod elfogyasztani a kondiknak.
Tehát vagy négyszerezed a kapacitást, és mondjuk használsz 2mF-od, vagy használsz 5000uF-ot és valami jó boost convertert.
Esetleg ha nagyobb feszültségű tápod lesz valahol, pl. 12V akkor tegyél 16V 5000uF-ot (0,36J). Annak már ki tudod használni a bő 2/3-át, ami 0,24 J, azaz bő négyszerese amire szükséged van.Ebben a pesszimista helyzetfelmérés miatt már jó kis biztonsági tartalék is van.
Hasznos linkek:
[Energia számoló teljesítmény és idő alapján]
[Kondenzátor kapacitás számoló energia és feszültség alapján] -
Janos250
őstag
Valahogy nem értem én ezeknek a könyvtáraknak a logikáját.
Most SHA1 és base64 ami kell nekem, de mindkettőből tele van a padlás különböző verziókkal.
Pl. SHA-ból ezt#include <C:\Arduino\arduino-1.8.19\portable\packages\esp32\hardware\esp32\1.0.6\tools\sdk\include\esp32\hwcrypto\sha.h>
akarom használni, mert az hw.
Ha így beírom a teljes utat, meg is találja, és azt találja meg, ami nekem kell, de hogy írjam be, hogy más környezetben is megtalálja, ha máshova teszem az Arduinot, vagy ha pl. nem portable?
Base64-ből is rengeteg van.#include <base64.h>
hatására talál egyet, ami jó eredményt is ad, de honnan tudom, hogy ez éppen a sok közül melyik base64.h-t, és base64.cpp-t használja? -
Dißnäëß
nagyúr
Üdv Urak, megjött a kis csúcskütyüm. Tök jó, hogy naptár funkció is van benne.. bár én úgyis csak bekapcsolva eltöltött órák száma miatt vettem + gombnyomásra lehessen nullázni azt. És legalább van mibe beírni..
Remélem, megfelel a célnak.Segítenétek nekem behasalni - tényleg semmi számolás meg ilyesmi - hogy az egész NodeMCU 8266-osom és kiegészítői hány mikrofarádon megy el táp nélkül úgy 10 mp-ig. A cél az, hogy áramszünet, központi táphiba, bármi egyéb esetén legyen ideje kiírni valamit a kijelzőre + az EEPROM-ban azonnal frissíteni három számláló óraszámát az aktuálisra. Aztán elszállhat, tartja a kijelzőt amíg lehet, majd goodbye.
Az ESP-re kötve:
- egy kijelző ugye
- ez az RTC + EEPROM
- terveim szerint vagy 4-5 hőérzékelő
- 3 szilárdtest relé, amiket már ki is próbáltam vele, kiváló (pici vezérlő fesz, pici vezérlőáram)Nos, mindez szerintem még így sem sok. Erre gondoltam. Tényleg csak hasra.
Vélemény ? -
Dißnäëß
nagyúr
válasz
Janos250
#16770
üzenetére
Köszi !
Szép lassan száll el minden ára. Először csak elektronika, aztán a többi, mert nem csak chiphiány van, hanem energiahiány is, áram, gáz, ami mindenre kihat.Lehet most kéne betárazni egy zsák ESP-t, egy marék Pi4-et, pár marék ellenállást, relét, kondit, szenzorokat, betolni egy kisebb szemmel látható összeget a dologba, aztán ha jön a Mad Max, csöndben elbütykölni otthon és automatizálni a medence töltést-ürítést, az esővízgyűjtő ciszternából a padláson lévő tartályba felpumpálást, meg a teljes üvegház öntözést, fűtést, minden fiszfaszt.
Na jó, bilibe lóg a kis kacsóm..
-
Dißnäëß
nagyúr
Sziasztok Szakik !
A NodeMCU ESP 8266-omat szeretném nyákra tenni. Természetesen cserélhetô foglalatba. Ami vagy gyári, vagy 1-1 ilyen nyákba forrasztható tüskesor, aminek a fenekébe meg bedughatom a kontroller tüskéit, így kivehetô-cserélhetô marad nyák zaklatás nélkül.
No, ennek nem tudom, mi a neve és hol kapni
(HEStore jóbarát).Köszönöm !
-
Ennyi erővel vehetek egy occó wireless gamepadot, és átalakíthatom azzal a kormányt
Akartam is javasolni.
Ha mindenképp Bluetooth kapcsolatot szeretnél, akkor lehet például egy tetszőleges Arduino uC + hc-05 Bluetooth modul, vagy ESP32, BT Serial módban fogsz tudni vele rácsatlakozni a gép beépített Bluetooth-ára, ehhez kell egy driver/host program a célgépre. Vagy fogsz egy Digispark (Attiny85) modult, rákötsz egy hc-06 modult, a kettőt összepárosítod, a Digispark-ot felprogramozod USB-HID eszköznek.
De minek, ha minimális átalakítással 1db uC-el meg tudod oldani és kapsz egy komplett, hordozható, problémamentes plug&play megoldást. -
#16722
razorbenke92
őstag
biker
#16721
Nem úgy értettem, hogy csináld újra.
ESP-ből tudsz csinálni egy dongle-t, amit USB-n a leonardora dugsz. USB hosztként felismeri a Leonardot, mint egy kontrollert, és bluetoothon emulál egy BT-s kontrollert, amire proxyzza a már elkészült eszközödet.
Más megoldást nem fogsz találni az adott problémára:
A Leonardon csak USB van szabad -> az USB-t protokoll szinten nem tudod átvinni BT-on, tehát kell egy aktív eszköz, ami fordít USB-ről BT-ra. -
#16721
biker
nagyúr
razorbenke92
#16720
biker
nagyúr
válasz
razorbenke92
#16720
üzenetére
nem kifejezetten megoldás egy kész arduino buttonbox helyett nekiállni egy esp32-t építeni.
De köszönöm a tippet, majd ha egyszer újrakezdem, ezzel fogom tenni, de most nem jó -
#16720
razorbenke92
őstag
biker
#16718
Plug-and-play megoldás sokáig nem létezett, majd az igényt felismerve az egyik kedvelt youtuberem csinált, azt hiszem meg is veheted tőle, vagy megycsinálhato magad is.
[Cheap USB Host Microcontroller [CH559, ESP32, HID]]Szerk.: Bocsi, azt elfelejtettem hozzátenni, hogy ez csak az USB-host rész. De utána ebből BT kontrollert csinálni már csak egy lépés: [link]
Szerk2.: A Blitzwolf cucc az csak audio. -
#16717
razorbenke92
őstag
biker
#16715
Pontosan milyen Arduino, és mit szeretnél az USB átvitel közben megoldani?
Ha sima Uno/Nano/Mega, ott amúgy is az Rx/Tx-en van az USB egy USB-Serial chipen keresztül. Ha arra az Rx/Tx-re felteszed a BT modult, akkor utána tudsz vezeték nélkül kommunikálni. A programozás is megoldható.
Persze az ajánlott ESP-vel egyszerűbb a dolog. Ott van OTA is.
Ha valami komolyabb USB protokollt (pl. HID) akarsz átvinni bluetoothon, az már annyira nem evidens.
-
Tankblock
aktív tag
válasz
tibi-d
#16713
üzenetére
Szia
14+2 pin egy sima TFT + touch [link] ez szerint (16+ 4 SD kártyának),
a nextionnal lerövidíted a fejlesztési időt, hiszen GUI nem a MCU számolja és csak UART-on kell küldeni üzeneteket. ESP32 van vagy 3 UART, szóval a debug portot sem kell mellőzni.
ESP8266 platformmal végig kellene számolni van e annyi lába amit fel tudsz használni, szerintem csak GPIO extenderrel lesz annyi, főleg mert 4 PWM lába van, és erre szeretnél I2C is.....
-
-
#16709
razorbenke92
őstag
tibi-d
#16706
válasz
tibi-d
#16706
üzenetére
A wifi eléggé kézenfekvővé teszi az Esperif SoC-it.
Ha kell a 12bit analógnál jobb, akkor tehetsz mellé külső ADC-t.
A 4 digit jel valamilyen periféria? Van előírt jelszint? (5V / 3.3V)Az érintőképernyő csak kezelőfelület lesz, vagy aktív kijelző is lesz? Képfrissítés miatt kérdezem.
(Damn 4 másodpercet késtem :D)
-
Tankblock
aktív tag
válasz
tibi-d
#16707
üzenetére
Szia,
A Wifi és az analóg jelek rejtik a kulcsot...
Ha megelégszel egy nem túl pontos 12bites ADCvel akkor ESP32 + Nextion kijelzőt mondanék a feladat kivitelezésére, mint minimum hardware.
Analog pontosságán lehet segíteni külső SPI busra tervezett külső ADCkkel.A probléma az lesz mit engedhetsz meg a projectben anyagilag, és mit tudsz megvenni a piacról....
-
Dißnäëß
nagyúr
Hát, röhögni fogsz, Nektek triviális, de .. bekötöttem MINDENT, azt is, amit említett a konstruktor (és ott a helyes portot kiválasztottam neki), a maradék, vélhetően default (csak itt kódban nem említett) bekötéseket pedig rendre a jobboldali zöldekre tettem, szóval most így néz ki a bekötésem, ha hozzá nézed ezt az ábrát:
U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 15, /* dc=*/ 4, /* reset=*/ 5); // Enable U8G2_16BIT in u8g2.hA fentebbi definiálandók közül:
- cs-t is bekötöttem azért, biztos ami biztos alapon, bár értettem, hogy nem szükséges, a GPIO15-re (zölddel jelölt HCS) - fizikailag a D8
- dc-nek kinéztem a GPIO4-et - fizikailag a D2
- reset-nek kinéztem a GPIO5-öt - fizikailag a D1A vélhetően defaultokat is bekötöttem, amit nem kellett kódban megadni:
- kijelző SCLK-t ESP8266 HSCLK-ra (GPIO14/D5)
- kijelző SDIN-t ESP8266 HMOSI-ra (GPIO13/D7)
+ a GND és 3v3 természetesen.Így most ha jól látom, 7 kábellel megyek a kettő között, ebből 2 táp, 5 a többi.
Jó ez így, míg működikSzerk.: próbaképp lehúztam róla RST-t és CS-t, és kifogástalanul megy. Kihúzva-újrabedugva is. Szóval így most 5 kábel, 2 táp, ergo 3 SPI-s kábellel meg van oldva.
-
Janos250
őstag
válasz
Dißnäëß
#16687
üzenetére
"lehet más fejlesztőkörnyezetben és más library-vel jó."
Ezért szeretem én - ha nem nagyon bonyolult - saját magam megírni a kezelést, más által megírt könyvtár helyett.
Látom, közben ESP32-t is bekommenteltél. Ha azon csinálod, akkor többet tudok segíteni, mert azt jobban ismerem. -
Janos250
őstag
válasz
Dißnäëß
#16687
üzenetére
"Ha pedig önkényesen mégis megadom azt neki ugyanúgy, mint az SW verziónál (ahol viszont kéri), hibára fut a fordító."
Ne add meg neki, de kösd be!Mivel csak ESP32-n használtam az SPI-t, ESP8266-on nem, ezért csak általánosságban tudok hozzászólni.
Az általad linkelt képen látszik, hogy két SPI van. Zölddel vannak jelölve.
Általánosságban az SPI használ MOSI , MISO (Master Out Slave Input, a másik fordítva), és egy CLK clock jelet. Az ESP a master, a kijelző, stb. a slave. Van egy-egy CS (chip select láb). Be lehet úgy állítani, hogy a CS-t is a hardver kezelje, általában ez a default. Viszont ezzel az a baj, hogy akkor csak egy slave használható, holott az SPI több slave kezelésére alkalmas. Ebben az esetben minden slave-nek külön CS láb kell, és ezeket szoftverből kell vezérelni, hogy most éppen kihez akarsz szólni. Mivel nálad egyetlen slave (a kijelző) van, ezért célszerű a default választás. Általában a könyvtárakban, ha olyan konstruktort használunk, amiben nem szerepel a CS, akkor a default lesz érvényes, és a hw kezeli. Esetedben ez azt jelenti, hogy HSPI esetén a GPIO15 lesz automatikusan a CS, míg VSPI esetén a CMD-vel jelzett láb. Ha pl. kijelzőt hajtunk meg, akkor vissza irány (MISO) nem is kell. A H-nak, V-nek ne akarj értelmet tulajdonítani, tekintsd egyszerűen egy megkülönböztető jelnek.Az, hogy hány lábat kell a konstruktorban megadni, az még nem jelenti azt, hogy a többi lábat nem kell megadni.
Itt úgy látom, a CS mindig megadandó, nincs default.
Természetesen a /* clock=*/ 14, /* data=*/ 12, bármelyiket használod is, mindenképpen bekötendő akkor is, ha a konstruktorban nem adod meg, hanem defaultként kezeli. -
Dißnäëß
nagyúr
válasz
Dißnäëß
#16686
üzenetére
Az u8g2 doksijában nézelődve, a táblázatot középtájon, a második sor lenne rám releváns, tehát clock, data, cs, dc - 4 vezeték.
És mégis, mikor a constructor reference-ből a számomra megfelelőt teszem be a kódba (előre ott van a minta kódban, csak ki kell kommentelnem és a megfelelő GPIO-t megadnom neki), már csak 3 vezetékkel tudok operálni, amit nagyon nem értek, miért. A 6. sor lenne jó, azaz ez:
U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI(rotation, cs, dc [, reset]) [full framebuffer, size = 2048 bytes]
F mint full framebuffer, 4W mint 4-vezetékes, HW mint hardveres, és utána ? A rotation mint paraméter tiszta, megadom, de utána cs és dc marad, clock és data sehol.
Ha pedig önkényesen mégis megadom azt neki ugyanúgy, mint az SW verziónál (ahol viszont kéri), hibára fut a fordító.SPI-kről:
The ESP32 contains 4 SPI bus hosts calledSPI,SPI1,HSPI, andVSPI.SPIis locked to flash communication and is not available for the application.SPI1is currently also tied to flash support, but might be available in the future. Applications can currently only use theHSPIandVSPIhosts.
Még ezt a srácot megkérdezem Youtube-ról, hátha mond valami okosat, ő összetákolta a dolgot sikeresen. Köszi azért a próbát. Kicsit bonyinak tűnik u8g2-vel, lehet más fejlesztőkörnyezetben és más library-vel jó. -
Dißnäëß
nagyúr
Sziasztok,
beszereztem ezt a kijelzőt (leírás, portok legörgetésre lentebb), 256x64-es OLED.
És van egy NodeMCU ESP8266-om, hajszálpontosan ez.Leszedtem Arduino IDE alá a megfelelő library-t a kijelző meghajtására, u8g2 (elvileg ez valami új, ami a régit leváltotta).
A github oldalán az instrukcióknak megfelelően
U8g2 is configured for 8 Bit mode by default. For any device with a pixel width of 256 or higher, you must uncomment (remove the//) from the following line inu8g2.h://#define U8G2_16BIT
u8g2.h-ban kiszedtem a kommentet a fentebbi sorból.Próbáltam bekötögetni a kábeleket, és rájönni arra a mapping-re, ami azt mondja, hogy az ESP lábai más számú GPIO-hoz vannak rendelve az IDE-ben. Ez mesél erről, ha legörgettek.
Hát mondom jó, legyen.
A kijelző 4-SPI jelölésű, azaz 6 drótos, ebből 2 a táp, 4 pedig a többi.
-----------------------------------------
Az IDE alatt mondom betöltök valami Example kódot, legyen egy klasszik Hello World.
A kódban megjegyzés van arra, hogy a sok contructor sorból a rám megfelelőt ki kell kommentelni.Ez a kettő van:
U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 12, /* cs=*/ 15, /* dc=*/ 13, /* reset=*/ 4); // Enable U8G2_16BIT in u8g2.h//U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 15, /* dc=*/ 13, /* reset=*/ 4); // Enable U8G2_16BIT in u8g2.hAz első SW, a második HW módban kezeli a kijelzőt. Az első tetűlassú, a második gyors. Az elsőnél clock, data, cs, dc, reset PIN-ek adhatók meg, a másodiknál csak cs, dc és reset. Clock és data nuku.
- Tehát az első 5-wire SPI nekem
, nem 4, bár elvileg a reset elhagyható és akkor 4-wire.
- A második viszont csak 3-wire SPI így, és meg se mukkan vele a kijelző.Az első működik, viszont látszik szemre, hogy tetűlassan teszi ki, lehet úgy 2fps talán ?
Srác is ezt tapasztalta előttem, hasonló cipő: [link]Szerintetek hogy a pékbe kell ezt HW módban használni, hogy működjön ? Mi a péket kössek hova, egy 4-SPI-s kijelzőnek, 3-kábeles felállásban, hogy működjön a gyors HW módban ?
-
Janos250
őstag
válasz
gyulank
#16678
üzenetére
Régen én is PIC-et használtam, míg meg nem találtam az Arduinot. A régi PIC fejlesztő így már kipróbálás nélkül szomorkodik a fiókban a PICKIT mellett.
Az STM32 előnye - egyebek mellett - hogy ARM, amihez rengeteg minden van.
Én is Arduino alatt használtam, és kedveltem, amíg az ESP32 támogatottsága el nem érte azt a szintet, aminél már érdemesnek láttam átállni.
Akkor átálltam, és nagyon megkedveltem.
A PICBASIC-et én is használtam, de így utólag azt látom, hogy gyermeteg játék volt.
A PIC-en szerzett ismereteimet nem tudtam a későbbiekben felhasználni, a chipeket elajándékoztam, ami meg már annyira régi, hogy nem kellett senkinek, azt kidobtam.
Kedveltem, hogy a ChipCAD-nél mindent viszonylag tűrhető áron be lehetett szerezni, de persze a mostani kontroller árakkal nem versenyezhetne.
Az STM32-ből a nagyobbak, és a komolyabb fejlesztő készletek ára húzósabb, de a már említett kicsik olcsók, és jók, nagyon sok mindent tudnak, Arduino alatt is lehet jól használni a hardver lehetőségeiket.
Én az ESP32 mellett azért maradok, mert valós 2 magja van, és a hozzá illesztett fordító C++11, és a benne lévő WiFi nekem nagy előny, mert én nem használok se kijelzőt, se gombot, tekertyűt, miegymást, nekem minden a WEB lapon van, mert az ingyenes, és univerzális, a telefon meg kéznél van. És persze fel akarom hívni a figyelmet erre az "okos otthon", stb irányvonalra, aminek én komoly jövőt jósolok. Persze tévedhetek is. -
-
válasz
Janos250
#16639
üzenetére
Ne becsüljük alá annak a jelentőségét, hogy nagyon sokszor azért használnak egyszerűbb processzort, mert egyszerűbb-> megbízhatóbb. Nem ok nélkül használtak például még a 90-es évek végén is Intel 8086-os CPU-kat az NASA űrsiklóiban: a lassabb órajel, a nagyobb csíkszélesség jobban tűrte a szélsőséges körülményeket, kiröhögte az űrbéli háttérsugárzást.
Én ha egy feladatot meg tudok oldani AVR-rel, nem fogok ESP-t használni, ha nincs szükségem a nagyobb tudásra. Miért? Mert régebbi, kipróbált technika, jobban tűri a hibákat (például: ESP-n lévő flash chip 3,6V tápfeszültségen megfő, egy AVR 7-8V-ot simán kiröhög).
-
Janos250
őstag
válasz
Tankblock
#16638
üzenetére
Igazad van, de éppen a mikrokontrolleres alkalmazásban gyakran vannak egymástól teljesen független teendők. Például az egyik szál nem csinál mást, csak egy hőmérsékletet olvas, és ez alapján állít egy PWM-et, és ezeket senki más nem használja. A másik szál meg figyeli a lángérzékelő detektort, hogy nem lángol-e az Anetka (kigyulladni szerető 3D nyomtató), és ha igen, akkor mindent áramtalanít, vagy szirénázik, vagy akármi. Hát az ilyennel nagy tudomány lenne deadlockot generálni.
Aztán, ha egy több bájtos adatot egy valaki ír, de többen olvassák, akkor meg lehet flaget használni.
És persze - mint írtad - a freeRTOS tudja ezeket kezelni. A minták szerintem nem igazán használhatók a sokszálazáshoz.Megnéztem, tényleg rendben van a PWM.
Én továbbra is úgy vagyok vele, hogy ha ott van a ládafiában a Mega, akkor ne dobja ki, használja, de venni már ne vegyen, hanem vegyen korszerűbbet. Elsősorban azért, hogy megtanulja.Én mindenesetre maradok az ESP-nél, pedig valóban van még nekem Z80 is. Amit mellesleg - a maga idejében - kedveltem is. Lehet, ezért szerettem a ZX81-et, és a Spektrumot is.
-
Tankblock
aktív tag
válasz
Janos250
#16637
üzenetére
Szia,
Ha már Thread és kezelés, ESP32 -n ott a FreeRTOS, az legalább threadsafe módon tud megszakításból is adatokat kezelni, van benne MUTEX, miegymás....
Ha nem vagy jártas Design Patternekben a sokszálazáskor random fogsz találkozni a az ugynevezett Deadlock jelenséggel, ami kezdőnek megtalálni nem triviális. Azt nem mondom egy szóval sem hogy a FreeRTOS nem lehet ilyet csinálni, mert lehet, de a dokumentációjában nagyban segít benne.
AVR ekben nagyszerűen van hardwaresen a PWM megoldva. A Mega az egy 2560 as (még ANSI Cből vagy Assemblyből is
)... [link]
Volt alkalmam könyékig turkálni pár kódban, van amire nem használnak ESP-t csak bevált technológiát hiába régi. -
#16637
Janos250
őstag
tonermagus
#16629
Janos250
őstag
válasz
tonermagus
#16629
üzenetére
"Egyszerűen csak profibbnak érezné ha ESP/STM-en futna..."
Nem az a lényeg a váltásnál, hogy "profibb"!
A korszerűbb technikára való áttérésnek az az elsődleges előnye, hogy megtanulod.
Évek múltával úgyis mindenből a korszerűbb jön elő. Én használtam a Z80-at. Ami akkor kellett, meg tudtam vele oldani, mert nem is gondoltam olyan dolgokra, ami azzal ne lett volna megoldható. Ma már nagyon nem szívesen dolgoznék Z80-al, pedig még valószínűleg kerülne 1-2 darab belőle, és vannak olyan dolgok, amit azzal is meg tudnék oldani.
A jelen problémára visszatérve: Az, hogy egy csomó minden hardverben meg van oldva, ha azokat az emberfia megismeri, azok azért hasznosak.
Továbbá a multitasking szisztéma is olyan, hogy nagyon sok mindent világosabban, áttekinthetőbben lehet vele megoldani. Mondok egy példát a saját dolgomból.
Hőmérő méri a hőmérsékletet (akár Z80-al is meg tudnám oldani, de nem teszem), és időnként WiFi-n átküldi egy másik lapra, ami mindenféléket csinál. Hogyan oldjuk ezt meg? Időnként lekérdezzük a ciklusban, hogy jött-e új adat, ha igen, akkor azt beolvassuk, és beírjuk, hogy onnantól kezdve azzal számoljunk.
ESP32-n: egyik task semmi mást nem csinál, csak megnézi, érkezett-e új adat, ha igen, akkor azt beteszi a globális változóba, így mindig automatikusan a legfrissebb adattal történik a további meló. Az "időnként megnézi" azt jelenti, hogy semmi más nincs egyik taskban, mint "megnézi", ha van beolvassa, majd delay. Ugyanis a multitasking esetén a delay nem jelenti azt, hogy ténylegesen várakozik, hanem, hogy a várakozás alatt egyszerűen nem megy rá a vezérlés arra a taskra, hanem fut a többi. Az már csak hab a tortán, hogy két mag van, és megválogathatjuk, ha akarjuk, hogy melyik task melyik magon fusson. Így ídőkritikus dolgokat lehet tenni önállóan az 1-es magra, ami meg ráér, az mehet minden a 0-ra. Ha meg nem akarjuk, akkor rábízhatjuk az oprendszerre, hogy válogasson, azaz egyszerűen használjuk a C++ thread-jét
Például:thread szal1(helloWorld1);
thread szal2(helloWorld2);Ha kell:
szal1.join();
szal2.join();
Ő majd eldönti, mit hova tegyen.
Ha ezeket megtanulod, akkor jössz rá, mire is használd. Evés közben jön meg az étvágy."- 8 db PWM értéket mérek digitális bemeneten
- 10 db PWM értéket írok ki digitális kimeneteken"Nem tudom, mennyire jól van a PWM a Megán megoldva, de STM-en, ESP32-n például igen kényelmesen, hardverből.
-
#16635
Tomika86
senior tag
tonermagus
#16632
Tomika86
senior tag
válasz
tonermagus
#16632
üzenetére
A jelszintek is változnak ESP32 esetén, 3,3v lehet maximum.
-
#16634
Aryes
nagyúr
tonermagus
#16632
válasz
tonermagus
#16632
üzenetére
Egyszerűen csak profibbnak érezné ha ESP/STM-en futna...
Hülye sznob...
-
#16632
tonermagus
aktív tag
Aryes
#16630
tonermagus
aktív tag
Hát ez az, nem lassú semmi
Egyszerűen csak profibbnak érezné ha ESP/STM-en futna...
Természetesen nem használok blocking delay()-t, csak millis()-el operálok.Személyes véleményem hogy hiába lenne gyorsabb a hardware, az adatok amikkel dolgoznom kell úgyis csak 500ms-enként jönnek... Szerintem ezt röhögve tudja a Mega.... Még ha 100ms-enként jönne az adat, gondolom még az sem lenne neki probléma.
-
#16629
tonermagus
aktív tag
tonermagus
aktív tag
Sziasztok!
Sebességgel kapcsolatos kérdésem lenne.
Egyik kollégám folyamatosan csesztet, hogy a már meglévő Arudino Mega 2560-on futó projektemet ültessem át ESP32/STM32-re, mert hogy azok sokkal gyorsabbak.
Ebben igazat adok neki, tény hogy azok a mikrovezérlők jóval gyorsabbak.
Viszont én úgy gondolom, hogy arra a feladatra amire én használom az Arduino Mega 2560 sebessége is túlzó.
Ebben kérném a segítségeteket, hogy ti mit gondoltok? Elég a Mega?
A kód kb. ~300 sorból áll.
Amit a fő loop csinál dióhéjban:
- másodpercenként 2 alkalommal GPS koordinátát olvasok be (2Hz)
- ezekhez a koordinátákhoz képest looponként számításokat végzek. Irány, távolság, szatelitek száma, stb.
- 1 db UART porton keresztül looponként beolvasok 10 sort
- 1 db UART porton keresztül looponként kiírok 5 sort
- 8 db PWM értéket mérek digitális bemeneten
- 10 db PWM értéket írok ki digitális kimeneteken
- Másodpercenként 10 alkalommal olvasok be i2c eszközről adatot
- a kód többi része if feltételek és matematikai sorokból áll össze, jellemzően soronként egy feltétel/művelet és tök egyszerű összeadás/kivonás
- Feltétel teljesülése esetén EEPROM-ba írok 10 memóriaterületre adatot (ez csak ~10 secenként forul elő)
Szerintem ez egy Arduino Megának bele kell hogy férjen a számítási sebességébe, jól gondolom?
Nem akarnék teljesen feleslegesen áttérni ESP/STM-re csak azért mert az gyorsabb, de amúgy gyakorlatilag semmi különbség nincs a kettő között... Én úgy gondolom a vékony keresztmetszet jelenleg a GPS modul...
Amúgy meg a sok EEPROM kezelés miatt úgy hallottam célszerűbb Arduinot használni. Talán annak jobb a memória kezelése.
Ti mit gondoltok? -
Janos250
őstag
Régebben én is megnéztem, de úgy döntöttem, maradok az ESP32-nél:
Okok:
A legfontosabb, hogy az ESP32-n bótilag ott a WiFi
Ugyanígy 2 mag van benne, amihez elég jó a kezelés, nem tudom, ez hogyan van a RP-nél
C++11 fordító van hozzáillesztve, lehet, hogy az RP-nél ez jobb, mert ARM proci van benne.
Vannak, akik szidják az Arduino kezelő felületét, de én megszoktam, nekem jó.
Az ESP32-n van még egy csomó hardver (periféria) lehetőség, ami hasznos, de az RP-n nincs.
Az, hogy az ESP32 összes lábát bármire tudom használni, azaz bármit át tudok helyezni bármelyik lábró bármelyik másikra, az számomra előny.
Az ESP32-re rengeteg kidolgozott program, könyvtár van, fene tudja, mi a helyzet az RP-vel. -
Janos250
őstag
válasz
Tankblock
#16614
üzenetére
Igazad van, az RTOS nem operációs rendszer olyan értelemben, hogy nem tudok konzolról ilyen-olyan userként bejelentkezni, programokat futtatni, de nekem erre egy mikrokontrolleren nincs is szükségem. Amire szükségem van, azt tudja. Legalábbis az Espressif kiegészítéseivel. Tudja a fájlok kezelését úgy, hogy ha írok neki egy fájlnak a C szerinti megnyitását, tudja mi az, vagy ha azt mondom neki, hogy cout, tudja miről beszélek.
Ha valamelyik perifériát fájlként akarom használni, akkor persze meg kell hozzá írnom a drivert, de ezt be tudom illeszteni az ő rendszerébe, beírja a fájl leíró táblába, és onnantól már fájlként (is) tudom használni. Kell persze saját magamnak írni drivert, de már a DOS-hoz is saját magunk írtunk COM port kezelő drivert, mert az eredeti nem megszakítással dolgozott, pedig az Ix86x proci tudta.
Vagy, ha nem akarom az ő thread kezelését használni, hanem a programban szerepel a thread és a join, tudja, mit akarok, a fordító le tudja fordítani az ő API-jaira.
Végezetül, ami elvárásom nekem van egy mikrokontroller nem tudom, minek nevezzemjétől, az ebben az ESP32-ben benne van. Mellesleg viszonylag korszerű fordítót használ, bár nagyon sok mindent nem használok ki, mert például lambdát csak minden második szökőévben, bár azzal számos dolog tömörebb. -
Janos250
őstag
válasz
Tankblock
#16612
üzenetére
(I)"FreeRTOS használ és az nem egy operációs rendszer sokkal inkább egy scheduler."(/I)
Hát, azért az OS, ha nem is hejde...
Igaz ugyan, hogy boldog és boldogtalan ráhúzta a freeFTOS-t a legkülönbözőbb kontrollerekre, és gondolom, pl. az AVR-ekre megírt verziók csak schedulerek.
A freeRTOS tartalmazza például az lwip-t, ami egyértelműen UNIX filozófia.
Onnan tudom, hogy az ESP32 net kezeléséről kevés info van a neten, de a UNIX-hoz rengeteg, és azt kell nézni, mert teljesen passzol az ESP-hez. A teljes socket kezelés, miegymás. A nevek is megegyeznek.
Espéék nem találták fel a spanyol viaszt, hanem - jó kínai módra - alkalmazzák azt, amit mások megcsináltak.
Van file leíró tábla, ahova a file-ok be vannak jegyezve. A soros port sorszáma (file descriptor) például 2.
Futtasd le a következő programot:void setup() {
Serial.begin(115200);
delay(2000);
FILE* filePointer = fdopen(2, "r+");
fprintf (filePointer, "Szevasz ESP!\nEn vagyok a soros port\n") ;
fclose(filePointer);
} ;
void loop() {};Vagyis eredendően a Serial is file, csak rá van ültetve mindenféle Arduino dolog.
-
Tankblock
aktív tag
válasz
Janos250
#16611
üzenetére
Nem véletlenül a ESP32 Flash structúrájában hasznáét SPIFF et használod itt, mint háttértár?
Arduino alatt lehet hogy az is be van hozzá includálva.
Ahol minden egy file az UNIX alapú operációs rendszerek.
ESP32 FreeRTOS használ és az nem egy operációs rendszer sokkal inkább egy scheduler. -
Janos250
őstag
Való igaz, hogy mondjuk az UNO-n és se akartam fájlként kezelni semmit, a PIC-eken meg végképp nem. Attól függetlenül, hogy nincs háttértároló, még a UNIX-ból adódóan eléggé elterjedt a "minden fájl" szemlélet. Tényleg az ESP-ben gondolkodom, de én azt hiszem, növekszik azoknak a tábora, akik áttérnek valamilyen 32 bitre.
ESP32-n például a WiFi is fájl. Lehet rá fájlként írni, róla fájlként olvasni, és nem kell hozzá külön library, hanem a C-ben szokásos file kezelési módon használható.
Például:FILE* filePointer = fdopen(fileSorszama, "r+");
fprintf (filePointer, "Szevasz!\n") ; -
-
Janos250
őstag
válasz
Tankblock
#16605
üzenetére
Igen, így van.
"előre meg nem határozott számú paramétert"
Rossz volt a megfogalmazás, mert valóban egy paramétert visz be.
A helyes megfogalmazás az lett volna, hogy "előre meg nem határozott számú adatot" . Ezalatt azt értettem, hogy a függvény írásakor nem tudjuk, hogy hány beviendő adat lesz. Persze, a ... a feladathoz jobban passzoló. Ezért is kerestem ki a neten először azt, mert már nagyon régen csináltam, gőzöm nem volt, hogyan is kell. Ezt tettem a 16600-ba.
"Amit csinász az standard C ben is egy láncolt listára is mutathatna.... akár egy pointer is". Teljesen igazad van, de én azok közé tartozom akiknek feláll a szőr a hátukon a standard C nagyon széles pointer használatától. Nem is foglalkoztam a C-vel, csak később a C++ -al. Igyekszem nem lemenni alacsonyabb szintekre, ha nem muszáj. Épp eleget programoztam assemblyben ahhoz, hogy kerüljem az alacsonyabb szinteket. Persze azért nem akarom a COBOL szószátyár szintjét sem, de a C++ az szimpatikus, szimpatikusabb, mint a pascal bővítések.
"ennyi erővel struct ba tehetnél". Igen az általánosabb, nem macerás.Én azért úgy gondoltam/lom, hogy nem káros emlékeztetni/megmutatni/memóriát frissíteni (ki hol tart a programozásban) azt, hogy a vektor, list, deque, és egyéb konténerekről se feledkezzünk meg, és hogy az iterátorok nem felesleges dolgok, meg az auto se, ezek néha egyszerűbbé teszik az életünket, mintha visszamennénk a standard C szintre. Ott nem kell se iterátor, se auto.
Mellesleg most muszáj a standard C-vel foglalkoznom, mert kíváncsiságból az ESP32 net kezelését bogarászom mélyebben, és az LWIP ugyebár a standard C-ben íródott.
Ez legalább emlékeztet arra, hogy minden külvilággal való kapcsolat "file". Tulajdonképpen nem is tudom, hogy a mikrokontrolleres világban a perifériákra miért nem a bevált file kezelést alkalmazzuk, ahelyett, hogy ezerféle könyvtárat használnánk, és összevissza hibákat okoz, hogy egy neten talált program nem megy, mert más könyvtárat használ.
Az SPI, stb. kényelmesen kezelhető file-ként is az ESP32-n is.
Hű, hosszú lett, bocs mindenkitől. -
Tomika86
senior tag
válasz
Janos250
#16560
üzenetére
Most esp32-re készült el a kódom, amiben persze van library, és nagyon sok segítséget kaptam innét is. A library belvilágát nézegettem, azokat nem értettem meg, a többit már kapisgálom.
A fejlesztés alatt, a különböző részegységeket külön külön kipróbáltam az ESP32-őn. Átrágtam minden lépést. A tömbökkel még vannak gondjaim, aztán a bonyolultabbakkal osztályok, stb.
Így nagyon sokat tanultam mire ide jutottam a kijelzővel. Majd teszek fel videót róla, hogy sikerült.Köszönöm!
-
Janos250
őstag
válasz
Tomika86
#16559
üzenetére
Még pár megjegyzés:
A C++ tanulásához célszerű valamelyik korszerűbb fordító használata, mert abban minden benne van, ami a leírásokban szerepel. Az ESP32 ilyen, de bizonyára vannak mások is.
Futtasd a mintaprogramokat.
Ami a main()-ben van, az kerüljön a setupba, a return-t hagyd ki. A deklarációk a setup elé. A loop maradhat üresen.
Kiíráshoz, beolvasáshoz általában a cin, és cout szerepel, ezeket az ESP32 tudja.
Egy lehetséges indulás, ami nem a száraz "tudománnyal" kezd:Példának itt van a 3. lecke programja
https://www.webotlet.hu/?p=1726#include <iostream>
using namespace std;
int main()
{
int fokozat;
double sebesseg;
char szinkod;
bool metal;
cout << "Ez egy virtualis auto." << endl;
fokozat = 4;
sebesseg = 48.6;
szinkod = 'R';
metal = true;
cout << "Az auto sebessegfokozata: " << fokozat << endl;
cout << "Az auto pillanatnyi sebessege: " << sebesseg << endl;
cout << "Az auto szinkodja: " << szinkod << endl;
cout << "Az auto metalszinu: " << metal << endl;
return 0;
}Beírva/átírva az Arduino IDE-be:
Feltöltés előtt nyisd meg a soros monitort, mert oda fog írni.
#include <iostream>
using namespace std;
int fokozat;
double sebesseg;
char szinkod;
bool metal;
void setup() {
// ez kell, hogy a cout a soros monitorra irjon
Serial.begin(115200);
delay(2000);
cout << "Ez egy virtualis auto." << endl;
fokozat = 4;
sebesseg = 48.6;
szinkod = 'R';
metal = true;
cout << "Az auto sebessegfokozata: " << fokozat << endl;
cout << "Az auto pillanatnyi sebessege: " << sebesseg << endl;
cout << "Az auto szinkodja: " << szinkod << endl;
cout << "Az auto metalszinu: " << metal << endl;
// return 0;
// ezt ki kell hagyni, mert mikrokontrolleren egy progran nem ér véget,
// ez majd a loop-ban az idők végezetéig fut
} ;
void loop() {
} ;Ezt irja ki a soros monitorra:
Ez egy virtualis auto.
Az auto sebessegfokozata: 4
Az auto pillanatnyi sebessege: 48.6
Az auto szinkodja: R
Az auto metalszinu: 1Ez még alap lecke, de van itt minden a későbbiekben.
-
Janos250
őstag
A múltkori késő esti string és String kínlódásom után úgy döntöttem, hogy nincs értelme a brute force módszernek, inkább gondoljuk át logikusan. És tényleg! Ideírom a tapasztalataim, hátha valaha valakinek hasznos lesz a jövőben.
Kösz mindenkinek, aki segített!Arduino String (nagybetűs), és a C++ string (kisbetűs) kapcsolata.
Az Arduino String nem írható be paraméterként olyan helyre, ahol C++ string az elvárás, és ez fordítva is igaz.
A kettő közötti átmenetet a .c_str() tagfüggvény teszi lehetővé.String ArduinoString_Hello = "Hello";
string Cpp_string_World = "World";
EzekkelString ArduinoString_Hello02 = Cpp_string_World.c_str();
String ArduinoString_Hello03 (Cpp_string_World.c_str());
string Cpp_string_World02 = ArduinoString_Hello.c_str();
string Cpp_string_World03 (ArduinoString_Hello.c_str());
Így új példányok jönnek létre.A szöveget mind a String, mind a string belül egy 0x0 terminált karakter tömbben tárolja, és a .c_str() konstans pointer mutat rá, ezért ha (char*) C típusú sztinget akarunk, akkor "const" miatt (char*) átdefiniálás szükséges.
Például:char* ArduinoString_Hello_c_str = (char*)ArduinoString_Hello.c_str() ;
char* Cpp_string_World_c_str = (char*)Cpp_string_World.c_str() ;
Ebben az esetben nem jön létre új példány, hanem a char* típusú karaktertömb pointere is az eredeti objektumban tárolt karaktertömb kezdetére mutat. Ha az egyikben megváltoztatjuk valamelyik karaktert, a másikban is megváltozik.Az ESP32-höz használt fordító ismeri az iterátor típust is. A C++ string rendelkezik .begin(), .end() iterátorral.
for ( std::string::iterator it=Cpp_string_World.begin(); it!=Cpp_string_World.end(); ++it)
std::cout << *it;
std::cout << '\n';
/*
Woyld
*/std::string::iterator it=Cpp_string_World.begin();
std::cout << "Cpp_string_World.begin() = :" << *it<< "\n"; // W
it=Cpp_string_World.end()-1; // mert a .end() a 0x0 terminátorra mutat
std::cout << "Cpp_string_World.end() = :" << *it<< "\n"; // dMintának egy teljes program:
#define __cplusplus 201103L
#include <iostream>
using namespace std;
void setup() {
Serial.begin(115200);
delay(2000);
Serial.println("Arduino String (nagybetus), es a C++ string (kisbetus) kapcsolata.");
String ArduinoString_Hello = "Hello";
string Cpp_string_World = "World";
String ArduinoString_Hello02 = Cpp_string_World.c_str();
String ArduinoString_Hello03 (Cpp_string_World.c_str());
Serial.printf("ArduinoString_Hello :%s\n",ArduinoString_Hello);
Serial.printf("ArduinoString_Hello02 :%s\n",ArduinoString_Hello02);
Serial.printf("ArduinoString_Hello03 :%s\n",ArduinoString_Hello03);
Serial.printf("ArduinoString_Hello[0]:%c\n",ArduinoString_Hello[0]);
Serial.printf("ArduinoString_Hello.c_str()[0]:%c\n\n",ArduinoString_Hello.c_str()[0]);
/*
ArduinoString_Hello :Hello
ArduinoString_Hello02 :World
ArduinoString_Hello03 :World
ArduinoString_Hello[0]:H
ArduinoString_Hello.c_str()[0]:H
*/
string Cpp_string_World02 = ArduinoString_Hello.c_str();
string Cpp_string_World03(ArduinoString_Hello.c_str());
std::cout << "Cpp_string_World :" << Cpp_string_World<< "\n";
std::cout << "Cpp_string_World02 :" << Cpp_string_World02 << "\n";
std::cout << "Cpp_string_World03 :" << Cpp_string_World03 << "\n";
/*
Cpp_string_World :World
Cpp_string_World02 :Hello
Cpp_string_World03 :Hello
*/
char* ArduinoString_Hello_c_str = (char*)ArduinoString_Hello.c_str() ;
char* Cpp_string_World_c_str = (char*)Cpp_string_World.c_str() ;
ArduinoString_Hello_c_str[2] = 'x';
Cpp_string_World[2]= 'y';
Serial.printf("ArduinoString_Hello is atirodik :%s\n",ArduinoString_Hello);
std::cout << "Cpp_string_World_c_str is atirodik :" << Cpp_string_World << "\n";
/*
ArduinoString_Hello is atirodik :Hexlo
Cpp_string_World_c_str is atirodik :Woyld
*/
// iterator:
std::cout << "Iterator:\n";
for ( std::string::iterator it=Cpp_string_World.begin(); it!=Cpp_string_World.end(); ++it)
std::cout << *it;
std::cout << '\n';
/*
Woyld
*/
std::string::iterator it=Cpp_string_World.begin();
std::cout << "Cpp_string_World.begin() = :" << *it<< "\n"; // W
it=Cpp_string_World.end()-1; // mert a .end() a 0x0 terminátorra mutat
std::cout << "Cpp_string_World.end() = :" << *it<< "\n"; // d
} ;
void loop() {} ; -
Janos250
őstag
válasz
JozsBiker
#16425
üzenetére
"Én az oldalamra ennek segítségével tettem be a kódot."
Én is
http://arduinouser.hu/esp32/wifisocket/index.htmRégebben itt ajánlottátok nekem a WEB-socketot, de fogalmam se volt mi az. Azt hittem, a klasszikus internet socket. Amikor rájöttem, hogy az egész más, elhatároztam, hogy írok egy hevenyészett leírást az ESP32-n az LWIP internet socket használatáról. Ez most történt meg. Majd egyszer a WEB-socketról is.
-
MPM
tag
1. Azért mert ez a 8 pin-es változat van nekem, és híján vagyok a pineknek, de most látom hogy a tx/rx-et is lehet használni, valószínűleg ez lesz a megoldás, mert működés közben nem kell kommunikálnom vele.
2. Nem tudtam, hogy lehet fordított logikával használni Ezzel a részével nem én foglalkoztam, és rá se néztem, de valóban az enyémet is lehet így használni. Ilyen esetben, ha lebeg a relé jelbemenete, akkor mi történik? Csak azért kérdem, mert ha tönkremegy valahogy a pin, és nem ad jelet, akkor magas jel hiányában mindig kapcsolni fog, vagy mindenféleképpen le kell húzni a földre, hogy kapcsoljon? (Gondolom az utóbbi.) A biztonság miatt érdekel, mert nem lenne jó ha az ESP tápellátásának megszűnése, vagy pinjének rövidrezárása után, folyamatosan kapcsolna a relé. (Bocs, az amatőr kérdésekért 
)
3. Aham, világos. -
MPM
tag
Helló!
ESP8266-tal szeretnék egy relét vezérelni, azonban ha minden igaz, e bejegyzés és az általa hivatkozott hivatalos dokumentum szerint, ha a 0-ás pint (amit használni szeretnék) ha lehúzom a földre boot-oláskor, akkor a kódfeltöltő üzemmódban indul el az ESP (mivel ilyenkor még csak inputként tudnak működni a pinek).
Ha a relét rákötöm a 0-ás pinre, akkor gyakorlatilag lehúzom a földre, és így minden indításkor feltöltő üzemmód indul el, és nem a korábban rátöltött projekt.
Ennek megoldásában tudnátok segíteni? A hivatkozott stack exchange-s válasz azt ajánlja, hogy FET-en keresztül hajtsam meg. Sajnos az elektronikai tudásom eléggé hiányos még, így azt kérdezném, miért csak ezzel oldható meg, és milyet kell használnom?
Próbáltam csak diódát használni a 0-s jelnél (hogy csak kimenetként működhessen), ez miért nem elég ahhoz, hogy megakadályozzam a lehúzást? -
-
Tomika86
senior tag
válasz
Janos250
#16395
üzenetére
Szia
Úgy döntöttem, hogy nem a fejlesztőpanelt teszem a panelemre, hanem magát az ESP32-WROOM-32 tokot.
Megrajzoltam a sprint layout makróját.
Egy olyan kérdésem van hogy ha veszek külön usb cp2101 panelt, ezen tx és rx van csak.
Kellenek nekem a dts, cts, dtr... lábak?Köszi
-
Janos250
őstag
válasz
wakula778
#16391
üzenetére
Itt egy minta a használatára az egyik nálam futó programból. ESP32-n.
Mivel két szenzor van, ezért kell kézzel állítani a CS-t.SPI.beginTransaction(SPISettings(100000, MSBFIRST, SPI_MODE1)); // Set the settings to work with SPI bus
digitalWrite(CSpinForralo, LOW); // Select slave
Hbyte = SPI.transfer(0);
Lbyte = SPI.transfer(0);
digitalWrite(CSpinForralo, HIGH); // Release slave again
SPI.endTransaction();
readed16bit = ((uint16_t)Hbyte)<<8 ;
readed16bit = readed16bit + Lbyte;
forraloHomerseklet = readed16bit >> 6 ;
printf("forralo homerseklet= %d \n ",forraloHomerseklet); -
Dißnäëß
nagyúr
Próbálok "igényeskedni", nem nagyon van rajta sehol műanyag burkolat, vagy bármi hasonló. A hátlapra tudnám elhelyezni, a tápcsati környékére-mellé például (belül), és mint az RCA csatiknak is, ennek is (az antennának) egy lyukat fúrva, oda felcsavarom az antennát, így kilát a kis kütyü a dobozból.
Ha az ESP-t kívülre tenném felragasztva, az olyan nagyon "kendács" lenne nekem. "Professzionális" kivitelezésű eszközt szeretnék alkotni.
-
Dißnäëß
nagyúr
Olvaslak Titeket, ez de jó tipp ... !!! Köszi én is
(Bocs mindkettőtöktől, jöttem a "lepattanóra") ---------------------------------------------------------------------
És akkor: Sziasztok
Van egy ESP 8266-om. Próbáltam már, kiválóan műxik. Beépíteném egy audio erősítőbe, vezérelni és "figyelni" pár paramétert. Ezeknek általában fém háza van, ami - ez is az elsődleges feladata - árnyékol. A WiFi-re lehet antennát tenni ? És ha igen, hogyan szokás ?
Arra gondoltam, hogy megfúrom a készülékházat a kontroller közelében, felteszek oda egy csinos-divatos 2.4GHz kisantennát, amolyan igazi IT-s, wifi-s antennát, aminek melegpontját egyszerűen ... ráforrasztom a kis WiFi szál végére óvatosan egy pöttyel ? Ennyi elég lenne ?
Ti hogyan oldanátok meg ?
Az eszközt amúgyis elszigetelném a többi belsőségtől acél válaszfalakkal is, ne szórjon oda semmit esetleg.. így mivel eléggé be van dobozolva, saját wifi használata esélytelen antenna nélkül.
-
Janos250
őstag
válasz
Tomika86
#16343
üzenetére
A témát kevésbé ismerők kedvéért:
AZ ESP32-ben van egy "mátrix", amiben minden sorhoz tartozik egy jelforrás, (például serial rx, serial tx, stb.) és minden oszlophoz az IC-nek egy lába.
Ahova beteszünk egy 1-est, (az össze van kötve) az a láb fog kapcsolódni az adott jelhez.
Viszont a programozónak ezt nem kell ilyen alapszinten kezelni, mert a könyvtárak az inicializáló részben ezt le szokták kezelni.
Lásd a Serial portot:void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert, unsigned long timeout_ms)Úgy van megcsinálva, hogy ha a végéről lehagyod a megadást (pl. int8_t rxPin stb.), akkor a default érték lép életbe. Ezért elég pl. csak annyit írni, hogy
Serial.begin(9600) -
Tomika86
senior tag
Sziasztok!
ESP32 esetén, ha CAN buszt szeretnék használni autóhoz akkor ezt az IC-t kell használnom?
SN65HVD23x
CAN kommunikáció lábait meghatározhatom én? GPIO13, GPIO27Köszönöm!
-
Tankblock
aktív tag
-
Janos250
őstag
És ha floating állapotban hagyod?
ESP32 GPIO pinjeinek az állapotai:
pinMode(pin, mode)
//mode:
INPUT //input is floating
INPUT_PULLUP
INPUT_PULLDOWNmode bitjeinek jelentése: (esp32-hal-gpio.h)
//GPIO FUNCTIONS
#define INPUT 0x01
#define OUTPUT 0x02
#define PULLUP 0x04
#define INPUT_PULLUP 0x05
#define PULLDOWN 0x08
#define INPUT_PULLDOWN 0x09
#define OPEN_DRAIN 0x10
#define OUTPUT_OPEN_DRAIN 0x12
#define SPECIAL 0xF0
#define FUNCTION_1 0x00
#define FUNCTION_2 0x20
#define FUNCTION_3 0x40
#define FUNCTION_4 0x60
#define FUNCTION_5 0x80
#define FUNCTION_6 0xA0
#define ANALOG 0xC0"GPIOs 34, 35, 36, 39 are input only pins"
"These pins don’t have internal pull-up or pull-down resistors." -
#16285
vegyszer
addikt
tonermagus
#16283
vegyszer
addikt
válasz
tonermagus
#16283
üzenetére
Kedvenc gazdasági blogom 3 éve írta, és mind a mai napig igaznak vélem: Glamour napi felárazás
Gondolom nem véletlen van egész évben Black Friday az Alzánál.A kínai barátok meg mindig tudnak egy nagyobb számot írni a termékre, és áthúzni, hogy jól érezzük magunkat. Csak ha követed, látod, mint én pl a M5Stack STAMP PICO ESP32 esetén. Eredetileg 5.99$ volt mot akciósan már majdnem 10€...
-
#16277
Janos250
őstag
tonermagus
#16274
Janos250
őstag
válasz
tonermagus
#16274
üzenetére
Egy példa:
Most például 1750 Ft darabja az ESP32-nek tízes tételben, szállítással, ÁFÁ-val, ügyintézéssel együtt, de lehet, hogy pár óra múlva már sokkal több lesz.
https://www.banggood.com/10Pcs-ESP-32S-ESP32-Development-Board-Wireless-WiFi+Bluetooth-2-in-1-Dual-Core-CPU-Low-Power-Control-Board-ESP-32S-p-1896926.html -
Janos250
őstag
válasz
ekkold
#16230
üzenetére
"Nem akartam saját könyvtárat írni erre"
Pedig szerintem az a legcélravezetőbb, nem egy bonyolult a bitek kivitele.
Én ESP32-re csináltam ugyanezt, mert akkor legalább tudom, hogy mit csinál.
Ha párszáz nano időzítési pontossággal tudsz kiírni, azzal már be lehet lőni.
Kíváncsiságból megcsináltam GPIO billegtetéssel (ESP32), és úgy is működött, bár az ESP32-n van erre célhardver (RMT) -
#16225
razorbenke92
őstag
Aryes
#16220
Azta, ez egy nagyon hasznos tanács! Hasonló módon más platformon reszeltem már kódot, eszembe sem jutott, hogy itt is lehet ilyen lehetőség.
Megnézem majd, és mindenképp visszajelzek (ha megtaláltam a bakit, ha nem).
ESP32 Cam témában:
https://www.instructables.com/Video-Capture-Using-the-ESP32-CAM-Board/Itt egy rögzítős tutorial, de ebből a network stream hiányzik. Bele kell nézni, hogy lehet e AVI helyett mp4-ben rögzíteni, és azt FTP-ről VLC-vel tudod streamelni.
Szerk: Talán mintha lenne is preview a http szerverben gyárilag is. -
Danielo
csendes tag
Igaz, hogy nem teljesen Arduino...de mégis...
ESP32 Cam modult szeretném úgy használni, hogy folyamatosan rögzítse a videót SD-re és az élő kép bármikor nézhető legyen mobilon wifi-n keresztül.
Az utóbbi megoldására ezer féle ötletet találtam, de a folyamatos rögzítésre nem találtam példát. (Lehet, hogy túlzott elvárás?) Csak álló kép rögzítésére van leírás..... (Természetesen 12 óra után felülírhatja az SD-t, hogy benne legyünk a 32GB-ban)
Van esetleg erre valakinek egy jó tippje, linkje?
Köszönettel
Üdv.. -
Tomika86
senior tag
Sziasztok
Mi okozhatja azt Esp32 esetén, hogy néha nem kell a boot gombot nyomni? Van hogy automatikusan csatlakozik, van hogy nyomni kell.
Illetve a GPIO2 láb, ezen van egy led alapból az esp panelen. Ez alapból piros, ha kapcsolok a 2es lábon akkor kéken világít. Tehát fizikálisan működik.
Programban megvan adva INPUTként.
Viszont ahol használom egy "if" feltételben, az nem akar jó lenni. Ha if (nyomogomb) ot írok akkor mindig végrehajtódik a feltétel. Ha !nyomogomb akkor soha.
Ha kapcsolom a bemenetet, ha nem. Programban végig true értékű.De akkor miért működik a lapon lévő led?
Le van húzva 0ra és akkor világít kéken a led ha 3,3vot adok rá.
#define nyomogomb 2, így van definiálva minden be/ki menet. Nodemcu 32s a panelKöszönöm
-
-
Tomika86
senior tag
Igen még mindig 🙂
Jelenleg már esp32-vel. Azért jött az i2c ad hogy ne használjak el lábat az esp32ből. Hosszú project lesz ez.
Tehát akkor vagy csökkentek az ad bemenetein lógó impedanciákon, vagy követő opampot rakok plusszba be, de akkor új panel kell.
Nem tudom, hogy kell e nekem ez a túlzott dupla szűrőtag. Mennyire kell szűrnöm a bemenetet. Milyen frekvenciára kell szűrnöm? Mert ez a 10kohm, 100nf 160hz törésponti frekvenciát ad. -
Janos250
őstag
Semmit nem ajánlok, csak elmondom, én hogyan csinálnám.
Nem csinálnék szintillesztést, hanem az eredetit mérném. Igaz ugyan, hogy akkor pontatlanabb lesz, de az illesztő áramkörrel is beviszek annyi pontatlanságot. Ha mégis pontosabb kell, akkor külső A/D konverter.
Leválasztás:
Én az én paneljaimon egyszerűen oldottam meg.
- egy kontroller (ESP8266 vagy ESP32) mér, vagy vezérel a nagyobb fesszel működő részen, és WiFi-n küldi/veszi a jelet a fő panelon lévő kontrollernek (ESP32). A WiFi-n keresztül általában nincs áramütés
- a központ, a lényegi panel méri azt, amit helyben kell és lehet, valamint WiFi-n begyűjti az adatokat (ESP32).
- A 0-ás mag a WiFi-n kívül azzal foglalkozik, hogy begyűjti és előfeldolgozza a külső adatokat, és lerakja globális változókba, és azt használja az 1-es magon futó fő program. Igaz, nekem az eddigi panelokon nem sok teendő volt, de az Arduino (ESP32) alig-alig volt terhelve.
- Az egyes "perifériák" kezelését a 0-ás magon külön-külön taskban oldom meg, mert ott a delay a vezérlés másik tasknak való átadására fordul. Így minden jól elkülönül, jól átlátható, nincs kölcsönhatás. -
vegyszer
addikt
Szia!
Egyébként ez milyen projekt?
Én eredetileg egy ESP32 alapú két enkóderrel megoldott előfordulás érzékelő rendszert szerettem volna lemásolni. Sikerült is, de a mechanikai rögzítés még várat magára.
Egy távcső két irányban való elmozdulását hivatott követni 8000 jel/360° felbontással.
Nekem kijelző nem kell. A vezérlést telón futó app látja el Bluetooth/WiFi kapcsolat segedelmével.Most egy ESP32 stamp jön. Valahogy nagyon tetszik a mérete, bár még nem látom, hogy a kódot magát hogyan tudom fellőni rá.
-
válasz
MC Pite
#15997
üzenetére
1. Ilyet még nem láttam, de tetszik.
2. Egyetlen mikrokontrollerre sem lehet tudtommal közvetlenül fogyasztót kötni, a kimenetek maximum egy LED-et képesek meghajtani (max. 10-20mA). Amire neked szükséged van, az egy relé (csak ki-be kapcsoláshoz), vagy egy egyszerű (?) FET meghajtó fokozat (ha PWM is kell): az ESP kimenete kapcsolgatja a FET-et, a FET pedig elbírja a 10V-ot. Az egyszerű abból a szempontból nem egyszerű, hogy olyan FET kell, ami 3,3V-on képes teljesen kinyitni, ilyet Janos250 szokott használni,korábban írta is a típusát,
majd mindjárt visszakeresem neked.IRLB4030.3. Hát miben szeretnéd, ha nem C-ben?
Nem kell mindent neked megírni, a komplikáltabb dolgokhoz van valamilyen library, amit csak be kell illeszteni a kódba. Ha szerencséd van, a library-hez lesz egy példa program, ami kisebb módosításokkal lehet, hogy pont megfelel a feladatra.
![;]](http://cdn.rios.hu/dl/s/v1.gif)
Ha pedig önkényesen mégis megadom azt neki ugyanúgy, mint az SW verziónál (ahol viszont kéri), hibára fut a fordító.
)
Új hozzászólás Aktív témák
Hirdetés
- PlayStation 5
- Milyen okostelefont vegyek?
- Sony MILC fényképezőgépcsalád
- WoW avagy World of Warcraft -=MMORPG=-
- Motorolaj, hajtóműolaj, hűtőfolyadék, adalékok és szűrők topikja
- Mini-ITX
- Milyen légkondit a lakásba?
- A fociról könnyedén, egy baráti társaságban
- Intel Core i5 / i7 / i9 "Alder Lake-Raptor Lake/Refresh" (LGA1700)
- EAFC 25
- További aktív témák...
- HP Omen - 27" IPS - UHD 4K - 144Hz 1ms - NVIDIA G-Sync - FreeSync - HDR 400 - USB-C - KVM Switch
- Garanciális MSI Katana GAMER 15,6"240Hz!i5 12500H(16X4,5Ghz)RTX 3060 6 GB VGA,32-64GB RAM/1TB SSD
- Bivaly MAGYAR Lenovo P1 gen2 (Core I7 32 Gb 1Tb 15" 4K 4Gb Nvidia) Laptopom eladó!!!
- HP ProBook 640 G8, 14" FHD IPS Touch, I5-1145G7 CPU, 16GB DDR4, 256GB SSD, WIN 11
- HP ProBook 640 G8, 14" FHD IPS Touch, I5-1145G7 CPU, 16GB DDR4, 256GB SSD, WIN 11
- Telefon felvásárlás!! Samsung Galaxy A16, Samsung Galaxy A26, Samsung Galaxy A36, Samsung Galaxy A56
- Csere-Beszámítás! Xbox One X 1TB Játékkonzol Olvass! Model 1787
- Bomba ár! Lenovo X1 Yoga 2nd - i7-7G I 8GB I 256SSD I 14" WQHD I HDMI I W11 I CAM I Garancia!
- Thinkpad X230 legenda: i7 CPU, IPS kijelző, 12 GB, dupla SSD, magyar villbill, webcam, fingerprint
- Csere-Beszámítás! Asus Prime RTX 5060Ti 16GB GDDR7 Videokártya! Bemutató darab!
Állásajánlatok
Cég: Promenade Publishing House Kft.
Város: Budapest
Cég: PC Trade Systems Kft.
Város: Szeged