ESP Wireless Modules

ESP32

Introduction

There are a variety of ESP32 based boards, some of which will be dealt with in this section, but first you may like to watch this video as an introduction to the ESP32:

To get an idea of what is possible with the various ESP32 based modules you may want to watch YouTuber ToP Projects Compilation's video:

ESP32-DevKitC V4

My first encounter with ESP32 was a ESP32-DevKitC V4 development board which I got as part of an eBay job lot, the board uses an Espressif ESP32-WROOM-32U module. A getting started guide can be found at:

https://docs.espressif.com/projects/esp-idf/en/latest/esp32/hw-reference/esp32/get-started-devkitc.html

The bottom of the page includes links for the ESP32 datasheet, board schematics, and so on.

My board doesn't have the antenna shown sticking out one end of the board as in the featured photo. This is called the 'keepout zone', which can be seen on page 8 of the datasheet:

https://www.espressif.com/sites/default/files/documentation/esp32-wroom-32d_esp32-wroom-32u_datasheet_en.pdf

The page mentions that the ESP32-WROOM-32U doesn't have the keepout zone. It seems the keepout zone is so called because when designing boards featuring the module you shouldn't have anything in that area but the antenna otherwise wireless performance may be bad.

To summarise some of the board features:

32-bit Xtensa dual-core 240MHz

WiFi 2.4GHz 802.11 b/g/n 150Mbps

Bluetooth 4.2 classic and BLE, client/server

520KB SRAM

448KB ROM

34 GPIO broken out on x2 19-way male headers either side of the board. Some of the GPIO can be configured as digital input or output (some input only), and the following are also available:

x4 SPI

x3 UARTs

x2 i2C

x2 i2S

The board has an on-board micro USB port for powering, programming, and serial connection. On the underside of the board it has written: 'ESP32_DevKitC_V4'.

In order to test the board I followed the instructions to set up the Arduino IDE, from 10:24 in the video linked in the Introduction section; please note: I used Arduino V2.1.1. After installing ESP32 support in the Arduino IDE I couldn't find my board (ESP32-DevKitC V4) listed so I selected 'ESP32 Dev Module', as recommended by a YouTuber. I opened up the Blink example (File->Examples->01.Basics->Blink) and plugged the ESP32 module to the USB of my PC. The on-board red LED illuminated and Windows detected the board as 'CP2102 USB to UART Bridge Controller' but despite claiming to install the driver, Device manager said there were no compatible drivers. This is a downside of boards using some particular USB to serial chips. I found this page with help:

https://techexplorations.com/guides/esp32/begin/cp21xxx/

On the linked Silicon Labs page I downloaded this driver:

CP210x Windows Drivers

After extracting the downloaded file and then installing by running the CP210xVCPInstaller_x64.exe file and then the board showed up in Device manager as 'Silicon Labs CP210x USB to UART Bridge'. In the Arduino IDE I could then set the port (Tools->Port) but the sketch wouldn't compile, I got 'LED_BUILTIN' was not declared in this scope error since LED_BUILTIN isn't defined for the ESP32 Dev Module and looking at the schematic I could see there was no on-board LED. This means we have to connect an external LED and resistor to the board and swap LED_BUILTIN with the GPIO pin that we've connected the LED to. So I connected an LED and resistor to pin 0 (note: not the same as D0) and GND and in the sketch changed LED_BUILTIN to 0. I then clicked upload and it went though the motions (no need to press any buttons on the board), listing some useful information. Of particular note we can see that the chip is an ESP32-D0WDQ6, which is the chip used in the ESP32-WROOM-32U module.

However, at the end it appears to get stuck on:

Leaving...

Hard resetting via RTS pin...

But it's not actually stuck, as the attached LED was flashing and I could upload other sketches.

Blinking an LED is one thing but of course it's the wireless capabilities that we're really interested in, so I tried out the WiFi Scanner example (File->Examples->WiFi->WiFiScan), covered at 21:05 in the introduction video. After uploading the sketch I opened the serial monitor, changed the baud setting to 115200 and then a few WiFi networks appeared in the serial monitor. Perhaps because the board doesn't have an external antenna it only detected 3 networks whereas my desktop, which was very closely located to the ESP32, picked up 8 networks.

Following on I next tried the WiFi Access Point example (File->Examples->WiFi->WiFiAccessPoint), 24:23 in the video. I kept the LED_BUILTIN definition as 2, and set the SSID and password. Remember that these are your chosen SSID and password for the ESP32 acting as a WiFi access point. After uploading the sketch you can then connect to the ESP32 with the SSID and password you set in the sketch and then go to 192.168.4.1 and click the buttons to turn the LED attached to pin 2 on and off.

Since the ESP32 supports Bluetooth as well as WiFi, I continued with the introduction video and tried the SerialToSerialBT example in the video from 31:20 (File->Examples->BluetoothSerial->SerialToSerialBT). Whereas in the video a Bluetooth serial app on Android was used, on Windows 10 we can add a Bluetooth serial COM port, just follow these instructions:

https://community.element14.com/technologies/internet-of-things/b/blog/posts/standard-serial-over-bluetooth-on-windows-10

We can then add the ESP32 to Windows as a Bluetooth device: on Windows open Bluetooth settings, click 'Add Bluetooth or other device', click 'Bluetooth' and select 'ESP32-BT-Slave' or whatever 'device_name' has been set to in the sketch. Open the serial monitor in the Arduino IDE, make sure the baud is set to 115200, and press the En button on the ESP32 to reset it and then you will see the boot output text in the serial monitor.

Next, I opened PuTTY and started a serial connection with the Bluetooth COM port - I found in Device manual three 'Standard Serial over Bluetooth link' devices had appeared so I selected each one until it worked, which you will only know when you try to type. I didn't change the baud setting in PuTTY and left it at 9600.

When I entered text into the Arduino serial monitor the text appeared into PuTTY although oddly the cursor then moves to the next line but several characters to the right. I noticed a slight delay from entering text into the serial monitor and receiving in PuTTY, but that's to be expected. Typing into PuTTY causes the characters to appear almost immediately in the Arduino serial monitor but pressing return doesn't cause a newline. There are perhaps settings in PuTTY to fix these issues.

Next I tried the Hall Sensor example at 39:17 in the introduction video and accessible from File->Examples->ESP32->HallSensor in the Arduino IDE. This worked fine for me, when I brought the magnet close to the wireless modules the values in the serial monitor become negative, as expected. I found that the magnet only needed to be close to the module for the values to change and it's important which way the magnet is positioned compared to the module for it to have an affect.

