Die Esp-32 Chips gibts als Devboards mit USB-Schnittstelle und integriertem USB/Serial-Wandler oder als „Buttoned Breakout Boards“ ohne zusätzliche Beschaltung.

Nur was macht man ohne einen extra 3.3-Volt RS232-Wandler? Man benutzt seinen Raspberry Pi.

Verkabelt wird wie folgt:

Raspberry Pi	ESP-32
Tx	Rx
Rx	Tx
Ground	Gnd
3.3V	3.3V

Mein Programm kompiliere ich auf meinem großen PC, den Raspberry benutze ich nur zum Programmieren, denn es ist ziemlich kompliziert, die ESP32-Toolchain auf dem Raspberry Pi zu installieren.

Also auf dem PC erstmal ein ESP-32 Programm erstellen und kompilieren. Ich nehme statt Arduino lieber platformio, weil.

cd ~
mkdir esp32
cd esp32
virtualenv --python=python2.7 venv_platformio
. ./esp32/venv_platformio/bin/activate
pip install platformio
mkdir wifitest
cd wifitest
platformio init

Nun die Datei ~/esp32/wifitest/platformio.ini so ergänzen:

[platformio]
env_default = esp32


[env:esp32]
platform = espressif32
framework = espidf
monitor_baud = 115200
board = lolin32
board_flash_mode = dio

Das ausgewählte Board ist egal.

Eine Datei ~/esp32/wifitest/src/main.c nach dem offiziellen Template anlegen:

#include "freertos/FreeRTOS.h"
#include "esp_wifi.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_event_loop.h"
#include "nvs_flash.h"
#include "driver/gpio.h"

esp_err_t event_handler(void *ctx, system_event_t *event)
{
    return ESP_OK;
}

void app_main(void)
{
    nvs_flash_init();
    tcpip_adapter_init();
    ESP_ERROR_CHECK( esp_event_loop_init(event_handler, NULL) );
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK( esp_wifi_init(&cfg) );
    ESP_ERROR_CHECK( esp_wifi_set_storage(WIFI_STORAGE_RAM) );
    ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );
    wifi_config_t sta_config = {
        .sta = {
            .ssid = "SSID",
            .password = "passwrd",
            .bssid_set = false
        }
    };
    ESP_ERROR_CHECK( esp_wifi_set_config(WIFI_IF_STA, &sta_config) );
    ESP_ERROR_CHECK( esp_wifi_start() );
    ESP_ERROR_CHECK( esp_wifi_connect() );

    gpio_set_direction(GPIO_NUM_4, GPIO_MODE_OUTPUT);
    int level = 0;
    while (true) {
        gpio_set_level(GPIO_NUM_4, level);
        level = !level;
        vTaskDelay(300 / portTICK_PERIOD_MS);
    }
}

mit

platformio run

kompilieren. Bei allen platformio Befehlen darauf achten, dass das virtual environment aktiviert ist, in das platformio hinein installiert wurde. Aktivieren mit . ./esp32/venv_platformio/bin/activate, deaktivieren mit deactivate.

Auf dem Raspberry Pi muss das esp-idf Toolkit installiert werden, denn darin befindet sich das Tool zum Flashen.

# Raspberry
sudo apt-get install git python python-serial
cd ~
mkdir esp32
cd esp32
git clone --recursive https://github.com/espressif/esp-idf.git

Außerdem muss der Serielle Port freigegeben werden, der ist derzeit noch als Login-Shell unter Benutzung.

sudo raspi-config
# -> Interfacing-Options
#   -> Serial
#     -> Would you like a login shell to be accessible over serial? -> No
#     -> Would you like the serial port hardware to be enabled? -> Yes
# -> Finish
#   -> Reboot now

Seit dem Raspberry Version 3 liegt die Serielle Schnittstelle nicht mehr unter /dev/ttyAMA0 sondern unter /dev/ttyS0. AMA0 ist stattdessen die serielle Schnittstelle der Bluetoothfunktionalität.

Dann legen wir auf dem Raspberry Pi ein Script an, dass sich die Dateien vom großen PC holt und auf den ESP-32 flasht: ~/esp32/get_and_flash.

#!/bin/bash

REMOTEBUILDDIR=daniel@yak.local:esp32/wifitest/.pioenvs/esp32/

mkdir -p tmp
scp ${REMOTEBUILDDIR}partitions_table.bin tmp
scp ${REMOTEBUILDDIR}firmware.bin tmp
scp ${REMOTEBUILDDIR}bootloader.bin tmp

. ~/esp32/venv_platformio/bin/activate

python2.7 ~/esp32/esp-idf/components/esptool_py/esptool/esptool.py --chip esp32 --port "/dev/ttyS0" --baud 115200 --before default_reset --after hard_reset write_flash -z --flash_mode dio --flash_freq 40m --flash_size detect 0x1000 tmp/bootloader.bin 0x8000 tmp/partitions_table.bin 0x10000 tmp/firmware.bin

Die Adressen bzw den ganzen Befehl habe ich aus dem Kommando platformio run --target upload -v extrahiert.

Jetzt muss nur noch irgendwie eine OTA-Flash-Möglichkeit her.