Micropython on ESP8266 - WLAN/DHCP setup and common issues

First, the minimal example that shall work with most hotspots you create on your mobile phone:

import network

 

# configure your hotspot like this or change this

WIFI_SSID = 'mySSID'

WIFI_PASSWORD = 'myWIFIPASSWORD'

# start the wlan
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

wlan.connect(WIFI_SSID , WIFI_PASSWORD)

# test if the wlan is connected
wlan.isconnected()

If everything works fine, sooner or later the test will return true.

If not, continue here (for firmware version esp8266-20220618-v1.19.1.bin):

# print debugging information
import esp
esp.osdebug(0)

Then reconnect again and watch  the logs.

wlan.connect(WIFI_SSID , WIFI_PASSWORD)

In my case it was like this:

>>> sl
scandone
usl

 

This is not one of the common errors like 'wrong password' or something I could find at google. But maybe it can help in your case.

Besides the test if the wlan is connected there's also a command to check the status of the wlan, that I executed next:

wlan.status()

In my case it returned 1, equal to 'STAT_CONNECTING'. My WLAN router showed the device, along with a note 'The device doesn't need an IP address'. For me, DHCP didn't work, and to make it work I first configured a static IP address on the device, then connected to the WLAN and then configured my WLAN router to always assign a static address to my ESP8266. The last step is optional, though.
For the next example my WLAN router is configured with the IP address 192.168.1.1, the netmask 255.255.255.0 and the address 192.168.1.123 is a free address in my network.

# preparation
wlan.active(False)
wlan.active(True)

# set a static IP address
wlan.ifconfig(('192.168.1.123', '255.255.255.0', '192.168.1.1', '8.8.8.8'))

# start the wlan

wlan.connect(WIFI_SSID , WIFI_PASSWORD)

# test if the wlan is connected
wlan.isconnected()

The ESP8266 is now connected to my WLAN router. And after a reboot it would connect again, and DHCP would magically work.

Micropython on ESP8266 and ESP32 (Windows 7)

Identify the ESP Module
https://www.espressif.com/en/products/modules

Install USB to serial port drivers
https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers

Download the latest version of MicroPython
https://micropython.org/download/
Select your board and download the corresponding .bin file. Only this is needed, there is no need to download the complete source code.

Setup a Python environment on Windows

You can download and install python from the Windows store or from a website, or follow this guide that will use Anaconda.

Download and install Anaconda (a python distribution)
Manual download ind installation: https://www.anaconda.com/
Using choccolately: choco install -y anaconda

Download and install nano (a simple text editor) or Visual Studio Code
Nano:
Manual download ind installation: https://www.npackd.org/p/gnunano
Unpack nano.exe and all dlls into a folder in the path, so it can be started by typing in 'nano'.
Using choccolately: choco install -y nano
Visual Studio Code
Manual download ind installation: https://code.visualstudio.com/
Using choccolately: choco install -y vscode

Create a virtual python environment with Anaconda
Start the Anaconda PowerShell prompt, then type:
(base) PS C:> conda update -n base -c defaults conda
(base) PS C:> conda create --name micropython
(base) PS C:> conda activate micropython
(micropython) PS C:> conda install python=3.8 #3.9 is not supported
(micropython) PS C:> pip install terminal-s
(micropython) PS C:> pip install esptool
(micropython) PS C:> pip install rshell
(micropython) PS C:> pip install adafruit-ampy

 

Install MicroPython on the ESP module

Identify the serial port
Disconnect the ESP module (if it was already connected), then type:
(micropython) C:> terminal-s

Press Ctrl+C to abort (or if this does not work use the Windows Task Manager to kill the process). Then connect the ESP module, repeat the command and there should be an additional port listed. Again press Ctrl+C to abort. If there is no additional port listed there might be an error in the board, USB port, cable or drivers. Fix the error before you continue. In the following guide I'll use 'COM10', most likely you'll have a different port.