A neat thing about the ESP32 board is that it has 10 touch switch inputs on various GPIO and we can see an example in the introduction video at 43:40. In the Arduino IDE it's accessed from File->Examples->ESP32->Touch->TouchRead. Strangely, the comments in the sketch mention T0 but in the loop() T1 is read but of course that can be changed. This example worked flawlessly for me, using just a piece of wire connected to the GPIO pin to act as the touch point.

I hope this has been a good introduction to using the ESP32-DevKitC V4 and ESP32 modules in general, be sure to try out the other examples available in the Arduino IDE to get more familiar with your board.

ESP32-C3-DevKitC-02

The ESP32-C3-DevKitC-02 was my second ESP32 development board (ESP32-DevKitC V4 being my first, covered in its own section on this page) and I was especially attracted to it because of it featuring a RISC-V processor and appears to be a fairly recently released device (the GitHub entry was added in 2021). I bought the board from Mouser, since it was the cheapest option at the time, costing me just under £8 but I didn't get it quite as quick as I had hoped due to export restrictions requiring me to fill in a form and inform Mouser exactly was I planned to do with the board. The board came in a small box with the QR code printed on it to quickly access the user guide. The top side of the board features the ESP32-C3-WROOM-02 module with rectangular antenna sticking out one end of the PCB, along with an on-board RGB LED, micro USB port, and boot and reset switches. Along the two long edges are 15-way male headers for GPIO and power, the pinout for the pins are labelled on both sides of the board. On the underside of the board it has written 'esp32-c3-devkitc-02 v1.1'.

I plugged the board into the USB of my PC and the red power LED came on as well as the RGB LED (which is very bright) which lit up blue, I didn't have the need to install any drivers, probably because I had already installed them for the ESP32-DevKitC V4, which uses the same CP210X USB to UART bridge. So I could easily test out the board I opened up the Arduino IDE (I was using V2.1.1) and since I already had the ESP32 boards installed it was just a matter of choosing 'ESP32C3 Dev Module' as the board. I started with the classic Blink example and that worked, it flashed the on-board RGB LED white. Note that, unlike the ESP32-DevKitC V4, LED_BUILTIN has been defined so there were no changes I had to make to the Blink sketch.

As the sketch is being uploaded we get some useful text in the Arduino output window, including identifying that the board's chip is 'ESP32-C3 (revision v0.3)'. As with other ESP32 boards, after uploading (which took about 7 seconds) we get this message:

Leaving...

Hard resetting via RTS pin...

Which shows all is good, the program is running on the board.

Another example sketch I tried was the BlinkRGB sketch (File->Examples->ESP32->GPIO->BlinkRGB), which was especially designed for the on-board RGB LED, so no surprises it worked with no problems. The sketch lights the RGB led white, red, green, and, blue. As mentioned in the sketch, using digitalWrite(RGB_BUILTIN, HIGH); turns the LED on white, in fact, we can use LED_BUILTIN instead of RGB_BUILTIN, as seen in the blink sketch.

Next I tried SimpleTime (File->Examples->ESP32->Time->SimpleTime), which uses a WiFi internet connection to get the current date and time, outputting it to the serial port. You need to change ssid and password in the sketch to that of your WiFi network. When you open  the Arduino serial monitor (make sure baud is set to 115200) it will (hopefully) say that it's connected to the Internet (provided you supplied the correct info) and then it will print the date and time every 5 seconds. As pointed out in sketch's comments, it doesn't handle daylight savings, so it was an hour ahead for me. Fortunately, we can set the time_zone variable, which is normally set for Rome (CET-1CEST,M3.5.0,M10.5.0/3). So I looked online and found this page listing time zones:

https://sites.google.com/a/usapiens.com/opnode/time-zones

Then I set time_zone to:

GMT+0BST-1,M3.5.0/01:00:00,M10.5.0/02:00:00

Which is for London, Great Britain.

Then I commented out configTime() on line 54 of the sketch and uncommented configTzTime() on line 61. After uploading to the board and opening the serial monitor again I now had the right time.

Because the ESP32-C3-DevKitC-02 only has Bluetooth LE support we cannot run sketches that use Bluetooth classic. For an introduction to Bluetooth LE and associated examples have a look at:

https://randomnerdtutorials.com/esp32-bluetooth-low-energy-ble-arduino-ide/

I tried (File->Examples->ESP32 BLE Arduino->BLE_scan) and when uploaded I opened the serial monitor and it printed out information about the devices it's found though all of them had the name part blank so it wasn't clear what devices it actually found.

Since the board has an on-board RGB LED I wanted to make a more advanced version of the WiFIAccessPoint example (File->Examples->WiFi->WiFiAccessPoint), which turns an LED on/off using a webpage hosted by the ESP32, and having not found online a ready to use example I loaded up the example sketch (WiFiAccessPoint) to modify. The resulting sketch is called WiFiAccessPointRGB.ino and can be downloaded from the bottom of this page, don't forget to set ssid and password in the script to something more appropriate as that is what you will use to connect to the ESP32. After uploading the sketch to the ESP32, connect your computer's WiFi to the ESP32 using the SSID and password you set in the sketch and then open the Arduino IDE serial monitor and copy the stated IP address into your browser. You should see the various prompts to change the colour of the RGB LED and clicking on any of the links should change the LED colour immediately.

Going over how I modified the WiFIAccessPoint sketch: I had commented out the LED_BUILTIN define on line 18 but that wasn't necessary as neopixelWrite() is used to operate the on-board RGB LED, which uses RGB_BUILTIN macro. I also commented out using pinMode() to set LED_BUILTIN to output on line 28 as it's not needed when using neopixelWrite(). In loop() I used x4 client.print() to provide links for changing the RGB LED to red, green, blue, or off, represented by 'R', 'G', 'B', and 'O', respectively. Later in the function where we respond to the links it's just a matter of checking each request (R/G/B/O) and changing the RGB LED colour using neopixelWrite(), passing the appropriate colour values. Note that RGB_BRIGHTNESS is defined as 64, providing a convenient constant for LED brightness.

This has been just a brief look at the ESP32-C3-DevKitC-02 and while it lacks some features compared to older ESP32 development boards it remains very good value for money and I'm already thinking of what project to incorporate it into.

Lilygo T7 S3 ESP32-S3

I got a Lilygo T7 S3 as part of an eBay job lot so I was interested to try it out.

The product page can be found at:

https://www.lilygo.cc/products/t7-s3

Where it currently retails for $7.93 (£5.91).

On the product page you can see various images of the board along with a very handy image showing the various pins and features.

You can find the community page at:

https://community.lilygo.cc/

The board features USB 3.0 (type C), an ESP32-S3-WROOM-1-N16R8 Xtensao 32-bit RISC-V MCU featuring  Wi-Fi and Bluetooth 5.0 + Bluetooth Mesh along with 16MB flash and 8MB PSRAM, can be programmed in C/C++ or MicroPython, and measures 3.9 x 3.1 x 0.6 cm. It's suitable for many different Internet of Things (IoT) applications, particularly for small portable devices.

