Nuovo chip della serie ESP di Espressif di prossima uscita che integra Wi-Fi e Bluetooth
ESP32, il prossimo compagno di banco :)
(https://pbs.twimg.com/media/CTCgl3WUAAAXKjv.jpg)
:)
Ultima fatica del Pighixxx :)
Download pdf qui. (http://www.pighixxx.net/test/2015/12/esp32-pinout/)
Rilasciata la versione 1.1
Download sempre al solito posto (http://www.pighixxx.net/test/2015/12/esp32-pinout/)
Tutte le informazioni me le sta passando direttamente Espressif :)
ULP+RTC (counter non clock) sarà molto interessante.
Periferica Infrarossi ? strana, probabilmente genera la portante senza doverla creare via sw ? Lato ricezione magari è connessa con interrupt ?
Lo scopriremo solo vivendo :)
Forse è un'IRDA?
Che intendi ?
IR == IrDa
xiscrizione
xiscrizione
(https://pbs.twimg.com/media/CeYM2NcWwAAE_Ie.jpg)
Ci sono già dei moduli in vendita o è ancora sulla carta?
al momento non prima di giugno se ne potra' avere uno in mano
sperando che non si allungano ancora i tempi visto che doveva essere dic2015 e poi via via piu' avanti
sono presenti al mondo solo 200 chip dati in demo a 200 fortunati. e non sono nemmeno ESP32 ma ESP31, che hanno una pedinatura diversa
Ciao,
estremamente interessante, visto che c'erano potevano portare la SRAM a 1G; penso che una delle chicche sia la presenza di CAN che rispetto ad altre diciamo piccole da una marcia in più.
Per in povero novizio quell'ethernet MAC interface vuol dire che è già predisposta per un connettore ethenet?
grazie
serve il PHY prima del connettore
ci sono novita' importanti che vanno rpoprio a creare nuovi modi di progettazione, cioe' il fatto che in modalita' standby lui possa comunque andare a valutare il valore dei sensori. Oppure se ho capito bene che si possano eseguire una certa quantita' di linee di codice mentre la cpu e' dormiente
Ma prendetelo con le pinze, potrei aver inteso male
(http://www.pighixxx.com/test/wp-content/uploads/2016/07/ESP32b_pinout_v1_0.png)
Buongiorno a tutti.
Buone novità in arrivo. Espressif ha rilasciato le nuove specifiche del processore.
In anteprima mondiale il pinout e il nuovo datasheet Qui (http://www.pighixxx.com/test/2016/07/the-new-esp32-specs/)
Ci vediamo dopo allo SB che è un bel po' che latito :D
Ciao, bentornato :)
Ottima notizia, ormai non si ci sperava più, Espressif ha più volte comunicato una data di distribuzione poi non mantenuta.
Sai se c'è una nuova data di inizio vendite ?
Nella prima versione molte cose non erano state implementate e quindi hanno riprogettato il wafer. Se dai un'occhiata al datasheet adesso si incomincia a ragionare :D
Ragionevolmente per settembre inizia la distribuzione.
Mi hanno appena confermato che da circa metà agosto (di quest'anno) inizia la distribuzione dei samples.
Ottima notizia
Rilasciato SDK ver3.0
Espressif SDK (https://github.com/espressif/ESP32_RTOS_SDK/releases/tag/v3.0.0)
sul forum ufficiale un utente ha fatto una lista di cosa ci sara' su un ESP32:
-> low power
-> Ultra Low Power Management
-> Robust Design -40 C to 125 C
-> 2 cores, one of them for user application
-> 240MHz dual core Tensilica LX108 microcontroller with 600 DMIPS
-> Integrated 512KB SRAM
-> Integrated 802.11BGN HT40 Wi-Fi transceiver, baseband, stack and LWIP
-> Integrated dual mode Bluetooth (classic and BLE)
-> Ultra low noise analog amplifier
-> Hall sensor
-> 10x capacitive touch interface
-> 32kHz crystal oscillator
-> 3 x UARTs, including hardware flow control
-> 3 x SPI
-> 2 x I2S
-> 12 x ADC input channels
-> 2 x DAC
-> 2 x I2C
-> 32 GPIO's
-> PWM/timer input/output availabe on every GPIO pin
-> OpenOCD debug interface with 32kB TRAX buffer
-> SDIO master/slave 50MHz
-> Supports external SPI flash up to 16MB
-> SD-card interface support
-> WEP, WPA/WPA2 PSK/Enterprise
-> Hardware accelerated encryption: AES-256 / SHA2 / Elliptical Curve Cryptography / RSA-4096
-> Supports sniffer, station, softAP and Wi-Fi direct modes
-> Max data rate of 150Mbps@11n HT40, 72Mbps@11n HT20, 54Mbps@11g, and 11Mbps@11b
-> Maximum transmit power of 19.5dBm@11b, 16.5dBm@11g, 15.5dBm@11n
-> Minimum receiver sensitivity of -98dBm
-> 135Mbps UDP sustained throughput
-> 2.5uA deep sleep current
Rilasciato SDK ver3.0
Espressif SDK (https://github.com/espressif/ESP32_RTOS_SDK/releases/tag/v3.0.0)
La versione NON OS è ferma alla 2.0 --> http://www.espressif.com/en/products/hardware/esp8266ex/resources (http://www.espressif.com/en/products/hardware/esp8266ex/resources)
Cipicchia quante periferiche!
..... ma esiste?
Non trovo un rivenditore....
Esce in pre-release (solo per sviluppatori) a Settembre.
Ah caspita, qualcuno che ci lavora alacremente c'è già: http://www.heise.de/make/artikel/Espressif-ESP32-3256039.html?artikelseite=2 (http://"http://www.heise.de/make/artikel/Espressif-ESP32-3256039.html?artikelseite=2")
... c'è anche il porting in arduino IDE: https://github.com/me-no-dev/ESP31B (https://github.com/me-no-dev/ESP31B)
Bello bello !
La versione NON OS è ferma alla 2.0 --> http://www.espressif.com/en/products/hardware/esp8266ex/resources (http://www.espressif.com/en/products/hardware/esp8266ex/resources)
ESP32 non ha un NonOS sdk
queso e' il topic dedicato ESP32, non esp8266 ;)
Esce in pre-release (solo per sviluppatori) a Settembre.
quando uscira' non lo sanno nememno loro, visto che la rpima data fu aprile e poi di mese in mese, piano piano, si allungano.
Tattica commerciale o problemi hw ?
l'ultimo giuramento e' stato esce per agosto, tante' che alcuni produttori che vendono il loro rpodotto basato su ESP32 hanno messo Agosto come data di invio
Sul forum stm32duino ci sono alcuni che hanno scritto che gli invii sono già partiti. Avevano fatto il preordine su Aliexpress
Confermo. La prossima settimana ne ho in casa alcuni. :smiley-mr-green:
e luce fu :)
(http://www.cnx-software.com/wp-content/uploads/2016/09/ESP32.jpg)
e' davvero uscito, qui la documentazione ufficiale aggiornata
http://www.espressif.com/en/products/hardware/esp32/resources (http://www.espressif.com/en/products/hardware/esp32/resources)
la documentazione dell'API sembra non presente, ma in realta' se si scarica l'SDK completo all'interno c'e' una cartella documentation con il .pdf
al momento sembra possibile ordinare solo il chip, non sono ancora usciti moduli in stile nodemcu.
Uscira' anche un modulo ufficiale direttamente da ESP che si chiama wroom-32
Finalmente arrivato :)
la Espressif oltre al modulo wroom32 (lo schedino con esp32+flash+antenna) ha deciso di produrre anche direttamente dei moduli per breadboard con adattatore usb.
Sembra si chiamino ESPRESSIF ESP32 DEVELOPMENT BOARD
(https://cdn-shop.adafruit.com/1200x900/3269-02.jpg)
Il chip seriale/usb usato sulla board (esp32 non ha la usb) e' il CP2102
Win10-64 ha installato automaticamente il driver,
Di fabbrica e' installato il classico firmware per i comandi AT.
Connessione a 115200 8N1N
Questo il messaggio di boot (a differenza del fratellino minore non serve usare baudrate strani):
-------------------------------------------------------------------------
ets Jun 8 2016 00:22:57
rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
ets Jun 8 2016 00:22:57
rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0x00
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:2
load:0x3ffc0000,len:0
load:0x3ffc0000,len:2304
load:0x40078000,len:3788
ho 0 tail 12 room 4
load:0x40098000,len:532
entry 0x4009813c
[1B][1;36m
[1B][0m[1B][1;36m**************************************
[1B][0m[1B][1;36m* hello espressif ESP32! *
[1B][0m[1B][1;36m* 2nd boot is running! *
[1B][0m[1B][1;36m* version (V0.1) *
[1B][0m[1B][1;36m**************************************
[1B][0m[1B][0;36mcompile time 09:59:36
[1B][0m[1B][0;36m SPI Speed : 40MHz
[1B][0m[1B][0;36m SPI Mode : DIO
[1B][0m[1B][0;36m SPI Flash Size : 1MB
[1B][0m[1B][1;36mPartition Table:
[1B][0m[1B][1;36m## Label Usage Type ST Offset Length
[1B][0m[1B][1;36m 0 factory factory app 00 00 00010000 00100000
[1B][0m[1B][1;36m 1 rfdata RF data 01 01 00110000 00040000
[1B][0m[1B][1;36m 2 wifidata WiFi data 01 02 00150000 00040000
[1B][0m[1B][1;36mEnd of partition table
[1B][0m[1B][1;36mLoading app partition at offset 00010000
[1B][0m[1B][0;36msection 0: paddr=0x00000020 vaddr=0x00000000 size=0x0ffe8 ( 65512)
[1B][0m[1B][0;36msection 1: paddr=0x00010010 vaddr=0x3f400010 size=0x0ac70 ( 44144) map
[1B][0m[1B][0;36msection 2: paddr=0x0001ac88 vaddr=0x3ffbae60 size=0x0140c ( 5132) load
[1B][0m[1B][0;36msection 3: paddr=0x0001c09c vaddr=0x40080000 size=0x00400 ( 1024) load
[1B][0m[1B][0;36msection 4: paddr=0x0001c4a4 vaddr=0x40080400 size=0x154f4 ( 87284) load
[1B][0m[1B][0;36msection 5: paddr=0x000319a0 vaddr=0x00000000 size=0x0e670 ( 58992)
[1B][0m[1B][0;36msection 6: paddr=0x00040018 vaddr=0x400d0018 size=0x38054 (229460) map
[1B][0m[1B][0;36mstart: 0x400807f0
[1B][0mInitializing heap allocator:
Region 19: 3FFBC26C len 00023D94 tag 0
Region 25: 3FFE8000 len 00018000 tag 1
Pro cpu up.
Pro cpu start user code
nvs_flash_init
misc_nvs_load g_misc_nvs=0x3ffbc428
frc2_timer_task_hdl:3ffbcf7c, prio:22, stack:2048
tcpip_task_hdlxxx : 3ffbec88, prio:20,stack:2048
phy_version: 80, Aug 26 2016, 13:04:06, 0
pp_task_hdl : 3ffc34d0, prio:23, stack:8192
:>enter uart init
uart init wait fifo succeed
exit uart init
IDF version : developing(09542f06)
WIFI LIB version : master(fbb084da)
ssc version : master(r260 cb8d627d)
!!!ready!!!
mode : sta(18:fe:34:6a:94:78)
+WIFI:STA_START
-------------------------------------------------------------------------
x iscrizione
Ohhh bene... come se nn avessi altro da fare :)
Espressif ha deciso ufficialmente di creare un core arduino.
È stato ingaggiato l'autore del core del vecchio esp31, ed è stato da poco pubblicato su github la prima versione per esp32
https://github.com/espressif/arduino-esp32 (https://github.com/espressif/arduino-esp32)
Se non sbaglio è la terza azienda produttrice che crea o appoggia la creazione di un core arduinico. La prima, anni fa, è stata la Texas Instruments, a settembre la ST per alcune schede STM32 e adesso Espressif.
La Texas è stata forse la prima a proporre delle board molto economiche con un lancio sottocosto.
si, la TI fece un fork dell'intero IDE che divento' energia, e praticamente regalava la board a tipo 3€ incluso spese postali.
Launchpad MSP430, la cosa sfiziosa e' che puoi usare una mcu piu' piccola o una con piu' pin, inserendola nello stesso alloggiamento :-)
A me piace di piu' l'idea del core che poi vai ad inserire nell'ide ufficiale, non so se c'erano motivi insormontabili per i quali fare un fork dell'ide, oppure solo marketing
Espressif ha deciso ufficialmente di creare un core arduino.
È stato ingaggiato l'autore del core del vecchio esp31, ed è stato da poco pubblicato su github la prima versione per esp32
https://github.com/espressif/arduino-esp32 (https://github.com/espressif/arduino-esp32)
Ottima notizia.
Anche SparkFun ha rilasciato un modulino con ESP32 ... QUI (https://www.sparkfun.com/products/13907) :)
(https://cdn.sparkfun.com//assets/parts/1/1/5/6/4/13907-01.jpg)
Guglielmo
bella, con caricabatteria integrato
utile anche la mini guida per installare l'attuale core arduino ufficiale
https://learn.sparkfun.com/tutorials/esp32-thing-hookup-guide#installing-the-esp32-arduino-core
(https://learn.sparkfun.com/tutorials/esp32-thing-hookup-guide#installing-the-esp32-arduino-core)
Stanno uscendo come funghi, mi sono appena accorto che nel core e' stata aggiunta una variante chiamata Nano32, cerca cerca eccola qui:
https://twitter.com/maker_asia/status/779310519886884869 (https://twitter.com/maker_asia/status/779310519886884869)
Mi ricordavo bene, si tratta di un dual core.
Ci vedrei bene un ArduESP32. :)
Scheda con il layout della UNO che monta un ESP32.
Ci vedrei bene un ArduESP32. :)
Scheda con il layout della UNO che monta un ESP32.
Diamine, ho appena comprato la mkr1000! :D
A chi può interesare, QUI (https://hackaday.com/2016/10/31/whats-new-esp-32-testing-the-arduino-esp32-library/) un articolo di Hackaday sull'argomento ESP32 <-> Arduino.
Guglielmo
e'stato anche scoperto un interprete basic nascosto nel fw precaricato, che funziona per davvero :)
Non è che ti riferisci al LUA?
:o
In effetti il LUA sembra un basic
basic esp32 (http://hackaday.com/2016/10/27/basic-interpreter-hidden-in-esp32-silicon/)
:o
:o E' proprio il caso.
Se ci fosse stato anche il peek e poke sarei tornato ai tempi del C64......
Veramente, se leggi bene, peek e poke ci sono eccome :D.
Sembra un Basic tipo Amstrad.
E' un porting del TinyBasic Plus
Visto che nel progetto originale peek & poke sono dichiarati "unimplemented" vuol dire che li ha aggiunti espressif
https://github.com/BleuLlama/TinyBasicPlus (https://github.com/BleuLlama/TinyBasicPlus)
5 POKE &H3FF44020, 16
10 POKE &H3FF44004, 16
20 DELAY 200
20 POKE &H3FF44004, 0
30 DELAY 200
40 PHEX PEEK(&H3FF4403C)
50 GOTO 10
Mi hanno regalato una schedina ESP32 della sparkfun, questa:
https://www.sparkfun.com/products/13907
$19.95
Dovrebbe arrivarmi a giorni.
Mi sono impostato le board come indicato nel sito della sparkfun,
compila gli esempi senza problemi
Ho fatto qualche esperienza con ESP8266/wemos utilizzando sempre
la libreria ESP8266WebServer
Esisterà una libreria simile alla ESP8266WebServer per questa scheda?
la sezione wifi e' dichiarata compatibile al 99%, quindi non dovresti avere problemi, le lib sono state prese quasi paroparo dal rpogetto 8266
Concordo, se vuoi puoi provare anche il mio Webbino (https://github.com/SukkoPera/Webbino).
bella cosa, quando ho un attimo lo testo, per ora ti watcho :)
Grazie, proverò con le librerie dell' ESP8266
La scheda della sparkfun è arrivata, pagata il 20 dic arrivata il 5 gen dalla Germania.
Il solito blink caricato sulla ESP32 funziona.
Come detto ho fatto pratica con ESP8266 e la lib ESP8266WebServer con ottimi risultati.
@testato come suggerito
ho provato ad utilizzare la suddetta libreria con la ESP32 ma non va a buon fine, si ferma sulla queue.h
Messaggio di errore in compilazione:
In file included from /home/../hardware/espressif/esp32/libraries/ESP8266WiFi/src/ESP8266WiFi.h:33:0,
from /home/.../hardware/espressif/esp32/libraries/ESP8266WebServer/src/ESP8266WebServer.h:28,
from /home/.../ESP8266-01_un_LED_05.ino:14:
/home/.../hardware/espressif/esp32/libraries/ESP8266WiFi/src/ESP8266WiFiType.h:26:19: fatal error:
queue.h: No such file or directory
#include <queue.h>
Ho provato anche a copiare questo file insieme alle librerie ma il risultato non cambia.
devo trovare il tempo per mettere mano seriamente a questo chip.
Il fatto e' che e' ancora in una fase embrionale nonostante abbiano assunto il tipo del core esp8266
secondo me ci sono sotto cose ancora non pronte, cose importanti o bug non previsti.
Uno dei motivi per i quali voglio metterci mano e' il BT, eppure al momento sul core arduino nulla di nulla di BT, e sul IDF non puoi usarlo assieme al wifi :(
Ho dato uno sguardo alla cartella libraries del ESP32:
https://github.com/espressif/arduino-esp32/tree/master/libraries/WiFi/src (https://github.com/espressif/arduino-esp32/tree/master/libraries/WiFi/src)
Al momento sono state implementate poche librerie rispetto a quelle disponibili per ESP8266:
https://github.com/esp8266/Arduino/tree/master/libraries (https://github.com/esp8266/Arduino/tree/master/libraries)
Inoltre molte delle librerie del ESP8266 si chiamano "ESP8266qualcosa" e non solo "qualcosa".
Per quel motivo si generano gli errori di compilazione che Busco ci ha segnalato, quando cerca di usare le librerie del ESP8266 anche per l'ESP32.
Dobbiamo aspettare che il team ESP32 implementi le librerie mancanti per usare l'ottima libreria WebServer:
https://github.com/esp8266/Arduino/tree/master/libraries (https://github.com/esp8266/Arduino/tree/master/libraries)
Mi hanno regalato la ESP32 della Sparkfun:
Sparkfun ESP32 Thing
https://www.sparkfun.com/products/13907
IDE arduino-1.8.1
Scheda ESP32 Dev Module
Utilizzo come base il codice degli esempi della lib WiFi nome SimpleWiFiServer.ino
https://github.com/espressif/arduino-esp32/tree/master/libraries/WiFi/examples/SimpleWiFiServer
Ho aggiunto due pulsanti e una textbox.
Il codice HTML l'ho messo in un file separato per facilitare il debug.
File: SimpleWiFiServer_13.ino //Codice C
paginaHTML.h //Codice HTML
maschera.png //Come appare
Il problema:
Gira abbastanza bene però dopo quanche minuto anche 10-15 minuti si blocca
Nel file allegato (ESP32_problemi.txt)
Visualizzo dei dati:
tempo in mS ad ogni passaggio
durata della prova.
alla fine alcuni messaggi emessi dalla board
e CPU Halt
A questo punto si blocca, questo è il mio problema.
Penso che tra i messaggi emessi dalla board ci sia anche
il motivo del problema ma non saprei come ricavarlo.
Allego i file.
Grazie per eventuali suggerimenti.
Ho decodificato l'errore:
0x40084807: uxListRemove at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/./list.c line 214
0x40084807: uxListRemove at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/./list.c line 214
0x40083dce: xPortGetCoreID at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/./tasks.c line 4398
: (inlined by) xTaskRemoveFromEventList at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/./tasks.c line 3018
0x40082ba1: xQueueGenericSend at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/freertos/./queue.c line 1998
0x400e2a6d: sys_mbox_post at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/lwip/port/freertos/sys_arch.c line 500
0x400dbd41: tcpip_send_api_msg at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/lwip/api/tcpip.c line 467
0x400e2cc8: tcpip_apimsg at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/lwip/api/api_lib.c line 811
0x400e30c4: netconn_recved at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/lwip/api/api_lib.c line 811
0x400db24c: lwip_recvfrom at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/lwip/api/sockets.c line 3233
0x400db755: lwip_recvfrom_r at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/lwip/api/sockets.c line 3233
0x400db7ad: lwip_recv_r at /Users/ficeto/Desktop/ESP32/ESP32/esp-idf-public/components/lwip/api/sockets.c line 3233
0x400d108c: WiFiClient::read(unsigned char*, unsigned int) at /home/giorgio/Programmi_gio/arduino-1.6.13/hardware/espressif/esp32/cores/esp32/Print.h line 50
0x4010735d: WiFiClient::read() at /home/giorgio/Programmi_gio/arduino-1.6.13/hardware/espressif/esp32/libraries/WiFi/src/WiFiClient.cpp line 158
0x400d0e40: loop at /home/giorgio/Programmi_gio/arduino-1.6.13/portable/sketchbook/SimpleWiFiServer_13/SimpleWiFiServer_13.ino line 51
0x4010015d: loopTask(void*) at /home/giorgio/Programmi_gio/arduino-1.6.13/hardware/espressif/esp32/cores/esp32/main.cpp line 11 (discriminator 1)
Conviene caricare nel Arduino IDE l' EspExceptionDecoder
https://github.com/me-no-dev/EspExceptionDecoder/releases/download/1.0.6/EspExceptionDecoder-1.0.6.zip (https://github.com/me-no-dev/EspExceptionDecoder/releases/download/1.0.6/EspExceptionDecoder-1.0.6.zip)
Istruzioni:
https://github.com/me-no-dev/EspExceptionDecoder (https://github.com/me-no-dev/EspExceptionDecoder)
Qualcuno dice che serve cancellare la memoria flash del ESP32 quando comincia a dare i numeri
esptool --port COM3 erase_flash
Per chi usa linux:
invece di COM3 mettete l'indirizzo linux della porta USB
ho rpovato anche io una volta il decoder delle eccezioni sull 8266, buona cosa che sia stato aggiornato anche per il 32.
ma poi ti ha aiutato a beccare il rpoblema ? perche' a me non aiuto' piu' di tanto
Io lo uso parecchio, lo trovo molto utile.
fate un esempio,
tipo come si interpreta il risultato di roboticboyer ?
e' importante quella scritta discriminator 1 ?
Io ho interpretato che la CPU si è bloccata quando ha eseguito la linea 11 del main.cpp
0x4010015d: loopTask(void*) at /arduino-1.6.13/hardware/espressif/esp32/cores/esp32/main.cpp line 11 (discriminator 1)
Sembra che l'errore segnalato da Busco capiti anche ad altri:
https://github.com/espressif/arduino-esp32/issues/109 (https://github.com/espressif/arduino-esp32/issues/109)
https://github.com/espressif/arduino-esp32/issues/119 (https://github.com/espressif/arduino-esp32/issues/119)
https://github.com/espressif/arduino-esp32/issues/207 (https://github.com/espressif/arduino-esp32/issues/207)
ma il main.cpp e' nel core, vai a modificare quello ?
il rpoblema e' nel tuo .ino no ?
Lo stacktrace si legge al contrario :). Il punto dove si è piantato è nella prima riga, che è stata invocata dalla seconda, ecc... Fino al main, dove il programma è partito.
Quindi freertos, list.c linea 214
che e' ugualmente nel core e quindi non ci mettiamo mano.
L'unica indicazione utile che riguarda un .ino e'
SimpleWiFiServer_13.ino line 51
E' qui il problema ?
I casi sono due: o c'è un problema nella libreria (improbabile), o nel proprio sketch si fa qualcosa che la fa crashare. Bisogna fare dei test e cercare di capire l'arcano.
certo, ma a questo punto torniamo alla mia affermazione originaria, cioe' che sto decoder non mi dice il problema, in cosa mi aiuta ?
Alla fine sei sempre tu nel tuo .ino a dover risolvere
Questo è un caso un po' sfortunato, ma lo stacktrace in generale è utilissimo, perché almeno sai esattamente DOVE si è piantato il programma.
Questo caso andrebbe analizzato un po' meglio, ma comunque qualcosa di utile te lo dice.
Ho provato più volte il codice che ho proposto nel post #63
su una scheda ESP8266 (una wemos) sostituendo solo la libreria
con la ESP8266WiFi.h ed ha funzionato perfettamente per ore.
Qualcuno ha informazioni su come implementare codice che utilizzi il Bluetooth classic su ESP32?
Qualcuno ha informazioni su come implementare codice che utilizzi il Bluetooth classic su ESP32?
Non l'ho ancora provato, vorrei veder funzionare il WiFi.
Come segnalato sopra ho ancora dei problemi.
Tu lo hai provato il WiFi?
il bluetooth non e' stato ancora implementato nel core Arduino.
Lo si puo' usare solo con l'SDK ufficiale, e comunque ho letto che non si puo' far funzionare contemporaneamente wifi+BT
Da tempo avevo i sospetti, ora e' arrivata la conferma ufficiale:
Bug su Chip ESP32 (http://espressif.com/sites/default/files/documentation/eco_and_workarounds_for_bugs_in_esp32_en.pdf)
Tra l'altro problemi da poco..
Non capisco il senso si rilasciare una cosa che non funziona
Sono costretto a ripiegare su esp826
Peccato
Un sito ricco d' informazioni sul ESP32:
http://esp32.net (http://esp32.net)
ESP32 scende sotto i 5€
https://it.aliexpress.com/item/Replace-ESP8266-ESP32-ESP-32S-ESP-WROOM-32-Bluetooth-WIFI-Module-Dual-Core-CPU-With-Low/32799649345.html (https://it.aliexpress.com/item/Replace-ESP8266-ESP32-ESP-32S-ESP-WROOM-32-Bluetooth-WIFI-Module-Dual-Core-CPU-With-Low/32799649345.html)
Si sta smuovendo qualcosina, apparso un esempio Bluetooth nel core arduino
Bluetooth ESP32 Arduino (https://github.com/espressif/arduino-esp32/blob/master/libraries/SimpleBLE/examples/SimpleBleDevice/SimpleBleDevice.ino)
Con gli ultimi aggiornamenti ho riscontrato miglioramenti, prove solo con il WiFi.
non si blocca più come capitava qualche mese fa.
grazie dell'update,
lo stai usando su core arduino o idf ?
grazie dell'update,
lo stai usando su core arduino o idf ?
arduino
Secondo voi è difficile da saldare?
Misura 7x7 mm
(https://cdn-images-1.medium.com/max/1600/1*yN1sALmQ5wraeahD82ZcCA.jpeg)
Fonte --> https://blog.hackster.io/introducing-the-new-esp32-pico-d4-sip-99476238bc07 (https://blog.hackster.io/introducing-the-new-esp32-pico-d4-sip-99476238bc07)
Bello, quel pezzo di ferro immagino sia l'antenna ?
Tutto si può saldare, mano ferma ed occhi buoni :)
Ma non c'è nel core arduino come board ?
Si. E' da installare a parte.
--> https://github.com/espressif/arduino-esp32 (https://github.com/espressif/arduino-esp32)
Purtroppo copiando il contenuto manualmente. Non hanno predisposto il file json per l'acquisizione automatica tramite IDE.
Si questo é il core dell'esp lo uso regolarmente, intendevo dire che non c'è come board questo chip, lo usano con la board esp32 dev board ?
Non lo so.
dichiarato aggiornato il core per l'attacco KRACK
https://github.com/espressif/arduino-esp32/issues/739 (https://github.com/espressif/arduino-esp32/issues/739)
Ragazzi, ma qualcuno usa ESP32 per qualcosa di stabile? Io l'ho preso in mano l'altro giorno, perché mi serviva una scheda Wifi, ma tutti i miei ESP8266 erano occupati. Finora l'unica prova che avevo fatto era metterci Webbino: l'avevo lasciato girare per giorni senza alcun problema. Ora ho provato a farci qualcosa di un po' meno fine a sé stesso e ho iniziato a scontrarmi con una serie di strani problemi:
1. analogWrite() non è ancora implementata.
2. Se collego qualcosa al pin 12, non riesco a flashare la scheda.
3. A volte, alla prima accensione, la scheda parte, dopo un po' si riavvia e quindi parte come dovrebbe.
C'è poi in generale un velo di oscurità su quali funzioni sono assegnate a quali pin. Mi pare di capire che sto chip ha una GPIO matrix, che permette sostanzialmente di assegnare le funzioni più o meno ai pin che si vuole. Ad esempio, l'interfaccia i2c di default dovrebbe essere sui pin 21 e 22, ma io l'ho usata su 13 e 14. Un documento chiarificatore in questo senso dovrebbe essere tale ESP32 Pin List (http://wiki.ai-thinker.com/_media/esp32/docs/esp32_chip_pin_list_en.pdf), ma sinceramente io non ci capisco granché, non mi pare molto chiaro.
Non riesco nemmeno a capire quanta corrente può erogare ciascun pin :(.
Se non altro, devo dire che (a parte i già citati problemi al primo avvio), il sistema pare stabile, e non ho riscontrato alcun problema col wifi. Personalmente ho un doIT devkit V1.
Perché questo chip, che sulla carta è così figo, sta faticando così tanto ad affermarsi?
Io lo sto usando su un progetto ed al momento tutto ok.
Esistono due versioni del chip, la vecchia versione Rev0 ha un bel po di problemi.
É da poco stata mergiata la mia modifica per la lettura della revisione hw, io nel mio progetto ho messo un bel blocco nel Setup() in modo da costringere ad usare solo chip Rev1
Per i pin si puoi rimapparli ma sono così tanti che non vale la pena.
Uno dei bug della prima versione é proprio il reboot all'avvio
Mi passi il codice per la revisione?
Stampati il risultato di getchiprevision e butta nel cestino tutti i moduli che ti rispondono 0 :)
https://github.com/espressif/arduino-esp32/pull/704/commits/b6a3fa5ebc5f7f68743bf724834e3017b5fc8da6 (https://github.com/espressif/arduino-esp32/pull/704/commits/b6a3fa5ebc5f7f68743bf724834e3017b5fc8da6)
Grazie. A quanto pare, dovrò buttare l'unico ESP32 che ho :smiley-confuse:.
Ma come posso essere certo di comprare un rev. 1?
Probabilmente comperando dagli specializzati, quelli che sono loro stessi produttori delle schede che ventono, tipo RobotDyn che però non ha schede con ESP32.
Probabilmente comperando dagli specializzati, quelli che sono loro stessi produttori delle schede che ventono, tipo RobotDyn che però non ha schede con ESP32.
Sparkfun ne ha diverse, esempio QUESTA (https://www.sparkfun.com/products/13907), ma, se ho ben capito, tocca chiedergli che visione del chip montano ... ::)
Guglielmo
Io ho preso 7 chip che mi servivano d'urgenza adafruit via mouser.
Risultano tutti Rev0 :o
Quindi sembra che al momento non v'è certezza, anzi credo proprio che stiano svuotando i magazzini dei Rev0 finché non risulta troppo conosciuta la situazione
Ho trovato QUESTO (https://www.hackster.io/rayburne/esp32-development-board-official-vs-clone-7f4ff7) interessante articolo che compara la "sensibilità" di due assembraggi diversi ... ;)
Guglielmo
A questo punto si potrebbe trattare di due revisioni diverse.
Per cui ho aggiunto un commento al post di Ray Burnette vosto che è l'unico che può eseguire il test.
Dal documento ufficiale ESP non risultano differenze sul discorso della sensibilità di ricezione tra Rev0 e Rev1.
Mi aspetto che risultano tutti Rev0 anche a lui.
Una cosa che ho notato subito è che il clone ha il pcb sotto l'antenna, se anche non c'è rame sotto, e non sappiamo se ce ne è sopra, di certo è meglio che non ci sia proprio nemmeno il pcb stesso.
Io sul mio progetto ho fatto uno squarcio lasciando invece lateralmente il pcb in modo da proteggere l'antenna
salve
sono nuovo in questo forum e sto cercando di usare l'esp32 con webbino per un mio progettino.
Ho un po' di esperienza con Arduino e la programmazione ma ogni tanto incontro problemi che per altri sono banali e per me insuparabili in tempi ragionevoli.
Il punto è che, dopo aver scaricato le librerie wifi e webbino, quando compilo l'esempio Simpl Server ottengo tutta una serie di errori. Ho provato a compilarlo per la scheda esp32.
Visto che qualcuno lo ha già utilizzato mi potreste dire come fare?
Un caffè virtuale a chi mi aiuta. Grazie
Questi gli errori di compilazione
Arduino:1.8.3 (Windows 10), Scheda:"ESP32 Dev Module, QIO, 80MHz, 4MB (32Mb), 921600, None"
In file included from C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\src/WebbinoCore/HTTPRequestParser.h:24:0,
from C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\src/WebbinoCore/WebClient.h:25,
from C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\src/WebbinoCore/NetworkInterface.h:25,
from C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\src/WebbinoCore/WebServer.h:24,
from C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\src/Webbino.h:21,
from C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\examples\SimpleServer\SimpleServer.ino:20:
C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\src/webbino_debug.h:48:2: warning: #warning Flash strings disabled [-Wcpp]
#warning Flash strings disabled
^
In file included from C:\Program Files (x86)\Arduino\libraries\Ethernet\src\Dhcp.cpp:4:0:
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h: In static member function 'static void W5100Class::initSS()':
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:353:64: error: 'digitalPinToPort' was not declared in this scope
*portModeRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) |= digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:353:65: error: 'portModeRegister' was not declared in this scope
*portModeRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) |= digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:353:112: error: 'digitalPinToBitMask' was not declared in this scope
*portModeRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) |= digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h: In static member function 'static void W5100Class::setSS()':
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:356:66: error: 'digitalPinToPort' was not declared in this scope
*portOutputRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) &= ~digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:356:67: error: 'portOutputRegister' was not declared in this scope
*portOutputRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) &= ~digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:356:115: error: 'digitalPinToBitMask' was not declared in this scope
*portOutputRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) &= ~digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h: In static member function 'static void W5100Class::resetSS()':
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:359:66: error: 'digitalPinToPort' was not declared in this scope
*portOutputRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) |= digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:359:67: error: 'portOutputRegister' was not declared in this scope
*portOutputRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) |= digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
C:\Program Files (x86)\Arduino\libraries\Ethernet\src\utility/w5100.h:359:114: error: 'digitalPinToBitMask' was not declared in this scope
*portOutputRegister(digitalPinToPort(ETHERNET_SHIELD_SPI_CS)) |= digitalPinToBitMask(ETHERNET_SHIELD_SPI_CS);
^
exit status 1
Errore durante la compilazione per la scheda ESP32 Dev Module.
Questo report potrebbe essere più ricco di informazioni abilitando l'opzione
"Mostra un output dettagliato durante la compilazione"
in "File -> Impostazioni"
Vai in webbino_config.h (https://github.com/SukkoPera/Webbino/blob/master/src/webbino_config.h#L26), commenta WEBBINO_USE_WIZ5100 e scommenta WEBBINO_USE_ESP8266_STANDALONE WEBBINO_USE_WIFI.
La libreria wifi non serve a niente, il core per ESP32 ha la sua implementazione.
grazie sukko,
sono andato avanti ma ora sono fermo per questo errore:
Arduino:1.8.3 (Windows 10), Scheda:"ESP32 Dev Module, QIO, 80MHz, 4MB (32Mb), 921600, None"
In file included from C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\examples\SimpleServer\SimpleServer.ino:45:0:
C:\Users\roberto\Documents\Arduino\libraries\Webbino-master\src/WebbinoInterfaces/AllWiFi.h:48:25: fatal error: ESP8266WiFi.h: No such file or directory
compilation terminated.
exit status 1
Errore durante la compilazione per la scheda ESP32 Dev Module.
Questo report potrebbe essere più ricco di informazioni abilitando l'opzione
"Mostra un output dettagliato durante la compilazione"
in "File -> Impostazioni"
Scusami, ho detto una boiata, il #define giusto è WEBBINO_USE_WIFI. :smiley-roll-sweat:
grazie mille 2 volte. ora compila :)
con tutto quello che hai scritto un piccolo errore è subito perdonato. Grazie per il tuo lavoro adesso inizierò a studiare webbino
dopo la compilazione lo carica ma non riesce ad ottenere l'indirizzo ip. per sicurezza del mio ambiente ho provato l'esempio Simplewifi server della libreria esp32 e questo funziona.
Qualche altro suggerimento?
PS ho anche provato a modificare l'esempio di webbino facendo luppare sul connect ma non riceve mai l'indirizzo.
Ho anche indicato ssid epw nelle 2 posizioni del source.
Ho visto che l'esempio si compila secondo alcune opzioni. immagino che avendo scommentato webbino_use_wifi
l'unica opzione usata sia questa ed ho quindi commentato la catena degli if lasciando solo questa. No result
Devi inserire SSID e password qui:
#include <WebbinoInterfaces/AllWiFi.h>
// Wi-Fi parameters
#define WIFI_SSID "ssid"
#define WIFI_PASSWORD "password"
NetworkInterfaceWiFi netint;
e sotto lasciare la riga:
bool ok = netint.begin (WIFI_SSID, WIFI_PASSWORD);
Ma puoi direttamente lasciare la serie di #if, dovrebbe funzionare.
Al limite prova anche l'esempio FixedIPAddress.
Non ci sono ancora. l'esempio di fix address ha questo errore:
ixedIPAddress:100: error: #error "WiFi/WiFi101 does not currently support static IP configuration"
#error "WiFi/WiFi101 does not currently support static IP configuration"
Mentre questa è la prima parte del code che uso per il simple server
#include <Webbino.h>
// Instantiate the WebServer
WebServer webserver;
// Instantiate the network interface defined in the Webbino headers
#if defined (WEBBINO_USE_ENC28J60)
#include <WebbinoInterfaces/ENC28J60.h>
NetworkInterfaceENC28J60 netint;
#elif defined (WEBBINO_USE_WIZ5100) || defined (WEBBINO_USE_WIZ5500)
#include <WebbinoInterfaces/WIZ5x00.h>
NetworkInterfaceWIZ5x00 netint;
#elif defined (WEBBINO_USE_ESP8266)
#include <WebbinoInterfaces/AllWiFi.h>
#include <SoftwareSerial.h>
SoftwareSerial swSerial (6, 7);
// Wi-Fi parameters
#define WIFI_SSID "Vodafone-roberto"
#define WIFI_PASSWORD "tim******"
NetworkInterfaceWiFi netint;
#elif defined (WEBBINO_USE_WIFI) || defined (WEBBINO_USE_WIFI101) || \
defined (WEBBINO_USE_ESP8266_STANDALONE)
#include <WebbinoInterfaces/AllWiFi.h>
// Wi-Fi parameters
#define WIFI_SSID "Vodafone-roberto"
#define WIFI_PASSWORD "tim******"
NetworkInterfaceWiFi netint;
#elif defined (WEBBINO_USE_DIGIFI)
#include <WebbinoInterfaces/DigiFi.h>
NetworkInterfaceDigiFi netint;
#endif
ho visto che ho 2 librerie wifi con wifi.h.Una si trova nelle librerie di arduino l'altra nell' hardware
espressif, ovvero nell'aggiunta che ho fatto per gestire la scheda. e dal source ho visto che sono differenti. Mi sa che il problema sta lì. Che ne dici Sukko?
Il compilatore rileva la presenza di 2 wifi.h ed usa quell'hardware.
OK, allora l'esempio con IP statico non lo puoi usare, sorry. Non saprei, io ho fatto un rapido test e me funziona, forse devo provare ad aggiornare il core e vedere se ci sono problemi con le ultime versioni.
>robademar: ti ricordo che in conformità al regolamento (http://forum.arduino.cc/index.php?topic=149082.0), punto 7, devi editare il tuo post #113 (quindi NON scrivendo un nuovo post, ma utilizzando il bottone More -> Modify che si trova in basso a destra del tuo post) e racchiudere il codice all'interno dei tag CODE (... sono quelli che in edit inserisce il bottone con icona fatta così: </>, tutto a sinistra). Grazie.
Guglielmo
thanks and sorry.
In effetti non sono molto pratico con questi strumenti :(
ciao a tutti
qualcuno ha aggiornamenti riguardo lo sviluppo di esp32?
in particolare si parlava nei post precedenti di bug e possibilità di avere esempi bluetooth classic nell'sdk arduino
Salve, ho un due esp32 e vorrei programmare usando ide arduino, il mio progetto è quello di creare una rete wifi e che l'altro si colleghi, i due esp e si dovrebbero scambiare dati o almeno uno che invii dati e l'altro li esegua (per esempio all'espA è collegato un potenziometro invece l'espB riceve il valore del potenziometro)
Io ho provato a creare uno come Accesspoint e l'altro client ma non riesco a far inviare dati.
Avevo pensato di configurare l'esp32 come AP+Station (credo che non sia possibile con questo modello) ma comunque ho usato le direttive (#if,#else e #endif) ma niente si blocca dopo la configurazione di AP
Non chiedo che mi mandiate per forza tutto il codice ma fatemi capire le librerie e le funzioni che dovrei usare
Lascia stare le direttive :)
Si può fare tranquillamente quello che chiedi,
In tanti modi diversi
Esempio puoi usare il primo come webserver ed il secondo come client, puoi passare dati in mofo bidirezionale
Oppute puoi usare Telnet, sempre da un lato come server e l'altro client.
Consiglio di iniziare a studiare gli esempi integrati nel core esp32, anche AP+Station è funzionante
Lascia stare le direttive :)
Si può fare tranquillamente quello che chiedi,
In tanti modi diversi
Esempio puoi usare il primo come webserver ed il secondo come client, puoi passare dati in mofo bidirezionale
Oppute puoi usare Telnet, sempre da un lato come server e l'altro client.
Consiglio di iniziare a studiare gli esempi integrati nel core esp32, anche AP+Station è funzionante
Se io creo un web server ho bisogno di una rete di accesso quindi di un access point, a questo punto avrei bisogno di tre dispositivi uno access point l'altro web server e l'altro client (anche con telnet), invece l'opzione ap+station non riesco a configurarla... se mi puoi dare una mano perfavore ti sono grato
In questa issue c'è un esempio
WiFi.mode(WIFI_MODE_APSTA);
https://github.com/espressif/arduino-esp32/issues/1040
(https://github.com/espressif/arduino-esp32/issues/1040)
Se io creo un web server ho bisogno di una rete di accesso quindi di un access point, a questo punto avrei bisogno di tre dispositivi uno access point l'altro web server e l'altro client (anche con telnet), invece l'opzione ap+station non riesco a configurarla... se mi puoi dare una mano perfavore ti sono grato
AP significa che altri dispositivi si possono connettere in WiFi all'ESP.
STA significa che l'ESP si connette ad un altro AP di solito il modem/router.
WebServer significa che c'è un programmino che ascolta per alcune richieste con un determinato protocollo, il suo funzionamento è indipendente dal fatto che l'ESP sia in STA o in AP.
Client è invece un programmino che si connette ad un server, anche questo è indipendente dal fatto che l'ESP sia in STA o in AP.
Ciò che cambia fra AP e STA è che mentre in AP sono accessibili solamente i dispositivi connessi all'ESP in STA si vedono fra loro tutti i dispositivi connessi all'AP, se è il modem/router è anche possible collegarsi ad internet, quindi l'ESP potrebbe essere accessibile da internet (in alcuni casi non è possibile, dipende dal provider) e sicuramente può accedere a server remoti presenti in rete internet.
Se hai due ESP che devono solo comunicare fra loro uno deve essere un AP e l'altro uno STA, ma possono essere anche due STA collegati allo stesso modem.
Credo che questo lo sappia, infatti tutto nasce dal fatto che vuole usare due soli esp ma non gli funziona ap+sta su uno dei due
Perché non hanno ancora creato il pacchetto di installazione tramite IDE di Arduino (Board Manager)?
Non l'hanno ancora implementato, magari se si ricevono più richieste sulla issue si danno una mossa.
https://github.com/espressif/arduino-esp32/issues/515 (https://github.com/espressif/arduino-esp32/issues/515)
Salve a tutti!
Sono davvero niubbo sia per quanto riguarda Arduino, sia per quanto riguarda questo modulo ESP32.
Sto cercando di dare una mano per un progetto che prevede l'uso di Arduino Uno a cui sono collegati in un caso ad un semplice pulsante, in un altro a dei sensori.
La parte che mancherebbe sarebbe la possibilità di inviare i dati via wi-fi e/o bluetooth ad uno smartphone o ad un pc.
Nelle mie ricerche su questo argomento sono incappato in questo modulo ESP32, ma ho capito che la cosa non sia così semplice.
Anzitutto non ho capito come interfacciare una scheda Arduino Uno con l'ESP32: mi sembra che esistano in commercio solo delle schede di sviluppo che integrano il chip ESP32 che di fatto si sostitiscono a Arduino Uno, o sbaglio? C'è comunque la possibilità di far comunicare le due schede?
Inoltre mi sembra di aver capito che l'integrazione delle librerie in Arduino IDE è ancora incompleta, in particolare la gestione del bluetooth ho capito essere ancora non implementata o allo stato embrionale. Lo sviluppo completo sarebbe possibile passando a IDF. La domanda torna a questo punto quella precedente: usando programmi sviluppati in IDF è possibile interagire con una scheda Arduino Uno?
E' ovvio che su Arduino c'è già tutto un lavoro fatto che si vorrebbe "salvare".
Qualcuno può darmi delle dritte su come muovermi e quali guide e documentazione leggere per fare quanto mi serve?
Grazie per l'attenzione.
Maurizio
>mauri_va: essendo il tuo primo post, nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (http://forum.arduino.cc/index.php?topic=113640.0) (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO (http://forum.arduino.cc/index.php?topic=149082.0) ... Grazie.
Guglielmo
>mauri_va: essendo il tuo primo post, nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (http://forum.arduino.cc/index.php?topic=113640.0) (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO (http://forum.arduino.cc/index.php?topic=149082.0) ... Grazie.
Guglielmo
Grazie Guglielmo per la segnalazione!
L'avevo letto il regolamento, ma l'obbligo della presentazione mi era sfuggito.
Ho rimediato.
Scusate la svista!
Maurizio,
ho preso l'ESP32 ma non è ancora arrivato. Per quanto ne so, può benissimo sostituire la UNO con adattamenti del caso.
Ma può comunicare con la UNO tramite la seriale ma credo che i livelli vadano adattati perché l'ESP32 dovrebbe essere un dispositivo che lavora solo a 3.3V.
Ci sarebbe anche l'ESP8266 di cui esiste una libreria per farlo funzionare come lo shield WiFi ufficiale della UNO ma non ha il bluetooth.
Maurizio,
ho preso l'ESP32 ma non è ancora arrivato. Per quanto ne so, può benissimo sostituire la UNO con adattamenti del caso.
Ma può comunicare con la UNO tramite la seriale ma credo che i livelli vadano adattati perché l'ESP32 dovrebbe essere un dispositivo che lavora solo a 3.3V.
Ci sarebbe anche l'ESP8266 di cui esiste una libreria per farlo funzionare come lo shield WiFi ufficiale della UNO ma non ha il bluetooth.
Grazie per la risposta.
Avevo capito che la scheda di sviluppo dovrebbe sostituire la UNO, ma le librerie al momento integrate nella IDE Arduino non sono ancora complete, da quanto ho capito, nonostante siano già passati parecchi mesi dalla commercializzazione.
Tra l'altro ho visto che esistono esempi d'uso del bluetooth per l'IDE, ma non ho ancora avuto modo di studiarli (possibile che nessuno in rete l'abbia ancora fatto?).
La scelta della ESP32 rispetto alla ESP8266 dipendeva proprio dalla possibilità di utilizzare sia il wifi che il bluetooth.
La mia scheda di sviluppo ha una porta microUSB per l'alimentazione, quindi a 5V, ma nel caso di collegamento con la UNO, dovrebbe essere possibile alimentarla a 3.3V, giusto?
La comunicazione frala UNO e la ESP32 tramite seriale non mi è molto chiara (come detto nella presentazione sono un VERO principiante in questo mondo, nonostante non sia del tutto digiuno di programmazione in genere). Se qualcuno su questo ha un suggerimento, una pagina di esempio da indicarmi, ne sarei davvero grato.
Grazie mille!
Il BT, se parliamo di core Arduino, é affidato ad una libreria esterna, e mi sembra che ad oggi non possa essere usato in contemporanea bt e wifi.
Questo se parliamo di BLE, che non tutti i cell hanno. Se parli di BT Classic c'è ancora meno in giro, credo nulla su core Arduino e non so se Idf lo supporta già.
Potresti rinunciare a BT e usare un esp8266, oppure usare un esp per wifi e un altro modulo per bt hc6, hm10, ecc
Sul topic esp8266 trovi allegato al primo messaggio uno schema per la questione dei livelli sulla connessione seriale ad una Uno
https://forum.arduino.cc/index.php?topic=265682.0 (https://forum.arduino.cc/index.php?topic=265682.0)
A scanso di equivoci la stragrande maggioranza delle schede Arduino UNO non è in gradi di alimentare correttamente tali moduli dalla linea a 3.3V: la corrente fornita non basta.
Lo schema a cui mi riferisco tiene conto anche di questo ;-)
Grazie a tutti per le risposte: appena avrò tempo mi studierò le cose che mi avete indicato.
Il BT, se parliamo di core Arduino, é affidato ad una libreria esterna, e mi sembra che ad oggi non possa essere usato in contemporanea bt e wifi.
Questo se parliamo di BLE, che non tutti i cell hanno. Se parli di BT Classic c'è ancora meno in giro, credo nulla su core Arduino e non so se Idf lo supporta già.
Effettivamente che wifi e bt non si potessero usare contemporaneamente l'avevo capito. Fra gli esempi c'è un file chiamato "WiFiBlueToothSwitch.ino" il cui nome non lascia molto spazio ai dubbi...
Mi è arrivato il modulo, la scansione delle reti funziona ma non mi si connette all'access point, cui altri moduli ESP8266 si connettono senza problemi. Potrebbe essere colpa dell'AP ma non ho avuto tempo di indagare.
Si tratta di una revisione 1.
Mi è arrivato il modulo, la scansione delle reti funziona ma non mi si connette all'access point, cui altri moduli ESP8266 si connettono senza problemi. Potrebbe essere colpa dell'AP ma non ho avuto tempo di indagare.
Si tratta di una revisione 1.
Grazie, tienici aggiornati sugli sviluppi!
Funziona! A casa mi si è connesso regolarmente, al lavoro invece non si è connesso all'AP costituito da un pennino WiFi e Virtual Router, forse ho sbagliato qualcosa perché di solito le difficoltà di connessione le ho nell'assegnazione dell'IP ma in questo caso nel Virtual Router Manager vedo la connessione lo stesso e in questo caso non ho visto nulla.
A questo punto mi scarico il PDF di Neil Kolban, che ha già scritto quello sull'ESP8266 (solo in inglese), che dovrebbe riportare tutto quello che si conosce su questo chip. Su GitHub ho visto degli esempi e la libreria BLE è la sua.
Io ho installato il core manualmente senza git.
Ho scaricato il repository da GitHub e l'ho decompresso in hardware/espressif/esp32 se lo mettete in un'altra cartella l'IDE non lo vede. La cartella hardware è una sottocartella di quella dove stanno i vostri sketch, dove c'è anche la libraries.
Poi ho scaricato la singola libreria BLE dal sito di Neil usando downGit che ti permette di scaricare una singola parte di un repository e l'ho decompressa in hardware/espressif/esp32/libraries/BLE
Se non lo fate il core funziona lo stesso ma ovviamente non potete usare il BLE e l'IDE vi darà continuamente errore sulla libreria perché vede la cartella ma dentro non c'è nulla.
Infine vado nella cartella hardware/espressif/esp32/tools e lancio get.exe come amministratore. Questo programma scaricherà il compilatore, un paio di file zip.
L'unico sketch che ho provato è quello che fa uso dei server NTP per sincronizzare l'orologio interno ed avere l'ora esatta tenendo conto di fuso orario e ora estiva ed invernale.
La storia che bluetooth e wifi non possono funzionare contemporaneamente è seccante. Il vantaggio di questo affare è che ci sono 2 core di cui uno gestisce il WiFi come l'ESP8266 mentre l'altro può fare... altro senza essere interrotto.
Rev1 l'hai testato con l'apposito comando ?
Affermativo!
Più precisamente con quello modificato da te.
Quindi funziona :)
Puoi postare il link per comprarne uno che i miei sono tutti Rev0 anche avendo preso degli Adafruit
Funziona si, quello precedente, per dire, non funziona perché c'è qualcosa non dichiarato.
A scanso di equivoci allego lo sketch.
L'ho preso da Aliexpress
https://www.aliexpress.com/item/LOLIN32-Wifi-Bluetooth-Development-Board-Antenna-ESP32-ESP-32-REV1-CH340-CH340G-MicroPython-Micro-USB-Lithium/32846143452.html (https://www.aliexpress.com/item/LOLIN32-Wifi-Bluetooth-Development-Board-Antenna-ESP32-ESP-32-REV1-CH340-CH340G-MicroPython-Micro-USB-Lithium/32846143452.html)
Ma devo ancora capire cosa farci perché i progetti che ho visto finora sono fattibili anche con un ESP8266 mentre questo affare ha molte più caratteristiche interessanti.
In effetti anch'io ho questo "problema": L'ESP8266 è già più che sufficiente per praticamente ogni progetto. Prendere un ESP32, che costa di più, ha un core meno maturo, ha alcuni problemi hardware (sulla Rev.0 almeno)... Chi me lo fa fare?
Possibili usi da verificare: gestione di moduli video (l'OV7670) e forse comunicazioni cifrate. La memoria RAM in più dovrebbe essere utile.
Ci sarebbe anche anche la generazione di segnali video anche se si spreca la parte WiFi.
C'è il discorso https, qui la cifratura è inyegrata in HW.
Poi il bluetooth, Sia Classic che Ble
Poi c'è il coprocessore, che può fare gestione di sensori tenendo spente le due Cpu.
Il problema è il core Arduino, che pur essendo Ufficiale è indietro anni luce.
Ad esempio il dns server è stato integrato da pochissimo solo grazie ai tipi di wifimanager coi quali ho collaborato rompendo le palle con issue e test :-)
Mentre il Webserver non c'è ancora, sei costretto ad usare webserver modificati da terzi.
Nemmeno il board manager è presente, purtroppo sembra che aver deciso di creare ufficialmente un core arduino invece di velocizzare le cose le rallenta
Le comunicazioni cifrate le avevo dimenticate. Se non sbaglio sull'ESP8266 sono possibili ma consumano un sacco di risosrse.
L'installazione manuale è un po' particolare, come ho scritto sopra non basta decomprimere il repository come succedeva con altri core. Installando git, come consigliato da expressif si risparmia lo scaricamento della sola libreria BLE e un po' si automatizza l'aggiornamento.
Buona giornata ragazzi
spero di non commettere cavolate ponendo qui la mia domanda,
visto che ci sono 180 topic pero mi trovo sul primo, non so come funziona,
la mia domanda, più cortesemente una richiesta di aiuto,
qui si parla della ESP8266 ma io credo sia molto simile alla ESP32 che io posseggo,
il problema e il seguente:
dopo molte ricerche sono riuscito a scrivere un file per una specie di telecomando via WiFi,
il tutto funziona correttamente fin tanto che la ESP si trova all'interno "ovviamente" del segnale WiFi,
ma se per un qualsiasi motivo perde il segnale, ovvio si di sconnette, ma poi anche se sono molto vicino al ruter ed ovviamente il segnale e presente lei non si connette più, perché si riconnetta la devo resettare,
vorrei postare il file ma non so se sia corretto farlo qui,
se posso lo posto volentieri
mille grazie a chi mi può dare qualche suggerimento per risolvere l'inghippo
Si che puoi postarlo, se non è troppo lungo mettilo in un post tra i tag [ code ] altrimenti mettilo come file allegato.
Ho spostato io gli ultimi due post nel thread dedicato al ESP32.
Guglielmo
Come ho scritto su, io ho avuto problemi banali di connessione che, con l'ESP8266 non ho mai avuto.
Non ho mai provato quel che capita a te ma posso confermare che con l'ESP8266 non succede, se perde la connessione poi evidentemente prova finché si riconnette. Ma è una cosa che fa la parte di firmware che non vediamo e che è curata da Espressif.
Qui sarà la stessa cosa ma temo che ancora il firmware sia immaturo, nonostante l'esperienza ESP8266.
Io metto comunque un controllo sulla connessione, e se é disconnesso provo a riconnettere.
Così hai la gestione di tutto senza affidarti a cose che non vedi
scusate il ritardo, ma viene prima la famiglia,
non ne combino una di giusta,
grazie Guglielmo di aver sistemato,
bene veniamo al problema della riconnessione posto il file
/***************************
Telecomando con ESP32
via WiFi
****************************/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <WiFi.h>
#define I2C_ADDR 0x27 // <<- indirizzo del PCF8574
#define Rs_pin 0
#define Rw_pin 1
#define En_pin 2
#define BACKLIGHT_PIN 3
#define D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7
LiquidCrystal_I2C lcd(I2C_ADDR, En_pin, Rw_pin, Rs_pin, D4_pin, D5_pin, D6_pin,
D7_pin);
#define btn1 5
#define btn2 23
#define btn3 14
#define btn4 12
#define led 18
boolean PB1_Flag;
boolean PB2_Flag;
boolean PB3_Flag;
boolean PB4_Flag;
unsigned long headLunga = 0;
unsigned long totLunga = 0;
// WiFi parametri
const char* ssid = "Mia_Linea"; // <<- definite la vostra rete WIFI
const char* password = "Mia_Password"; // <<- e la vostra password
// Si crea un' instance di server
WiFiServer server(80);
void DisplayClear(void) {
int i;
for (i = 0; i < 4; i++) {
lcd.setCursor(0, 0);
lcd.print(" ");
}
}
//*******************************************************************
void setup() {
// Viene inizializzato il display
lcd.begin(20, 4, LCD_5x10DOTS); // LCD 16x4 e formato caratteri
lcd.setBacklightPin(BACKLIGHT_PIN, POSITIVE);
lcd.setBacklight(HIGH); // accende Bachkight
// Si definiscono le porte e le condizioni iniziali
pinMode(btn1, OUTPUT);
digitalWrite(btn1, LOW);
pinMode(btn2, OUTPUT);
digitalWrite(btn2, LOW);
pinMode(btn3, OUTPUT);
digitalWrite(btn3, LOW);
pinMode(btn4, OUTPUT);
digitalWrite(btn4, LOW);
pinMode(led, OUTPUT);
digitalWrite(led, LOW);
// Start Seriale
Serial.begin(115200);
delay(10);
WiFi.begin(ssid, password); // inizializza la connessione WIFI
// Verifica lo stato fino a connessione avvenuta.
while (WiFi.status() != WL_CONNECTED) {
lcd.setCursor(0, 0);
lcd.print(" CONNESSIONE ");
lcd.setCursor(0, 1);
lcd.print(" IN CORSO ");
Serial.print(".");
delay(500);
}
DisplayClear();
lcd.setCursor(0, 0);
lcd.print("CONNESSO A: ");
lcd.setCursor(0, 1);
lcd.print(" ");
lcd.setCursor(0, 1);
lcd.print(ssid);
lcd.setCursor(0, 2);
lcd.print("INDIRIZZO IP: ");
lcd.setCursor(0, 3);
lcd.print(WiFi.localIP());
// Start del server
server.begin();
}
void loop() {
while (WiFi.status() != WL_CONNECTED) {
WiFi.reconnect();
digitalWrite(led, HIGH);
}
digitalWrite(led, LOW);
// Verifica se un client si è connesso
WiFiClient client = server.available();
if (!client) {
return;
}
// Attende di ricevere qualche dato
while (!client.available()) {
delay(1);
}
// Legge la richiesta fino a r, poi con client.flush elimina eventuali caratteri
// ricevuti ma non letti.
String req = client.readStringUntil('\r');
client.flush();
Serial.println(req);
//se viene ricevuta "GET/favicon.ico HTTP/1.1" risponde che non trova jl file
if (req.indexOf("favicon.ico") != -1) {
client.flush();
client.print("HTTP/1,1 404 Not Found\r\n");
Serial.println("Non Trovato");
delay(1);
} else {
if (req.indexOf("PB1ON") != -1) {
digitalWrite(btn1, HIGH);
PB1_Flag = true;
}
if (req.indexOf("PB1OFF") != -1) {
digitalWrite(btn1, LOW);
PB1_Flag = false;
}
if (req.indexOf("PB2ON") != -1) {
digitalWrite(btn2, HIGH);
PB2_Flag = true;
}
if (req.indexOf("PB2OFF") != -1) {
digitalWrite(btn2, LOW);
PB2_Flag = false;
}
if (req.indexOf("PB3ON") != -1) {
digitalWrite(btn3, HIGH);
PB3_Flag = true;
}
if (req.indexOf("PB3OFF") != -1) {
digitalWrite(btn3, LOW);
PB3_Flag = false;
}
if (req.indexOf("PB4ON") != -1) {
digitalWrite(btn4, HIGH);
PB4_Flag = true;
}
if (req.indexOf("PB4OFF") != -1) {
digitalWrite(btn4, LOW);
PB4_Flag = false;
}
String buff = "HTTP/1.1 200 OK\r\n Content-Type:text/html\r\n content-lenght:2166\r\n\r\n";
headLunga = buff.length();
buff += "<html>";
buff += "<head><title>TETECOMANDO</title>";
buff += "<style type=\"text/css\">";
buff += "td{align:center;width:auto;height:70px;}";
buff += "</style></head>";
buff += "<body style=\"width:99,99%;height:99,99%\">";
buff += "<div align=\"center\">";
buff += "<table style=\"width:auto;background-color:#dcdcdc\">";
buff += "<thead style=\"width:100%;background-color:#6699FF\">";
buff += "<tr><th colspan=\"5\"style=\"font-weight:bold;font-size:2em\">TELECOMANDO</th></tr></thead>";
buff += "<tr>";
if (PB1_Flag) {
buff += "<td><a href=\"/?PB1ON\"><button style=\"background-color:#008000;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b> ON </font></button></a></td>";
buff += "<td><a href=\"/?PB1OFF\"><button style=\"background-color:#ffff66;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>OFF</font> </button></a></td>";
} else if (!PB1_Flag) {
buff += "<td><a href=\"/?PB1ON\"> <button style=\"background-color:#ffff66;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b> ON </font></button></a></td>";
buff += "<td><a href=\"/?PB1OFF\"><button style=\"background-color:#cc0000;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>OFF</font></button></a></td>";
}
buff += "<td><h3>LUCE GIARDINO</h3></td></tr>";
buff += "<tr>";
if (PB2_Flag) {
buff += "<td><a href=\"/?PB2ON\"><button style=\"background-color:#008000;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>ON</font></button></a></td>";
buff += "<td><a href=\"/?PB2OFF\"><button style=\"background-color:#ffff66;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>OFF</font></button></a></td>";
} else if (!PB2_Flag) {
buff += "<td><a href=\"/?PB2ON\"><button style=\"background-color:#ffff66;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>ON</font></button></a></td>";
buff += "<td><a href=\"/?PB2OFF\"><button style=\"background-color:#cc0000;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>OFF</font></button></a></td>";
}
buff += "<td><h3>LUCE INGRESSO</h3></td></tr>";
buff += "<tr>";
if (PB3_Flag) {
buff += "<td><a href=\"/?PB3ON\"><button style=\"background-color:#008000;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>ON</font></button></a></td>";
buff += "<td><a href=\"/?PB3OFF\"><button style=\"background-color:#ffff66;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>OFF</font></button></a></td>";
} else if (!PB3_Flag) {
buff += "<td><a href=\"/?PB3ON\"><button style=\"background-color:#ffff66;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>ON</font></button></a></td>";
buff += "<td><a href=\"/?PB3OFF\"><button style=\"background-color:#cc0000;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>OFF</font></button></a></td>";
}
buff += "<td><h3>LUCE NOTTURNA</h3></td></tr>";
buff += "<tr>";
if (PB4_Flag) {
buff += "<td><a href=\"/?PB4ON\"><button style=\"background-color:#008000;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>ON</font></button></a></td>";
buff += "<td><a href=\"/?PB4OFF\"><button style=\"background-color:#ffff66;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>OFF</font></button></a></td>";
} else if (!PB4_Flag) {
buff += "<td><a href=\"/?PB4ON\"><button style=\"background-color:#ffff66;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>ON</font></button></a></td>";
buff += "<td><a href=\"/?PB4OFF\"><button style=\"background-color:#cc0000;width:99%;height:99%;border-radius:15px\">";
buff += "<font size=\"6\"><b>OFF</font></button></a></td>";
}
buff += "<td><h3>LUCE SCALA</h3></td></tr>";
buff += "</table></div></body></html>";
totLunga = buff.length();
Serial.print("lunghezza intestazione = ");
Serial.println(headLunga);
Serial.print("lunghezza totale = ");
Serial.println(totLunga);
// Invia la risposta al client
client.print(buff);
delay(1);
}
}
spero che qualcuno mi possa dare qualche dritta
toni
Ciao ragazzi, è da un pò che ci smanetto con l'esp32, ma ora mi sono bloccato a un progetto,
1) volevo avere una connessione diretta wifi tra due esp32 senza l'uso di un access point (accendere un led)
2) avere una connessione diretta tra esp32 e android (accendendo un led)
Ci smanetto da vari giorni, ho impostato un esp32 in modalità softAP nel loop ho messo questo e non funziona
void loop(){
WiFiClient client = server.available();
if (client) {
Serial.println("New Client.");
String currentLine = "";
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n') {
if (currentLine.length() == 0) {
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println();
client.print("Click <a href=\"/H\">here</a> to turn the LED on pin 5 on.<br>");
client.print("Click <a href=\"/L\">here</a> to turn the LED on pin 5 off.<br>");
client.println();
break;
} else {
currentLine = "";
}
} else if (c != '\r') {
currentLine += c;
}
if (currentLine.endsWith("GET /H")) {
digitalWrite(5, HIGH); }
if (currentLine.endsWith("GET /L")) {
digitalWrite(5, LOW);
}
}
}
client.stop();
Serial.println("Client Disconnected.");
}
}
>andrea1201: ti ricordo che in conformità al regolamento (http://forum.arduino.cc/index.php?topic=149082.0), punto 7, devi editare il tuo post qui sopra (quindi NON scrivendo un nuovo post, ma utilizzando il bottone More -> Modify che si trova in basso a destra del tuo post) e racchiudere il codice all'interno dei tag CODE (... sono quelli che in edit inserisce il bottone con icona fatta così: </>, tutto a sinistra).
In pratica, tutto il tuo codice dovrà trovarsi racchiuso tra due tag: [code] _il _tuo_ codice_ [/code] così da non venire interpretato e non dare adito alla formazione di caratteri indesiderati o cattiva formattazione del testo. Grazie.
Guglielmo
>andrea1201: ti ricordo che in conformità al regolamento (http://forum.arduino.cc/index.php?topic=149082.0), punto 7, .....
Grazie l'avevo dimenticato :D
File json da inserire nell'IDE.
https://dl.espressif.com/dl/package_esp32_dev_index.json (https://dl.espressif.com/dl/package_esp32_dev_index.json)
Alla fine dopo un sacco di messaggi su github lo hanno fatto. Sai se scarica anche le librerie che sono al di fuori del repository come la bluetooth? Io ho capito di no, anche se non è un problema, basta saperlo.
No, non le scarica
Credo sia voluto
Nel momento in cui le scaricasse l'utente crederebbe fossero parte integrante del progetto, portando ad aprire issue sul core esp in caso di problemi ad esempio sul BT
Comunque non capisco questa via di mezzo, o le tieni dentro o fuori, che senso ha averle così ?
Rilasciato il core stabile per ESP32
--> https://github.com/espressif/arduino-esp32/blob/master/docs/arduino-ide/boards_manager.md (https://github.com/espressif/arduino-esp32/blob/master/docs/arduino-ide/boards_manager.md)
Incluso di board manager finalmente :)
Eliminato il vecchio core e installato il nuovo: la libreria bluetooth è inclusa!
Ottimo, quindi va a scaricarla automaticamente via board manager, visto che nel core non é presente
Salve a tutti,
volevo sapere come inviare comandi AT di ESP32 per confingurare il bluetooth tradizionale(non il BLE). Utilizzo un sistema operativo Linux e vorrei evitare di installare Microsoft Windows. Grazie.
>Andrea_81: essendo il tuo primo post, nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (http://forum.arduino.cc/index.php?topic=113640.0) (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con MOLTA attenzione il su citato REGOLAMENTO (http://forum.arduino.cc/index.php?topic=149082.0) ... Grazie.
Guglielmo
Scusate il disturbo, mi sono arrivate le schedine ESP32, una la Nano (LOLIN) e l'altra la DEVKIT V1.
Nesson problema per la LOLIN
Problema su quella più "grande", la DEVKIT
Apro la seriale e schiaccio il reset: OK, mi trasmette tutto quello che deve.
Ho anche io il problema, come molti da quanto ho visto, che non riesco a caricare niente perche dopo connecting mi da l'errore Failed to connect ESP32 timeout waiting ecc ecc ecc
C'è qualcuno che sa il perché?
Grazie in anticipo.
TROVATO, dopo un po' di surfing in internet.
Quando IDE scrive Connecting ....._____..... basta premere il tasto BOOT fino a quando non inizia la trasmissione.
I parametri che ho usato sono:
Scheda: ESP 32 Dev Module
Flash mode: DIO
Flash size: 4Mb
Partition scheme: Pochi
Flash frequency: 80Mhz
Upload speed: 921600
Salve a tutti,
volevo sapere come inviare comandi AT di ESP32 per confingurare il bluetooth tradizionale(non il BLE). Utilizzo un sistema operativo Linux e vorrei evitare di installare Microsoft Windows. Grazie.
Comandi AT su ESP32 ?
Spreco inutile, la forza di questo modulo sta proprio nel poterlo programmare evitando di abbinarlo ad una mcu.
Comunque ho visto che e' uscito il manuale dei comandi at anche per esp32 (attenzione che non devi averlo programmato, devi lasciarlo cosi' come da fabbrica)
cerca sul sito Espressif il manule comandi AT
--> https://github.com/espressif/esp32-at (https://github.com/espressif/esp32-at)
chiedo già scusa per la domanda ingenua, ma non ho ancora capito cosa centra questo modulo con arduino.
ovvero è completamente compatibile con il codice già scritto per arduino?
Esatto, se hai scritto codice ad alto livello (senza accessi a registri, ecc...) e non usi pin che su questo modulo non ci sono, non dovresti avere molte difficoltà ad adattare i tuoi sketch.
Ciao a tutti
Sto cercando da giorni di risolvere un problema con un ESP32 che riguarda l'utilizzo del modulo per applicazioni di bridging da UART a BLE e UART a WIFI.
I dettagli li trovate in forum ufficiale ESP32 a questo link
https://www.esp32.com/viewtopic.php?f=2&t=8407 (https://www.esp32.com/viewtopic.php?f=2&t=8407)
Praticamente all'avvio della board l'applicazione va a controllare lo stato di un GPIO e a seconda che sia alto o basso parte in modalità bridge per BLE o per WIFI
Il problema nasce dal fatto che:
- se carico l'applicativo per funzionare in BLE e commento la parte WIFI va tutto
- se carico l'applicativo per funzionare in WIFI e commento la parte BLE va tutto
- se carico l'applicativo per funzionare in BLE o WIFI non commentando il codice di entrambi l'applicativo parte lasciando sulla seriale in output un messaggio di IllegalIstruction, StoreProhibited o LoadProhibited.
Sembra quasi che all'avvio dell'applicativo venga sforata la RAM a disposizione.
Il modulo non utilizza moduli esterni per estendere la RAM quindi utilizza quella fornita dall'ESP-WROOM32.
Qualcuno ha avuto esperienza in merito o ha già avuto un problema simile?
Nel caso si tratti come penso di un problema di memoria, avete dritte da darmi per cercare di ridurre uno dei due stack al minimo necessario per un applicazione di bridging per BLE e WIFI?
Grazie
Fabrizio
Quando compili quanta ram ti resta libera ?
Posta la scritta che appare a fine compilazione.
Grazie del suggerimento. Alla fine non era la RAM ma era la FLASH che non bastava.
Risolto cambiando partition scheme.
Buongiorno, qualcuno può cortesemente spiegarmi cos'è e come funziona in modo semplice la SPIFFS?
Si tratta di una partizione della flash che può essere utilizzata per memorizzare file, quasi come se fosse una SD.
Si tratta di una partizione della flash che può essere utilizzata per memorizzare file, quasi come se fosse una SD.
Si qualcosa o trovato e sono riuscito a creare la partizione, fare l'upload dei files (immagini nel mio caso) e leggerli/visualizzarli su TFT.
Ho usato il tool esp32fs.jar però non so come vedere tutto il contenuto della partizione e/o eliminare file non pià utili.
Togli il file dalla cartellina sul tuo pc e fai upload :)
Togli il file dalla cartellina sul tuo pc e fai upload :)
:o
Non ci sarei mai arrivato! :D
Rilasciata nuova versione stabile 1.0.1 alcune settimane fa.
Testata e posso dire che risolve diversi problemi su BLE (compatibilità Android e iOS)
Qualcuno ha esperienza sul riuscire a fare andare BLE e WiFi in contemporanea utilizzando il core di Arduino? (No esp-idf framework per capirci)
Leggendo in giro dovrebbe essere possibile dividendo sui due core due task che si dividono l'antenna.
A che so io non si può fare perché anche la radio è la stessa.
Se é così non si può nemmeno con Idf.
Dobbiamo dire che é un modulo "Wifi o Bt" non "Wifi + Bt" :smiley-roll-sweat:
Mi pare sia possibile però alternare WiFi e Bluetooth
Con alternare intendi una specie di multiplexing in modo da dare l'illusione che siano utilizzati contemporaneamente ?
No, se non ricordo male quando parli in bluetooth il WiFi è praticamente scollegato e spento e quando parli in WiFi vicerversa. Non so con che velocità possa avvenire questo cambio per cui non so se è possibile effettuare una sorta di multiplexing.
Quindi sempre di modulo "Wifi o Bt" si deve parlare :)
Ho trovato QUESTA (http://bbs.esp32.com/viewtopic.php?t=6707) discussione, la cui conclusione mi pare abbastanza chiara:
Again, this is not a software issue. The ESP32 only has one radio and only one antenna. This radio and antenna, if viewed in a somewhat simplified fashion, can be used for one of six things: send a WiFi packet, send a BT packet, listen for a WiFi packet, listen for a BT packet, receive a WiFi packet, receive a BT packet. I think we actually do some magic that allows us to listen for BT and WiFi packets at the same time in some circumstances, but in general, we're limited to doing only one of these things. To get around this, we would need a separate radio and antenna, something which is not in the current ESP32. No software hacks can change this, because it's a hardware limitation, not a software one.
Guglielmo
Grazie della ricerca, sarebbe interessante capire precisamente cosa intende con:
we actually do some magic that allows us to listen for BT and WiFi packets at the same time in some circumstances
Scusate se disturbo, ma non capisco come scrivere su EEPROM col modulo ESP32 DEVKIT
Ho seguito le istruzioni ma nelle celle 0 - 1 - 2 - 3 ecc trovo sempre ZERO
Ho scritto
EEPROM.begin(1); nel setup e poi
lcd.clear ();
lcd.print (F(" W R I T I N G "));
EEPROM.write (0, set1);
EEPROM.write (1, set2);
EEPROM.write (2, set3);
EEPROM.write (3, setAux);
EEPROM.write (4, DPset);
EEPROM.commit ();
delay (800);
La domanda che mi faccio è: la libreria EEPROM.h è la stessa?
Se non fosse la stessa perché si fa riferimento sempre a questo nome di libreria?
Comunque non ho nessun errore, anche con i due comandi (begin e commit) che non ho mai usato su NANO.
Naturalmente la lettura la faccio così:
int set1 = EEPROM.read (0);
int set2 = EEPROM.read (1);
int set3 = EEPROM.read (2);
int setAux = EEPROM.read (3);
int DPset = EEPROM.read (4);
SE (
non ho mai usato il ESP32) funziona come sul ESP8266, in realtà
NON c'è una EEPROM, ma, si alloca della RAM con la begin(), si scrive con le write() e si trasporta da RAM a Flash (
viene usata la Flash per simulare la EEPROM) al momento della commit().
Dalla documentaione del ESP8266 "core" ...
EEPROM
This is a bit different from standard EEPROM class. You need to call EEPROM.begin(size) before you start reading or writing, size being the number of bytes you want to use. Size can be anywhere between 4 and 4096 bytes.
EEPROM.write does not write to flash immediately, instead you must call EEPROM.commit() whenever you wish to save changes to flash. EEPROM.end() will also commit, and will release the RAM copy of EEPROM contents.
EEPROM library uses one sector of flash located just after the SPIFFS.
Guglielmo
P.S.: Sulla Nano non hai mai suato la begin() e commit() perché NON ci sono, la libreria per ESP è differente.
...
P.S.: Sulla Nano non hai mai suato la begin() e commit() perché NON ci sono, la libreria per ESP è differente.
Era quello che immaginavo, però ha lo stesso nome...
Era quello che immaginavo, però ha lo stesso nome...
... e che vuol dire ? ? ? :)
Ogni "
core" che implementa librerie standard è costretto ad adattarle per fale funzionare sul hardware che gestice aggiungendo, modificando, adattando o ... eliminando i vari metodi.
Guglielmo
Se scrivi degli int, credo che su ESP32 occupino 32 bit, quindi devi scriverli ad indirizzi spaziati di 4.
Allora, qui c'è un po' di confusione, magari non è tutta mia...
Però caricando gli esempi e lavorandoci su ho capito diverse cose:
- intanto lo sapevate che se includo la libreria EEPROM da MENU, questa appare colore rosso mentre se la scrivo a mano appare di colore verde scuro (anche se a livello pratico non noto differenze) ?
- poi con i "credo" purtroppo si aggiunge confusione (anche se in buona fede, ci mancherebbe SukkoPera)
La EEPROM viene gestita a bytes :
"With the ESP32 and the EEPROM library you can use up to 512 bytes in the flash memory. This means you have 512 different addresses, and you can save a value between 0 and 255 in each address position."
Quindi con
EEPROM.begin(5);
vado a dire a ESP32 che voglio usare 5 celle della sua memoria, dalla 0 alla 4, su cui posso scrivere 5 bytes.
- l'errore che nessuno ha notato è che io, come su NANO, inizializzavo delle variabili così
int set1 = EEPROM.read (0);
int set2 = EEPROM.read (1);
int set3 = EEPROM.read (2);
int setAux = EEPROM.read (3);
int DPset = EEPROM.read (4);
mentre (a causa di EEPROM.begin) prima devo dichiarare le variabili e solo dopo l'istruzione
EEPROM.begin (5);
posso leggerle, altrimenti ottengo sempre ZERO anche se sono scritte correttamente.
int set1;
int set2;
int set3;
int setAux;
int DPset;
void setup ()
EEPROM.begin(5);
set1 = EEPROM.read (0);
set2 = EEPROM.read (1);
set3 = EEPROM.read (2);
setAux = EEPROM.read (3);
DPset = EEPROM.read (4);
Questa non l'ho capita.
Cioè dici che le variabili devono essere globali altrimenti non funziona?
O che il compilatore non riesce a gestire l'allocazione della memoria su cui salvare il risultato contestualmente alla lettura del valore tramite chiamata di funzione?
O che l'esito dipende dalla funzione chiamata?
O solo che prima non mettevi la
EEPROM.begin(5);
prima di fare le read?
...
O solo che prima non mettevi la
EEPROM.begin(5);
prima di fare le read?
La EEPROM.begin (5) la posso solo fare nel void setup ()
Di seguito leggo le variabili da EEprom, però prima del void setup () le devo dichiarare.
Su NANO le leggevo già in fase di dichiarazione, prima del void setup ()
però, se la
EEPROM.begin(5)
è nel setup, nel loop puoi comunque fare
int set1 = EEPROM.read (0);
...
e dovrebbe funzionare.
Non dovrebbe richiedere variabili globali.
la set1 è il posto dove decidi di salvare il valore che ti passa la read, potrebbe anche essere il parametro di una funzione, non una variabile locale o globale che sia, il funzionamento della read non dovrebbe dipendere da questo.
Giusto?
però, se la
EEPROM.begin(5)
è nel setup, nel loop puoi comunque fare
int set1 = EEPROM.read (0);
...
Giusto?
Eh no, perché ho anche un soubroutine di scrittura
void scrivi () { //subroutine di scrittura su EEPROM interna
lcd.clear ();
lcd.print (F(" W R I T I N G "));
EEPROM.write (0, set1);
EEPROM.write (1, set2);
EEPROM.write (2, set3);
EEPROM.write (3, setAux);
EEPROM.write (4, DPset);
EEPROM.commit ();
delay (800);
lcd.clear ();
e quando compilo mi da errore
'DPset' was not declared in this scope
Ma anche levando questo ciclo di scrittura, al primo utilizzo di una di quelle variabili mi da errore, quindi vanno globali
- poi con i "credo" purtroppo si aggiunge confusione (anche se in buona fede, ci mancherebbe SukkoPera)
Nessun problema. D'ora in poi invece di darti un suggerimento che magari ti permette di andare avanti da solo con un minimo di ricerca farò che stare zitto.
Eh no, perché ho anche un soubroutine di scrittura
Ok, quindi dipende da come hai strutturato tu il codice, non dalla libreria.
Ovvio che le varie funzioni (subroutine) vedono solo le variabili globali e non quelle locali dichiarate altrove.
Ora mi torna.
Scusa l'intermezzo ma:
mentre (a causa di EEPROM.begin) prima devo dichiarare le variabili e solo dopo l'istruzione
EEPROM.begin (5);
posso leggerle, altrimenti ottengo sempre ZERO anche se sono scritte correttamente.
non mi quadrava proprio.
Se scrivi degli int, credo che su ESP32 occupino 32 bit, quindi devi scriverli ad indirizzi spaziati di 4.
E' solo che con questo consiglio mi sono intestardito a modificare continuamente il valore di EEPROM.begin() e non ottenevo nulla. Poi sono andato di nuovo in giro per internet e ho capito diverse cose (anche se spiegate male).
EEPROM.begin() ha un senso proprio perchè ESP32 non ha una EEPROM quindi, come diceva Guglielmo, riservi della memoria PRIMA di eseguire il programma perché magari uno può anche scrivere EEPROM.begin(512) ma in questo modo porti via memoria per altre cose.
Un int è di 16 bit e si memorizza come con NANO e cioè
EEPROM.write (3, highByte(variabile1));
EEPROM.write (4, lowByte (variabile1));
quindi usi due celle di memoria per avere i 2 bytes
A me, SukkoPera, i tuoi consigli sono sempre stati utili quindi se vorrai continuare a darmeli te ne sarò grato.
Ho trovato questo (https://github.com/espressif/arduino-esp32/issues/1745), vi risulta?
Qui dice che l'int è a 4 byte su ESP32 in base ai suoi test.
Ho trovato anche questo (https://www.robolinkmarket.com/datasheet/kolban-ESP32.pdf) e a pag. 416 elenca i tipi dato con le dimensioni e indica 4 byte per gli int.
Sono documenti farlocchi oppure effettivamente l'int è a 4 byte, cioè 32 bit?
Ovvio che se sul codice si dichiara int16_t o uint16_t si forza a 16 bit a prescindere dai tipi nativi della piattaforma.
Controllando su uno dei "sacri testi" (Kolban's Book on ESP32" di Neil Kolban), confermo che:
(https://forum.arduino.cc/index.php?action=dlattach;topic=358374.0;attach=294128)
Guglielmo
E' sicuramente così.
Le mie prove si limitano a mettere dei numeri oltre 255, quindi 300 o 400 e in questo modo anche se si sovrastano uno con l'altro non si nota alla successiva lettura con solo 2 bytes.
Controllando su uno dei "sacri testi" (Kolban's Book on ESP32" di Neil Kolban)
che per puro caso è proprio quello che avevo linkato io poco sopra ;) e che riporta quella tabella proprio a pag. 416... ho anticipato il maestro :P
Quindi possiamo togliere il "forse" dal post di
@SukkoPera e fare pace tutti? ;)
Io mi son chiarito i dubbi. bye.
int è legato all'architettura, è normale che su mcu diverse hai dimensioni diverse.
Per aumentare la chiarezza e la portabilità io consiglio sempre di udare i nomi autoesplicativi che includono la dimensione, tipo:
uint8_t
Esatto, e soprattutto int dovrebbe rappresentare il tipo "nativo", quello con cui l'architettura in questione esegue le operazioni più velocemente. E il fatto che la piattaforma si chiami ESP32...
ma in genere il numero sulla sigla, quando assume un significato di questo tipo, si riferisce ai bit di indirizzamento o sbagio? ;)
No, di solito è la dimensione del bus dati e, dunque, dei registri interni e, dunque, quella che ogni singola istruzione elabora.
mi sa che hai ragione tu
(https://www.clinicaveterinariacmv.it/dp-admin/ckeditor/kcfinder/upload/images/vomito-cane-malato%281%29.jpg)
No, di solito è la dimensione del bus dati e, dunque, dei registri interni e, dunque, quella che ogni singola istruzione elabora.
...
in principo era ... la dimensione della
ALU (
l'unità aritmetico/logica), ovvero il numero di bit che trattava.
Il primo micro
Intel i4004 era una
CPU a 4 bit, aveva la ALU a 4 bit ed una serie di registri affiancati (
parte bassa e parte alta) da poter unire per trattare anche 8 bit (
una word) ... è la prima CPU su cui ho lavorato ... anni '70 :D :D :D
(https://hackadaycom.files.wordpress.com/2018/01/intel_c4004_b.jpg?w=646)
Guglielmo
P.S.: In allegato il datasheet ... :D
Bei tempi. Io cominciai con z80 con Nuova Elettronica...
Buongiorno,
nella speranza di non aver sbagliato sezione, in caso contrario chiedo scusa ed invito i mod a spostare il mio post in sezione Software, vorrei da parte vostra un aiuto per ottimizzare questa porzione di codice:
void wifi()
{
tft.setTextSize(1);
while (WiFi.status() != WL_CONNECTED) {
if (previousMillisWiFi < intervalWiFi)
{
previousMillisWiFi = millis();
Serial.print(".");
delay(500);
}
else break;
}
}
void WiFiScan()
{
unsigned long attesa = 0;
do {
Touch();
//Una volta ogni 10 secondi per dare il tempo necessario di recepire eventuali azioni durante la scansione WiFi
if (millis() - attesa > 10000)
{
int n = 0;
attesa = millis();
tft.setTextColor(TFT_YELLOW, TFT_BLACK);
// WiFi.scanNetworks will return the number of networks found
n = WiFi.scanNetworks();
if (n == 0) {
tft.setTextColor(TFT_RED, TFT_YELLOW);
tft.fillRect(58, 65, 216, 155, TFT_BLACK); //pulisco l'area di scansione WiFi
tft.fillRect(56, 44, 219, 17, TFT_BLACK); //pulisco l'area di scansione WiFi
tft.drawString("WiFi Assenti!", 95 , 110, 4);
esp_wifi_wps_disable();
Serial.println("RIAVVIO WPS");
wps();
}
else {
tft.drawRect(55, 10, 223, 215 , TFT_BLUE);
tft.drawFastHLine(55, 42, 223, TFT_BLUE);
tft.drawFastHLine(55, 62, 223, TFT_BLUE);
tft.setTextColor(TFT_RED);
tft.drawString("Premi il tasto WPS sul tuo router", 62 , 10, 2);
tft.drawString("ed attendi la connessione", 95 , 25, 2);
x = 65;
y = 45;
spr.createSprite(219, 17); // Creo lo sprite 219 pixels di lunghezza e 17 di altezza
spr.fillSprite(TFT_BLACK);
spr.setTextColor(0x000F);
spr.setCursor(x, y);
x += spr.drawNumber (n, x , y, 2);
x += spr.drawString(" reti trovate", x , y, 2);
spr.pushSprite(57, 43); // Posiziono la scritta
spr.deleteSprite(); // Libero la memoria
y = 1;
spr.createSprite(219, 160); // Creo lo sprite 219 pixels di lunghezza e 160 di altezza
spr.fillSprite(TFT_BLACK);
spr.setTextColor(0x000F);
for (int i = 0; i < n; ++i) {
// Print SSID and RSSI for each network found
x = 1;
spr.setCursor(x, y);
spr.setTextColor(0x000F);
x += spr.drawNumber(i + 1, x , y, 2);
x += spr.drawString(": ", x , y, 2);
x += spr.drawString(WiFi.SSID(i), x , y, 2);
x += spr.drawString(" (", x , y, 2);
x += spr.drawNumber(WiFi.RSSI(i), x , y, 2);
x += spr.drawString(")", x , y, 2);
x += spr.drawString((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " " : "*", x , y, 2);
y = y + 15;
}
spr.pushSprite(57, 63); // Posiziono la scritta
spr.deleteSprite(); // Libero la memoria
}
if (WiFi.status() != WL_CONNECTED) {
Serial.println("AVVIO WPS");
WiFi.onEvent(WiFiEvent);
WiFi.mode(WIFI_MODE_STA);
wpsInitConfig();
esp_wifi_wps_enable(&config);
esp_wifi_wps_start(0);
}
else {
tft.unloadFont(); // Remove the font to recover memory use
spr.unloadFont(); // Remove the font to recover memory use
tft.setTextSize(1);
tft.fillScreen(TFT_BLACK);
tft.setCursor(40, 110);
tft.print("Connesso a: ");
tft.println(WiFi.SSID());
tft.print("IP Address: ");
tft.println(WiFi.localIP());
delay(3000);
tft.fillScreen(TFT_BLACK);
Maschera();
Home();
Update_time();
break;
}
}
} while (!pressed);
tft.fillScreen(TFT_BLACK);
Maschera();
Home();
}
void wps()
{
Maschera();
if (WiFi.status() != WL_CONNECTED) {
Serial.println("AVVIO WPS");
WiFiScan();
}
}
Ciò che vorrei è che quando richiamo la funzione wps() la mia Lolin D32 Pro mi faccia la scansione delle reti WiFi e, nel caso in cui io abbia premuto il tasto WPS sul mio router si agganci automaticamente e torni sulle schermate di default Maschera() ed Home().
Tra l'altro sono stato costretto a mettere un delay molto lungo di 10 secondi tra i cicli di scansione della WiFi perchè riducendolo il touch del display non riusciva a reagire prontamente alla pressione del tasto.
Un'altro grosso problema è gestire il buzzer poichè utilizzando la libreria EasyBuzzer.h spesso il cicalino va in tilt.
Grazie per l'aiuto.
Ho provato la tua modifica (prima ti avevo letto sul forum inglese) e sul mio programma quella parte di programma funziona. (anche se devo pensare come dargliene un'altra per vedere se funziona... Modifico il mio SSID?...Modifico la Password?...)
D'accordo che non me ne può fregare di meno di nome SSID e Password, ma siamo sicuri che l'ultima configurazione rimane memorizzata su ESP32?
E, comunque, se volessi farne una copia su EEPROM come dovrei fare
Ciao, spero di aver azzeccato il topic.
Sto facendo qualche prova con un ESP32:
Vorrei leggere i valori acquisti da un encoder su un app sul telefono tramite il BLE (praticamente vorrei vedere ciò che vedo sul serial monitor.
Ho buttato giù questo schizzo che non funziona...
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
BLECharacteristic *pCharacteristic;
bool deviceConnected = false;
int encoderPin1 = 2;
int encoderPin2 = 4;
volatile int lastEncoded = 0;
volatile long encoderValue = 0;
long lastencoderValue = 0;
int lastMSB = 0;
int lastLSB = 0;
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
class MyServerCallbacks: public BLEServerCallbacks {
void onConnect(BLEServer* pServer) {
deviceConnected = true;
};
void onDisconnect(BLEServer* pServer) {
deviceConnected = false;
}
};
void setup() {
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init("MyESP32");
// Create the BLE Server
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
// Create the BLE Service
BLEService *pService = pServer->createService(SERVICE_UUID);
// Create a BLE Characteristic
pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE |
BLECharacteristic::PROPERTY_NOTIFY |
BLECharacteristic::PROPERTY_INDICATE
);
// Create a BLE Descriptor
pCharacteristic->addDescriptor(new BLE2902());
// Start the service
pService->start();
// Start advertising
pServer->getAdvertising()->start();
Serial.println("Waiting a client connection to notify…");
pinMode(encoderPin1, INPUT_PULLUP);
pinMode(encoderPin2, INPUT_PULLUP);
attachInterrupt(0, updateEncoder, CHANGE);
attachInterrupt(1, updateEncoder, CHANGE);
}
void loop() {
if (deviceConnected) {
Serial.printf("*** NOTIFY: %d ***\n", encoderValue * 0.942/4,1);
pCharacteristic->setencoderValue(&encoderValue, 1);
pCharacteristic->notify();
//pCharacteristic->indicate();
encoderValue++;
}
void updateEncoder(){
int MSB = digitalRead(encoderPin1); //MSB = most significant bit
int LSB = digitalRead(encoderPin2); //LSB = least significant bit
int encoded = (MSB << 1) |LSB; //converting the 2 pin value to single number
int sum = (lastEncoded << 2) | encoded; //adding it to the previous encoded value
if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encoderValue ++;
if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encoderValue -;
lastEncoded = encoded; //store this value for next time
}
}
Per caso qualcuno saprebbe e sarebbe cosi' gentile da aiutarmi?
P.S
Abbiate pazienza per gli eventuali strafalcioni ma sono alle prime armi!
Simone
Come per il modulo ESP8266, così ora per il modulo ESP32, che ha raggiunto una certa maturità ed interessa sempre più persone, mi sembra giusto spostare questa discussione in area "Megatopic". :)
Guglielmo
Ottima idea, grazie.
Per il BLE non ci ho ancora giocato quindi non posso aiutarti, però due tips in generale:
- esp32 supporta anche BT classic, trovi degli esempi in giro
- tutti i cellulari supportano BT classic, non tutti il BLE quindi controllare sempre se il telefono è compatibile.
- se con il core Arduino non riesci puoi sempre usare quello ufficiale IDF, anche internamente all'Ide arduino credo
- tutti i cellulari supportano BT classic, non tutti il BLE quindi controllare sempre se il telefono è compatibile.
Purtroppo NO ...
... tutti i device mobili
iOS supportano
SOLO BLE e NON BT v2.x,; tutti i device mobili Android supportano BT v2.x e, già da parecchio, quasi tutti anche BLE ;)
Guglielmo
Ottima idea, grazie.
Per il BLE non ci ho ancora giocato quindi non posso aiutarti, però due tips in generale:
- esp32 supporta anche BT classic, trovi degli esempi in giro
- tutti i cellulari supportano BT classic, non tutti il BLE quindi controllare sempre se il telefono è compatibile.
- se con il core Arduino non riesci puoi sempre usare quello ufficiale IDF, anche internamente all'Ide arduino credo
In realtà non ho problemi di connessione e riesco anche a passare e visualizzare dei valori di prova caricando uno sketch di esempio... Il mio problema è capire come passare i valori dell' encoder in particolare... Diciamo i valori provenienti a 2 ingressi.
Purtroppo NO ...
... tutti i device mobili iOS supportano SOLO BLE e NON BT v2.x,; tutti i device mobili Android supportano BT v2.x e, già da parecchio, quasi tutti anche BLE ;)
Guglielmo
Non considero l'esistenza delle melemorse :D
In realtà non ho problemi di connessione e riesco anche a passare e visualizzare dei valori di prova caricando uno sketch di esempio... Il mio problema è capire come passare i valori dell' encoder in particolare... Diciamo i valori provenienti a 2 ingressi.
Leggi il valore degli encoder, li piazzi in una variabile, li spedisci al BT.
Quale é il problema ?
Se dici che ricevi dati di esempi via BLE, guarda come fanno, e gli invii la variabile che contiene i tuoi encoder
In realtà non ho problemi di connessione e riesco anche a passare e visualizzare dei valori di prova caricando uno sketch di esempio... Il mio problema è capire come passare i valori dell' encoder in particolare... Diciamo i valori provenienti a 2 ingressi.
il tuo sketch così a naso sembra anche giusto.
Devi collegare i contatti di un encoder sui pin 2 e 4 mentre un eventuale terzo pin di bottone non é gestito (si assume che pin 2 e 4 siano pin di interrupt)
Quando i contatti vengono variati la funzione updateEncoder() vieene richiamata e incrementa la variabile encoderValue se ruoti in un senso mentre la decrementa se la ruoti nell'altro.
Tutta la parte di BLE crea un servizio e una caratteristica e le espone aggiornando il valore a ogni ciclo programma.
Se con un app da cellulare tipo nRF connect vai a fare una scansione dovresti trovare il device "MyESP32".
Entrandoci dentro dovresti riuscire a poter vedere la caratteristica e di conseguenza ruotando l'encoder dovresti vedere i valori variare (passi solo un byte quindi valori 0-255, occhio)
Secondo me questa istruzione non può andare
pCharacteristic->setencoderValue(&encoderValue, 1);
pCharacteristic->notify();
dovresti usare qualcosa tipo questo:
pTxCharacteristic->setValue(&encoderValue,1);
pTxCharacteristic->notify();
Prendi come riferimento questo esempio del leggendario Nicolone Kolbone
https://github.com/nkolban/ESP32_BLE_Arduino/blob/master/examples/BLE_uart/BLE_uart.ino
Se vuoi visualizzare il valore di piu' sensori basta che vai a notificare tali valori su piu' caratteristiche distinte
Spero di averti confuso le idee
Non considero l'esistenza delle melemorse :D
... se fossi uno sviluppatore sapresti che "
pecunia non olet" e quindi, visto lo
share di mercato, considereresti l'esistenza di entrambi i sistemi :smiley-twist:
Guglielmo
La pecunia non mi é mai interessata, sono comunista :smiley-yell:
La pecunia non mi é mai interessata, sono comunista :smiley-yell:
(http://www.nikonland.eu/forum/public/style_emoticons/default/post-42-1201873916.gif)
Guglielmo
il tuo sketch così a naso sembra anche giusto.
Devi collegare i contatti di un encoder sui pin 2 e 4 mentre un eventuale terzo pin di bottone non é gestito (si assume che pin 2 e 4 siano pin di interrupt) ...
Grazie mille!!!
In effetti sono un pò confuso ma piano piano forse ci capisco qualcosa!
Ne approfitto per farvi un' altra domanda: la mia intenzione è di alimentare il tutto con una batteria a bottone da 3volt.
Il problema è che misurando col tester l' uscita "Vin" ho appena 1,5 volt... Cosi a naso me ne sarei aspettato 3...
Come potrei fare per risolvere il "problema" e mantenere una tensione di 3 volt con cui alimentare l' encoder? (ammesso che ne trovi uno da 3 volt perchè quello che ho adesso sotto mano ne richiede 5)
--- Quando si quota un post, NON è necessario riportarlo (inutilmente) tutto; bastano poche righe per far capire di cosa si parla ed a cosa ci si riferisce. Gli utenti da device "mobile" ringrazieranno per la cortesia ;) - gpb01
Comunque ho provato ad aggiornare lo sketch con i suggerimenti:
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
BLECharacteristic *pTxCharacteristic;
bool deviceConnected = false;
int encoderPin1 = 2;
int encoderPin2 = 4;
volatile int lastEncoded = 0;
volatile long encoderValue = 0;
long lastencoderValue = 0;
int lastMSB = 0;
int lastLSB = 0;
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
class MyServerCallbacks: public BLEServerCallbacks {
void onConnect(BLEServer* pServer) {
deviceConnected = true;
};
void onDisconnect(BLEServer* pServer) {
deviceConnected = false;
}
};
void setup() {
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init("MyESP32");
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
BLEService *pService = pServer->createService(SERVICE_UUID);
// Create a BLE Characteristic
pTxCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE |
BLECharacteristic::PROPERTY_NOTIFY |
BLECharacteristic::PROPERTY_INDICATE
);
pTxCharacteristic->addDescriptor(new BLE2902());
// Start the service
pService->start();
// Start advertising
pServer->getAdvertising()->start();
Serial.println("Waiting a client connection to notify...");
pinMode(encoderPin1, INPUT_PULLUP);
pinMode(encoderPin2, INPUT_PULLUP);
attachInterrupt(0, updateEncoder, CHANGE);
attachInterrupt(1, updateEncoder, CHANGE);
}
void loop(){
if (deviceConnected) {
Serial.printf("*** NOTIFY: %d ***\n", encoderValue * 0.942/4,1);
pTxCharacteristic->setValue(&encoderValue * 0.942/4,1);
pTxCharacteristic->notify();
//pTxCharacteristic->indicate();
encoderValue++;
}
void updateEncoder(){
int MSB = digitalRead(encoderPin1); //MSB = most significant bit
int LSB = digitalRead(encoderPin2); //LSB = least significant bit
int encoded = (MSB << 1) |LSB; //converting the 2 pin value to single number
int sum = (lastEncoded << 2) | encoded; //adding it to the previous encoded value
if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encoderValue ++;
if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encoderValue --;
lastEncoded = encoded; //store this value for next time
}
Però mi da diversi errori...
Il problema fondamentale di iOS è che non puoi installarti le app fatte da te se non attraverso lo store a meno che non diventi sviluppatore. Per dire, io una app Android la posso persino testare su un PC.
@simone91,
ma tu l'encoder lo riesci a leggere e a mandare i valori sulla seriale?
L'app bluetooth è un terminale seriale su bluetooth o qualcosa di più evoluto?
[OFF-TOPIC]
Il problema fondamentale di iOS è che non puoi installarti le app fatte da te se non attraverso lo store a meno che non diventi sviluppatore. Per dire, io una app Android la posso persino testare su un PC.
Non è del tutto esatto, hanno cambiato alcune cose. Di sicuro, se vuoi "aprire al pubblico" la tua app, allora devi pagare la quota annuale di sviluppatore, ma per uso personale (
solo sui TUOI devices), sono cambiate alcune cose.
Da sempre le App le puoi provare (
... anzi DEVI provarle, altrimenti come fai il debug?) con il simulatore su desktop, simulatore che è
sempre esistito.
Guglielmo
[/OFF-TOPIC]
Mi sono informato sul wachdog di ESP32 e... mi è venuta una emicrania.
Ho capito che ce ne sono tre, che sono hardware e software eccetera eccetera ma all'accensione quello hardware non è attivo, o sbaglio?
Ho provato a fare un ciclo infinito ma non succede nulla.
Quindi, c'è modo di avere un wachdog SEMPLICE, hardware o software che sia, con il minor numero di istruzioni? (come sul nano, lo accendi, lo spegni e via...)
prova cosi:
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
void updateEncoder();
BLECharacteristic *pCharacteristic;
bool deviceConnected = false;
int encoderPin1 = 2;
int encoderPin2 = 4;
volatile int lastEncoded = 0;
volatile int encoderValue = 0;
long lastencoderValue = 0;
int lastMSB = 0;
int lastLSB = 0;
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
class MyServerCallbacks: public BLEServerCallbacks
{
void onConnect(BLEServer* pServer)
{
deviceConnected = true;
};
void onDisconnect(BLEServer* pServer)
{
deviceConnected = false;
}
};
void setup()
{
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init("MyESP32");
// Create the BLE Server
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
// Create the BLE Service
BLEService *pService = pServer->createService(SERVICE_UUID);
// Create a BLE Characteristic
pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE |
BLECharacteristic::PROPERTY_NOTIFY |
BLECharacteristic::PROPERTY_INDICATE
);
// Create a BLE Descriptor
pCharacteristic->addDescriptor(new BLE2902());
// Start the service
pService->start();
// Start advertising
pServer->getAdvertising()->start();
Serial.println("Waiting a client connection to notify…");
pinMode(encoderPin1, INPUT_PULLUP);
pinMode(encoderPin2, INPUT_PULLUP);
attachInterrupt(0, updateEncoder, CHANGE);
attachInterrupt(1, updateEncoder, CHANGE);
}
void loop()
{
if (deviceConnected)
{
//Serial.println("*** NOTIFY: %d ***\n", encoderValue * 0.942/4,1);
int value = encoderValue;
pCharacteristic->setValue(value);
pCharacteristic->notify();
//pCharacteristic->indicate();
//encoderValue++;
}
}
void updateEncoder()
{
int MSB = digitalRead(encoderPin1); //MSB = most significant bit
int LSB = digitalRead(encoderPin2); //LSB = least significant bit
int encoded = (MSB << 1) |LSB; //converting the 2 pin value to single number
int sum = (lastEncoded << 2) | encoded; //adding it to the previous encoded value
if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encoderValue ++;
if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encoderValue --;
lastEncoded = encoded; //store this value for next time
}
Nell'esp8266 c'è un solo core che si occupa anche del WiFi per cui se fai un ciclo infinito si resetta.
L'ESP32 invece ha due core, uno si occupa del WiFi e l'altro è a disposizione (ma anche il primo) per cui anche se lo tieni occupato con un ciclo infinito l'altro core continua ad andare.
Però sull'ESP32 di watchdog ce ne sarebbero solo 2, uno controlla che si abbia un passaggio fra i task e l'altro controlla che un task non occupi troppa CPU.
https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/system/wdts.html (https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/system/wdts.html)
Ma non so come vanno gestiti dal core Arduino.
prova cosi:
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
void updateEncoder();
BLECharacteristic *pCharacteristic;
bool deviceConnected = false;
int encoderPin1 = 2;
int encoderPin2 = 4;
volatile int lastEncoded = 0;
volatile int encoderValue = 0;
long lastencoderValue = 0;
int lastMSB = 0;
int lastLSB = 0;
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
class MyServerCallbacks: public BLEServerCallbacks
{
void onConnect(BLEServer* pServer)
{
deviceConnected = true;
};
void onDisconnect(BLEServer* pServer)
{
deviceConnected = false;
}
};
void setup()
{
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init("MyESP32");
// Create the BLE Server
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
// Create the BLE Service
BLEService *pService = pServer->createService(SERVICE_UUID);
// Create a BLE Characteristic
pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE |
BLECharacteristic::PROPERTY_NOTIFY |
BLECharacteristic::PROPERTY_INDICATE
);
// Create a BLE Descriptor
pCharacteristic->addDescriptor(new BLE2902());
// Start the service
pService->start();
// Start advertising
pServer->getAdvertising()->start();
Serial.println("Waiting a client connection to notify…");
pinMode(encoderPin1, INPUT_PULLUP);
pinMode(encoderPin2, INPUT_PULLUP);
attachInterrupt(0, updateEncoder, CHANGE);
attachInterrupt(1, updateEncoder, CHANGE);
}
void loop()
{
if (deviceConnected)
{
//Serial.println("*** NOTIFY: %d ***\n", encoderValue * 0.942/4,1);
int value = encoderValue;
pCharacteristic->setValue(value);
pCharacteristic->notify();
//pCharacteristic->indicate();
//encoderValue++;
}
}
void updateEncoder()
{
int MSB = digitalRead(encoderPin1); //MSB = most significant bit
int LSB = digitalRead(encoderPin2); //LSB = least significant bit
int encoded = (MSB << 1) |LSB; //converting the 2 pin value to single number
int sum = (lastEncoded << 2) | encoded; //adding it to the previous encoded value
if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encoderValue ++;
if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encoderValue --;
lastEncoded = encoded; //store this value for next time
}
Innanzi tutto grazie!
Cosi' si carica ma purtroppo non visualizzo nulla perchè la stringa che mi farebbe visualizzare il valore è un commento... Ma se la rendo una riga di codice mi da errore...
per zoomx con un codice che non utilizzi il ble riesco a vedere i valori sul serial monitor e per l' app sto cercando di utilizzare "nRF Connect"
Se intendi questa:
//Serial.println("*** NOTIFY: %d ***\n", encoderValue * 0.942/4,1);
hai usato la virgola al posto del punto come separatore decimale
La virgola viene usata come separatore dei parametri delle funzioni per cui non va bene.
Devi scrivere 4.1 e non 4,1
Se intendi questa:
//Serial.println("*** NOTIFY: %d ***\n", encoderValue * 0.942/4,1);
hai usato la virgola al posto del punto come separatore decimale
La virgola viene usata come separatore dei parametri delle funzioni per cui non va bene.
Devi scrivere 4.1 e non 4,1
No è proprio un altro parametro l' 1... Non volevo scrivere 4.1
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
void updateEncoder();
BLECharacteristic *pCharacteristic;
bool deviceConnected = false;
int encoderPin1 = 2;
int encoderPin2 = 4;
volatile int lastEncoded = 0;
volatile int encoderValue = 0;
long lastencoderValue = 0;
int lastMSB = 0;
int lastLSB = 0;
#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
class MyServerCallbacks: public BLEServerCallbacks
{
void onConnect(BLEServer* pServer)
{
deviceConnected = true;
};
void onDisconnect(BLEServer* pServer)
{
deviceConnected = false;
}
};
void setup()
{
Serial.begin(115200);
// Create the BLE Device
BLEDevice::init("MyESP32");
// Create the BLE Server
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
// Create the BLE Service
BLEService *pService = pServer->createService(SERVICE_UUID);
// Create a BLE Characteristic
pCharacteristic = pService->createCharacteristic(
CHARACTERISTIC_UUID,
BLECharacteristic::PROPERTY_READ |
BLECharacteristic::PROPERTY_WRITE |
BLECharacteristic::PROPERTY_NOTIFY |
BLECharacteristic::PROPERTY_INDICATE
);
// Create a BLE Descriptor
pCharacteristic->addDescriptor(new BLE2902());
// Start the service
pService->start();
// Start advertising
pServer->getAdvertising()->start();
Serial.println("Waiting a client connection to notify…");
pinMode(encoderPin1, INPUT_PULLUP);
pinMode(encoderPin2, INPUT_PULLUP);
attachInterrupt(0, updateEncoder, CHANGE);
attachInterrupt(1, updateEncoder, CHANGE);
}
void loop()
{
if (deviceConnected)
{
Serial.println(encoderValue * 0.942/4);
int value = encoderValue;
pCharacteristic->setValue(value);
}
}
void updateEncoder()
{
int MSB = digitalRead(encoderPin1); //MSB = most significant bit
int LSB = digitalRead(encoderPin2); //LSB = least significant bit
int encoded = (MSB << 1) |LSB; //converting the 2 pin value to single number
int sum = (lastEncoded << 2) | encoded; //adding it to the previous encoded value
if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encoderValue ++;
if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encoderValue --;
lastEncoded = encoded; //store this value for next time
}
Cosi funziona e vedo variare i valori sia sul serial monitor che sull app!
Però non sono valori veritieri o meglio non dovrebbero esserci quelli...
Però qualcosa vedo ed è già qialcosa!!
Rettifico mi ero dimenticato di collegare l' alimentazione!!
Vedo i valori corretti!
L' unica cosa che ancora non mi soddisfa è che per vedere aggiornarsi "Value" sull app devo cliccare sull' icona della freccia che mi fa acquisire il valore aggiornato ed invece mi piacerebbe che si aggiornasse in tempo reale.
Ma usi una app dallo store android ?
C'è n'è saranno altre che magari funzionano in realtime
E' un' app IOS comunque è vero potrebbe dipendere dall' app! Provero con altre...
Scrivo per porvi un' altra domanda: Sto alimentando l' ESP32 dal pin "VIN" con un' alimentazione di 6 volt.
Il problema è che non vedo il dispositivo sull' app che comunica con il BLE, invece se lo connetto al PC funziona tutto... Qualcuno saprebbe spiegarmi il perchè?
Devo implementare il codice per caso?
Su Arduino 6V sono troppo pochi ma l'ESP32 va a 3.3V.
Però nelle caratteristiche di questa versione di ESP32 vedo che come minimo ci vogliono 7V
https://docs.zerynth.com/latest/official/board.zerynth.esp32_devkitc/docs/index.html (https://docs.zerynth.com/latest/official/board.zerynth.esp32_devkitc/docs/index.html)
quindi può essere che sia lo stesso con la tua.
Su Arduino 6V sono troppo pochi ma l'ESP32 va a 3.3V.
Però nelle caratteristiche di questa versione di ESP32 vedo che come minimo ci vogliono 7V
https://docs.zerynth.com/latest/official/board.zerynth.esp32_devkitc/docs/index.html (https://docs.zerynth.com/latest/official/board.zerynth.esp32_devkitc/docs/index.html)
quindi può essere che sia lo stesso con la tua.
Si l' ho letto anche io però scendendo un pò dice:
"Power to the Esp32 DevKitC is supplied via the on-board USB Micro B connector or directly via the "VIN" pin. The power source is selected automatically.
The device can operate on an external supply of 6 to 20 volts. If using more than 12V, the voltage regulator may overheat and damage the device. The recommended range is 7 to 12 volts."
Quindi in teoria dovrebbe andare...
Adesso provo a verificare col tester effettivamente quanto arriva...
Ho provato a dare 12 volt ma col tester tra VIN e GND misuro solo 4,6 volt... Non capisco se sto sbagliando qualcosa
Forse è l'alimentatore che non funziona.
No perchè misurando direttamente sull' alimentatore non ho nessuna caduta di tensione...
Ma misuri con carico collegato oppure a vuoto?
L' alimentatore a vuoto (sono poi delle batterie in serie)...
Potrebbe essere un problema di scarso amperaggio?
Sono l' unico che ha problemi di questo tipo?
Potrebbe essere un problema di scarso amperaggio?
Direi di si, ho provato con una batteria a 9 volt e funziona!
L'ESP32 si mangia una buona maciata di milliampere già quando è acceso ma in trasmissione ancora di più ma solo per brevi picchi.
Gentilmente qualcuno può darmi indicazioni su come collegare un sensore galleggiante come quello in foto ad una LOLIN D32 PRO?
(https://www.shopdoro.it/705-thickbox_default/sensore-livello-acqua-liquidi-galleggiante-arduino-raspberry.jpg)
(https://wiki.wemos.cc/_media/products:d32:d32_pro_v2.0.0_5_16x9.jpg)
Ho fatto alcune prove ma la lettura non è stabile.
Ho collegato un filo a GND l'altro ad uno dei PIN VP(36), VN(39) oppure ad A(34) ed inoltre mi sono accorto che il sensore lo legge solo se tocco con le dita il PIN analogico dove lo collego.
Mettici una resistenza di PullUp
Mettici una resistenza di PullUp
Si ho letto in giro qualcosa però mi pare di aver capito che non è possibile usare la PullUp su quei PIN.
L'articolo parlava di pinMode(34, INPUT_PULLUP); LINK (https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=2&cad=rja&uact=8&ved=2ahUKEwissK7ghvPgAhXiMewKHemfDqoQFjABegQICBAB&url=https%3A%2F%2Fgithub.com%2Fespressif%2Farduino-esp32%2Fissues%2F510&usg=AOvVaw3hmznZh2qx1c7tytBQDBkB)
Ho capito male io?
La devi mettere FISICAMENTE, non via software
Perfetto grazie mille. Quindi l'articolo parlava solo di quelle interne... :smiley-wink: Grazie!
L'ESP32 si mangia una buona maciata di milliampere già quando è acceso ma in trasmissione ancora di più ma solo per brevi picchi.
Per il momento ho collegato una pila alcalina da 9 volt e 600 mAh e funziona. Adesso vorrei capire quanto potrà durare per capire se può andar bene! Non vorrei che non duri nulla...
Scusate ma utilizzando più variabili con millis per evitare di usare i delay, gli crea qualche problema o sono io che non riesco a farlo andare?
Non dovrebbe creare nessun problema.
9V ? Due o tre ore ce la fai :-)
Non dovrebbe creare nessun problema.
9V ? Due o tre ore ce la fai :-)
L' ho provato ieri sera e forse dura qualcosa in più direi 4-5 ore ma cercavo qualcosa che durasse almeno 10 o 20 ore. Qualche consiglio?
Vorrei utilizzare una soluzione il più compatta possibile.
Scusate ma utilizzando più variabili con millis per evitare di usare i delay, gli crea qualche problema o sono io che non riesco a farlo andare?
Allora, usare millis "per evitare i delay" mi sembra un po' poco come ragione.
Diciamo che se usi delay, la scheda ti si INCHIODA finché non ha finito di contare e non fa niente altro.
Usando millis continui a far girare il programma.
Puoi usare tutte le variabili che vuoi per andare a comparare il millis letto poco prima col millis letto attualmente
Non dovrebbe creare nessun problema.
9V ? Due o tre ore ce la fai :-)
Si, mi sono accorto anche io che ESP32 assorbe tanto. Ho solo messo una scheda ed un display 20x4, collegata alla sola USB del PC e all'accensione la retroilluminazione del display sfarfalla e molte volte il programma non partiva....
Con un alimentatore 5v è tutta un'altra cosa.
Allora, usare millis "per evitare i delay" mi sembra un po' poco come ragione.
Diciamo che se usi delay, la scheda ti si INCHIODA finché non ha finito di contare e non fa niente altro.
Usando millis continui a far girare il programma.
Puoi usare tutte le variabili che vuoi per andare a comparare il millis letto poco prima col millis letto attualmente
Chiedo venia, non ho specificato le ragioni ma erano le medesime da te citate.
Uso spesso millis per evitare che il microcontrollore si "INCHIODI" come dici tu senza alcun problema.
Con una LOLIN D32 PRO invece non capisco perchè non andava. :smiley-confuse:
Da qui la mia domanda ;)
Che poi in realtà il delay non é per forza bloccante, vedi yield, ma questo é altro discorso
Che poi in realtà il delay non é per forza bloccante, vedi yield, ma questo é altro discorso
Confesso di non avere ancora le idee chiare sull'utilizzo e sul perchè debba essere/venga utilizzato yeald(). Tra l'altro, yeald() è regolabile nel tempo o da come ho letto non è possibile associare nessun parametro e non fa nulla? Quindi a che serve? :smiley-confuse: :o
Quindi a che serve? :smiley-confuse: :o
Gli ESP in raltà
NON sono come Arduino dove hai SOLO il tuo programma che gira e sei tu che controlli tutto ...
... gli ESP sono sistemi "
multi-task" in cui il tuo programma è solo uno dei task che girano contemporaneamente all'interno.
Ora, per evitare blocchi e malfunzionamenti, negli ESP è implementato un meccanismo di "
watchdog" (
questo puoi averlo anche in un normale programma Arduino per controllarne il corretto funzionamento) il quale, se vede un blocco di più di X tempo, effettua un "
reset" dell'ESP con conseguente riavvio.
Dato che tu, nel tuo programma, potresti utilizzare un qualche cosa che
blocca l'esecuzione degli altri task, come la funzione
delay() che, normalmente, è bloccante, è stato introdotto un meccansismo che evita tale cosa ...
... semplificando, per farti capire, nel ESP, la delay() in realtà
NON blocca completamente tutto, ma, con regolarità chiama la funzione yield() che ha il compito di passare il controllo ad un altro task (
che così può essere eseguito per ciò che deve fare), resettare il "
watchdog" (
così da evitare il "reset" del ESP) e poi tornare al tuo ciclo di attesa ... e la cosa si ripete sino a quando non è passato il tempo d'attesa da te richiesto.
Spero di averti,
più o meno, chiarito le idee :D
Guglielmo
Grazie mille Guglielmo per l'esauriente e tempestiva spiegazione ;) In realtà alcuni semplici concetti da te menzionati li conoscevo già ma ciò che ignoravo era che l'ESP facesse ricorso a yeald per switchare i vari processi. ;)
Ora mi resta però da capire perchè se uso più di una variabile con millis (per evitare di usare delay) non riesco a tenporizzare più di una funzione. E' come se accettasse solo e soltanto una variabile da usare con millis e la cosa mi lascia sconcertato :smiley-eek-blue: soprattutto perchè mi avete già risposto che non è possibile che avvenga ciò :P
yield non yeald.
@ziopippo
non ho capito il problema che incontri. Usare millis è come guardare l'orologio molto molto molto spesso per vedere che ora è in modo da decidere cosa fare in base al tempo che è passato.
Ma gli esempi ti funzionano?
Edit:
grazie Guglielmo! ho corretto anche io!
yeld non yeald.
In verità
yield() (https://www.arduino.cc/en/Reference/SchedulerYield) (
... è anche documentata nel reference)... comunque, grazie, ho corretto il post :smiley-mr-green:
Guglielmo
yeld non yeald.
@ziopippo
non ho capito il problema che incontri. Usare millis è come guardare l'orologio molto molto molto spesso per vedere che ora è in modo da decidere cosa fare in base al tempo che è passato.
Ma gli esempi ti funzionano?
Nel mio sketch no e non ho fatto la prova del nove facendo un nuovo scketch pulito con solo l'utilizzo di più millis. Avendo in questo periodo solo un'oretta al giorno per portare avanti il mio progettino nel frattempo avevo lasciato in sospeso la questione millis per continuare con le altre funzioni che mi ero proposto di fargli fare ;) :smiley-evil:
In verità yield() (https://www.arduino.cc/en/Reference/SchedulerYield) (... è anche documentata nel reference)... comunque, grazie, ho corretto il post :smiley-mr-green:
Guglielmo
Mi aggiungo anche io agli autori dell'errore di sbaglio :smiley-razz: ;D
ziopippo,
dovresti partire dagli esempi per capire come funziona.
Attento a come fai i controlli del tempo passato, in genere si controlla che il tempo passato sia uguale o maggiore di quello che doveva passare. Uguale soltanto non va bene perché potresti guardare l'orologio troppo tardi.
ziopippo,
dovresti partire dagli esempi per capire come funziona.
Attento a come fai i controlli del tempo passato, in genere si controlla che il tempo passato sia uguale o maggiore di quello che doveva passare. Uguale soltanto non va bene perché potresti guardare l'orologio troppo tardi.
Se rileggi qui mio post (https://forum.arduino.cc/index.php?topic=358374.msg4064987#msg4064987) puoi verificare come uso i millis ;)
Se rileggi qui mio post (https://forum.arduino.cc/index.php?topic=358374.msg4064987#msg4064987) puoi verificare come uso i millis ;)
... e purtroppo
NON va bene.
NON si può usare in quel semplice modo, ma occorre sempre valutare una differenza di tempi (
che risolve anche il problema dell'overflow) ... come faccio sempre, ti invito a ristudiarti questi link ... PRIMO (http://www.leonardomiliani.com/2013/programmiamo-i-compiti-con-millis/), SECONDO (http://www.leonardomiliani.com/2012/come-gestire-loverflow-di-millis/) e tutti gli articoli che si trovano QUI (https://www.baldengineer.com/arduino-millis-examples.html), nonché QUESTO (http://forum.arduino.cc/index.php?topic=491944.msg3361369#msg3361369) bell'esempio ... dovrebbero chiarire le idee ... ::)
Guglielmo
Lo farò senz'altro grazie! ;)
Se non scrivo castronerie....
questo
if (previousMillisWiFi < intervalWiFi)
non va mica, dovrebbe essere
if (millis()- previousMillisWiFi > intervalWiFi)
cioè esattamente lo stesso confronto che fai più sotto.
Se non scrivo castronerie....
questo
if (previousMillisWiFi < intervalWiFi)
non va mica, dovrebbe essere
if (millis()- previousMillisWiFi > intervalWiFi)
cioè esattamente lo stesso confronto che fai più sotto.
Hai ragione scusa non mi ero accorto dell'errore, tant'è che poi in altre funzioni la uso così
void temperature()
{
if (millis() - t > 5000) //Una volta ogni 5 secondi:
{
t = millis();
sensors.requestTemperatures();
tempDALLAS = sensors.getTempCByIndex(0); //Read temperature of Dallas sensor
//Serial.print(tempDALLAS);
//Serial.println("° C");
dht12.get();
/*
if (dht12.get() == 0) {
Serial.print("Temperature in Celsius : ");
Serial.println(dht12.cTemp);
Serial.print("Temperature in Fahrenheit : ");
Serial.println(dht12.fTemp);
Serial.print("Relative Humidity : ");
Serial.println(dht12.humidity);
Serial.println();
}*/
}
}Ed è proprio per quella svista che molto probabilmente non andava. Maledetta fretta accompagnata dalla distrazione! :smiley-confuse: :-[ :-X
Infatti ho anche scritto che in un altro punto il confronto è corretto, che è anche quello che avevo visto per primo per cui non riuscivo a capire dove fosse l'inghippo.
Infatti ho anche scritto che in un altro punto il confronto è corretto, che è anche quello che avevo visto per primo per cui non riuscivo a capire dove fosse l'inghippo.
In realtà il mio quesito sul poter utilizzare più variabili per millis in una ESP (cosa che faccio comunemente con le altre board) derivava dal fatto che non riesco a sostituire la riga delay(6000) dalla void T_Setting() con millis
void Touch()
{
// Pressed will be set true is there is a valid touch on the screen
pressed = tft.getTouch(&px, &py);
if (!mute) drawBmp("/bmp/audio-on.bmp", 285, 200);
else drawBmp("/bmp/audio-off.bmp", 285, 200);
if (pressed) {
buzzer();
// Verifico Home
if ((px > 0) && (px < 30)) {
if ((py > 200) && (py <= 239)) {
Serial.println("Hai premuto il tasto HOME");
// buzzer();
tft.fillScreen(TFT_BLACK);
scelta = 0;
Maschera();
Home();
} // END 2° if Home
} //END 1° if Home
// Verifico WPS
if ((px > 290) && (px < 319)) {
if ((py > 90) && (py <= 130)) {
Serial.println("Hai premuto il tasto WPS");
tft.fillScreen(TFT_BLACK);
wps();
}// END 2° if WPS
}// END 1° if WPS
// Verifico Audio
if ((px > 290) && (px < 319)) {
if ((py > 200) && (py <= 239)) {
silenzia();
buzzer();
Serial.println("Hai premuto il tasto Audio");
}// END 2° if Audio
}// END 1° if Audio
// Verifico Setting
if ((px > 144) && (px < 174)) {
if ((py > 200) && (py <= 239)) {
Serial.println("Hai premuto il tasto Setting");
tft.fillScreen(TFT_BLACK);
scelta = 1; // Menù Setting
}// END 2° if Setting
}// END 1° if Setting
delay(100);
Serial.print("px = ");
Serial.print(px);
Serial.print(", py = ");
Serial.println(py);
} //END (pressed)
px = 0, py = 0; // resetto i valori di px e py
} //END Void Touch()
void Exit()
{
// Pressed will be set true is there is a valid touch on the screen
pressed = tft.getTouch(&px, &py);
drawBmp("/bmp/home.bmp", 144, 200);
if (pressed) {
// Verifico Home
if ((px > 144) && (px < 30)) {
if ((py > 200) && (py <= 239)) {
Serial.println("Hai premuto il tasto HOME");
tft.fillScreen(TFT_BLACK);
Home();
}// END 2° if Home
}// END 1° if Home
delay(100);
Serial.print("x = ");
Serial.print(px);
Serial.print(", y = ");
Serial.println(py);
} //END (istouched)
} //END Void Exit()
void T_Setting()
{
// Pressed will be set true is there is a valid touch on the screen
pressed = tft.getTouch(&px, &py);
if (pressed) {
buzzer();
EasyBuzzer.update();
if (KeyValvola) {
//buzzer();
// EasyBuzzer.update();
// Verifico Apertura Valvola
if ((px > 100) && (px < 230)) {
if ((py > 40) && (py <= 170)) {
Serial.println("Hai premuto il tasto APRI VALVOLA");
}// END 2° if Apertura Valvola
}// END 1° if Apertura Valvola
} //END (KeyValvola)
else
Serial.println("Non faccio nulla");
// Verifico Valvola
if ((px > 100) && (px < 134)) {
if ((py > 200) && (py <= 239)) {
Serial.println("Hai premuto il tasto Valvola");
tft.fillScreen(TFT_BLACK);
drawBmp("/bmp/Bvalve.bmp", 110, 50);
KeyValvola = true;
Serial.println("KeyValvola = true");
//scelta = 1; // Menù Setting
}// END 2° if Valvola
}// END 1° if Valvola
// Verifico Info
if ((px > 144) && (px < 174)) {
if ((py > 200) && (py <= 239)) {
Serial.println("Hai premuto il tasto Info");
tft.fillScreen(TFT_BLACK);
spr.createSprite(315, 100); // Creo lo sprite 150 pixels di lunghezza e 100 di altezza
spr.fillSprite(TFT_BLACK);
spr.setTextColor(TFT_WHITE);
x = 1;
y = 1;
spr.setCursor(x, y);
x += spr.drawString("ArduAcquario MALAWI V.", x , y, 2);
x += spr.drawString((Version), x , y, 2);
x = 1;
y = y + 20;
x += spr.drawString("By Ettore Di Fabio ", x , y, 2);
x += spr.drawString((date_Version), x , y, 2);
x = 1;
y = y + 20;
if (WiFi.status() != WL_CONNECTED) {
spr.setTextColor(TFT_RED, TFT_BLACK);
x += spr.drawString("NON CONNESSO", x , y, 4);
}
else
{
x += spr.drawString("Connesso a: ", x , y, 2);
x += spr.drawString(WiFi.SSID(), x , y, 2);
y = y + 20;
x = 1;
x += spr.drawString("IP Address: ", x , y, 2);
// x = 10;
// y = y + 30;
x += spr.drawString(WiFi.localIP().toString(), x , y, 2);
}
spr.pushSprite(50, 70); // Posiziono la scritta
spr.deleteSprite(); // Libero la memoria
EasyBuzzer.update();
delay(6000);
tft.fillScreen(TFT_BLACK);
scelta = 0;
Maschera();
Home();
}// END 2° if Info
}// END 1° if Info
// Verifico Power
if ((px > 184) && (px < 218)) {
if ((py > 200) && (py <= 239)) {
tft.fillScreen(TFT_BLACK);
Serial.println("Hai premuto il tasto Power");
x = 100;
x += tft.drawString("RIAVVIO", x , 110, 4);
for (int i = 0; i < 3; i++)
{
EasyBuzzer.update();
delay(1000);
x += tft.drawString(".", x , 110, 4);
}
ESP.restart(); // Riavvio
//scelta = 1; // Menù Setting
}// END 2° if Power
}// END 1° if Power
delay(100);
} //END (istouched)
} //END Void Setting()
Questo spezzone di codice non è definitivo e ci sto ancora lavorando per fargli fare alcune cose ;)
Quando devi fare più cose devi anche pensare diversamente il programma, questo perché il decidere cosa fare a secondo del tempo trascorso alla fine deve essere centralizzato in qualche modo.
Ad esempio l'apparizione di un messaggio per un certo intervallo (quello del delay(6000) se non ho capito male) dovrebbe diventare una funzione a parte, generica ed utilizzabile dal resto del programma e cheappartiene ad un ciclo di cose che possono essere eseguite in dipendenza, ad esempio, da un flag.
Oppure ti crei o usi un task scheduler, Guglielmo, se non ricordo male, ne ha realizzato uno ma ce ne sono tanti.
Oppure ti crei o usi un task scheduler, Guglielmo, se non ricordo male, ne ha realizzato uno ma ce ne sono tanti.
Questa la devo studiare meglio perchè non ci ho mai provato. Avevo pensato di usare il "case" ma devo ancora capire come strutturarlo.
Oppure ti crei o usi un task scheduler, Guglielmo, se non ricordo male, ne ha realizzato uno ...
Non mi piace fare pubblicità, comunque SI. Si tratta di un semplicissimo ma efficiente "
scheduler cooperativo" ed è stato pubblicato sul numero 229 di Ottobre 2018 di Elettronica In ...
Guglielmo
P.S.: ... dato che è passato un po' di tempo, ho già chiesto che lo rendano fruibile gratuitamente a tutti in formato .pdf scaricabile dal sito (... occorrerà solo registrarsi se già non lo si è). E solo questione dei necessari tempi tecnici ... ;)
Buona domenica, torno a bomba con le domande :smiley-twist:
Ho provato a collegare sia un relè singolo (cinese) che un modulo con doppio relè optoisolato. Quello singolo non ne vuol sapere di eccitarsi mentre sul doppio se ne eccita uno solo. Presumo quindi che i 3V della ESP non siano sufficienti.
Ora prevedendo di mettere un piccolo alimentatore switch a 12V esterno che userò per accendere delle ventole ed una elettrovalvola, mi consigliate di alimentare il relè con l'alimentatore esterno per risolvere il problema?
Io ho usato lo shield con relais per Wemos D1 mini e funziona benissimo. Credo però che il relè sia alimentato dalla linea a 5V mentre la logica sia a 3.3V. C'è anche il relè doppio se non ricordo male.
Sopra il relè ci dovrebbe essere scritta la tensione di eccitazione, se è da 5V dargliene 12 non credo faccia bene.
Devo leggere bene e poi ti faccio sapere.
La cosa strana è che quello cinese non ne vuol sapere di eccitarsi (si accende solo il led rosso) mentre l'altro, se collego solo un relè alla ESP non ho problemi ma, se collego entrambi i PIN alla ESP fa lo stesso difetto del cinese.
Presumo non siano sufficienti i 3V ad eccitarli entrambi.
Che tu sappia, è possibile prendere la 5V dall'ingresso della ESP (e come) se alimentato tramite porta USB? (Uso una LOLIN D32 Pro)
(https://www.cnx-software.com/wp-content/uploads/2018/06/LOLIN-D32-PRO-Pinout.jpg)
Non è chiarissimo ma sospetto che il piedino USB sia quello con i 5V dell'USB
Questi schemi della pagina ufficiale li consulto continuamente ma, non essendo un elettrotecnico, volevo il parere di un esperto. ;)
Ma io non sono né un esperto nè un elettrotecnico!
Beh ... basta fare un piccolo sforzo ... cercare lo schema ... ;)
Lo SCHEMA (https://wiki.wemos.cc/_media/products:d32:sch_d32_pro_v2.0.0.pdf) è pubblico e basta andarlo a guardare per vedere che quel pin (JP1 - 15) è direttamente collegato al VBUS della USB, ovvero ai 5V che arrivano direttamnete dalla porta USB senza passare attraverso a null'altro. :)
Guglielmo
Beh ... basta fare un piccolo sforzo ... cercare lo schema ... ;)
Lo SCHEMA (https://wiki.wemos.cc/_media/products:d32:sch_d32_pro_v2.0.0.pdf) è pubblico e basta andarlo a guardare per vedere che quel pin (JP1 - 15) è direttamente collegato al VBUS della USB, ovvero ai 5V che arrivano direttamnete dalla porta USB senza passare attraverso a null'altro. :)
Guglielmo
Perdona l'ignoranza (che in tale materia è davvero tanta) quindi potrei collegare direttamente il +5 del modulo relè ai pin USB o BAT(PIN 15 e 16) della LOLIN? :smiley-money:
... devi usare il pin USB, lascia stare il pin BAT ;)
Ovviamnete la scheda deve essere alimentata tramite la USB !
Guglielmo
Grazie! :smiley-wink: Peccato che non ci sono gli smiles con i cuoricini come in WhatsApp :smiley-lol:
Non so quanto "validi" siano, comunque volevo segnalare che DF Robot ha pubblicato una lunga serie di tutorials su ESP32 QUI (https://www.dfrobot.com/blog-964.html) ... provate a darci un'occhiata, magari trovate qualche cosa di interessante. ;)
Guglielmo
Lo sapremo solo leggendoli. Grazie Guglielmo!
Solo a fini informativi, QUI (https://hackaday.com/2019/05/21/new-part-day-espressif-announces-esp32-s2-with-usb/) un articolo sul nuovo ESP32-S2 ... versione differenziata del classico ESP32, senza la parte Bluetooth, ma con processore più potenete e FPU molto più veloce (64 FLOPS contro i 2 FLOPS del ESP32 standard).
QUI (https://www.espressif.com/en/news/espressif-announces-%E2%80%A8esp32-s2-secure-wi-fi-mcu) l'annuncio ufficiale da parte di Espressif.
Buona lettura.
Guglielmo
Accidenti ha anche l'USB OTG! Molto molto interessante.
Un solo core ma più veloce.
Già con l'ESP32 ci sono i moduli con OV2640, vedremo questo.
Edit: appena provato il modulop con OV2640(2MP) Aithinker preso a 8 euro con lo sketch presente fra gli esempi. Spettacolare, praticamente una webcam con possibilità vicino a quelle offerte dalla camera per RaspberryPi a parte la risoluzione notevolmente inferiore. Framerate accettabile.
Bella news,
Grazie
Altro che arduino nano, uno schedino con questa bestiolina, senza nemmeno bisogno del convertitore usb.
Dobbiamo vedere quando sarà supportato dal core arduino e quando i cinesi partiranno con i pcb
Ho acquistato questa ESP32 mesi fa
https://www.dx.com/it/p/geekworm-esp32-wi-fi-bluetooth-development-board-esp-wroom-32-board-2083294
Da oggi con un semplice sketch tipo blink o altro simile funziona, mentre con una pagina web anche
non molto complessa non funziona e sul Serial Monitor visualizza questo messaggio:
Brownout detector was triggered
ets Jun 8 2016 00:22:57
rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:952
load:0x40078000,len:6084
load:0x40080000,len:7936
entry 0x40080310
Ho provato diverse board ma il risultato è sempre quello.
Qualche idea?
Quel messaggio lo ripete in continuazione.
Brownout detector was triggered
Si tratta di un problema di alimentazione, l'alimentatore non fornisce sufficiente corrente o la tensione cala o tutt'e due. Oppure il cavo USB è troppo sottile.
Tipicamente capita quando si usa il WiFi o il Bluetooth ma principalmente il WiFi.
Grazie, cambiando cavo funziona.
Per ridurre il carico del cavo USB ho provato ad alimentare la scheda dal pin 5V
(i LED si accendono) però non funziona.
Questo mi sembra molto strano.
Dovrebbe essere normale programmare la scheda via connettore USB
e poi utilizzarla con alimentazione dal pin 5V.
Evidentemente al pin 5V non arriva abbastanza corrente. Quando usa il WiFi il consumo ha dei picchi notevoli.
Potrebbe essere.
Farò una una scheda su millefori per avere connessioni migliori.
Volevo segnalare questo simpatico progetto per ESP32 ... "Run a C Language Interpreter on Your ESP32 (https://www.codeproject.com/Articles/5061494/Run-a-C-Language-Interpreter-on-Your-ESP32)" ...
I put together a C language interpreter for the ESP32 based boards that allows me to use their built-in file system for persistent program storage, to edit and Interpret my programs within a browser page without needing a compile and upload cycle. Better yet, I built in support for the common I/O Arduino functions such as analogWrite, digitalRead/Write, and supplied highly accurate servo positioning functions. But maybe the best part is that I added a debugger to the Interpreter that supports conditional Debug tracing, and conditional Watch functions that report variable values as the program executes. This article gives credit to those who built tools that I used for the Interpreter and also explains how to use it on your ESP32.
... un qualche pazzo che ha implementato un piccolo interprete 'C' che gira su ESP32 ed al quale ci si interfaccia tramite browser :smiley-mr-green:
Guglielmo
Incredibbbile! Lo ha fatto per provare degli sketch senza doverli caricare sulla flash.
Alcune MCU permettono di avere lo sketch interamente in RAM (alcuni STM32 se non tutti, se non sbaglio, ma questo ne ha implementato una sorta di emulazione tramite l'interprete.
Però per me la cosa più interessante è la CAM a 2 Mpx.
Gente con le palle
Qualcuno cortesemente saprebbe indicarmi una libreria funzionante per collegare un RTC ds3232 con la ESP32?
Ma scusa, ESP32 non usa la libreria Wire? ? ? :o ... perché, altrimenti, una libreria per Arduino dovrebbe andare bene, dato che, di sicuro, non vengono fatte cose a basso livello, ma solo chiamate alla Wire per gli accessi I2C ::)
Guglielmo
Ne ho provate diverse ma non ancora riesco a far funzionare il modulo RTC.
Ho provato anche quella di JChristensen (https://github.com/JChristensen/DS3232RTC/blob/master/examples/TimeRTC/TimeRTC.ino) ma mi da errore su setSyncProvider(RTC.get); // the function to get the time from the RTC
Hai provato QUESTA (http://downloads.arduino.cc/libraries/github.com/JChristensen/DS3232RTC-1.2.6.zip) versione qui (sempre di JChristensen)? ... magari è più aggiornata ::)
Guglielmo
Hai provato QUESTA (http://downloads.arduino.cc/libraries/github.com/JChristensen/DS3232RTC-1.2.6.zip) versione qui (sempre di JChristensen)? ... magari è più aggiornata ::)
Guglielmo
No, la proverò e ti farò sapere, grazie ;)
Hai provato QUESTA (http://downloads.arduino.cc/libraries/github.com/JChristensen/DS3232RTC-1.2.6.zip) versione qui (sempre di JChristensen)? ... magari è più aggiornata ::)
Guglielmo
Nulla di fatto Guglielmo.
Ho provato la tua libreria ma oltre a dire che non è compatibile con la Lolin D32 Pro in compilazione restituisce sempre l'errore sulla riga "setSyncProvider(RTC.get); // the function to get the time from the RTC2"
questa è la schermata di errore:
Arduino:1.8.9 (Windows 10), Scheda:"LOLIN D32 PRO, Disabled, Default, 80MHz, 921600, None"
ATTENZIONE: la libreria DS3232RTC dichiara di funzionare sulle architetture (avr) e potrebbe non essere compatibile con la tua scheda che utilizza l'architettura (esp32)
C:\Users\Ettore\AppData\Local\Temp\arduino_modified_sketch_61938\TimeRTC.ino: In function 'void setup()':
TimeRTC:13:21: error: 'RTC' was not declared in this scope
setSyncProvider(RTC.get); // the function to get the time from the RTC
^
exit status 1
'RTC' was not declared in this scope
Questo report potrebbe essere più ricco di informazioni abilitando l'opzione
"Mostra un output dettagliato durante la compilazione"
in "File -> Impostazioni"
Prova con la Adafruit
http://www.esp32learning.com/code/esp32-and-ds3231-rtc-example.php
Prova con la Adafruit
http://www.esp32learning.com/code/esp32-and-ds3231-rtc-example.php
Quella è per DS3231 ... non so se è compatibile con i
DS3232 che usa lui e, sicuramente, mancano una serie di funzioni per accedere alla memoria in più che ha detto chip.
Guglielmo
Sto provando ad usare la libreria RtcDS3231.h come in questo esempio https://www.hackster.io/shaddow1201/using-the-esp32-with-rtc-ds3231-module-de9d85 (https://www.hackster.io/shaddow1201/using-the-esp32-with-rtc-ds3231-module-de9d85)
Sembrerebbe funzionare però il problema è che non riesco ad interfacciarlo con la libreria NTP (NtpClientLib.h) che uso nel mio sketch. Non riesco a capire come assegnare epochTime nell'esempio postato sopra.
Il mio intento è ricevere l'ora da NTP ed aggiorare il modulo RTC di tanto in tanto.
Rettifico: non da errore in compilazione ma devo verificare se il modulo RTC dialoga correttamente con I2C (non ne sono molto sicuro).
L'ESP8266 ha un RTC software che gestisce automaticamente il passaggio fra orario invernale ed estivo e anche l'aggiornamento via NTP. Immagino sia lo stesso su ESP32.
L'ESP8266 ha un RTC software che gestisce automaticamente il passaggio fra orario invernale ed estivo e anche l'aggiornamento via NTP. Immagino sia lo stesso su ESP32.
Questa cosa mi sarebbe utile perchè senza RTC al primo avvio non riesco a visualizzare correttamente l'ora sul display fino a che non riceve l'ora giusta dal NTP
Io ho un piccolo orologino che dall'avvio all'ora in 5 secondi mostra l'ora esatta. A volte ci sta di più per problemi di rete.
Su ESP32, avete mai provato a sfruttare la programmazione dei due core tramite arduino IDE creando due task (in multitasking)? Secondo voi come si possono passare variabili tra un task e l'altro?
1) no.
2) credo di si, ne parlano qui (http://esp32.com/viewtopic.php?t=895)
Quella è per DS3231 ... non so se è compatibile con i DS3232 che usa lui e, sicuramente, mancano una serie di funzioni per accedere alla memoria in più che ha detto chip.
Guglielmo
Il 3232 ha solo la ram in più, funzionano tutte le lib 3231, a lui non serve la ram integrata
Aggiorno sulle porte ESP32 (e così rinfresco un po' anche la sezione ESP32.
Per chi non seguiva, avevo notato che le analogiche di ESP32 leggono diversamente da scheda a scheda (!!!!!).
Proseguendo le ricerche sul sito Espressif, la cosa era stata notata (con un po' di ritardo) e si era corso ai ripari eseguendo la taratura delle porte direttamente sul chip in fase di produzione, uno a uno.
Di questi chip, però, sembra che ancora non se ne vedano, almeno sul mercato cinese.
Infatti esiste ancora il solito problema alla programmazione con IDE che obbliga a premere il tastino BOOT per far partire il trasferimento del programma, e le porte analogica continuano a leggere valori diversi da chip a chip.
Vi allego un foglio che ho redatto proprio ora con 12 schedine esp32-devkit dove leggo le prime due porte analogiche e le confronto con un DHT22 (che, chiaramente, essendo digitale, non può che dare valori identici su tutte le schede).
Le differenze, come potete vedere, si aggirano anche oltre i 3 gradi.
Gli asterischi li ho messi a schede con una stampigliatura diversa e molto più completa dello schermo metallico.
Se qualcuno ha avuto a che fare con ESP32 nuove ci può rendere edotti...
Dovresti leggere delle piccole tensioni note, tipo una pila alcalina carica o un generatore, se lo hai.
Mi hai dato una bella idea, per vedere se il problema è del regolatore interno da 3,3 volt oppure...peggio (perchè significa che il problema è all'interno della CPU).
Quindi a un terzo ingresso analogico ho attaccato una tensione di 3,3 volt da un alimentatorino stabilizzato (ho messo anche un bell'elettrolitico).
Sul terzo canale ho lasciato la formula di lettura della ntc degli altri due canali (non mi interessa leggere la tensione ma la differenza di valori letti)
Nel foglio allegato si evidenziano le stesse differenze. Quindi non è la tensione del regolatore interno montato sulla schedina DEVKIT, perchè se sulle ntc leggo la tensione erogata da questo, nel terzo ingresso leggo una tensione esterna. Ma l'errore esiste ugualmente ed è proporzionale all'errore delle NTC.
Non so se leggere una tensione di 3.3V, che è giusto il fondoscala, sia un bene, per questo ti avevo suggerito una banale pila e confrontare i valori del convertitore, non convertiti in tensione.
Ops, mi sono dimenticato di dirti che ho fatto un partitore 10k-10k quindi ho esattamente la metà.
Qualcuno mi può dare una mano?
Ho visto che ci sono stati sviluppi e bisogna includere una libreria di correzione.
Si chiama esp_adc_cal.h
Non ho capito come inserirla in un programma, mi sono fermato a #include.....
Mi mandano QUI (https://github.com/espressif/esp-idf/blob/a45e99853/components/esp_adc_cal/include/esp_adc_cal.h), poi mi mandano QUI (me è in pyton!!!), (https://github.com/espressif/esp-idf/tree/a45e9985344575a80acb1dc9c12e7bec4d8af401/examples/peripherals/adc) poi ho visto QUI.... (https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/peripherals/adc.html)
Il programma in python serve per caricare il bin compilato nell'ESP32 e ha anche un monitor seriale.
La calibrazione proposta del documento espressif è lineare quindi usa la semplice equazione y=ax+b che, nel documento, vengono chiamati coeff_a e coeff_b.
Si tratta di prendere una serie di valori raw del convertitore e delle corrispondenti tensioni misurate in altro modo. Quest'ultimo punto nel documento espressif non è molto chiaro, mi è sembrato di capire.
Metti i dati in un foglio di calcolo, plotti i punti e, nel foglio di calcolo stesso, fai un fit lineare, e usi i settaggi per far scrivere sul plot la funzione lineare trovata che avrà la forma y=ax+b e al posto di a e b ci saranno i valori che cerchi.
Oppure usi un programma per calcolare il fit lineare a partire dai tuoi dati.
Il diagramma nel documento espressif mi sembra sbagliato, nell'asse X ci dovrebbero essere i valori raw e nelle Y le tensioni ma può essere che il sonno mi tradisce.
Nel plot ci sono diversi punti ma la procedura può essere fatta anche solo con 2. Però più punti hai più puoi correggere eventuali piccoli errori.
Tale calibrazione è diversa a seconda delle attenuazioni che, mi par di capire, non sono altro che una variazione della tensione VREF.
Quindi, se hai un chip nuovo, la libreria ti permette di scrivere i valori a e b in efuse e successivamente di leggerli da li.
Ma nessuno ti vieta invece di utilizzare direttamente nel codice tali valori. E magari di leggerli dalla SPIFFS.
Questo tipo di procedura vale per qualsiasi ADC di qualsiasi MCU. La procedura potrebbe anche essere usata per passare direttamente dai valori raw a quelli di temperatura usando temperature note se il sensore ha comportamento lineare.
Praticamente.... GRANDE Arduino Uno oppure NANO. Lo attacchi e leggi lo STESSO VALORE su 20 schede di diversi fornitori.
Ancora mi domando come può uscire sul mercato una scheda così...
Su Arduino il riferimento è la tensione di alimentazione che, essendo la stessa per tutti, ti da valori identici.
Credo che se tu usi il riferimento interno ad 1.1V mi sa che succede la stessa cosa dell'ESP32.
Comunque dai link allegati avevo capito che si legge il valore dei fuses e il programma ne tiene conto automaticamente in fase di lettura delle analogiche...
Si, il vantaggio è che una volta calibrato la calibrazione rimane anche cambiando sketch.
Ma se fai pochi progetti puoi usare un file SPIFFS o forse la EEPROM simulata.
Appunto: mi puoi fare un esempio PRATICO di come inserirlo in un programma?
Grazie infinite
Faccio un primo esempio banale.
Collego l'ingresso analogico a massa.
La tensione V è zero e il convertitore mi da zero.
Collego l'ingresso all'alimentazione.
La tensione V è 3.3V e il convertitore mi da 4095
Faccio quindi la regressione lineare. Per questo esempio uso
https://www.graphpad.com/quickcalcs/linear1/ (https://www.graphpad.com/quickcalcs/linear1/)
Nella tabella metto i miei valori, in X i valori del convertitore e in Y le tensioni misurate con il multimetro.
0 0
4095 3.3
Premo calculate now
Si tratta di una regressione lineare, cioè vogliamo trovare l'equazione della linea che segue meglio i nostri valori misurati.
L'equazione della linea è
Y=aX+b
Slope sarà il nostro valore di a = 0.0008059
Y-intercept sarà il nostro b = 0.0
Poiché stiamo usando solo 2 valori R è 1. Questo perché abbiamo 2 punti e quindi una sola retta che passa per i nostri 2 punti.
Quindi l'equazione diventa Y=0.0008059x+0
E quindi per passare dal valore del convertitore alla tensione basta moltiplicare per 0.0008059
Ma questo è un caso ideale e non ci da molte informazioni. Dobbiamo usare 2 o più tensioni che siano maggiori di zero e minori di 3.3V
Metti 1V e 2 V
A 1V il convertitore mi da 1235
A 2V il convertitore mi da 2483
In tabella quindi
1235 1
2483 2
Calcolando abbiamo
a=0.0008013
b=0.01042
L'equazione diventa
Y = 0.0008013*X + 0.01042
Quindi il valore preso dal convertitore AD va moltiplicato per 0.0008013 e poi va aggiunto 0.01042, otterrai la tensione.
Questi 2 valori di a e b sono quelli da memorizzare in qualche modo, nel programma, nella eeprom, in un file SPIFFS o in questi efuses anche se non so se questi efuses memorizzano dei float.
Puoi anche usare più tensioni, basta inserire i rispettivi valori nella tabella. Sconsiglio gli estremi 0 e 3.3V in quanto sono proprio i valori di riferimento del convertitore.
Il discorso può anche essere fatto per le temperature, ti servono 2 temperature note, cacci i valori in tabella al posto della tensione e ottieni direttamente la temperatura. Questo se il legame tra la temperatura e tensione è lineare ma tu credo usi le NTC che invece non sono lineari.
Se non ricordo male lo sono le Pt100 e le termocoppie.
Spero di non aver scritto fesserie.
Buongiorno,
so che tempo fa si era parlato del tasto di boot sul DevKit ESP32, ma non riesco a trovare dove :smiley-sweat:
comunque volevo condividere con voi la mia esperienza, su sistema Win devo premere ogni volta il tasto di Boot per caricare uno sketch, mentre su sistema Mac non è necessario. Che dipenda dal chip usb to uart della silicon lab ?
Inoltre volevo chiedere se c'è qualcuno che utilizza un debugger per caricare lo sketch pre-compilato dall' Arduino IDE sull'esp32 e quale mi consigliate ?
...
su sistema Win devo premere ogni volta il tasto di Boot per caricare uno sketch, mentre su sistema Mac non è necessario....
Queste cose mi fanno notevolmente inc...avolare!
Primo, perché non dovrebbero esserci differenze tre Linux, Mac e Windows se di un programma è stato fatto un porting decente.
Secondo, perché QUESTO dovrebbe essere il sito dell' IDE di Arduino e se c'è un problema andrebbe quantomeno risolto (e di ciò vorrei un parere dei moderatori...)
Mi succede la stessa cosa con IDE su Windows e IDE su Linux quando devo riscrivere il bootloader dei NANO: su Linux ZERO PROBLEMI, su Windows ogni tanto mi da errore e non c'è modo di scrivere.
A meno che mi dichiarate che su Windows alcune cose non si possono assolutamente fare.....
Queste cose mi fanno notevolmente inc...avolare!
vero da fastidio quando le cose non funzionano come dovrebbe, ma io la prendo con filosofia visto che è gratis non pretendo la perfezione :D
Comunque ho idea che non dipenda dall'IDE, ma penso sia un discorso di porte... magari qualcuno più esperto può darmi conferma.
Aggiungo che ho provato su Mac OSx + Eclipse + Plugin Arduino 3.0 e neppure li ho bisogno di premere il tastino di boot, su win devo ancora provare.
Ma con quale delle oltre 30 schede ESP32 ti succede? Io ho la Lolin e il tastino non c'è.
Ma con quale delle oltre 30 schede ESP32 ti succede? Io ho la Lolin e il tastino non c'è.
Io utilizzo ESP32 DEVkit V4.
Ho utilizzato anche huzzah32 di Adafruit, ma è un pò diversa e nemmeno su questa c'è il tastino di boot.
E' il classico ESP32-DEVKIT da 15+15 piedini, con due tastini (BOOT e EN).
A meno che mi dichiarate che su Windows alcune cose non si possono assolutamente fare.....
ad esempio dormire sonni tranquilli?
scusa la facile battuta, ma io sono passato a Linux col Papero Signorile, non mi ricordo nemmeno più perché
ma so benissimo perché non torno indietro
Sono passato a Win10 ho installato Arduino IDE 1.8.10, core versione ESP32 1.0.4.
Ora quando carico programmi su ESP32 devKit non serve più che prema il tasto di boot, cosa che fino a ieri dovevo fare.
Il mistero si infittisce :o
Faccio un primo esempio banale.
Collego l'ingresso analogico a massa.
La tensione V è zero e il convertitore mi da zero.
Collego l'ingresso all'alimentazione.
La tensione V è 3.3V e il convertitore mi da 4095
........
Non è così semplice.
Se vai a vedere su Espressif ma anche su altri siti, gli ingressi analogici di ESP32 non sono come qualli a cui siamo abituati con UNO o Nano.
Infatti la lettura parte dopo lo Zero e si ferma prima dei 4095 punti.
Insomma, un casino.
Guarda QUI. (https://randomnerdtutorials.com/esp32-adc-analog-read-arduino-ide/)