Note: In the next step, if 'Connecting...' is followed by more dots and underscores you might have a broken board or you'll have to press and/or hold one or more buttons to bring the board in a state where it can be flashed. E.g. if there are both an 'EN' and 'BOOT' button: Press and hold 'EN', then press and release 'BOOT' - or if the labels are printed wrong, : Press and hold 'BOOT', then press and release 'EN'.

Erase the flash
Type:
(micropython) PS C:> $port='COM1'
(micropython) PS C:> esptool --port $port erase_flash
esptool.py v4.5.1
Serial port COM1
Connecting....
Detecting chip type... Unsupported detection protocol, switching and trying again...
Connecting....
Detecting chip type... ESP8266
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: 84:0d:8e:8c:84:e5
Uploading stub...
Running stub...
Stub running...
Erasing flash (this may take a while)...
Chip erase completed successfully in 8.7s
Hard resetting via RTS pin...

Install the firmware on ESP8266:
Type:
(micropython) PS C: > esptool --chip ESP8266 --port $port --b
aud 460800 write_flash --flash_mode dio --flash_size detect 0x0 .\esp8266-20220618-v1.19.1.bin
esptool.py v4.5.1
Serial port COM1
Connecting....
Chip is ESP8266EX
Features: WiFi
Crystal is 26MHz
MAC: 84:0d:8e:8c:84:e5
Uploading stub...
Running stub...
Stub running...
Changing baud rate to 460800
Changed.
Configuring flash size...
Auto-detected Flash size: 4MB
Flash will be erased from 0x00000000 to 0x0009afff...
Flash params set to 0x0240
Compressed 634844 bytes to 419808...
Wrote 634844 bytes (419808 compressed) at 0x00000000 in 9.5 seconds (effective 5
36.4 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

Install the firmware on ESP8266:
Type:
(micropython) PS C: > esptool --chip ESP32 --port $port --b
aud 460800 write_flash --flash_mode dio --flash_size detect 0x0 .\esp32-20220618-v1.19.1.bin

Install notes
- The option '--baud 460800' makes the transfer faster than usual
- The option '--flash_mode dio' makes the flashing slower than usual, but safer supporting all types of flash modules

Connect to the ESP Module
Type:
(micropython) PS C: > rshell -p $port -a -e nano
Using buffer-size of 32
Connecting to COM1 (buffer-size 32)...
Trying to connect to REPL  connected
Retrieving sysname ... esp8266
Testing if ubinascii.unhexlify exists ... Y
Retrieving root directories ... /boot.py/
Setting time ... Mar 12, 2023 16:35:17
Evaluating board_name ... pyboard
Retrieving time epoch ... Jan 01, 2000
Welcome to rshell. Use the exit command to exit rshell.
C:>

Note
If rshell throws the error 'AttributeError: module 'collections' has no attribute 'Callable'' then search the local file py3k_compat.py and change line 8 to 'return isinstance(x, collections.abc.Callable)' (Python version 3.10.0 throws this error).

Note
When using Visual Studio Code, type 'rshell -p $port -a -e code'.

Using the editor
Now you can edit files on the ESP module with 'edit filename' and they will be opened in either nano or Visual Studio Code. However there's no backup to your local machine, the files are stored only on the ESP module. The two most common files you would edit:
C:> edit /pyboard/boot.py
C:> edit /pyboard/main.py

Using the interactive python interpreter
Type:
C:> repl
Entering REPL. Use Control-X to exit.
>
MicroPython v1.19.1 on 2022-06-18; ESP module with ESP8266
Type "help()" for more information.
>>>
>>>

To exit repl press Ctrl+X, to exit rshell type 'exit'.

Using rsync to transfer files
In rshell you can use rsync to syncronize files between a local folder on your computer and the ESP module:
C:> rsync /local/computer/folder /pyboard

Using ampy to transfer files
To transfer individual files, e.g. main.py, type:
ampy --port $port put main.py

Using rshell to start repl automatically:
rshell -p $port -a -e nano repl

That's it. For an introduction to Python, MicroPython look somewhere else. And if you want to use Adafruit CircuitPython forget everything on this page.

Windows 10: Flashing Colibri-T20 Iris 1.1B with Linux

 This is more like a scratch-pad than a full guide.

Files that I used:

1) https://docs.toradex.com/103231-tegra-update-tool.zip?v=21