The various pins are labelled on the board and on the underside is written 'LILYGO', 'T7S3-V1.1', and '22-07-28'.

The board I received came in a box with V1.1 pinmap paper, 2-way cable, 4-way cable, and various headers (x2 long female, x2 short female, x2 short male), but note that the board originally came with x1 JST 1.25mm 2P cable as well as the headers.

For reference, the datasheet for the ESP32-S3-WROOM-1-N16R8 can be found at:

https://www.mouser.co.uk/datasheet/2/891/esp32_s3_wroom_1_wroom_1u_datasheet_en-2930317.pdf

There is also a GitHub page:

https://github.com/Xinyuan-LilyGO/T7-S3

On the GitHub page you will find 3D files, images, examples, and schematic.

When I plugged the board into my computer the blue LED on the board's underside continually blinked and the green LED (next to the USB port) flashed. The green LED is programmable LED IO17, and the blue LED is the charging indicator. Windows detected the board as USB JTAG/serial debug unit as well as a USB Serial Device. In Arduino IDE it's detected as WiFiduninoV2 under port selection. Since I already had various ESP boards installed in the Arduino IDE I just had to set the board to 'ESP32S3 Dev Module'.

I started with the built-in Blink example (File->Examples->Basics->Blink) but that didn't work, possibly a problem with how LED_BUILTIN is define but it was easy enough fix by replacing LED_BUILTIN with 17 to blink the on board LED.

I also tried the WiFiScan example but after uploading nothing appeared in the Serial Monitor. I found on this site:

https://community.lilygo.cc/topic/219/issues-with-the-t7-s3/3

Which advised to 'Set USB CDC On Boot' to Enabled. That worked, and now could I got serial communication (the Wi-Fi networks during the scan). I also Set Flash Size to 16MB (128Mb).

Next I tried the WiFiAccessPoint example and changed:

#define LED_BUILTIN 2

From 2 to 17

You can change password to something else.

Then I connected to Wi-Fi access point yourAP, went to 192.168.4.1 in my browser, and clicked as prompted to turn the board's on board LED on/off.

Although I was able to upload to the board using my Surface Pro when I tried on my desktop I got an error:

A fatal error occurred: Failed to connect to ESP32-S3: Wrong boot mode detected (0x8)! The chip needs to be in download mode.

For troubleshooting steps visit: https://docs.espressif.com/projects/esptool/en/latest/troubleshooting.html

Failed uploading: uploading error: exit status 2

According to:

https://www.reddit.com/r/esp32/comments/11awl5h/a_fatal_error_occurred_failed_to_connect_to_esp32/

"The most common problem is that the USB driver on your development machine has been updated/reverted and isn't handling the DTS/RTS signalling."

Looking online some more I found a solution that worked for me; plug the board into the computer. Hold the board's boot button and reset button at the same time, release reset then boot. Select the board's port in the Arduino IDE if it was unselected and then upload.

M5StampS3

The M5StampS3 is an Espressif ESP32-S3FN8 based microcontroller board in small form factor (26mm × 18mm × 4.6mm, 3.1g) while remaining very capable thanks to the wireless connectivity (2.4GHz Wi-Fi and Bluetooth 5 LE), powerful processor (Xtensa 32-bit LX7 dual-core processor maximum 240MHz), versatile GPIO, and 8MB flash. This makes the board ideal for IoT applications including smart home and wearables.

Note the ‘S3’ in the name comes from the processor designation ESP32-S3FN8.

You can view the product page for the version with 1.27mm headers (SKU: S007-PIN127) at:

https://shop.m5stack.com/products/m5stamps3-with-1-27-header-pin

Where it's currently selling for $7.50 (£5.83).

Despite the 1.27mm spacing of the connections, standard 2.54mm headers can be soldered (as is the case of the one I bought) but you can't access all the GPIO. As can be seen with the photo of the underside (see previous link) there are larger holes for 2.54mm headers.

You can see the version with 2.54mm headers at:

https://shop.m5stack.com/products/m5stamps3-with-2-54-header-pin

Which has a SKU of S007-PIN254 and is selling for the same price as the 1.27mm version.

They is also a breakout adapter board:

https://shop.m5stack.com/products/m5stamps3-breakout

To convert between 1.27mm and 2.54mm pitch.

The M5StampS3 is similar to the M5Stamp (SKU: S007) which can be found at:

https://shop.m5stack.com/products/m5stamp-esp32s3-module

For sale at $7.50.

It seems the main difference to the M5StampS3 is that it doesn't have header pins already soldered.

Note that none of the product pages mention that the ESP32-S3FN8 supports Bluetooth 5 LE, which you would think would be an additional selling point.

Oddly, the board features a shorter ‘fin’ on one side of the plastic case.

Going forward I will use 'StampS3' to refer to all versions of the boards.

A hex key is required to remove the plastic covering, which is heat resistant (250℃) and has 'M5' written on it, is orange on the versions with headers, black on the one without headers. A summary of further features of the board are as follows:

USB-C connector (power/programming).
Programmable push button.
2.4G 3D antenna.
Programmable RGB LED (WS2812B-2020) (next to USB-C port, visible through a hole in the plastic case).
23 GPIO.
Touch sensor pins.
SD/SDIO/MMC master controller. SDIO/SPI slave controller.

For further information about the StampS3 see:

https://docs.m5stack.com/en/core/StampS3

The page shows you how to put the board into download mode and has a tutorial for Arduino and UIFlow. Further down the page is the GPIO layout, schematic (with link for better viewing), PCB package kicad link, mechanical drawing, and an Arduino example for download.

When it came to testing the StampS3 I plugged it into my Windows 11 laptop, no LED was lit on the board but Windows detected it as a USB Serial Device. I followed the ‘Arduino IDE’ tutorial on the previously linked site. I already had Arduino IDE (V2.3.2) installed, but I needed to install the library, which is M5Unified. The github can be found at:

https://github.com/m5stack/M5Unified

Which includes a list of supported devices. After installing the library you will find a number of examples in the M5Unified examples.

Further down the page for the Arduino IDE tutorial there are programming tutorials for the various boards, this is the link for M5StampS3:

https://docs.m5stack.com/en/arduino/m5stamps3/program

However we need to install the board:

https://docs.m5stack.com/en/arduino/arduino_board

After installing, you can then select the board as M5StampS3. A lot of the examples installed with the M5Unified library make use of a display. However, an RGB program is linked to on the programming tutorial page, the link to the sketch:

https://github.com/m5stack/STAMP-S3/blob/main/examples/Led/Led.ino

