ESP32: chip di nuova degli oggetti da Espressif

L'ESP8266 dalla casa Espressif è popolare non solo con Arduino-maker. Il chip integrato Wi-Fi, un processore veloce, e molte altre caratteristiche ad un prezzo imbattibile. Può essere utilizzato come una scheda compatibile Arduino o come componente di comunicazione per un host Arduino esistente. Il successore di recente pubblicazione ESP32 contiene anche Bluetooth e offre caratteristiche che superano quelli di molti schede Arduino lontane. Quindi, un motivo sufficiente per prendere un primo sguardo al ESP32.

Il blog fa pausa invernale

Dal momento che l'autore di questo blog richiede una volta fuori, il blog crea una pausa artistica fino a metà gennaio 2017e

Nel 2017 aspettare argomenti di nuovo eccitanti. I piani includono i contributi al

  • Meccatronica / Robotica
  • Arduino @ cloud
  • simulatori di Arduino,
  • Audio / sintetizzatore Shields,
  • altre schede a microcontrollore,
  • a schede con Linux embedded come ad esempio Udoo Neo, BeagleBone e lampone Pi,
  • strumenti di misura basati su FPGA di redpitaya,
  • schede FPGA per principianti, sensori / attuatori progetti

Naturalmente, è sempre possibile inviare suggerimenti via mail a me. Le critiche costruttive è inoltre benvenuto.

questo blog aveva segnalato già in due episodi di esp8266. I piccoli moduli con i produttori di chip hanno una grande base di fan, offrono una funzionalità prezzo MCU e WiFi insuperabile. Con mezzi semplici ad un Arduino con un ESP8266 possono essere estese al WiFi. Ben presto, alcuni produttori di sostituire il firmware incorporato di ESP8266 con il proprio firmware in modo che gli sviluppatori possano programmare ESP8266 schede come schede Arduino. L'ESP32 ora fa un passo avanti ed è più potente rispetto alle esp8266 sotto ogni aspetto. Egli ha inoltre implementato la logica Bluetooth.

Per capire la portata della ESP32, ho compilato i seguenti tutti i dati. Come sono alcuni dettagli molto tecnici, la loro più profonda comprensione non appare necessario. Tuttavia, è utile per avere un senso delle possibilità dei nuovi chip.