2) https://docs.toradex.com/102307-tegra-wince-image.zip?v=19

3) https://files.toradex.com/Colibri/Linux/Images/Colibri-T20_LXDE-Image_2.8b7.-20200610.tar.bz2

 

First things first: Scan the QR code and keep a note of the serial number. If it's lost due to a failing update you'll have to enter it.

You'll need:

• PC with Windows 10 with WSL (windows subsystem for linux) or a extra linux computer/vm
• USB cable (USB to Micro-USB)
• RS-232 serial port, either build-in or an USB to RS-232 adapter (a serial port adapter with 3.3V or 5V will not work)
• USB stick (or Micro SD card and a card reader for the PC) with 1 or 2 GB
  

Optional: Flashing Windows CE (make sure everything works):

On the computer:

• Connect the USB cable
• Connect the serial adapter (if there's no build-in serial port)
• Start a serial terminal, with either (9600 or 115200 baud, 8 data bits, no parity, one stop, no hardware/software flow control). The speed depends on the currently installed bootloader.

A good serial terminal: terminal-s for python (to install: pip install terminal-s). Start it with terminal-s, there's no need to specify the baud rate.

On the micro-controller:

• Power off 
• Connect pins 1 and 2 of jumper one, to enter recovery mode
• Connect the USB cable
  
• Connect the serial port X13 to the serial cable (X13.pin3 (RXD) to serial.pin3 (TXD), X13.pin5 (TXD) to serial.pin2 (RXD) and X13.pin9 (GND) to serial.pin9 (GND).
• Power on

On the computer a new device will be recognized. Install the drivers provided with file (1). Then execute update.bat provided with file (1) and select a config file provided with file (2) to flash Windows CE on the micro-controller. On the serial console you'll see the progress. Now, you might power off, remove the connection at jumper one, and start Windows CE. Flashing works.

Flashing Linux

On the computer:

• Prepare the USB stick (or Micro SD card) using diskpart
  Note: The filesystem fat is limited to 2 GB, when using a larger stick/card you'll have to adjust the create partition command.
• start PowerShell (as Adminstrator), then diskpart and execute:
  
• list disk
• select disk [number of the USB stick]
• convert gtp
• create partition primary
• list partition
• format fs=fat
• Prepare the linux files for the USB stick (or Micro SD card)
  Note: You might want to use a different folder than the Desktop to copy the files, as you wish.
  
• start wsl (I used Ubuntu 20.04 LTS) and execute:
  
• su
  
• cd /tmp
• mkdir output
• wget https://files.toradex.com/Colibri/Linux/Images/Colibri-T20_LXDE-Image_2.8b7.-20200610.tar.bz2
• tar xjvf Colibri-T20_LXDE-Image_2.8b7.-20200610.tar.bz2
• cd Colibri-T20_LXDE-Image_2.8.7
• ./update.sh -o /tmp/output
• cp -r /tmp/output /mnt/c/Users/[your user name]/Desktop
• cp ./colibri-t20_bin/u-boot-dtb-tegra.bin /mnt/c/Users/[your user name]/Desktop/
• Copy the files from the Desktop to the prepared USB stick (or Micro SD card)
• Copy nvflash.exe provided with (1) to Desktop/colibri-2
  and finally
  
• Connect the USB cable
• Connect the serial adapter (if there's no build-in serial port)
• Start a serial terminal, with either (9600 or 115200 baud, 8 data bits, no parity, one stop, no hardware/software flow control). The speed depends on the currently installed bootloader.

On the micro-controller:

• Power off 
• Connect pins 1 and 2 of jumper one, to enter recovery mode
  
• Insert the  USB stick (or Micro SD card) 
  
• Connect the USB cable
  
• Connect the serial port X13 to the serial cable (X13.pin3 (RXD) to serial.pin3 (TXD), X13.pin5 (TXD) to serial.pin2 (RXD) and X13.pin9 (GND) to serial.pin9 (GND).
• Power on

On the computer, load the recovery boot block into the microcontroller

• start PowerShell and execute:
• cd C:/Users/[your user name]/Desktop/
• .\nvflash.exe --bct colibri-t20\colibri_t20-256-v11-nand.bct --bl colibri-t20\u-boot-dtb-tegra.bin --go

On the computer, switch to the serial terminal, you might see something like this:

Toradex Flash Loader 2.6 for Tegra Built May  6 2019 17:38:39
DeviceUID: 0x0000000000000000028841C140E09297
WARNING: No PartitionTable Pointer found in BCT
Nand Boot Device
Micron M61A PS:4KB BS:512KB DS:0MB BCH16 ECC
Detecting Memory Size...
256MB RAM
AdjustingBCT: NAND, PageSize=4KB, BlockSize=512KB, RamSize=256MB, isApalis=0, isIT=0
WARNING: Config Block not found at default location
WARNING: Missing MAC Entry
WARNING: Missing HW Entry
WARNING: Missing PROD Entry

If so, first install Windows CE, that will fix the broken bootloader as well.

Or you might see something like this:

Toradex Bootloader 2.4 for Tegra Built Jan  7 2022 14:04:27

Press [SPACE] to enter Bootloader Menu

Colibri T20 256MB 1.1A  Serial: 4754078
RAM: 256 MB, CarveOut: 64 MB
Loading IM1 image from flash...Done(808ms)
Checking Image CRC...OK(46ms)
Decompressing IMAGE(17555884, 33594664) from 8201FD3C to 80016000...Done(374ms)
Jumping to image at 0x80016000...

That's good, all you'll have to do is press the SPACE bar and power-cycle the micro controller to the interactive bootloader menu:

Toradex Bootloader 2.4 for Tegra Built Jan  7 2022 14:04:27

Press [SPACE] to enter Bootloader Menu

BootLoader Configuration:

C) Clear Flash Registry
X) Enter CommandPrompt Mode
D) Download image to RAM now
F) Download image to FLASH now
L) Launch existing flash resident image now