The sketch can be copy and pasted into the Arduino IDE or downloaded and opened. The sketch needs the FastLED library so you will need to install it - I used FastLED by Daniel Garcia. However, after trying to compile I got USBSerial errors. This is an issue raised on the github:

https://github.com/m5stack/STAMP-S3/issues/3

As described, delete all USBSerial lines as well as the #include <Arduino.h> line. After compiling, you will still get a warning about SPI pins.

To download the sketch to the board you have to hold the button while plugging into your computer. I found a new COM port appeared as a USB Serial Device, and in the Arduino IDE it showed up as u-blox NORA-W10 series (ESP32-S3). Although it successfully uploaded no LED was lit on the board. However, I unplugged and replugged and the RGB LED was now changing colours as expected - perhaps it didn't properly get reset or was held in reset. You can press the board's button to cycle through rainbow (changing colours), red, green, and blue.

To test Wi-Fi and Bluetooth (BT) I used the generic examples for ESP32. For BT:

File->Examples->ESP32 BLE Arduino->BLE_scan

After uploading you have to disconnect and reconnect and then open the serial monitor set to 115200 and you should see a list of BT devices after a few moments.

For Wi-Fi:

File->Examples->WiFi->WiFiScan

Upload, disconnect and reconnect, enter serial monitor set to 115200 and a list of 2.4G Wi-Fi networks should show.

At this point the board appeared to be working, in the future I will return to try out other features.

Particle IoT Boards

Please go to Particle IoT Boards.

Waveshare ESP32-S3-Nano

I got the ESP32-S3-Nano from PCBWay essentially for free as they gave away free beans for their 10th anniversary in 2024. You can view the product page at:

https://www.pcbway.com/project/gifts_detail/ESP32_S3_Nano_Development_Board_Based_on_ESP32_S3R8_Compatible_with_Arduino_Na_d420fed9.html

Where it is currently selling for $9 (£6.73), I 'paid' 1080 beans.

The product page can be found at:

https://www.waveshare.com/wiki/ESP32-S3-Nano

The page gives a detailed specification, some of which I've included below:

ESP32-S3R8 as the main controller with with Xtensa 32-bit LX7 dual-core processor, capable of running at 240 MHz.

512KB SRAM, 384KB ROM, 8MB PSRAM, 16MB Flash memory.

2.4GHz Wi-Fi and Bluetooth LE dual-mode wireless 

14 digital pins

8 analog pins

1 UART

Seamless switching between Arduino and MicroPython programming

Compatible with Arduino IoT Cloud

Supports HID (Human Interface Device), emulating Human Interface Devices such as keyboards or mice via USB port

Compatible with Arduino Nano ESP32

The board is available with headers pre-soldered (ESP32-S3-Nano-M) and without (ESP32-S3-Nano). The Waveshare page has comparison between similar boards, hardware layout description, pinout definition, and user guide including how to use with Arduino. At the bottom of the page various resources including schematic, demo software, and datasheet can be found.

On the top side of the PCB we find:

USB-C

RST push button

Winbond 25Q128JVSQ 128Mb flash

ESP32-S3 R8MRK485000 (ESP32-S3R8) 2.4GHz Wi-Fi (802.11 b/g/n) and Bluetooth 5 (LE) module with Xtensa 32-bit LX7 dual-core microprocessor

Mounting hole in each corner

Red user LED left of USB-C and power LED right of USB-C, RGB LED near flash chip

15 holes (castellated) on both long sides with pinout for I/O and power, headers can be soldered

On the underside of the PCB it has written:

Waveshare

ESP32-S3-Nano

The PCB edge opposite the USB end was rough as if not cut straight enough or it was broken from a larger PCB by hand, although you can file that down it would have been better if they had done that.

The datasheet for the ESP32-S3 series can be found at:

https://www.espressif.com/sites/default/files/documentation/esp32-s3_datasheet_en.pdf

As to quickly test the board I decided to use the Arduino IDE, following the ‘Arduino’ section of the Waveshare page. This starts by installing the Arduino IDE - since I was working on my new laptop I did indeed need to install IDE, so I installed V2.3.2, which was the current version at the time. Next, I installed the Nano ESP32 Package: Tools->Board->Boards Manager… Search for Nano ESP32 and install Arduino ESP32 Boards.

After instructing to open the Blink example, the site didn't mention to plug in the board, just to ‘Select the development board and COM ports.’ So I plugged the board into my laptop and the on-board RGB LED cycled through various colours (likely a demo program), and the user LED blinked on/off (also likely part of a demo program), the power LED was on solid.

In Device Manager the board showed up as a ‘USB Serial Device’ COM port. In the Arduino IDE I set the COM port number and set the board type to Arduino Nano ESP32. I uploaded the Blink sketch, which took 25 seconds to compile and upload, uploading was the quickest part, during which the progress was shown in the Arduino IDE Output section.

After uploading, the user LED was blinking as before but of course the RGB LED was now off, since the sketch only blinks the 'standard' built-in LED but there's no reason why the sketch couldn't be modified to manipulate the RGB LED. The main thing is that I was successful in uploading a sketch to the board.

In the Output section of the Arduino IDE it was reported:

Sketch uses 285877 bytes (9%) of program storage space. Maximum is 3145728 bytes.

Global variables use 30732 bytes (9%) of dynamic memory, leaving 296948 bytes for local variables. Maximum is 327680 bytes.

As another test I opened the WiFiScan example sketch (File->Examples->WiFi->WiFiScan), after uploading I went into the Serial Monitor (set to 9600 baud) and saw a list of (2.4GHz) Wi-Fi networks listed. Lastly, I uploaded the BLE_scan example sketch (File->Examples->ESP32 BLE Arduino->BLE_scan) and in the Serial Monitor it showed the BLE devices it had found.

Just to add I noticed that the ESP32 chip gets quite hot especially on the PCB underside, which I imagine is normal, considering there is a lot going on inside the small chip.

This was just a brief introduction of the Waveshare ESP32-S3-Nano, I'm sure there will be lots of uses for the very capable board in which wireless networking is needed in a relatively small space.

ESP8266

Introduction

Please see the following video to get an overview of the ESP8266 and the various boards based around the chip:

To get an idea of what is possible with the various ESP8266 based modules you may want to watch YouTuber ToP Projects Compilation's video:

ESP-01/S

The original ESP-01 Wi-Fi module was made by Ai-Thinker, available August 2014, but was surpassed by the upgraded version, the ESP-01S.

You can find a wealth of information about the ESP-01 at:

https://www.microchip.ua/wireless/esp01.pdf

The schematic can be found toward the end of the PDF, although it seems somewhat incomplete compared to typical ESP-01 modules.

