- iPhone topik
- Motorola Edge 50 Neo - az egyensúly gyengesége
- Google Pixel topik
- Profi EKG-s óra lett a Watch Fitből
- Magyarított Android alkalmazások
- Mobil flották
- One mobilszolgáltatások
- Magisk
- Samsung Galaxy Watch5 Pro - kerek, de nem tekerek
- Samsung Galaxy S23 és S23+ - ami belül van, az számít igazán
-
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
-
ngabor2
nagyúr
Szolgálati közlemény!
Úgy tapasztalom, hogy a topik egyre gyakrabban kezd elkanyarodni a címtől, ami nem probléma, inkább a technikai fejlődést követi. Ezért új címjavaslatokat várnék, mire lehetne átnevezni, hogy a kereső megtalálja, ha valaki a témában keres. Az Arduino az mindenképp benne maradna, de kiegészíteném az ESP8266/ESP12/ESP32 résszel. De milyen összefoglaló, könnyen idevezető nevet lehetne adni ezeknek?
Várom és köszönöm a címjavaslatokat.
-
vargalex
félisten
válasz
fecske13
#7382
üzenetére
Szia!
Szóval, a kód:
#include <ESP8266WiFi.h>
#include <Wire.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <ESP8266HTTPClient.h>
#include <time.h>
#define TEMPERATURE_PRECISION 11
#define REPORT_INTERVAL 60 // in sec
#define INTERVAL_CORRECTION 1.01 //1.06001
//AP definitions
#define FIRST_SSID "SSID1"
#define FIRST_PASSWORD "PASS1"
#define SECOND_SSID "SSID2"
#define SECOND_PASSWORD "PASS2"
#define UPDATEURL "http://az.en.szerverem.hu/updatesensor.php"
#define ONEWIRE_GPIO 2
#define VCC_ADJUST 1.0
#define MAXRTCDATACOUNT 50
#define MINPOSTCOUNT 10
#define NTPSERVER "time.kfki.hu"
ADC_MODE(ADC_VCC);
struct {
uint32 lastTime;
int cnt;
float temperatures[MAXRTCDATACOUNT];
float battery[MAXRTCDATACOUNT];
} rtcData;
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONEWIRE_GPIO);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
// device addresses
DeviceAddress DSAddress;
// device address in char array
static char DSAddressStr[18];
static char *hex = "0123456789ABCDEF";
int deviceCnt;
char *ap_ssid = NULL;
char *ap_password;
HTTPClient http;
boolean setSNTPTime(char *NTPServer) {
unsigned long entry=millis();
configTime(0,0,NTPServer);
while (millis()-entry<5000 && time(NULL)<3600) {
delay(500);
}
if (time(NULL)>100) return true;
else return false;
}
void scanWifi() {
WiFi.mode(WIFI_STA);
WiFi.disconnect();
delay(100);
Serial.println("Scanning for wireless networks");
// WiFi.scanNetworks will return the number of networks found
int n = WiFi.scanNetworks();
Serial.println("scan done");
if (n == 0)
Serial.println("no networks found");
else
{
Serial.print(n);
Serial.println(" networks found");
ap_ssid = NULL;
for (int i = 0; i < n; ++i)
{
// Print SSID and RSSI for each network found
Serial.print(i + 1);
Serial.print(": ");
Serial.print(WiFi.SSID(i));
Serial.print(" (");
Serial.print(WiFi.RSSI(i));
Serial.print(")");
Serial.println((WiFi.encryptionType(i) == ENC_TYPE_NONE) ? " " : "*");
if (WiFi.SSID(i) == FIRST_SSID) {
ap_ssid = FIRST_SSID;
ap_password = FIRST_PASSWORD;
}
if (WiFi.SSID(i) == SECOND_SSID) {
ap_ssid = SECOND_SSID;
ap_password = SECOND_PASSWORD;
}
}
}
if ( ap_ssid == NULL) {
Serial.println("Defined SSID-s not found. Resetting.");
ESP.restart();
}
Serial.println("");
}
void connect() {
// Connecting to Wifi.
Serial.println();
if (WiFi.SSID() == "") {
// Never connected, scanning for wireless networks
scanWifi();
WiFi.mode(WIFI_OFF);
WiFi.mode(WIFI_STA);
Serial.print("Connecting to ");
Serial.println(ap_ssid);
WiFi.begin(ap_ssid, ap_password);
}
else {
Serial.print("Connecting to ");
Serial.println(WiFi.SSID());
}
unsigned long wifiConnectStart = millis();
while (WiFi.status() != WL_CONNECTED) {
// Check to see if
if (WiFi.status() == WL_CONNECT_FAILED) {
Serial.println("Failed to connect to WiFi. Please verify credentials: ");
scanWifi();
WiFi.mode(WIFI_OFF);
WiFi.mode(WIFI_STA);
Serial.print("Connecting to ");
Serial.println(ap_ssid);
WiFi.begin(ap_ssid, ap_password);
ESP.restart();
}
delay(500);
Serial.print(".");
// Only try for 5 seconds.
if (millis() - wifiConnectStart > 15000) {
Serial.println("Failed to connect to WiFi");
scanWifi();
WiFi.mode(WIFI_OFF);
WiFi.mode(WIFI_STA);
Serial.print("Connecting to ");
Serial.println(ap_ssid);
WiFi.begin(ap_ssid, ap_password);
ESP.restart();
}
}
Serial.println("");
Serial.println("WiFi connected");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}
// function to return device address as a String
String deviceAddressToStr(DeviceAddress deviceAddress)
{
String ret = "";
for (uint8_t i = 0; i < 8; i++)
{
// zero pad the address if necessary
ret = ret + hex[DSAddress[i] / 16];
ret = ret + hex[DSAddress[i] & 15];
}
return ret;
}
// getting temperature from DS18B20 sensor
float getTemperature() {
float tempC = 150;
// Start up the library
sensors.begin();
if (!sensors.getAddress(DSAddress, 0)) {
Serial.println("Unable to find address for Device 0");
}
else {
// set the resolution
sensors.setResolution(DSAddress, TEMPERATURE_PRECISION);
sensors.requestTemperatures();
tempC = sensors.getTempC(DSAddress);
Serial.print("Temp C for device ");
Serial.print(deviceAddressToStr(DSAddress));
Serial.print(" ");
Serial.println(tempC, 4);
}
return tempC;
}
// POST data as JSON to the server
bool sendData(DeviceAddress dsAddress) {
bool ret;
int i;
String postStr = "{\"sensorAddress\": \"" + deviceAddressToStr(dsAddress) + "\", \"values\": [";
for (i=0; i<rtcData.cnt; i++) {
if (i>0) {
postStr += ",";
}
postStr += "{\"offset\":\"" + String(i-rtcData.cnt+1) + "\", \"temperature\":\"" + String(rtcData.temperatures[i], 3) + "\", \"voltage\":\"" + String(rtcData.battery[i]) +"\"}";
}
postStr += "]}";
if (http.begin(UPDATEURL)) {
Serial.print("Post string: ");
Serial.println(postStr);
http.addHeader("Content-Type", "application/json");
int httpCode = http.POST(postStr);
Serial.print("HTTP POST return code: ");
Serial.println(httpCode); //Print HTTP return code
if (httpCode>0) {
ret = true;
}
else {
Serial.print("[HTTP] POST... failed, error: ");
Serial.println(http.errorToString(httpCode).c_str());
ret = false;
}
http.end();
}
else {
ret = false;
}
return ret;
}
void setup() {
unsigned long startTime = 0;
Serial.begin(115200);
// Wait for serial to initialize.
while (!Serial) { }
Serial.println("");
Serial.println("Dallas Temperature Sensor Control and post data to server (deep sleep version with RTC memory)");
Serial.print("Reset reason: ");
Serial.println(ESP.getResetReason());
if (ESP.getResetReason() != "Deep-Sleep Wake") {
Serial.println("Non deep-sleep wake. Clearing RTC data storage.");
rtcData.cnt = 0;
rtcData.lastTime = 0;
ESP.rtcUserMemoryWrite(0, (uint32_t*) &rtcData, sizeof(rtcData));
scanWifi();
WiFi.mode(WIFI_OFF);
WiFi.mode(WIFI_STA);
Serial.print("Connecting to ");
Serial.println(ap_ssid);
WiFi.begin(ap_ssid, ap_password);
startTime = micros();
}
if (ESP.rtcUserMemoryRead(0, (uint32_t*) &rtcData, sizeof(rtcData))) {
float temp = getTemperature();
rtcData.cnt++;
rtcData.temperatures[rtcData.cnt-1] = temp;
rtcData.battery[rtcData.cnt-1] = ESP.getVcc() * VCC_ADJUST;
Serial.print("CNT: ");
Serial.println(rtcData.cnt);
if (rtcData.cnt>=MINPOSTCOUNT) {
connect();
Serial.print("Setting NTP time with server ");
Serial.print(NTPSERVER);
while (!setSNTPTime(NTPSERVER)) Serial.print(".");
Serial.println("");
uint32 seconds = time(NULL);
if (seconds != 0) {
Serial.print("seconds: ");
Serial.println(seconds);
Serial.print("rtcData.lastTime: ");
Serial.println(rtcData.lastTime);
uint32 waitSecs;
if (rtcData.lastTime == 0 || rtcData.lastTime+rtcData.cnt*REPORT_INTERVAL< seconds) {
waitSecs = 0;
}
else {
waitSecs = (rtcData.lastTime+rtcData.cnt*REPORT_INTERVAL) - seconds;
}
Serial.print("Waiting ");
Serial.print(waitSecs);
Serial.println(" seconds before posting data");
delay(1000*waitSecs);
seconds = time(NULL);
startTime = micros();
if (sendData(DSAddress)) {
Serial.print("sendData returned true, setting cnt to 0 and lastTime to ");
Serial.println(seconds);
rtcData.cnt=0;
rtcData.lastTime = seconds;
}
}
else {
Serial.println("time function returned 0");
}
}
ESP.rtcUserMemoryWrite(0, (uint32_t*) &rtcData, sizeof(rtcData));
}
else {
Serial.println("RTC Memory read failed");
}
Serial.print("startTime: ");
Serial.print(startTime);
Serial.println(" microseconds");
Serial.print("Entering to deep sleep for ");
if (rtcData.cnt+1<MINPOSTCOUNT) {
Serial.print((REPORT_INTERVAL*1000*1000-(micros()-startTime))*INTERVAL_CORRECTION);
Serial.print(" microseconds and waking up with ");
Serial.println("wifi disabled");
ESP.deepSleep((REPORT_INTERVAL*1000*1000-(micros()-startTime))*INTERVAL_CORRECTION, WAKE_RF_DISABLED);
}
else {
Serial.print(((REPORT_INTERVAL-10)*1000*1000-(micros()-startTime))*INTERVAL_CORRECTION);
Serial.print(" microseconds and waking up with ");
Serial.println("wifi on");
ESP.deepSleep(((REPORT_INTERVAL-10)*1000*1000-(micros()-startTime))*INTERVAL_CORRECTION, WAKE_RF_DEFAULT); //WAKE_NO_RFCAL);
}
}
void loop() {
// put your main code here, to run repeatedly:
}A lényege: kb. percenként méri a hőmérsékletet és a VCC-t, ezeket tárolja RTC User memóriába. A MINPOSTCOUNT-ban meghatározott ébresztés valamivel korábban történik, hogy NTP-n időt szinkronizáljon, így a POST pontosan 10 percenként tud megtörténni (sajnos a deep sleep időmérése valamiért nem túl pontos). A szervernek JSON-ban küldi az adatokat (sensor address, majd a hőmérséklet/feszültség és offset (aktuális időpillanathoz képest időeltolás percben).
2 SSID-t és hozzá tartozó jelszavakat definiáltam, mivel 2 helyszínen szeretnék ledobni ilyen szenzorokat. Így a wifi scan-ból tudja majd a kód, hogy melyik látható a 2 közül és ahhoz csatlakozik.
A percenkénti méréshez wifi bekapcsolása nélkül ébresztem az ESP8266-ot, így kisebb a fogyasztása és néhány ms alatt végez is a méréssel, tárolással. Minden 10. mérésnél (vagy ha valamiért nem tudta POST-olni az adatokat, akkor minden következő mérésnél) wifi bekapcsolásával ébred a korábban említett rövidebb sleep után, csatlakozik a wifi-hez, NTP-n szinkronizál, POST-ol és elrakja RTC memóriába a POST idejét. A következő POST-kor ehhez képest történik a várakozás.Képet most nem készítettem az eszközről, de nekem az ESP8266-ok (ESP-12F) nálam ilyen boardra vannak felforrasztva. Ennek a hátoldalán ott a hely az LDO-nak (ahogy írtam, HT7333-at használok). Az LDO-t beforrasztva az előlapon található középső 0 ohm-os ellenállást le kell forrasztani. Így a board VCC lábára kötött feszültség az LDO-n keresztül jut el az ESP8266-ig, azaz annak VCC-jén már 3.3V fog megjelenni. Ennek megfelelően az ESP VCC lábát kötöttem össze a CH_PD-vel (mert ugye az alaplap VCC-jéről a Li-Ion cella feszültségét kapná, ami induláskor kb. 4,2 V). Az ESP VCC lábáról kapja a feszültséget a DS18B20 is, valamint az ESP VCC és GND lába közé a stabil tápellátás érdekében egy 1000 uF-os kondit tettem. A DS18B20 GND lába GND-re, a DATA lába a GPIO2-re van kötve (ez utóbbit konstansként definiáltam a proggiban). Ennyi a bekötés, nincs semmi varázslat.
Azóta is stabilan megy mindkét példány. Mindenképpen beszámolok, hogy 1 cellával meddig bírja az eszköz. -
_q
addikt
válasz
Janos250
#7392
üzenetére
Régebben nem volt szerintem akkora gond még. Mikor kezdtem az MSP430-as Texas Instruments mikrovezérlőkkel, akkor egyszerűbb volt a portok BIT szinten történő beállítása, legalább is az ESP32-es kóddal összehasonlítva. Persze ott nem is volt lehetőség minden portot mindenféle módban használni.
Ahogy rugalmasabbá válik a programozás (portkezelést mint példa), mellette meg úgy bonyolodik is. Viszont Arduino kerek segítenek megtalálni az egyensúlyt. Egymást kiegészítve jönnek fel párhuzamosan. MSP430 mikor elkezdett terjedni, még nem csak BIT szinten lehetett programozni, ma meg már Arduino keretek között is lehet. Fejlődik ez a terület is, ami nekünk csak jó.
-
Janos250
őstag
válasz
Teasüti
#7383
üzenetére
"Példánál maradva:"
Ha ugyanabból a
hardware\espressif\esp32\cores\esp32\esp32-hal-gpio.c
fájlból a pinMode-ot idézed, még szembetűnőbb a dolog. A 77. sortól a 165-ig tart!
Na, ezekért választom én is az Arduinot. Persze azért fél szemmel lesem azt is, hogy freeRTOS-ben mi van mögötte, illetve, hogy a freeRTOS mögött mi van regiszter szinten. -
Tankblock
aktív tag
válasz
Teasüti
#7383
üzenetére
Hello,
Akkor én felvállalom hogy több mint 1 van ebben az értelemben.
Arduino defacto programozási nyelv --> azaz szépen eltünteti a felhasználó elöl hogy mit is használ, aztán meg ha véletlenül 2 könyvtár ugyanazt az erőforrást használja akkor jön a probléma.
Ugyanaz mint amikor a WS2812 könyvtár RMT használja, meg mondjuk lehetne még használni IR adó vevőnek ugyanezt az erőforrást mert 8 csatornája van ha jól emlékszem,
Én ezért fogtam bele az ESP-IDF be és igen nincs minden dokumentálva, és néha nagyot lehet mellényúlni.
A másik oldalról, meg a fejlesztők ESP-IDF c++ kompatibilis és eclipse alatt lehet c++ is programozni. Akár Arduinos könyvtárat is behúzni / átírni....Vagy csak kevés időmben is mazoista vagyok...
Nem szólnám le ezt sem. Ez mellett szeretem az Arduino-t. Szeretem, hogy kész dolgokat kell csak összerakni és fut. Ezzel spórolhatok időt és az összes ESP8266 home automation erre épül.
Mindegyiknek megvan a szépsége.
-
_q
addikt
válasz
Janos250
#7389
üzenetére
Én STM32-t keil-be programoztam függvénykönyvtárak segítségével. Regiszter vagy alacsonyabb assembly programozás sose vonzott, nem is terveztem használni, tehát ez ennek dokumentált hiányossága nem zavaró számomra.
Így ha jól értem az ESP32 + Arduino kombó nekem való, ráadásul a bluetooth (BLE vagy minden féle bluetooth nem tudom) kommunikációs hiányosságokat eltekintve mindent meg lehet Arduino környezetben valósítani. Meglátom, ha megjön a valóságban mi lesz.Köszi a részletes leírást.
-
Janos250
őstag
Teasüti jól összefoglalta a dolog lényegét, pár dolgot tennék hozzá:
Az Arduino ugyebár egy de facto "programozási szabvány". Azt mondja ki, hogy ha portolják egy kontrollerre, akkor bizonyos függvényeket, osztályokat kötelező az adott kontroller "nyelvén" megcsinálni, ami utána az "Arduino része" lesz. Ez nagyon nagy könnyebbség. Az STM32-re is portolták az Arduinot, elég jó is.
Az ESP32 kissé más, mint a többi:
Először is adott két mag. Azonkívül az általam ismert kontrollereknél a perifériák regisztereit memória címen símán elértem. Többnyire adott volt, hogy melyik periféria melyik lábhoz tartozik. Na, ez az ESP32-nél nem ennyire egyszerű. Bevezettek egy mátrixot, ezen keresztül lehet elérni a perifériákat. Ez nagyfokú rugalmasságot biztosít, mert bármelyik periféria bármelyik lábhoz kapcsolható, de egyben bonyolultságot is, mert meg kell mondanod,hogy mi mihez kapcsolódjon. Aztán, hogy még bonyolítsuk a dolgot, a perifériák alapállapotban "alszanak", pl. órajelet se kapnak.
Így még a hozzá tartozó regisztereket se tudod se írni, se olvasni. Először kell nekik órajelet adni, és resetelni, utána írhatók, olvashatók a regiszterei. Az órajel adás és a resetelés elvileg egyszerű: elérhető regiszterekben az adott perifériához tartozó bitet kell beállítani órajelhez, illetve törölni a resethez.
Igen ám, csakhogy az ESP azt nem mondja meg, hogy melyik perifériához melyik bit tartozik. Sebaj, kinézzük az illesztő programokból, gondolja Móricka. Viszont az illesztő programok lefordított assembly programok, aminek a forráskódját az ESP nem hozta nyilvánosságra eddig. Tehát a processzor közeli programozás még egy ideig macerás lesz. Az Arduino rendszerben viszont minden elég jól ki van dolgozva.
Tehát:
Az ESP megcsinálta az alapvető kezelést biztosító assembly nyelvű rutinokat.
Erre épülve készült el rá a freeRTOS. Ezt használja az IDF is. A freeRTOS-ra épülve portolták az Arduinora.
A freeRTOS függvényeit - általában - Arduino rendszerben is lehet használni, hiszen az Arduino "szabvány" függvényei is ebben íródtak.
Összefoglava:
Arduinoban programozása kényelmes, nagyon gyors, rengeteg a periféria, a két mag más programozási technikákat is lehetővé tesz, de ha processzor közeli módon akarod használni, az azért még jelenleg szívás. -
-
Janos250
őstag
válasz
ngabor2
#7385
üzenetére
Én ezt így oldottam meg:
https://www.aliexpress.com/item/Mantistek-WR300-Wifi-Router-Repeater-802-11N-B-G-Computer-Networking-Range-Expander-Wireless-300M-Roteador/32797460376.html?ws_ab_test=searchweb0_0,searchweb201602_5_10152_10065_10151_10344_10068_5000016_10345_10342_10343_10340_5060016_10341_5130016_10541_10084_10083_10304_10307_10302_10539_10312_10059_10313_5080016_10314_10534_100031_10604_10603_10103_10605_10594_10596_10142_10107,searchweb201603_31,ppcSwitch_5&algo_expid=207c876a-062e-40dd-9580-789d0625f104-2&algo_pvid=207c876a-062e-40dd-9580-789d0625f104&rmStoreLevelAB=1
Az egész házban mindenre van erős WiFi.Szerk: most vettem észre, hogy a készülék házról beszélsz. Arra persze nem jó, de azért a linket hagyom, hátha valakinek gyenge WiFi gondja van, mert arra nekem nagyon bevált.
Ehhez adnak antennát, de csatit nem látok a panelon. Pedig tényleg jó lenne bizonyos esetekben.
https://www.ebay.com/itm/4-MB-Flash-WEMOS-ESP-32-Lolin32-CP2104-WIFI-Bluetooth-Card-2-4G-SMA-Antenna/322918312671?hash=item4b2f6e6adf:m:mZNqIunaMOUkNkwzeHbjrCg -
ngabor2
nagyúr
Én is kacsingatok az ESP32 felé. Viszont ebből egyáltalán nem, ESP12-ből is elvétve lehet találni olyat, amire külső antennát lehet csatlakoztatni. Ez zárt fém háznál viszont igen hasznos tud lenni.
Rá lehet valahogy mégis tenni, vagy könnyebb elrontani mint jól megcsinálni?
-
_q
addikt
válasz
Teasüti
#7383
üzenetére
Köszi a részletes leírást. Tetszett a fogalmazási stílus, 1-2 mondaton jól felmosolyogtam, természetesen jó értelemben
és tudtam azonosulni azzal amiket írtál.STM32-t, TI launchpadokkal van kevéske tapasztalatom, de azt látom, hogy egyre jobban jönnek fel a mindent függvénnyel, illetve arduino módszerrel (nem tudom ennek mi a pontos neve, tehát hogy ne kelljen mély C tudás, említett példa: digitalRead() ) programozzunk lehetőségek és nekem ez tetszik is. Vannak területek ahol fontos a minél kisebb kód, és optimalizált megoldás, de a mikrovezérlők teljesítmény növekedésével egyre kevésbé fontos, így szerencsére mindenki meg tudja találni a maga számára elegendő C tudást igénylő kontrollert. Emellett STM32-t se zárom ki, nekem az is tetszett, de most kicsit az arduino jellegű programozás foglalkoztat.
Egy a nehéz, projektet kitaláljak magamnak ami hasznos is, esetleg kicsit tanulni is lehetne belőle, de még is nem annyira nehéz, hogy fogjam a fejem, hogy most ez mi
Erre neten szerencsére vannak ötletek.Szóval még egyszer köszi, maradok a topicnál, sok jó dolgot lehet is olvasni és jó látni, hogy sok a segítőkész fórumtárs
-
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. -
_q
addikt
válasz
Janos250
#7354
üzenetére
Olvasgattam kicsit. Azt íták, hogy az ESP IDF környezetben lehet a leginkább kihasználni az ESP32-t. Arduinot fejlesztgetik, ezzel is használható, de elsődlegesen nem ez az ajánlott.
Én Arduino IDE környezetben szeretném a programozást megoldani. Kérdésem az, hogy mit tapasztaltatok, milyen funkció nem az igazi, mi nincs implementálni ami miatt nem használható ki az ESP32?
-
vargalex
félisten
válasz
vargalex
#7023
üzenetére
Jelentem, 1 hete szépen megy 2 példány az ESP8266+DS18B20 RTC-s megoldásból. Végül azt választottam, hogy minden 10. mérésnél kicsivel hamarabb ébresztem a cuccot deep sleep-ből, szinkronizálok NTP-n, ha kell, akkor várok és post-olok. Természetesen RTC-be az NTP időt (unix timestamp) is leteszem, hogy tudjak mihez viszonyítani a következő post-kor. Az ESP-vel mérem a feszültséget is (getVcc függvénnyel), amit 10 percenként tárolok, de ugye ez a HT7333 által már csökkentett feszültséget méri. Ez nyilván nem változott az indulás óta. Azért rámértem multiméterrel is, most 4,15 V a cella feszültsége. Sajnos induláskor nem mértem, hogy megvolt-e a 4,2V, így sokat még nem jelent. Illetve mindkét példány bontott (Lii-500 szerint kb. 2000 mAh-s példányok) notebook akkuból származik. Kíváncsi vagyok, hogy meddig fog üzemelni (figyelem a mért feszültséget, 2,8-2,9V körül majd cserélem). Ha érdekel valakit, szívesen megosztom a kódot, illetve bekötést, valamint képet is csinálhatok, bár még a kinézet szépsége nem volt cél.
-
_q
addikt
válasz
Tankblock
#7369
üzenetére
Köszi. Végül egy külső tápcsatis nélkülit rendeltem. Ha esetleg kell akkor magam beforrasztok egy csatit pluszba.
Addig is míg megjön. Tudtok ajánlani oldalt, amit érdemes olvasgatni ESP 32S-el kapcsolatban? Kezdve az arduino környezet beüzemelésével, ahol adatlapot találok a development board-ról, esetleg hasznos kiinduló minta példákat tartalmazó oldalt?
-
-
-
Végre megcsináltam a 2 kerekes autóm, bluetooth távirányítással. Egyrészt nagyon király, hogy működik, de sajnos nem sokáig működik. Valami mindig szétmegy, legtöbbször a bluetooth modul veszti el a kapcsolatot. De gyakorlatilag bármi bármikor, kereke leeseik, jumper kábel leugrik a helyéről... Tipp? Fixáljak le mindent folyékony ragasztóval?
-
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.
-
CHIPman
nagyúr
Üdv.
Már régóta van egy címezhető RGB led stripem, viszont 3 bemenetű, "+", "data" és "-". Értelemszerűen 5V-os. Nem találtam még olyan leírást, ami ehhez lenne írva, mindenhol a 4 bemenetűt látom.
ESP eszközeim vannak, minimálisan konyítok hozzá, de eddig még nem sikerül működésre bírnom a ledeket. (Nem címezhető stripet mosfettel már vezéreltem gond nélkül ESP-ről, csak ez nem megy.) Dolgozott már valaki ilyennel? -
_q
addikt
válasz
Janos250
#7348
üzenetére
Köszi a részletes leírást. Ezek szerint minimális eltérés van, pl.: Wemos tesz rá egy külsö táp csatlakozót is mint ami a lentebb képen látható és 1 reset gombot (ami szemmel látható különbség elsőre). WROOM esetén nincs külső táp csatlakozó, de van egy plusz gomb, gondolom programozható. Szignifikáns külnbség nem nagyon van közöttük. Illeve ide jöhetnek még az OLED kijelzős verziók, ahol már kicsivel nagyobb lábkiosztás vagy egyéb eltérések is felléphetnek.
Arduino-t akartam először a programozási könnyebbség miatt, de mivel ESP32 teljesítményben illetve modulokban is jobb, olcsóbban, így gyorsan tovább is léptem az arduino-n. Köszi a linkeket, valószínűleg ezek közül választok.Tankblock
Neked is köszi az észrevétel. Ha jól értem akkor a képen jelölt külső aksi/táp csatlakozóra érted, hogy fel van cserélve a VCC-GND kivezetés?
-
Janos250
őstag
válasz
Janos250
#7348
üzenetére
Még annyit, hogy itt látható, mi van ez ESP-WROOM-32 hibrid chipben:
https://github.com/boseji/ESP-Store/blob/d80a4bafb5d0d2b9f78954681f995429110383d6/Ref-Designs/ESP-WROOM-32/SCH/sch.pdf
De ha magadnak akarsz gyártani
, a gerber adatok is megvannak:
https://github.com/boseji/ESP-Store/commit/d80a4bafb5d0d2b9f78954681f995429110383d6 -
Janos250
őstag
Én most nem tudok olcsót, általában min 1500 Ft körül vannak.
A verziók gyakorlatilag megegyeznek. Az ESP32 ugyebár az alap chip. Amikor ez megjelent, akkor pár gyártó gyorsan el is kezdett vele lapot gyártani. Mivel nagyon vártam az ESP32-t, én is rendeltem gyorsan tavaly ősszel 9000 Ft-ért egy ilyen panelt, ami azóta is a fiókban hever. Akkor még nem volt megfelelő támogatás hozzá.
Igen gyorsan megjelent az ESP32S, ami egy hibrid tokozás fém tokban, tartalmazza az ESP32 chipet, flash memóriát, és még pár alkatrészt. Aztán gyakorlatilag ugyanezt elkezdte gyártani az Espressif is, ESP-WROOM-32 néven. Ma már ez gyakorlatilag egyeduralkodóvá vált, ezt érdemes venni. Amit ESP32S megjelöléssel hirdetnek, ma már azok is általában ezt tartalmazzák.
Pl.: https://www.ebay.com/itm/ESP32-ESP32S-CH340G-Development-2-4GHz-Dual-Mode-WiFi-Bluetooth-Module-Antenna/282633370924?epid=866775664&hash=item41ce42fd2c:g
eMAAOSwv-ZZ9YZE
Én pl. ezeket használom, mert szeptember elején ezeket lehetett 1200 Ft körüli áron megvenni. Nem volt vele gondom:
https://www.ebay.com/itm/ESP-32S-ESP-32-Development-Board-2-4GHz-Dual-Mode-WiFi-Bluetooth-Antenna-Module/302252239864?hash=item465fa32bf8:g3kAAOSwTM5Yx~38
A különböző gyártók által gyártott lapok között nem különösebben lényeges az eltérés. A lábaknak a panelra írt elnevezése különböző, de azt általában tartalmazza az Arduino IDE, ha a megfelelő panelt választjuk ki.
A hardware\espressif\esp32\boards.txt fájlban láthatjuk, mennyi féle laphoz van meg a saját támogatás, de az ESP32S-et választva se szokott gond lenni. A lábak elnevezése, stb. a hardware\espressif\esp32\variants könyvtárban található verzióként.
USB mindenképpen legyen rajta. Az USB chipek közül ki melyiket szereti, az ízlés kérdése. Megfelelő driverrel mind jól működik tapasztalatom szerint. -
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. -
Jofi81
őstag
Még sosem használtam Arduino-t, most szeretnék vele megismerkedni. Néztem ezt az ingyenes 60 napos tanfolyamot. Ha valaki ismeri, akkor esetleg meg tudná mondani, hogy ez a starter kit elég-e a tanfolyamhoz vagy meg kell vennem ezt a TávIR-tól? Köszönöm!
-
-
Janos250
őstag
válasz
Janos250
#7317
üzenetére
Korrekció:
"A priorításokat is hiába variáltam, gyakorlatilag mindegy volt, hogy 1-es, vagy 24-es (25 a max) volt."
Nem 25 a max, hanem 24. (25 db. szint van, de a nullás is beleszámolandó)
Tehát 0 a legalacsonyabb prioritás, 24 a legmagasabb. (lehetne variálni, de minek) -
Tankblock
aktív tag
válasz
Teasüti
#7329
üzenetére
Hello,
Tasknál, ha van a végén vTaskDelete( xHandle ); és megfelelően magasra állítod a priorítását akkor nem tudod megölni sem...
ha csak meghívod 1000x akkor el fog fogyni a stack / memória akkor a xTaskCreate() fvg visszatér egy szép hibával:
errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY
Értem, így pont nem használod ki a HW képességeit. Ha az RTM használod erre akkor nem kellene delayel szórakozni....
Egy Queue ba bedobálni a mintákat az meg a RTM rakja a mintát.....
Bár nem ismerem a feladat részleteit..... -
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. -
Tankblock
aktív tag
válasz
Teasüti
#7312
üzenetére
Hello,
Ha jól emlékszem, akkor külön task ID fog kapni és fog párhuzamosan futni n-szer is.
Amit leírtál az tervezést igényel.
SW megoldásként : a megszakításban kellene viszgálni, hogy mikor volt utoljára meghívva az interupt és ha az idő megfelelően nagy csak akkor végigfuttatni a megszakítás logikáját.
Vagy
Perlmentesíteni HW esen,
Delay miért kell? nem lehet másképpen megoldani? pl Queue v xEventGroup (ez nem tudom, h implementálva van-e ESP32 FreeRTOS ra.) Vagy Taskot suspendedbe tenni és felkelteni amikor kell....
-
#7327
Oryctolagus
tag
Oryctolagus
tag
Üdv!
Korábbi projektem kissé megakadt idő hiányában.
Tehát képen látható orosz csodát szeretném modernizálni ezzel a kóddal ami egyelőre kicsit túl mutat rajtam.
Amikor elindítom egy ideig semmi gond nincs aztán, halk búgás hallható ami később erősödik.
Ekkor kikapcsoltam azon nyomban.
Nem kellene a motor lábaira kondenzátor? Hogyan méretezik azt?
A motorshield lábait lelehet vágni, azokat amelyek a arduino boardról tápfeszt kapnának?
A gondom az ezzel, ami már korábban írtam. A z usb portról akarja táplálni a motorshieldet is hiába van külső tápra jumperelve. Amikor kipróbálnék valamit a programban és feltölteném folyton össze kell dugni a két lapot elkerülendő az anomáliákat. Például az egér is lekapcsolt mér emiatt egyszer.Köszönöm!
-
Janos250
őstag
válasz
Teasüti
#7320
üzenetére
Nem a számolással van gond, mert mint írtam rá az assembly sort, azzal le lehet kérdezni a számlálót, ami egy másodperc alatt 240 milliószor lép, tehát igen nagy felbontású. Ez az utasítás behelyezhető egy C++ programba egy utasításként, tehát kényelmes magas szintű nyelven is.
-
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. -
-
Janos250
őstag
Na, akkor lássuk konkrétan, hátha mást is érdekel:
Láttam, hogy Teasüti egy kész könyvtárat használt a WS2812 led szalag vezérlésére. Innen jött az ötlet, hogy - játékból - kipróbáljam, hogy az elég bonyolult kész program helyett a "kézzel" való vezérlést használjam.
Ennek a szalagnak a vezérlése úgy történik, hogy a szalag minden egyes ledjéhez kiküldjük a saját színét, 24 biten. A kiküldés bitenként megy: pl. a 400 nanos hoszú impulzus jelenti a "0" értékű bitet, a 800 nanos az "1"-et.
Ha beállítok egy lábon magas sztintet, akkor ha ez 0 értékű bit, akkor 400 nano múlva kell levinnem alacsony szintre, ha 1 a bit értéke, akkor 800 nano múlva. Ezt kell ismételni a szalag minden egyes ledjére sorban egymás után, ahogy a szalagon vannak. Egy led színe 24 bit, tehát egy 100 ledből álló szalagra 2400 db. - az egyes led kívánt színei szerint - különböző hosszúságú impulzust kell kiküldeni.
Viszont, ha egy 400 nanos impulzus középén jön egy megszakítás, akkor mire "visszatér" a task, az már akár 800 nanos is lehet, tehát hibásan másik bitként értelmezi a led.
Na, ez talán a legtipikusabb példája az ESP32 "RTM" funkciójának. Az egyes impulzusok adatait feltöltöm egy megadott memória területre, és ráeresztem a hardvert, ami teljesen önállóan kiküldi ezeket az impulzusokat, igen nagy pontossággal, mert 15 biten írom le az impulzus hosszát. A 16. bit jelzi, hogy a megadott ideig L vagy H szinten kell lenni az adott lábnak.
Ezt nevezi az ESP32 RTM-nek. Eredetileg az infrás távvezérlők szimulálására ajánlják, mert lehet úgy programozni, hogy egy magasabb vivőfrekvenciát moduláljon az adott hosszal.
Tehát - mint írtam - nem egy élő projekt problémájáról van szó, hanem kíváncsiságról. -
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. -
Janos250
őstag
válasz
Teasüti
#7315
üzenetére
Na, de ha pl. egy 500 nanos jelet akarsz kiküldeni kézzel, akkor beállítod a pint 1-re, aztán figyeled az időt és 500 nano múlva átteszed 0-ba, de lehet, hogy közben megszakít, és akkor az már nem 500 nano lesz! Mivel gyors a proci, ezért menne így, kézzel is, ha biztosan nem lenne szaggatás. Elvileg persze le lehet tiltani a megszakítást, de hiába tiltottam le, akkor is közbejön néha egy pici szaggatás. Próbáltam az egyéb taskokat is leállítani, de nem jártam sikerrel. Tehát, ha valamire NAGYON GYORSAN kell válaszolnod, az nem biztos, hogy nagyon gyors lesz. Tudom, persze, használjunk RTM-et, PWM-et, vagy interruptot, de a kíváncsiság hajtott.
Elvileg "until"-os időzítés is van, de nekem azzal se jött össze. A priorításokat is hiába variáltam, gyakorlatilag mindegy volt, hogy 1-es, vagy 24-es (25 a max) volt. Még jó, hogy csak kíváncsiságból játszogattam vele, nem éles dologban. -
Janos250
őstag
válasz
Teasüti
#7312
üzenetére
Hát, ezt éppen nem próbáltam. Elég érdekes ez a két mag, több task rendszer. Azért pár dolgot leírok, nem Neked, hanem azoknak, akik még most kezdik. Automatikusan a core1-re megy a loop. Azt úgy lehet áttenni a core0-ra, ha megkeressük a main programot, és átírjuk benne 0-ra. Megy, bár lehetnek gondok, pl. mindkét magnak - úgy tűnik - külön számlálója van, ezért vigyázni kell az időzítésekkel. A számlálót ezzel lehet olvasni:
__asm__ __volatile__("esync; rsr %0,ccount":"=a" (CycleCount32));
Ez 240 MHz-el jár, de csak 32 bites, ezért tizen.. másodpercenként átfordul. Én csináltam hozza egy 64-bitest, az már az unokám életében sem fog átfordulni. Viszont, mivel gyors, finom időzítéseket lehet vele csinálni. Elvileg. Ugyanis hiába próbálunk mindent átrakni a core1-ről a 0-ra, akkor is szaggat valami. Talán a saját szoftver számlálója, amit az xTaskGetTickCount()-al lehet olvasni. A 240 MHz-es számlálót írni lehet, de ne írd, mert megbolondul az időzítés. Hogy pontosan mi hol fut, azt nem lehet tudni, mert a vTaskList nem működik. Meg a statisztika sem. A taskok számát le lehet kérdezni, de nem sokra mentem vele, hogy tudom, hogy nálam 7 task van, amiből háromról tudom, hogy mi, a többiről nem. A taskról információt akkor lehet lekérni, ha tudjuk a "nevét". Na, ezt nem tudjuk. Az IRAM-ba rakással is vigyázni kell, mert amit oda pakolunk, csak az egyik magon futtatható. Na, így egy szuszra ennyit.
Egyébként, ha a specialitásait nem akarja kihasználni az emberfia, akkor nagyon jó kis proci, ajánlom mindenkinek. Két mag, gyors, multitasking, de hiába freeRTOS, nem igazán RT (real time), a már említett okok miatt. Előbb-utóbb csak megoldja valaki, hogy a core1-en ne legyen szaggatás, de ezt még a neten is keresik.
Ha mondjuk egy UNO-n futó programot teszünk rá, akkor természetesen ilyen gondok nincsenek, csak annyit tapasztalunk, hogy megy mint a szélvész. Ajánlom is mindenkinek, hiszen alig drágább mint egy kínai UNO, az eredeti UNO árából meg féltucatot vehetünk.
Neked:
Kíváncsiságból megnéztem az RTM kezelést, de csak megnéztem, mert elég macerásnak tűnik első látásra, pedig nagyon jó lenne. Berakja az ember egy külön memória területre az adatokat (1 bit, hogy hi vagy low, és 15 bit a hossz, az időzítés), és utána elindítja, és a hardver sorra veszi ezeket a 16 bites (32= 2*16) adatsorokat és öntevékenyen kiküldi a "PWM" jelet.
Az eredeti kérdésedhez: a static változókra mindenképpen vigyázz, mert az közös! -
#7313
Spuri2000
senior tag
kormoskandur
#7305
Spuri2000
senior tag
válasz
kormoskandur
#7305
üzenetére
Árat is adj meg.
-
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! -
ok, köszi! Rákötöttem a shield v5 soros portjára. A telefont engedi is kapcsolódni, de semmit nem reagál a robot. Próbáltam több alkalmazással is. (bluetooth rc controller, meg a bluetooth conroller) Az a lényeg, hogy nagybetűket küldök soros porton: F:előre, B:hátra, L:balra, R:jobbra, W:ledek be. Bluetooth terminál van a 2. appban, azzal se csiál semmit.
Ha usb-n van az arduino (bluetooth kihúzva) és a soros monitoron keresztül küldök neki parancsokat, akkor az működik. Ha bluetoothon keresztül, akkor meg semmi. (usb kábel kihúzva, arduino ki-bekapcsolva) -
-
A shield v5-öt szeretnék használni bluetooth hc05 modullal. A shield v5-ön van bluetooth foglalat, de annak mi a címe? Hogy érem el a rajta levő d0 d1 pint? Van rajta több d0 d1 pin is, mert a wifi csatlakozónak is az a neve.
-
#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.
-
#7305
kormoskandur
tag
kormoskandur
tag
új arduino cuccok eladók
-
dzz
aktív tag
válasz
Janos250
#7301
üzenetére
Én linuxon élek már a 90-es évek közepe óta, szeretek mindent parancssorból intézni. Pl. az openwrt-nek megfelelő shell képességei vannak, valami ilyesmire gondoltam ESP32-n, tehát nem a PC oldalról hanem az eszközön magán. Mondjuk kicsi a memória minden ilyesmire, de csak feldobtam a kérdést, még nem jártam rendesen körbe az ESP képességeit csak meglepett, hogy mennyivel több a korábbi Arduino-s kütyüimnél
és tudtam azonosulni azzal amiket írtál.
Erre neten szerencsére vannak ötletek.
eMAAOSwv-ZZ9YZE
, ha 21C főlé akkor 
Meg gyakran a Microchip PIC-et is
Új hozzászólás Aktív témák
Hirdetés
ekkold
- GOPRO Hero 11 BLACK - 5.3k akciókamera - 2 akku, tartozékok (5.)
- DJI AVATA 2 Fly More Combo 1 akku - drón szett DJI Goggles N3 FPV szemüveggel
- Sony PlayStation 5 ( PS5 ) Sony PlayStation VR2 Csomag
- Dell Precision 7680 Eco FHD+ 13600HX 14C / 16G D5 / 1T G4 workstation
- Gigabyte GA-Z68A-D3-B3 LGA 1155 alaplap
- BenQ PD-2700-U Monitor - Designer 4K 27"
- BESZÁMÍTÁS! Samsung Odyssey G5 32 144Hz WQHD 1ms monitor garanciával hibátlan működéssel
- LG 27GR95UM - 27" MiniLED - UHD 4K - 160Hz 1ms - NVIDIA G-Sync - FreeSync Premium PRO - HDR 1000
- Országosan a legjobb BANKMENTES részletfizetési konstrukció! Vásárolj okosan, fizess kényelmesen!
- Lenovo Thinkpad T14 üzleti i5-10310u 10th gen. 8-32Gb RAM 256GB-1TB SSD gar.
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: CAMERA-PRO Hungary Kft
Város: Budapest