Enter your selection:

 Select x and then execute at the 'Colibri T20 #' prompt:

Colibri T20 # run setupdate
Colibri T20 # run migrate_v2.3b7

Then, again press the SPACE bar and power-cycle the micro controller, to re-enter the interactive bootloader menu. Again, select x and then execute (replace the xxx with your serial number):

Colibri T20 # nand erase.chip
Colibri T20 # cfgblock create
Is the module an IT version? [y/N] y
Enter the module version (e.g. V1.2A): V1.1B
Enter module serial number: 002011000xxxxxxx
Toradex config block successfully written
Colibri T20 # setenv fdt_addr_r 0x01000000
Colibri T20 # saveenv
Colibri T20 # run setupdate
Colibri T20 # run update

On the micro controller:

• Remove the connection between pins 1 and 2 at jumper one
• Remove the USB stick (or micro SD card)
• Connect a DVI (or DVI to HMDI adapter and an HDMI) display
• Connect an USB hub with keyboard and mouse
  
• Connect a network cable to the micro
  

To login at the serial terminal: username 'root', no password needed.

 

Note: I generated the serial number based on product images from the internet, and modified the first part with try-n-error to my module, because the serial number on my micro controller is not accepted. The second part is taken from my module, that part of the serial number is correct on my module.

Building Espruino for ESP8266 with storage support

Espruino ESP8266 firmware with Storage support

Note:  Storage is now included, in 2v13

Prerequesites

PC or VM with Ubuntu 18.04 LTS
ESP8266 with 4 MB flash and USB port

The following code is removed from the build: Remote access via telnet, remote firmware update, the graphics and crypto library

Basic steps

Compiling Espruino for ESP8266 on Ubuntu 18.04 LTS

Reference:
https://github.com/espruino/Espruino/blob/master/README_Building.md#for-esp8266