Both the ESP-01 and ESP-01S have on-board flash memory to store user programs, but while the ESP-01 features 0.5MB or 1MB flash memory, the ESP-01S has 1MB or 4MB flash. Another difference between the two boards is that the ESP-01 has two on board user LEDs - power LED and an LED connected to TX, but the ESP-01S has a single on board LED connected to GPIO2, and three 12K resistor pull-ups on RST, GPIO0, and EN (a.k.a. CH_PD).

For a more detailed breakdown see:

https://www.best-microcontroller-projects.com/esp-01-vs-esp-01s.html

This section will focus on the ESP-01S but some of it will still be applicable to the ESP-01.

The tiny PCB, measuring just 14.3 × 24.8mm, is home to an ESP8266EX 32-bit Wi-Fi SoC, on board antenna, one or more LEDs, 26 MHz crystal, and 4x2 male header for interfacing, typically with a programmer at least initially. On my particular ESP-01S there is no Ai-Thinker marking on it (thus possibly a clone), has a P25Q80H 8Mb SPI flash chip, pin 1 of the header is signified with a square outline, and the pinout is written on the PCB underside. Always check your particular ESP-01/S in case of any differences to the norm.

For testing the ESP-01S I found a getting started guide at:

https://www.instructables.com/Getting-Started-With-the-ESP8266-ESP-01/

As can be seen from the site linked above, the ESP-01/S is supposed to come with AT firmware, which accepts a range of commands sent to the module serially, which should makes it easier to test the board.

Note that on the site linked above no level converter has been used despite ESP modules limited to, at least according to the ESP8266EX datasheet, no more than 3.6V on it's I/O; while some people claim the ESP modules are 5V compliant I would advise to limit to 3.3V. Since I didn't have an ESP-01 programmer I thought about using a D1 Mini V4, which funny enough has the same chip as the ESP-01, but seemed suitable due to using 3.3V logic as I wanted to avoid using voltage level converters, and I could program it with the Arduino IDE, for convenience.

You are supposed to load the bare minimum sketch (which is an empty program) on to (in my case) the D1 Mini, which is effectively behaving like a USB to serial converter. Note that when uploading sketches to the D1 Mini, or any board connected to the ESP-01/S, you must disconnect the ESP-01/S's TX and RX pins from the other board otherwise the upload will fail.

I had the D1 Mini power the ESP-01S and when I plugged it into my PC, the ESP-01s' LED lit a few times. I opened the Serial monitor in the Arduino IDE (it's advised to set to 115200 baud) and sent the AT command but there was no response. I tried setting the Serial monitor to 'Both NL & CR' as advised by online posts, and I also tied RST to 3.3V but neither resulted in a response. Since I got my ESP-01S second hand it may not even have had the AT firmware, however, using my oscilloscope I could see that upon power on the ESP-01S was transmitting data on its TX pin so the board at least wasn't dead.

I did also write a simple sketch just the following in setup to simulate sending an AT command:

Serial.begin(115200);

Serial.print("AT\r\n");

Although I could see activity on the D1 Mini's TX pin there was no response from the ESP-01S but oddly pressing reset on the D1 Mini caused garbage to appear in the Serial monitor. I found reports online that 115200 can be unstable for the Arduino serial, so that.

So the next step was to try to put the AT firmware back on to the ESP-01S, I used a Waveshare USB to UART adapter that has shunt to put it into 3.3V mode. I followed a tutorial at:

https://www.allaboutcircuits.com/projects/flashing-the-ESP-01-firmware-to-SDK-v2.0.0-is-easier-now/

Since the ESP-01S has on board pull-ups there is no need to connect anything to the EN pinout, however, I connected a 220R resistor between GPIO0 and GND to enable programming mode rather than a straight connection in case something was setting it as an output. With GPIO0 floating I opened a PuTTY serial connection and when I resetted the ESP-01S by taking RST low, the LED flashed and some corrupted text followed by 'ready' appeared, although issuing an AT command got no response. Just to see what would happen, I tried enabling 'Implicit LF in every CR' in PuTTY but that didn't help, another recommendation was to use CTRL+J instead of enter to ensure the correct line feed characters are given, that responded with ERROR, same with using CTRL+M followed by CTRL+J.

I downloaded the Flash Download Tool v3.4.4 and ESP_SDK_v2.0.0 as instructed in the tutorial. When you run the Flash Download Tool it is very basic:

There is also a 'terminal' window (not shown) that gives useful information and should be consulted if there are any errors.

After clicking the 'ESP8266 Download Tool' button another window will appear:

Oddly, various fields were already filled with paths that didn't exist on my PC but the tutorial says to uncheck them anyway. Here is a screenshot after clicking the Start button to read ESP-01S information:

When selecting the files and typing in the addresses be careful as the addresses listed in the tutorial previously linked to are cut off at the end by one character (or at least they were for me), and if you enter them wrong the boxes will be red and you won't be able to proceed. Best to copy and paste the text from the site into notepad to see the full addresses. After clicking the START button a progress bar will show:

The downloading took about 40 seconds. If you have any problems it's recommended to uncheck SpiAutoSet but for me it worked having it checked.

As mentioned in the tutorial you can confirm succesful flash using Termite but I used Putty. Resetting the ESP-01S caused the same message as before but this time when I typed AT followed by CTRL+M CTRL+J I got an OK response (just using CTRL+J resulted in ERROR). Issuing AT+GMR gave AT and SDK versions. Below you can see the Putty output:

I then continued testing by following from step 4 in the following guide:

https://www.instructables.com/Getting-Started-With-the-ESP8266-ESP-01/

It instructs that we can install alternate firmware, such as NodeMCU, but I didn't get round to trying that - I had at least confirmed the ESP-01S was working and had a try out of the AT firmware. The tutorial links to the full list of AT commands, here is the link:

https://www.pridopia.co.uk/pi-doc/ESP8266ATCommandsSet.pdf

Don't forget the module can only connect to 2.4G Wi-Fi APs.

Interestingly, when I issued AT+RST, which restarts the module, it displayed the same boot message before but in addition it also reported:

WIFI CONNECTED

WIFI GOT IP

Oddly when I tried AT+CIOBAUD? to get the current baud rate as a matter of curiosity I was met with an ERROR response. Looking online it seems we can use AT+IPR=115200 to temporary change baud rate but AT+IPR? doesn't return the current baud rate. Even though I used 115200, that is, the current baud rate so I didn't mess things up, somehow after using AT+IPR=115200 the ESP-01S wouldn't boot completely after reset, I had to reflash the board to get it responsive again. Looking online it appears others have had the same issue:

https://www.esp8266.com/viewtopic.php?t=1997

It seems you can use AT+UART_DEF and AT+UART instead, with the examples given:

AT+UART_DEF=9600,8,1,0,0

AT+UART=9600,8,1,0,0

Installing a different version of the AT firmware may also be a solution.

Tips