Un ESP32 fornisce un sacco di interfacce Un ESP32 fornisce un sacco di interfacce(Immagine: http://sparkfun.com)

Così andiamo in medias res:

Un ESP32 ha un 240 MHz dual-core microprocessore del tipo Tensilica LX6 con un rendimento di 600 DMIPS. Oltre a 520 Kbyte di SRAM sono 16 MB di memoria flash a bordo. Viene azionato, il chip con tensioni da 2.2 to 3.6 V. Con una possibile temperatura ambiente di -40 ° C e 125 ° C, l'ESP32 risulta essere adatto per applicazioni industriali. Nel sonno profondo l'ESP32 consuma 2,5 microampere secondo il produttore. Per il basso consumo energetico assicura un processore appositamente ULP (Ultra-Low-Power). Qui, fino a 8 Kbyte di dati e programmi nella SRAM del RTC (Real-Time Clock) possono essere esternalizzate, in modo che anche in modalità di sonno profondo, l'accesso al timer, interrupt, periferiche è possibile.

Per comunicare con il mondo esterno include il SoC (System on a Chip) la componente HT40 802.11 b / g / n-WiFi e la funzionalità Bluetooth. Quest'ultimo sia "classico" (Versione di Bluetooth e Bluetooth Low Energy <= 4.2). Oltre al PCB antenna integrata mediante un connettore componente IPEX esterno può essere collegato.

Wi-Fi è possibile nella stazione di modalità operative sniffer, Access Point, Soft Access Point e in modalità diretta. Poiché i tassi di dati sono Espressif (tra parentesi sono l'energia di trasmissione massima specificata)

@ 150 Mbps 11n HT40 (15,5 dBm)
72 Mbps @ 11n HT20 (11,5 dBm)
54 Mbps @ 11g (16,5 dBm)
11 Mbps @ 11b (19,5 dBm)

sostenuti 135 Mbps sono così sotto protocollo UDP accessibile al throughput di rete.

La sensibilità minima del ricevitore è -98 dBm.

Per la comunicazione protocolli di sicurezza WEP, WPA / WPA2 PSK / Exter pizzico di preoccupazione, con la crittografia con accelerazione hardware utilizzando AES, SHA2, crittografia a curva ellittica e RSA-4096 è presente.

Come sensori ESP32 fornisce un sensore di Hall, dieci volte, interfaccia touch capacitivo, un amplificatore analogico per segnali bassi, e un cristallo di quarzo 32 kHz. V'è un sensore di temperatura è installato anche, ma che probabilmente dovrebbe essere scarsamente utilizzate dovuto alla temperatura ambiente per altri scopi.

Schema a blocchi del potente ESP32 Schema a blocchi del potente ESP32

32 ingressi e uscite general purpose (GPIO) sono, come nel grafico di cui sopra può essere visto, una totale disponibile, compresi tre UART con controllo di flusso via hardware, tre interfacce SPI, un controllore CAN bus 2.0, a due a due I2S I2C interfacce, anche 12 ingressi analogici con convertitore analogico-digitale con una risoluzione di 12 bit, e due uscite analogiche per convertitore digitale-analogico e risoluzione di 10 bit. Ciascuna porta GPIO in questo caso ha pulse width modulation timer e logica.

Supporta anche il chip di collegamento:

Coloro che vogliono conoscere maggiori dettagli: Per ulteriori informazioni su ESP32 si trova anche in questo Marchio: -Articolo.

tavole ESP32

Per sperimentare l'ESP32 un modulo ESP32 nudo è adatto solo per nerds hardware che vogliono conoscere il SoC intorno alla larghezza e profondità. Chi non vuole ed è più interessato a un approccio plug-and-play per accedere tavole ben fornito di diversi produttori. L'autore ha testato due opzioni e un po 'a sperimentare con un'opzione aggiuntiva.

SparkFun ESP32 Thing

L'ESP32 Thing da SparkFun è basato sul SoC ESP32 Espressif. con la "cosa" per conto dei produttori vorrebbe illustrare l'attenzione del consiglio di amministrazione come un dispositivo per l'Internet delle cose. Oltre a ESP32 scheda includerà un'interfaccia USB FTDI FT231x che sarà sviluppatori familiarità Arduino. Tuttavia, se non scheda Arduino ha utilizzato la macchina di sviluppo ha bisogno di installare i driver per il chip FTDI può. Come un add-on, la scheda integra un componente per la ricarica batterie Li-Po. Negli Stati Uniti, l'hardware per SparkFun fallisce con $ 17.96 per prenotare. In Germania, per esempio, offre exp-tech per la pensione a € 21,60.

SparkFun ESP32 Cosa è la patria di chip di ESP32SparkFun ESP32 Cosa è la patria di chip di ESP32
Watterott ESP Wroom-32 bordo di sblocco

Il consiglio di Watterott è quello di Espressif Core Board (DevKitC) compatibile, che porta alcuni benefici per i primi passi con esso, perché è già un software Espressif disponibili. Il collegamento delle schede per la macchina di sviluppo funziona microUSB. Come USB UART Ponte serve un modulo Silabs-CP2102N che richiede driver speciali. Maker ottenere la pensione a € 17,95 a Watterott. "Wroom" tra l'altro, proviene dalle ESP32 ESP32 moduli del produttore Espressif. La scheda Wroom-02 è più piccolo del bordo Wroom-32. Per quest'ultimo porta tutti i pin di ESP32 esteriori.

watterott.comBordo di sblocco ESP32 di Watterott(Immagine: watterott.com)
Exotic - PyCom WyPy 2.0

Fuori concorso di PyCom WyPy per trovare 2,0 menzione circa l'autore del blog vorrebbe dire un po 'più in dettaglio in futuro. PyCom non solo fornisce questo modulo ad un'altra scheda ESP32. La scheda sporge motivo particolare dalla concorrenza fuori perché ha un firmware Micro Python basata su Python. Può giocare su ma con un firmware diverso. Sotto Python e multi-threading è possibile. Questo prodotto offerta, tra l'altro exp-tech e Watterott per meno di € 24

PyCom WiPy v2 comprende un firmware basati su Micro PythonPyCom WiPy v2 comprende un firmware basati su Micro Python(Immagine: watterott.com)

programmazione

Per ESP32 tavole piace usare il citato senza soluzione di continuità in Arduino ecosistema richiede il firmware e gli strumenti speciali. Il firmware ESP32 Arduino core assicura che gli sviluppatori possono programmare una scheda ESP32 modo all'interno del Arduino IDE come un Arduino o pensione Teensy.

Oltre a un'installazione Git un ambiente runtime Python 2.7 come preparazione è necessaria. Suppongo che l'IDE Arduino è già disponibile in una versione aggiornata del computer.

Potete trovare le istruzioni riportate di seguito, tra l'altro, sul sito web del progetto Arduino ESP32 core su GitHub.

In primo luogo, si dovrebbe passare alla directory in cui si trovano Arduino Schizzi, biblioteche, e le definizioni di hardware. Nella maggior parte dei casi la directory Arduino è sotto la cartella documenti specifici dell'utente. Lì, immettere i seguenti comandi in una console o un terminale. Può anche darsi che ci sia già un hardware sottodirectory in modo che il comando hardware mkdir si rivela inutile:

hardware mkdir
hardware cd
mkdir espressif
cd espressif
git clone https://github.com/espressif/arduino-esp32.git ESP32

Ora dovete chiamare il get.py script Python all'interno della ESP32 directory appena creata:

python get.py

Lo script scarica gli strumenti GNU e Xtensa Kit ESP32 Software Development. Dopo la chiusura e la riapertura del Arduino IDE sono riportati nella IDE da Strumenti | bordi del menu schede ora disponibile anche.

Dopo aver installato le schede Arduino ESP32 ESP32 core sono in Arduino IDE disponibile Dopo aver installato le schede Arduino ESP32 ESP32 core sono in Arduino IDE disponibile

Per lo sviluppo con le schede ESP32 da SparkFun e Watterott Dev modulo ESP32 è disponibile come impostazione bordo.

Anche se tutte le funzionalità del lavoro firmware Arduino ESP32-core, al momento non è ancora completa, ma almeno i seguenti elementi:

Mini-example

Qui l'inevitabile perché esempio batter banale al pin 13 LED collegato e serial monitor. Quando SparkFun ESP32 cosa è necessario premere il pulsante RST se il blu a bordo LED debolmente al pin 5 e nient'altro mosse. Dopo di che si spegne sul palo. Quando ESP32-Wroom bordo di sblocco di Watterott premere invece il tasto EN.

Con il set sulla velocità di upload Arduino IDE di 921600 baud programmazione delle schede per inciso funziona piacevolmente veloce.

int ledPin = 13;
void setup ()
{
pinMode (ledPin, OUTPUT);
Serial.begin (115200);
}

void loop ()
{
scrittura digitale (ledPin, HIGH);
Serial.println ("a");
ritardo (500);
scrittura digitale (ledPin, LOW);
Serial.println ("da");
ritardo (500);
}

connessioni Wi-Fi

La caratteristica principale di ESP32 è la sua capacità di comunicare. Il seguente disegno mostra la connessione tramite Wi-Fi e il recupero di una pagina Web (heise.de). Al perno 13, un LED è di circa 220 ohm collegato.

Inserisci il codice sulle proprie credenziali. La spesa tramite il monitor seriale con 115.200 baud.

////////////////////////////////////////////////// ///////
//
// programma demo per l'accesso Web su
// ESP32 bordo di sblocco
//
////////////////////////////////////////////////// ///////


#include // utilizzare WiFi Biblioteca

// accesso Wi-Fi
const char * ssid = "StalWLAN";
const char * pswd = "........";

// essere pagina recuperata:
const char * link = "heise.de";
int port const = 80;

// LED sul pin 13
int LED const = 13;


////////////////////////////////////////////////// ///////
//
// configurazione
// connettersi al Wi-Fi
// & dichiarando LED
//
////////////////////////////////////////////////// ///////

void setup ()
{
// inizializza Hardware
Serial.begin (115200);
pinMode (LED, OUTPUT);

scrittura digitale (LED, LOW);
// connettersi alla rete
Serial.println ("collegamento");
connectWLAN (SSID, pswd);
}

////////////////////////////////////////////////// ///////
//
// ciclo
// Ogni 10 secondi Sito web http: //: Leggi
//
////////////////////////////////////////////////// ///////

void loop ()
{
leggere la pagina (link, porto);
ritardo (10000);
}

////////////////////////////////////////////////// ///////
//
// connectWLAN
// connettersi a Wi-Fi e la password
//
////////////////////////////////////////////////// ///////

connectWLAN void (const char * SSID, const char * pswd)
{
Serial.println ("connettersi con " + String (SSID));

WiFi.begin (SSID, pswd);

while (WiFi.status () = WL_CONNECTED!);

Serial.println ();
Serial.println ("collegato");
Serial.print ("indirizzo IP dedicato: ");
Serial.println (WiFi.localIP ());
}


////////////////////////////////////////////////// ///////
//
// stampa la pagina
// Leggi pagina sulla connessione
//
////////////////////////////////////////////////// ///////

vuoto pagina stampa (client WiFiClient) {
while (client.available ())
{
Linea String = client.readStringUntil ( '\ r');
Serial.print (line);
}
}

////////////////////////////////////////////////// ///////
//
// createGetCommand
// crea HTTP GET comando per la pagina
//
////////////////////////////////////////////////// ///////

String createGetCommand (const char * link) {
tornare (String)"GET / HTTP / 1.1 \ r \ n" +
"host: " + (Link) String + "\ R \ n" +
"Connection: close \ r \ n \ r \ n";
}

////////////////////////////////////////////////// ///////
//
// getPage: Pagina sulla connessione
// Ottenere con HTTP GET
//
////////////////////////////////////////////////// ///////

invalidare getPage (client WiFiClient, const char * link) {
client.print (createGetCommand (link));
unsigned long timeout = Millis ();
mentre (client.available () == 0) // massimo di 5 secondi
{
if (millis () - timeout > 5000)
{
Serial.println ("*** timeout client ***");
client.stop ();
tornare;
}
}
Serial.println ();
}

////////////////////////////////////////////////// ///////
//
// leggere la pagina
leggi: // http: //
//
////////////////////////////////////////////////// ///////

Pagina vuoto di lettura (const char * collegamento, porto uint8_t)
{
Serial.println ("Connettiti con URL: " String + (link));

// Creazione di una connessione TCP
cliente WiFiClient;
if (! client.connect (link, porto)) // connettersi
{
Serial.println ("*** *** connessione non riuscita");
tornare; // nel prossimo turno
}
// collegamento è iniziato:
scrittura digitale (a LED, HIGH); // LED
Serial.println ("connessione è");

getPage (client, link); // Get Pagina
pagina stampa (client); // invia pagina

Serial.println ("Chiusura della connessione");

scrittura digitale (LED, LOW); // LED spento
client.stop (); // stretta connessione
}

Esempio di output al monitor di serie potrebbe essere simile a questo:

connessione WiFi con l'ESP32 connessione WiFi con l'ESP32

ESP IDF come alternativa

Poiché non v'è poca funzionalità in questo momento che può essere utilizzato direttamente dal Arduino IDE dal programmatore, vale la pena di guardare ESP IDF o dettaglio Espressif IoT Development Framework. Questo può essere (in Windows -> Istruzioni per l'installazione), MacOS (-> Istruzioni per l'installazione) o Linux (-> Installare istruzioni di installazione). IDF utilizzato come sistema operativo o come FreeRTOS firmware.

Lo sviluppo avviene lì nella riga di comando di make.

Legalmente make menuconfig la configurazione dei parametri di sistema Legalmente make menuconfig la configurazione dei parametri di sistemarendono permette la traslazione della domanda ESP32 rendono permette la traslazione della domanda ESP32Lampeggiante un'applicazione opere in IDF rendere Flash Lampeggiante un'applicazione opere in IDF rendere Flash

Il programma Blink obbligatoria progettato lì come segue (l'elenco viene dalla directory degli esempi di installazione esp-IDF):

#include
#include "FreeRTOS / FreeRTOS.h"
#include "FreeRTOS / task.h"
#include "esp_system.h"
#include "nvs_flash.h"
#include "autista / gpio.h"
#include "sdkconfig.h"

/ * Può eseguire 'make menuconfig' per scegliere il GPIO a lampeggiare,
oppure si può modificare la riga seguente e impostare un numero qui.
* /

#define BLINK_GPIO CONFIG_BLINK_GPIO

blink_task void (void * pvParameter)
{
/ * Configurare il registro IOMUX per il pad BLINK_GPIO (alcune pastiglie sono
muxed per GPIO on reset già, ma alcuni di default ad altri
funzioni e devono essere commutati GPIO. consultare la
Riferimento tecnico per l'elenco dei cuscinetti e la loro impostazione predefinita
funzioni.)
* /

gpio_pad_select_gpio (BLINK_GPIO);
/ * Impostare il GPIO come un push / pull output * /
gpio_set_direction (BLINK_GPIO, GPIO_MODE_OUTPUT);
while (1) {
/ * Blink off (uscita bassa) * /
gpio_set_level (BLINK_GPIO, 0);
vTaskDelay (1000 / portTICK_RATE_MS);
/ * Lampeggiante on (alto rendimento) * /
gpio_set_level (BLINK_GPIO, 1);
vTaskDelay (1000 / portTICK_RATE_MS);
}
}

invalidare app_main ()
{
nvs_flash_init ();
xTaskCreate (&blink_task, "blink_task", 512, NULL, 5, NULL);
}

La spesa per monitor serie segue lo sviluppatore tramite programmi di terminale come stucco, schermo, TeraTerm.

Chi vuole avere più conveniente IDF può anche essere integrato in Eclipse CDT. Come funziona è descritto in dettaglio in questo sito web. La seguente schermata mostra fuori lampeggiare un programma di esempio per scheda ESP32 dalla Eclipse IDE.

IDF deluxe: lampeggiante dal IDE Eclipse IDF deluxe: lampeggiante dal IDE Eclipse

Per i più avventurosi: Nella directory esempio contiene anche esempi più complessi, vedere come un'applicazione tramite la connettività Bluetooth.

conclusione

In questo ultimo episodio blog prima della pausa invernale abbiamo avuto modo di conoscere l'ESP32 di Espressif e delle relative schede di breakout. Messa a fuoco l'uso delle schede era di circa autonomamente con firmware nucleo Arduino ESP32. In episodi successivi ulteriori funzionalità di ESP32 venire in discussione, così come il suo uso come componente Wi-Fi / Bluetooth di un host Arduino. Si prevede che per allora il sostegno della ESP32 nel firmware ESP32 Arduino matura Nucleo. Allo stesso modo è da aspettarsi con la comparsa di numerose biblioteche per il chip.

Tuttavia, dovrebbe già essere certi a questo punto che un bordo di sblocco ESP32 sulle prestazioni sia tecniche che prezzo rappresenta una vera alternativa ai Arduino da stiro. Dal momento che sembra quasi troppo bello per non utilizzare le possibilità di potente SoC, ma usarlo solo come slave del lavoro un Arduino. Soprattutto per applicazioni dell'internet degli oggetti con le loro esigenze di comunicazione, l'ESP32 è finalmente eccellente. Pertanto, l'ESP32 dovrebbe impiegare questo blog in futuro.

In questo senso, auguro a tutti voi un felice, buon Natale e un felice anno nuovo.