• development-tools
• sudo apt-get update && apt-get upgrade
• sudo apt-get install make unrar-free autoconf automake libtool gcc g++ gperf flex bison texinfo gawk ncurses-dev libexpat-dev python-dev python python-serial python-pip sed git unzip bash help2man wget bzip2 libtool-bin build-essential git esptool
• sudo pip install --upgrade pip
• esp-open-sdk
• https://github.com/pfalcon/esp-open-sdk 
• git clone --recursive https://github.com/pfalcon/esp-open-sdk.git
• make STANDALONE=n
• does NOT work on ARM, does not work with low memory (4 GB is ok)
• Espressif NONOS SDK (version 2.2.1)
• https://github.com/espruino/EspruinoBuildTools/blob/master/esp8266/ESP8266_NONOS_SDK-2.2.1.tgz
• wget  https://github.com/espruino/EspruinoBuildTools/raw/master/esp8266/ESP8266_NONOS_SDK-2.2.1.tgz
• tar xf  ESP8266_NONOS_SDK-2.2.1.tgz
• Espruino
•  git clone https://github.com/espruino/Espruino.git
• Test build
• cd Espruino
• export BOARD=ESP8266_4MB
• export FLASH_4MB=1
• export ESP8266_SDK_ROOT=/<path>/ESP8266_NONOS_SDK-2.2.1
• Replace <path>  with the folder containing the Expressiv NONOS SDK
• export PATH=$PATH:/<path>/xtensa-lx106-elf/bin/
• Replace <path> with the folder containing the esp-open-sdk
• export COMPORT=/dev/ttyUSB0
• Replace  ttyUSB0 if you're using another port
• make clean && make $*

Additional steps

Within the Espruino folder go to boards, make a backup copy and edit the build libraries in ESP8266_4MB.py:

'build' : {
   'libraries' : [
     'NET',
     #'TELNET',
     #'GRAPHICS',
     #'CRYPTO',
     'NEOPIXEL',
     'FILESYSTEM',
     'FLASHFS'
],

This will disable TELNET (personally I never used it), GRAPHICS (OK when building a web server) and CRYPTO (that supports SHA256 only anyway), saving storage space for the now enabled FILESYSTEM and FLASHFS.

Within the Espruino folder edit /targets/esp8266/user_main.c and comment out lines 30 (to //#include <ota.h>) and 241 (to //otaInit(88);) to remove remote firmware update from the code.

Within the Espruino folder edit Makefile and activate lines 24 (to RELEASE=1). Remove the trailing space in line 507 (to libs/network/esp8266/pktbuf.c) and remove line 508 (libs/network/esp8266/ota.c) to prevent OTA from being included in the code.


To get "make flash" to work you'll have to

• Adjust the link to esptool.py within the Expressiv NONOS SDK subfolder (delete current link (rm /<path1>/esptool/esptool.py), add new link (ln -s /usr/share/esptool/esptool.py / <<path1>/esptool/esptool.py)
• 
  
• Grand your user access to /dev/ttyUSB0:
• Add your user to the dialout group (sudo usermod -a -G dialout $USER)
• Eventually stop and remove modemmanager
• Logout and login after these changes
• If this doesn't work do it as root
• Flash the ESP8266
• cd Espruino
• export BOARD=ESP8266_4MB
• export FLASH_4MB=1
• export ESP8266_SDK_ROOT=/<path>/ESP8266_NONOS_SDK-2.2.1
• export PATH=$PATH:/<path>/xtensa-lx106-elf/bin/
• export COMPORT=/dev/ttyUSB0
• make clean && make $*
• make flash

If flashing doesn't produce a bootable devices then it's most likely because of the use of the option "--flash_mode qio" in the esptool.py command line, some flash modules don't support this. With "--flash_mode dio" it'll produce bootable devices. Change line 20 in the file make/family/ESP8266.make to ESP_FLASH_MODE ?= 2 # 0->QIO, 2->DIO and it'll work.)


To flash the ESP8266 using Windows copy the two binaries

espruino_esp8266_user1.bin
espruino_esp8266_user2.bin 

to Windows, and use them together with

blank.bin, boot_v1.6.bin, esp_init_data_default.bin

from  https://www.espruino.com/binaries/espruino_2v03_esp8266_4mb/ for flashing.

Testing

Connect the ESP8266 to the IDE and execute a few commands
1+1;
=2

process.env
={
  VERSION: "2v03.38",
  GIT_COMMIT: "0b21c5d4",
  BOARD: "ESP8266_4MB_FS",
  FLASH: 0, RAM: 81920,
  SERIAL: "dc4f2218-6db0",
  CONSOLE: "Serial1",
  MODULES: "Flash,Storage,hea" ... ",ESP8266,neopixel",
  EXPTR: 1073643644 }

console.log(process.env.MODULES);
Flash,Storage,heatshrink,net,dgram,http,NetworkJS,Wifi,ESP8266,neopixel
=undefined

const Storage = require("Storage");
Storage.getFree();
=196608

Storage.list();
=[  ]

//a test with the wrong length
Storage.write("name", [1,2,3], 0, 5);
=true

Storage.list();
=[
  "name"
 ]

Storage.read("name");
="\1\2\3\xFF\xFF"

Storage.getFree();
=196584

//a test with the correct length
Storage.write("name", "123", 0, 3);
=true

Storage.read("name");
="123"

// cleanup after the test
Storage.erase("name");
=undefined

Storage.list();
=[  ]

Storage.getFree();
=196608

ESP32-CAM with OV2640 camera

Flashing the example application

Prerequisites

ESP32-CAM with OV2640 camera (USD 5.59 + 1.98 shipping)
A serial programmer with 3.3V (e.g. CH341 or CH341A work fine)
Arduino IDE, version 1.9.8
5V (or 3.3V) power supply
Wifi Access Point
Six jumper wires
Windows-PC with an USB port

Setup Arduino IDE

File -> Preferences -> Additional Boards Manager URLs
Add these URLs (URLs are comma separated):

http://arduino.esp8266.com/stable/package_esp8266com_index.json, https://dl.espressif.com/dl/package_esp32_index.json

(Note: package_esp8266com_index is not needed for the ESP32-CAM)

Tools -> Board -> Boards Manager
Search for esp32 in the Boards Manager windows, select it and click Install to install it.

Tools -> Board -> ESP32 Wrover Module


Tools -> Partition Scheme -> Huge App (3MB No OTA)

Tools -> COM Port -> COMxyz
(Select the COM port of your programmer)

Tools -> Serial Monitor
This starts a serial monitor on the selected COM port (not active during flashing, set it to 115200 baud.

Tools -> Programmer -> AVRISP mkII
File -> Examples -> ESP32 -> Camera -> CameraWebServer
In line 14 insert // at the beginning and in line 18 remove // at the beginning defining the camera as CAMERA_MODEL_AI_THINKER.
Enter the SSID and password of your Wifi Access Point editing lines 22 and 23 of the file CameraWebServer and save it as MyCameraWebServer.

Wiring the ESP32-CAM

PINs o the ESP32-CAM board:
3.3V - IO16 - IO0 - GND - VCC - U0R - U0T - GND
IO4 - IO2 - IO14 - IO15 - IO13 - IO12 - GND - 5V 

Connections to be made:
ESP32-CAM pin GND -> GND of the 3.3V serial programmer
ESP32-CAM pin U0T -> RX of the 3.3V serial programmer
ESP32-CAM pin U0R ->  TX of the 3.3V serial programmer
ESP32-CAM pin GND -> GND of the power supply
ESP32-CAM pin 5 V    -> 5V of the power supply(*)

(*):When using a 3.3V power supply wire the pin 3.3V to the 3.3V power supply instead.

Press the RST button and you should see the log output of the pre-installed firmware in the Arduino IDE serial monitor.

Flashing ESP32-CAM 

To flash the software connect the last jumper cable:
ESP32-CAM pin GND <-> ESP32-CAM pin IO0

Then press RST to enter flashing mode.

In Arduino IDE press the upload button (Sketch -> Upload)
During flashing the output should be like this:

Global variables use 52696 bytes (16%) of dynamic memory, leaving 274984 bytes for local variables. Maximum is 327680 bytes.
esptool.py v2.6
Serial port COMxyz
Connecting........
Chip is ESP32D0WDQ5 (revision 1)
Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
MAC: 12:34:45:56:9a:bc
Uploading stub...
Running stub...
Stub running...
Configuring flash size...
Auto-detected Flash size: 4MB
Compressed 8192 bytes to 47...

Writing at 0x0000e000... (100 %)
Wrote 8192 bytes (47 compressed) at 0x0000e000 in 0.0 seconds (effective 7281.7 kbit/s)...
Hash of data verified.
Compressed 16832 bytes to 10888...

Writing at 0x00001000... (100 %)
Wrote 16832 bytes (10888 compressed) at 0x00001000 in 1.0 seconds (effective 140.3 kbit/s)...
Hash of data verified.
Compressed 2242064 bytes to 1795618...

Writing at 0x00010000... (0 %)
Writing at 0x00014000... (1 %)
[...]
Writing at 0x001c0000... (99 %)
Writing at 0x001c4000... (100 %)
Wrote 2242064 bytes (1795618 compressed) at 0x00010000 in 158.1 seconds (effective 113.4 kbit/s)...
Hash of data verified.
Compressed 3072 bytes to 134...

Writing at 0x00008000... (100 %)
Wrote 3072 bytes (134 compressed) at 0x00008000 in 0.0 seconds (effective 1536.0 kbit/s)...
Hash of data verified.

Leaving...
Hard resetting via RTS pin...

Then disconnect the last jumper wire and press the RST button. The output shall be (in the Arduino IDE serial monitor):

00:00:07.879 -> ets Jun  8 2016 00:22:57
00:00:07.879 ->
00:00:07.879 -> rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
00:00:07.913 -> configsip: 0, SPIWP:0xee
00:00:07.913 -> clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
00:00:07.913 -> mode:DIO, clock div:1
00:00:07.913 -> load:0x3fff0018,len:4
00:00:07.913 -> load:0x3fff001c,len:1100
00:00:07.913 -> load:0x40078000,len:9232
00:00:07.913 -> load:0x40080400,len:6400
00:00:07.913 -> entry 0x400806a8
00:00:09.951 ->
00:00:11.373 -> .....
00:00:13.375 -> WiFi connected
00:00:13.375 -> Starting web server on port: '80'
00:00:13.375 -> Starting stream server on port: '81'
00:00:13.375 -> Camera Ready! Use 'http://192.168.43.125' to connect

Copy the URL given in the last line, http://192.168.43.125 in this example, to your web browser.

When getting an image the output shall be:

00:01:52.537 -> JPG: 3461B 43ms

When getting an stream the output shall be:

00:02:32.723 -> MJPG: 3454B 3ms (333.3fps), AVG: 3ms (333.3fps), 0+0+0+0=0 0
00:02:32.757 -> MJPG: 3441B 30ms (33.3fps), AVG: 16ms (62.5fps), 0+0+0+0=0 0
00:02:32.791 -> MJPG: 3468B 49ms (20.4fps), AVG: 27ms (37.0fps), 0+0+0+0=0 0

When disconnecting power the output shall be (also happens when using a weak power supply):

00:03:36.486 -> 
00:03:36.486 -> Brownout detector

If you receive the following lines during startup of the module remove power from the module, reconnect power and press the RST button. Pressing the RST button while powered on will not fix this issue:

00:00:44.576 -> [E][camera.c:205] skip_frame(): Timeout waiting for VSYNC
00:00:44.576 -> [E][camera.c:1270] esp_camera_init(): Camera init failed with error 0x20003

Done

The camera stream in the browser looks like this:

TLDR

The video quality is really bad, it has a lot of noise. And for me the camera module crashes rather often, even when using a stabilized power supply. Might be a software issue, or whatever. Having two modules with the same issue I'm about to drop the camera module to the waste bin and keep the ESP32 as micro-controller with Espruino.