When an ESP-01/ESP-01S powers up it sends a boot message over serial (uart0), this feature is built into the ESP8266EX's internal firmware.

Huzzah feather ESP8266

The Huzzah feather development board from Adafruit features an ESP8266 Wi-Fi module with 4MB flash, it retails for $14.95 (£11.51). You can find a more detailed overview at:

https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/overview

Here is a highlight of the spec.:

Supports 3.7V Lithium polymer batteries and built in battery charging. 100mA LiPoly charger with charging status indicator LED.

Can also power from micro USB connector.

Measures 51mm x 23mm x 8mm without headers soldered in, and weighs 6 grams.

ESP8266 @ 80MHz or 160 MHz with 3.3V logic/power.

3.3V regulator with 500mA peak current output.

CP2104 USB-Serial converter onboard with 921600 max baud rate for uploading.

Auto-reset support for getting into bootload mode before firmware upload.

9 GPIO pins - can also be used as I2C and SPI.

1 x analog inputs 1.0V max.

Pin #0 red LED for general purpose blinking. Pin #2 blue LED for bootloading debug and general purpose blinking.

Power/enable pin.

4 mounting holes.

Reset button.

The board originally came with headers but since I got mine second hand the headers were already soldered.

Some useful links to get you started:

Pinouts:

https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/pinouts

Power Management:

https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/power-management

Using NodeMCU Lua:

https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/using-nodemcu-lua

Using Arduino IDE:

https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/using-arduino-ide

