- Gurulunk, WAZE?!
- D1Rect: Nagy "hülyétkapokazapróktól" topik
- Argos: Szeretem az ecetfát
- sziku69: Fűzzük össze a szavakat :)
- eBay-es kütyük kis pénzért
- Luck Dragon: Asszociációs játék. :)
- zebra_hun: Hűthető e kulturáltan a Raptor Lake léghűtővel a kánikulában?
- Parci: Milyen mosógépet vegyek?
- gban: Ingyen kellene, de tegnapra
- Kempingezés és sátrazás
-
LOGOUT
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
-
vargalex
félisten
-
vargalex
félisten
válasz
ZTE_luky
#9167
üzenetére
"Tehát akkor nem probléma hogy arduinón fut a szalag árama is? tehát hogy csak usbről kap áramot az arduino, is minden azon fut át? mert ugye a rajz elcsal annyit hogy a szalag nem közvetlen az áramforráshoz van kötve hanem az arduinóról kapja az 5V-ról"
Most lehet, hogy félreértek valamit, de a rajzon az arduino és a szalag is közvetlenül az áramforrásra van kötve. Az arduino is az 5V-os lábon van megtáplálva, nem USB-n. USB-n táplált arduino 5V-os lábáról nem valószínű, hogy számodra elegendő teljesítmény vehető ki.
-
-
vargalex
félisten
Elbénázták a redirect-et. A http://jlcpcb.com át van irányítva a https://jlcpcb.com-ra, ami pedig a https://jlcpcb.com:443-ra, ami ugye önmaga. Innentől végtelen rekurzió...
Szerk.: Úgy látszik, éppen javítják, már bejön CSS nélkül.
-
vargalex
félisten
Ahogy írtam, amiről a képet készítetted az a WAN, azaz Wide Area Network (tehát a routered külső lába, amin az internet felől látszik). Az most más kérdés, hogy a Digi a WAN oldalra is privát IP címet adott neked (100.x.x.x tartomány), tehát ezt az internet felől sehogy nem fogod elérni (lehet, hogy nem is akarod, tehát nem biztos, hogy gond neked).
A belső kliensek (legyen az vezetékes, vagy vezeték nélküli) a LAN, azaz Local Area Network-hoz kapcsolódnak, azaz abból a tartományból kapnak IP-t.
Ezek egy része a wifi kliensek, WLAN
A Wifi kapcsolat a WLAN, azaz Wireless Local Area Network, ahogy írtam a LAN része.
Remélem így tisztább lesz.
-
vargalex
félisten
Vannak, akik rendelkeznek ilyen műszerrel, ők mérték. Youtube-on is lehet róla videót találni. Nekem sincs, így én elhiszem. És természetesen a lényeg, hogy deepSleep hívás után ne húzd semmivel LOW-ra az RST lábat. Majd a timer lejártakor a GPIO16 LOW-ra állításával reset-eli a boardot.
Tuti működik, hiszen a percenként hőmérsékletet mérő cucc 1 Li-Ion cellával (notebookból bontott) elmegy 90+ napot.
-
vargalex
félisten
Nem teljesen értem a különbséget. Nyilván, Arduino alatt megnézed egy bemenet állapotát, majd csinálsz valamit. Miért foglalkozna vele, ha közben változott, hiszen a további programkódban már nem függ tőle semmi. Ha neked mégis úgy kellene, akkor mindig nézd meg az állapotot, ahol a futás függ tőle (esetleg használj megszakításokat).
Bár ezt a ciklus elején vs. beolvasás témát kifejthetnéd...
-
vargalex
félisten
-
vargalex
félisten
válasz
Tankblock
#8748
üzenetére
Én a hőmérőmnél éppen a második megoldást alkalmazom. Így le tudom dobni itthon/édesanyámnál/cégnél és mindhárom helyen működni fog.
Persze, mivel deep sleep megoldást használok, így csak a nem deep sleep-ből történő ébresztéskor scannelek és letárolom, hogy melyik SSID került kiválasztásra. De nem kell hozzá AP mód... -
-
-
vargalex
félisten
válasz
Teasüti
#8613
üzenetére
Látom, meglett a megoldás. Az ok pedig szerintem az, hogy C-ben változó (így ugye a buff tömböd esetében is) deklaráláskor nincs inicializálás. Egyszerűen egy memória területre fog mutatni, amiben valamilyen érték lesz. Érdemes kézzel inicializálni akár az általad használt módon, akár a
bzero(buff, sizeof(buff));hívással.
Szerk: Látom, ezt már megbeszéltétek. Én azt gondolom, hogy bootkor inicializálja a memória területeket (vagy ugye teljes áramtalanításkor elveszti úgyis a tartalmát), amiből serial print-kor fog még felhasználni (majd felszabatítani úja inicializálás nélkül), míg debug nélkül nem. Azaz debug esetén más lesz ugyan azon a RAM területen, mint nélküle.
-
-
vargalex
félisten
Szia!
Mindhárom eszközön ugyan az a kód fut? Ezt a doksit érdemes egyébként elolvasni. Konkrétan arra a részre gondolok, hogy az ESP8266-on alapban engedélyezett a Modem sleep mode kliens módban, ami ugye lekapcsolja a WiFi modult 2 DTIM Beacon intervallum között, ha nincs rajta forgalom. Nyilván, ha ilyen állapotban ping-eled, akkor előbb fel kell, hogy ébressze...
-
vargalex
félisten
válasz
Janos250
#7927
üzenetére
Szintén fehér panelra forrasztott ESP-12F-el oldottam meg a low power hőmérőt. Az alacsony fogyasztás miatt nem is lehet megoldani Wemos/NodeMCU-val. Jelen pillanatban már 88 napja megy mindkét példány folyamatosan, hiba nélkül. Lassan viszont cserélnem kell a cellát, mert már az ESP-n mért feszültség 3 V környékén van.
Viszont mindenképpen elégedett vagyok, szerintem teljesen korrekt lett ez az üzemidő egyetlen cellával percenkénti hőméréssel. -
vargalex
félisten
Mit tárolsz te 19 oszlopon? Nálam összesen 4 oszlop van, amiből 1 (unix timestamp) csak a group by gyorsítására van (és egy trigger tölti):
CREATE TABLE temperatures (
sensor_id mediumint(9) NOT NULL,
datum timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
temperature decimal(5,3) NOT NULL,
u_timestamp int(11) DEFAULT NULL,
KEY idx_temp_date (datum),
KEY idx_temp_sensor (sensor_id),
KEY idx_sens_date (sensor_id, datum),
KEY idx_sens_u_ts (u_timestamp, sensor_id),
CONSTRAINT temperatures_ibfk_1 FOREIGN KEY (sensor_id) REFERENCES sensors (id) ON DELETE CASCADE ON UPDATE CASCADE)
ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_hungarian_ci;Esetleg nálad egy rekord az egy időpont az összes szenzor által mért adattal?
-
#7639
vargalex
félisten
DrojDtroll
#7638
vargalex
félisten
válasz
DrojDtroll
#7638
üzenetére
Lehet, hogy valamit töröltem a percenkénti részletességet tartalmazó táblából (ami ugye fizikailag nem szabadít fel helyet), mert a 10 perces felbontást tartalmazó tábla csak 92 MB. Ezek alapján kicsit kisebb lehetne a teljes...
-
#7637
vargalex
félisten
DrojDtroll
#7636
vargalex
félisten
válasz
DrojDtroll
#7636
üzenetére
Jelenleg 9664778 rekord van a fő táblában, ennek mérete 1,2 GB. Ezen kívül trigger tölti a 10 percenkénti, óránkénti, 4 óránkénti, 12 óránkénti és napi összesítő táblákat, amiket a gyors megjelenítés miatt hoztam létre. A teljes adatbázis mérete 1,4 GB.
Fokozatosan jöttek a szenzorok (most sincs sok, csak 8). Az első tárolt mérés 2014.04.30 11:22:02-kor történt.Persze, ha nem szükségesek teljes részletességgel a régi adatok, akkor inkább RRD adatbázist érdemes készíteni. Nekem az egész MySQL-ben van. Így bármelyik időszeletre rá tudok nagyítani percenkénti részletességig.
-
vargalex
félisten
Én a különböző eszközök mérését egymással nem szinkronizálom, csak azt akartam elérni, hogy egy mérő lehetőleg mindig ugyan abban a másodpercben küldjön értéket (ne legyen olyan, hogy 1 percben 2 mérést küld, vagy 1 perc kimarad). A megjelenítésnél viszont percre kerekítek, így látszólag minden eszköz azonos időpontban mér, a szerverre küldés viszont eloszlik, így nem egyszerre kapcsolódnak.
-
vargalex
félisten
válasz
ratkaics
#7625
üzenetére
Hasonló elképzeléssel valósítottam meg a low power ESP8266 alapú hőmérőt. A cél a minél alacsonyabb fogyasztás volt. Az eszköz (jelenleg 2 példányt raktam le a lakásban) egyetlen Li-Ion celláról működik, ami így 42 nap folyamatos működés után 3.8 V-on áll. A pencenkénti hőmérést figyelembe véve azt gondolom, hogy eddig elégedett lehetek. Természetesen mindenképpen beszámolok, hogy meddig bírta (az ESP8266 miatt kb. 3V-ig hagyhatom merülni).
A kódot itt találod. A DS18B20 kiolvasása egyszerűen cserélhető bármilyen másik szenzorra. -
vargalex
félisten
Miért String-ként hasonlítod? Szerintem így kellene:
if (incomingByte == 0xB7) {Legalábbis, ha jól értem a problémádat. A serial.read byte-ot ad vissza, FF-ig jó vagy. Vagy 2 byte-on jön a B és a 7? Ha több byte-ban érkezik, akkor ciklusban kell byte-onként beolvasni és összerakni.
-
vargalex
félisten
válasz
Teasüti
#7523
üzenetére
A ws2813-at a pixelhibák miatt javaslod (ugye itt csak a hibás led nem fog működni, a mögötte lévőket nem befolyásolja)?
Elsőre egy hyperion-t (ambilight) próbálnék ki. Ehhez 60 led/m szalagot javasolnál, vagy kevesebbet?
Illetve lehet, hogy a gyerekeknek valami ébresztő napfelkelte "szimulátort" csinálok majd. -
vargalex
félisten
válasz
fpeter84
#7454
üzenetére
Én is gondolkodtam a deep-sleep-el megvalósított energiatakarékos hőmérő megoldasomnál, hogy a DS18B20-nak valamelyik GPIO-ról adok VCC-t, de egyrészt egyébként is minimális a fogyasztása, másrészt időm nem volt még utánaolvasni/tesztelni, hogy mennyivel kellene előbb feszt adni neki, hogy a mért érték kinyerhető legyen belőle. Ez utóbbi idő bármekkora is, sokat vesztenék azzal, hogy ezalatt nem deep sleep-ben van az ESP8266. Így én ennél a projektnél elvetettem.
Persze, ha nem a minél alacsonyabb fogyasztás a cél akkor abszolút korrekt megoldásnak érzem én is, ha az esp8266 által biztosított áramerősség elegendő. -
vargalex
félisten
válasz
gyapo11
#7432
üzenetére
Mivel a topictárs áramkört kérdezett, én ezt javasoltam volna tegnap azonnal, amivel tapasztalatom is van, de aztán vettem észre, hogy nem Li-Ion cellát, hanem Li-Po-t írt...
Persze, ha nem modul kell, akkor a Liitokala nagyon jó, nekem is van egy Lii-500 és egy Lii-100. Előbbi most kuponnal elhozható a Gearbest-ről $13-ért (teljes verzió, azaz hálózati és autós adapterrel). -
-
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. -
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.
-
#7270
vargalex
félisten
jrdani2001
#7269
vargalex
félisten
válasz
jrdani2001
#7269
üzenetére
De mire kellene bele az arduino?
-
vargalex
félisten
válasz
Janos250
#7261
üzenetére
//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 0xC0Biztos?
-
vargalex
félisten
válasz
Victoryus
#7096
üzenetére
Ha a korábban általad linkelt készletben lévő szenzorról van szó (amiről itt is raktál képeket), akkor az nem beszélget soros porton, hanem az Arduino beszél veled. A távolságot is a kód számolja az echo pin magas állapotának hosszából. A soros monitoron beállítandó baud rate pedig a lap által támogatott baud rate-októl, illetve ezek közül a Serial.begin paramétereként megadott baud rate-tól függ.
-
vargalex
félisten
Sziasztok!
Kis ötletelésre / tapasztalatra lenne szükségem.
Úgy gondoltam, hogy ledobok (még) néhány ESP8266-ot DS18B20-al a lakás különböző pontjaira. Ezek nem feltétlenül olyan helyen lennének, ahol elérhető valamilyen konnektor, így akkus táplálásra gondoltam. Ezt 18650-es cellákkal, HT7333-al fogom megvalósítani. Hőmérséklet olvasás percenként történik (akku feszültséggel együtt). A minél hosszabb akkuidő biztosítása miatt az ESP-t 2 mérés között deep sleep-be teszem, a wifi kapcsolatot csak 10 mérésenként építem fel, így a közben mért eredményeket RTC memóriában tárolom. A kódot megírtam, szépen működik minden.
Egyetlen problémám van, amivel úgy tűnik, hogy senki nem foglalkozik (legalábbis, amilyen deep sleep megoldásokat találtam). Ez pedig az, hogy az összes megvalósításban egyszerűen fix időtartamig küldik deep sleep-be az eszközt. Nekem viszont az kellene, hogy fix időközönként történjen meg a mérés és küldje a post-ot a szerverre. Ezt próbáltam megoldani úgy, hogy a szükséges deep sleep időből levonom az indulás óta eltelt időt (a micros() függvénnyel). Több kevesebb sikerrel megy, de úgy tűnik, hogy a deep sleep időzítése sem teljesen korrekt (mintha kevesebb idő telne el, mint kellene). Most éppen valamilyen korrekciós tényezővel próbálom még szorozni, de ugye a kód futása sem mindig pontosan azonos ideig tart (jellemzően a DS18B20 inicializálása és kiolvasási ideje ingadozik valamennyit).
Be lehetne még kavarni az NTP-t, de ahhoz vagy minden kiolvasásnál mégis csatlakoznom kell a wifi-hez, vagy csak 10 percenként a post-ot tudom szinkronizálni valamilyen egzakt időponthoz. Viszont a wifi folyamatos felébresztése nyilván növeli a fogyasztást (a wifi modul bekapcsolása és a nem deep sleep-ben töltött idő jelentős növekedése miatt is).Bármilyen ötletet várok.
-
#6828
vargalex
félisten
szabifotos
#6827
vargalex
félisten
válasz
szabifotos
#6827
üzenetére
Ha behúz, akkor csak az app-ban lehet hiba a visszajelzéssel. Miben íródott? Lehet látni az érintett részletet?
-
#6826
vargalex
félisten
szabifotos
#6824
vargalex
félisten
válasz
szabifotos
#6824
üzenetére
Nem 5V-os reléd van? Az nem fog kapcsolni a NodeMCU 3,3V-os pin-jeivel.
-
#6791
vargalex
félisten
BTminishop
#6788
vargalex
félisten
válasz
BTminishop
#6788
üzenetére
Ha feltölteni kell az adatokat, akkor oda neked nem web server kell, hanem client.
-
vargalex
félisten
válasz
Victoryus
#6552
üzenetére
Én a gyerekeknek (gyerekekkel) pont egy ilyet raktam össze, de nodeMCU alapokon. Vettem egy alap 2WD Car Chasis-t, külön L9110 motorvezérlőt, HC-SR04 ultrahangos szenzort és servo motort. NodeMCU volt itthon.
Az ultrahang szenzor és a servo motor még nincs beépítve, így csak wifi-n irányítható az autó. A nodeMCU szórja a wifi-t, illetve fut rajta egy web szerver. Telefonnal az általa szórt wifire csatlakozom, megnyitom a böngészőben az URL-t, ahol összesen 5 db gomb van jelenleg (előre, hátra, jobbra, balra, stop).
Nagyon tetszett a gyerekeknek. Az egészet egy 2200 mAh power bank hajtja. -
vargalex
félisten
válasz
peter1998
#6549
üzenetére
Ha nem a microUSB-ről programozod, hanem úgy, mint egy normál ESP8266-ot, akkor nem elég a VCC, GND, TX és RX lábak bekötése.
A CH_PD-t a VCC-re kell kötnöd (ez gondolom megvan a NodeMCU-n), illetve a program feltöltéshez a GPIO0-át a GND-re.A kimenet szerintem csak üres flash-t jelent.
-
vargalex
félisten
A két kérésed is GET kérés. Ezért értetlenkedem. Attól, hogy GET-nek hívják, az még adatküldésre alkalmas query string-el.
Az eredeti példánál maradva az egyszerűsített verzió:
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#define DEFAULT_STATE LOW
// Replace with your network credentials
const char* ssid = "Your_SSID";
const char* password = "your_password";
// GPIO for controlling the relay
uint8_t relay_pin = 12;
ESP8266WebServer server(80);
void setup(void){
//Set default state
digitalWrite(relay_pin, DEFAULT_STATE);
//Turn on serial output
delay(1000);
Serial.begin(115200);
WiFi.begin(ssid, password);
Serial.println("");
// Wait for connection
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// logging to serial output
Serial.println("");
Serial.print("Connected to ");
Serial.println(ssid);
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
// web server setup
server.on("/on", []() {
digitalWrite(relay_pin, HIGH);
Serial.println("Relay turned on");
server.send(200, "text/plain", "Relay turned on");
});
server.on("/off", []() {
digitalWrite(relay_pin, LOW);
Serial.println("Relay turned off");
server.send(200, "text/plain", "Relay turned off");
});
server.on("/state", []() {
String relay_state = (digitalRead(relay_pin)) ? "true" : "false";
server.send(200, "text/plain", relay_state);
});
server.begin();
Serial.println("HTTP server started");
}
void loop(void){
server.handleClient();
}Ha jól láttam, a sonoff-on a 12-es GPIO-ra van kötve a relé. A relé kapcsolgatása mellett a led-et is kapcsolhatod a 13-as GPIO-n. A fenti példa a kapcsoláskor is ad vissza választ, mert szerintem egy web szervernek illik (legalább a HTTP 200-at visszaadni).
-
vargalex
félisten
Pont azért linkeltem egy konkrét kódot, mert le tudod butítani úgy, ahogy neked kell. A példa kódban van get is. Az ne zavarjon meg, hogy ez a get egy html element click-jéhez van kötve. Ez sem kötelező. A példa egyébként éppen egy státusz oldal (csak ugye több relé is lehet) és a get kérések kezelése.
Továbbra is tartom, hogy az Arduino IDE-ben a példák között mindent megtalálsz. Vagy még mindig nem értem, hogy mit szeretnél... -
vargalex
félisten
Akartam kérdezni, hogy melyik eszköz milyen protokollon megy? Több I2C-s eszközt tudsz azonos lábakon kezelni... Én így hajtok meg egy ESP8266-on egy oled display-t és egy Sony Ericsson MMR-70 FM transmitter-t (a két eszközhöz csak a VCC, GND, SDA, SDC lábak kellenek összesen).
-
vargalex
félisten
-
vargalex
félisten
Tegyük hozzá, hogy az alap ESP8266 board-okhoz (ESP-01..ESP-12) is fullos az arduino támogatás, csak kicsit problémásabb a kód feltöltése, tápellátás, mint a Wemos d1 mini esetén.
Én is azért javasoltam az ESP programozását, mert nem figyeltem, hogy a kolléga ESP-07 serial wifi module-t használ, azt gondoltam, normál ESP-07-et. Azon lenne sok dologra elég GPIO láb.
Új hozzászólás Aktív témák
Hirdetés
ekkold- AKCIÓ! Lenovo Thinkpad P15 Gen1 15 FHD notebook - i7 10750H 16GB RAM 512GB SSD Quadro T1000 W11
- BESZÁMÍTÁS! ASUS H87I-PLUS H87 chipset alaplap garanciával hibátlan működéssel
- ÁRGARANCIA!Épített KomPhone Ryzen 7 5700X3D 32/64GB RAM RX 7800 XT 16GB GAMER PC termékbeszámítással
- Fujitsu USB Port Replicator PR09 docking station (1x5K vagy 2x4K felbontás) (DisplayLink)
- LG 25GR75FG - E-Sport Monitor - FHD 360Hz 1ms - NVIDIA Reflex + G-sync - AMD FreeSync - HDR 400
Állásajánlatok
Cég: PC Trade Systems Kft.
Város: Szeged
Cég: PC Trade Systems Kft.
Város: Szeged