To test the board I plugged it into my Windows 11 laptop and it showed up as a COM port in Device Manager. I opened up a serial connection in PuTTY (it's recommended to try 9600 baud otheriwse try 115200), and saw some text:

ets Jan  8 2013,rst cause:2, boot mode:(3,6)

load 0x4010f000, len 3584, room 16

tail 0

chksum 0xb0

csum 0xb0

v2843a5ac

~ld

After pressing the reset button I got exactly the same text. It looks to be describing a fault, likely from the program the previous user put on. Since I wanted to test with Arduino I moved on to the 'Using Arduino IDE' page. I installed the ESP8266 board package, selected the board types as 'Adafruit Feather HUZZAH ESP8266', and set the port COM number. Note: the CPU frequency was already set to 80MHz.

To start off simple, I tried the ESP8266 blink example (File->Examples->ESP8266->Blink), which took about 24 seconds to upload after compiling and then the red LED 0# started blinking. From the Arduino IDE output window I could see that the board was identified as having an ESP8266EX, 26MHz crystal, which flash size of 4MB.

Note: don't forget to close PuTTY (or whatever terminal program you are using) otherwise you won't be able to upload to the board.

As another quick test I used the WiFiScan example (File->Examples->ESP8266WiFi->WiFiScan). Before uploading I set Upload Speed (Tools->Upload Speed) to 921600, which uploaded at a much faster speed - it's a shame compiling takes so long. I then opened the Serial Monitor set to 115200 and it continually showed avilable Wi-Fi access points, confirming the wireless capability was working.

LoLin NodeMcu V3

I got this board from an eBay job lot. The packaging has the following written on it:

ZQ-BI-869
ESP8266 wifi NodeMcu Lua WIFI
CH340
2017-04-08

On the board it has written:

Lolin
Ver 0.1

The board features:

ESP8266MOD WiFi Module, low power 32-bit CPU , 802.11 b/g/n, SDIO 1.1 / 2.0, SPI, UART, 4MB flash, blue LED.
AMS1117 low voltage dropout regulator
12Mhz crystal oscillator
CH340G USB to serial
FLASH and RST buttons
Micro USB connector

There are 30 interface pins in the form of two rows of 15-way male headers on both long sides with labelled pins. The board is dirty near the pins as if they didn't clean the flux.

Note that the I/O pins should not be connected to a voltage exceeding 3.3V.

Although the board is breadboard friendly it is quite wide so you will need wide breadboard.

Written on the PCB underside it has the following information:

1.Install CH340G driver
2 Use 9600bps baud rate
3.Connect to WiFi

wemos.cc
LoLin
new NodeMcu V3

The 'new NodeMcu V3' is how I identified the board as a 'LoLin NodeMcu V3'

There are no components on the board underside.

I couldn't find a product page for the board but I did find a page with some information including details of the board revisions:

https://blog.howardpchen.com/2022/02/different-flavors-of-esp8266/#:~:text=There%20are%20v2%20and%20v3,bigger%2C%20but%20improvements%20are%20minimal.

As explained on the page, NodeMCU really refers to the firmware but is sometimes used to refer to the board itself. The board can be programmed using MicroPython, Lua, and Arduino IDE. I found a tutorial for using the board with the Arduino IDE:

https://www.xtronical.com/basics/systems/esp8266mcu-et-al/setting-nodemcu-v3-esp-12e-esp8266-arduino-ide/

The page refers to the board as ESP-12E variant, you can see an explanation and comparison with ESP-12F:

https://www.elecrow.com/blog/things-you-should-know-about-esp8266-wifi-module.html

ESP-12F has better antenna design than ESP-12E. The page implies ESP-12E doesn't have integrated flash but the ESP8266MOD reportedly does and the NodeMcu has no on-board flash chip, further supporting that some form of non-volatile memory built into the ESP chip.

Going back to the tutorial previously mentioned, since I already had ESP set up for the Arduino IDE I went ahead and plugged the board into my Surface Pro. The board's blue LED lit briefly and Device Manager showed a USB-SERIAL CH340 device. As mentioned in the tutorial, you need to select 'NodeMCU 1.0 (ESP 12E Module)' as the board type. I tried the Blink example but the one located under Examples->ESP8266, I think the only difference to the standard Blink example is that the ESP8266 doesn't use symmetrical blinking. Even though the sketch uses LED_BUILTIN I didn't need to change as was done on the tutorial site.

After uploading, which took about 20 seconds after compiling, the LED on the ESP module was steadily flashing on/off. Note that you can change LED_BUILTIN using Tools->Builtin LED (select 2, which is the default, or 16).

Note that the Arduino IDE reported, amongst other things, that the crystal is 26MHz (even though the one on the board is 12MHz) and detected flash size as 4MB, which is what we expected, and the chip is ESP8266EX (ESP8266MOD is compatible with ESP8266EX).

Since the tutorial only covered Blink example, I tried out WiFiScan (ESP8266WiFi->WiFiScan). After uploading you need to open the Arduino serial monitor, make sure to set to 115200 baud, after a few seconds you should see a list of detected Wi-Fi networks. Since the ESP module only works with 2.4G networks you won't see any 5G ones listed.

Lastly I tried HelloServer (ESP8266WebServer->HelloServer). STASSID needs to be set to your Wi-Fi's SSID, and STAPSK to the password. After uploading the sketch, enter the serial monitor and should see confirmation it's connected to your Wi-Fi, along with the IP address. Make sure your computer is on the same Wi-Fi network, put the IP address into your browser and you should see:

hello from esp8266!

WeMos D1 Mini V4.0

The D1 Mini V4 is the latest (as of 2024) in the D1 Mini ESP8266 powered Wi-Fi small form factor development boards series, featuring an ESP-8266EX microcontroller, 4MB flash memory, and USB-C (USB 2 speed) connectivity (previous versions used micro USB), and can be picked up for as little as £5 ($6). The board measures 34.2 x 25.6mm, weighs 3g, and features 11 digital I/O pins (3.3V maximum) with various hardware interfaces (I2C, SPI, etc.), and one analog input (3.2V maximum).

The particular version I have is made by Lolin, WeMos is the original manufacturer from what I can tell. Usually the board is sold with two short male headers, two short female headers, and two long female headers, giving you plenty of choice how you want to make connections to it.

The product page for the D1 mini can be found at:

https://www.wemos.cc/en/latest/d1/d1_mini.html

The page has a link to the schematic for V4 and tutorials for using the board with MicroPython and Arduino although they are very brief. The Nodemcu firmware is also supported by the board.

For a summary of changes that V4 brings please see:

https://www.reddit.com/r/esp8266/comments/yxsmk1/wemos_d1_mini_v4_first_look_differences/

Like the Arduino, many add-on boards called Shields are available for the D1 Mini with the ability for them to be stacked. Please see this site to get an idea of some of the Shields that can be bought:

https://www.wemos.cc/en/latest/d1_mini_shield/index.html

Don't forget you can also make your own Shields.

Please note that all of the D1 Mini's I/O pins run at 3.3V, do not expose them to higher voltages.

The D1 Mini can be programmed through the Arduino IDE, please see this guide:

https://www.instructables.com/Wemos-ESP8266-Getting-Started-Guide-Wemos-101/

When I tried it myself I already had the CH340G drivers installed, as well as support for the ESP8266 in the Arduino IDE since I had previously used the IDE to program similar boards. I used Arduino IDE V2.1.1 and for the board selection I used ESP8266->LOLIN(WEMOS) D1 ESP-WROOM-02, although that worked for me I later found someone using LOLIN(WEMOS) D1 R2 & mini, which makes sense as the Flash size (Tools->) is 4MB, whereas LOLIN(WEMOS) D1 ESP-WROOM-02 is limited to 2MB. As for installing libraries I didn't need to, the only other thing to do was select the port (Tools->Port->). Under Tools in the Arduino IDE there are a lot of board specific options for the D1 Mini, such as for debugging, flash, and CPU frequency.

As a first test I opened the Blink example (File->Examples->ESP8266->Blink), while programming the board's LED flashed a few times before it blinks continually as expected. The sketch says that the on board LED is connected to GPIO1 yet the schematic says GPIO2, but LED_BUILTIN worked either way. If it doesn't for you try a different GPIO number but keep in mind when using with Arduino IDE the GPIO numbering is different for the D1 Mini, see this site which is for a different but similar board:

https://cyaninfinite.com/getting-started-with-the-wemos-d1-esp8266-wifi-board/

In the Pinouts section you can see the Pin names that can be used in an Arduino sketch and how they relate to the pinout on the ESP board. For example, if you wanted to use GPIO13, you would use D7 in your sketch.

The next example I tried was WiFiScan (File->Examples->ESP8266WiFi), after uploading, you open the serial monitor (set to 115200 baud), and a list of Wi-Fi networks will be regularly listed. Note that only 2.4G networks will show.

I also tried the HelloServer (File->Examples->ESP8266WebServer) example. Toward the start of the sketch you will need to replace your-ssid and your-password with your Wi-Fi's SSID and password respectively. After uploading, open the Serial monitor (set to 115200 baud) and it should report that it's connected to the specified Wi-Fi access point, and the IP address. Put the IP address into your browser and you should see the following displayed:

hello from esp8266!

WeMos D1 R2

The WeMos D1 R2 development board is a so-called Arduino Uno compatible board with the same form factor (68.6mm x 53.4mm, 25g) and headers but powered by an ESP-8266 Wi-Fi module with 4MB flash rather than an ATmega328P microcontroller with 32KB flash that is the heart of an Uno, giving the D1 a big advantage in processing power, memory, and connectivity. I picked up a D1 from eBay for just £3.49, V2.1.0, which seems to be the common revision.

The board features a reset button, micro USB port for programming/serial access and powering the board, DC jack (9-24V) for alternative power input, and four female headers arranged in the same way as an Arduino Uno, carrying GPIO and power. The headers are labelled and to the side of each header are holes, which you could solder wires to, or male headers (although you might have difficulty plugging in wires), a feature not present on an Uno. There is also an arrangement of 4x2 holes which carry 3.3V, GND, serial and I2C, which you can solder header/wires to.

There are ON and SCK LEDs, both blue, and the ESP-8266 module has its own blue LED.

Some of the notable chips on the board are:

16 pin chip with no part number visible (don't know why it's rubbed off on mine), likely a USB to serial chip, possibly CH340.
MCP60021 1MHz low-power op amp.
ESP-8266 Wi-Fi module supporting 2.4GHz 802.11b/g/n.

Whereas the D1 has 11 digital input/output pins (supporting interrupt/PWM/I2C/one-wire except for D0), an Arduino Uno has 14 (with only a few supporting PWM, etc.). Another overall advantage of an Uno is that it has six analog pins that can safely take 0-5V but the D1 has just one analog input which is limited to 0-3.2V. Also be aware that Uno I/O operates on 5V as mentioned but D1 digital pins are supposedly not 5V tolerant (the ESP datasheet claims they are not) so it would be best to not expose the pins to more than 3.3V.

A wiki for the D1 can be found at:

https://wiki.geekworm.com/WEMOS_ESP8266_D1_R2_V2.1

The site has a link to the user manual but the link is dead, there is also a link to the schematic. Note that on the schematic the ESP module  isn't labelled (it's the large rectangle) and the unknown 16 pin chip isn't labelled either. On the schematic for a slightly different version of the board we can see the ESP module and a CH340G chip that likely is the mystery chip on my board:

https://www.elkim.no/wp-content/uploads/2021/06/Schematic0G-00005444WIFI-D1R2-ESP8266.pdf

There is discussion online whether the D1's DC input can tolerate as much as 24V or anything near that, although the regulator connected to the DC input isn't marked on the original schematic I found that my board has a 2359, likely an MP2359, which has an absolute VIN of 26V and considering there is a series SS24 diode on the board, the claimed 9 to 24V seems correct. However, it's always best to keep to the lower end if possible to keep the regulator cool and minimize risk of damage and be sure to check your particular board as there appears to be different manufacturers.

When I plugged the board into my Surface Pro using a micro USB cable the ON and SCK LEDs came on and in Device manager the board showed up as USB-SERIAL CH340, confirming the mystery chip is indeed a CH340. I already had ESP set up in the Arduino IDE so I just had to select the board: Tools->Board->esp8266->LOLIN(WEMOS) D1 R2 & mini. However, although the board's COM port showed up in Device manager it wasn't selectable in the Arduino IDE.

I tested the COM Port by opening a serial connection in PuTTY, set to 115200, and I could see the board was scanning for and listing Wi-Fi networks, so perhaps the previous owner had loaded the WiFiScan example sketch or something similar. Returning to the Arduino IDE, I closed all instances and opened the IDE again, now I could select the COM port.

I tried out a number of examples but before doing so I set the upload speed to 115200 (Tools->Upload Speed), as recommended to do so online. I then upload the classic Blink example, which took about 17 seconds to upload after compiling, the ESP module LED blinked while this happened. After upload, the LED on the ESP module steadily flashed, showing that we can use LED_BUILTIN to control it. LED_BUILTIN for this board is 2, that is, the ESP module LED is connected to GPIO2. Note that HIGH turns the led off, LOW on. However, to use the SCK LED, which is connected to GPIO14, replace LED_BUILTIN with 14. The SCK LED is equivalent to the 'L' LED on Arduino Uno, although on that board the LED's connected to IO pin 13.

I also tried out the WiFiClient example sketch (File->Examples->ESP8266WiFi->WiFiClient); had to set STASSID and STAPSK in the sketch to my Wi-Fi's SSID and password respectively. After uploading, I open the serial monitor set to 115200 baud and saw a connecting message and various information was displayed including IP address, and a quote of the day, which is fetched from the djxmmx.net host, every 5 mins.

WeMos Mega

The WeMos Mega is an Arduino Mega compatible board with an ESP8266 on-board.

Witty cloud

The Witty cloud is a small (32x32x17mm) Wi-Fi board containing an ESP8266MOD by AI-THINKER, supporting IEEE 802.11 b/g/n Wi-Fi, on the board is also an LDR light sensor, RGB LED, blue LED, a push button, micro-B USB, and an 8-way male header on both sides for interfacing and power. Although with the headers fitted the board is breadboard friendly you will need to utilize wide breadboard. On the PCB underside is home to a single AMS1117 LDO voltage regulator chip.

Along with the main processor, the board has 4MB flash memory for user programs, 11 digital I/O with PWM and interrupt support, 1 analog in (connected to the LDR), and there is support for serial, SPI, I2C, and 1-Wire protocols. Although the ESP8266MOD runs on 3.3V it has been claimed the I/O is 5V tolerant but the analog input is reportedly limited to 3.2V.

A rundown of how the on board devices are connected is as follows:

Blue LED is connected to pin 2 (GPIO2).
The RGB LED is common cathode and so lights when driven HIGH.
Pin 15 (GPIO15) = RGB Red LED
Pin 12 (GPIO12) = RGB Green LED
Pin 13 (GPIO13) = RGB Blue LED
Push button attached to pin 4 (GPIO4).

You can view much more information at:

https://protosupplies.com/product/esp8266-witty-cloud-esp-12f-wifi-module/

It should be made clear that I will be dealing with the main board (a.k.a. top board), an adapter board (bottom board) is used to program it; the micro USB on the main board is only for powering it, although alternatively you can supply 5V via the VCC and GND pins to power the board. It isn't absolutely necessary, however, to use a dedicated adapter board for programming the main board, as we shall see later on.

Supposedly the main Witty board comes preloaded with the NodeMCU software that accepts the standard AT command set but since I got my board second hand I would have to test it to see what it does. I powered the board with a micro USB cable and connected a USB to UART converter with common ground to the Witty, and TX of Witty connected to RX of UART board, and Witty RX to TX UART. I powered the Witty first and saw the RGB LED and blue LED come on, regularly the RGB LED blinked red as the blue LED came on, perhaps running the program the previous user had put on. I then plugged the UART board into my Surface Pro and opened a PuTTY serial session set to 115200 baud, I now saw that in time with the LEDs blinking it was outputting information to the serial port, showing that the board was continually performing a soft reset, while trying to run ESP RFID, trying to set up the RFID hardware (likely an add-on board). So indeed, that is what the previous owner had set it up for and it at least showed the board wasn't dead.

I looked into using the Witty with the Arduino IDE but using the previously mentioned UART adapter to program it. I found a guide at:

https://www.faranux.com/product/witty-cloud-board/

When it came to installing the board in the Arduino IDE I already had it installed from other ESP boards I've used so I only needed to select NodeMCU v1.0 as the board type. I downloaded the provided WittyBlink sketch from the site, making sure in the Arduino IDE to set the upload speed to 115200 and the port to the UART adapter COM port. I later found a page showing how to program a Witty with a USB adapter so I continued with that as it was more appropriate for what I wanted to do:

https://circuitjournal.com/esp8266-with-arduino-ide

Because my UART adapter doesn't have the additional pins I went with the manual approach as detailed on the site.

I connected the Witty's RESET, GPIO0, and GPIO15 to VCC via 10K resistors.

What I found out through testing is that GPIO15 can actually be left floating (which is just as well as the red LED is connected to that pin). This is what I did:

To put in programming mode I took GPIO0 to GND and briefly connected RESET to GND, the board's blue LED briefly lit.

I uploaded the WittyBlink sketch previously mentioned by clicking the Upload button in the Arduino IDE, after compiling it uploaded (taking about 20 seconds).

To get the program to run:

Remove GPIO0 from GND, briefly take RESET to GND.

In the serial monitor I could see various information:

The state of the button (=1 button not pressed, =0 button pressed).

LDR light level (1024 when illuminated with bright light, toward 0 when covered up).

Additionally, the RGB LED lit random colours. The RGB LED isn't very good in that you can see the individual colours rather than them being mixed (perhaps better to view from a distance) and green is much brighter than red and blue which are about the same intensity, which I confirmed by writing a sketch which turns each primary colour on and off in turn at maximum intensity. Although keep in mind our eyes are most responsive to green so perhaps that makes green appear somewhat brighter.

Troubleshooting

If you see in the Arduino Serial monitor (or any software showing serial output) 'Soft WDT Reset' and possibly garbage characters too then it may be that the board is resetting due to its watchdog timer triggering:

https://forum.arduino.cc/t/soft-wdt-reset-nodemcu/425567

Rather than have blocking code (waiting for an event to happen and not running any other code until) or a long blocking delay, rewrite your code to avoid such situations, which will stop the constant resets.

All content of this and related pages is copyright (c) James S. 2023-2025