Wifi and MPU Summary
There are SPI driven wifi interfaces such as the nRF2401, but they require a separate MPU and
suitable driver software and a separate MPU.
The Espressif ESP8266 provides an extendable MPU connected to a wifi interface, and is a simpler and very popular means
of obtaining embedded wifi connectivity. It may be used standalone or as an adjunct to another controller.
There is a vast amount of material on the net about it, some helpful, and some less
so.
The original poprietary default application firmware provided by Espressif was a wifi interface
controlled by simple commands ("AT" commands) sent via the serial interface. This was later extended by
Espressif and others to provide a fully capable IOT (Internet of Things) programming environment.
The CPU is based on the extendable Xtensa 32 bit architecture.
A later version is the ESP32, which has more RAM, and a partial ethernet interface. It is not directly compatible and has
a different SDK. Unfortunately the ethernet interface does not include the "PHY". If ethernet connection is required the ENC28J60
remains the easiest path.
A good resumee is
Summary Description
Here follows a brief summary of what I have found on the net and tried on the MPU.
The MPU has onboard rom with a fixed bootloader. The user/application program
and data is stored in a separate serial flash eeprom. These two chips may be covered
with a labelled metal RFI shield as in the ESP-12E and ESP-12F modules. The program data is loaded as
needed from the eeprom into a cache memory in the MPU as described in the memory map .
The chip includes a fully functional WiFi interface with a good operating range, which is the ESP8266's raison d'être.
Programming and Using the ESP8266
Espressif have provided libraries for using
the hardware functions of the chip, complete with useful documentation as well as a complete SDK.
I tried to build the Espressif IOT SDK, but it proved difficult to sort out the dependencies.
The Espressif libraries
have been incorporated into the alternative Open-Sdk ,
which can also compile and link C programs for the MPU. This built under Debian Linux with no
problems.
A final user firmware consists of 2 parts, a boot loader at location
0x0000 , and a user program at 0x10000. Both these sections need to be flashed.
The size of the flash memory varies, a common size is 4 megabyte. It can usually
be discovered using esptool.py. Information for the wifi interface is stored at
"msize-0x4000" ( e.g. 3fc000 if msize=4Mb=0x400000). If this is corrupted or erased
it must be reprogrammed from the file esp_init_data_default.bin (in the SDK) to
address msize-0x4000.
Serial Flash for Data Storage
The serial flash memory is very useful for data storage. The available memory depends on the memory map used. The mapping
depends in turn on the flash size and whether OTA is needed.
If OTA is not needed , then the space between the top of the pogram and approximately msize-0x8000 is available for user
data
Programming the flash is done through three system calls:
spi_flash_read , spi_flash_write and spi_flash_erase_sector,
as described in 99a-sdk-espressif_iot_flash_rw_operation_en_v1.0_0.pdf
The data buffers passed to these system calls must sit on 4 byte address boundaries, and the length parameters are rounded up to the next highest
multiple of 4. If any trailing bytes (+0 to +3) are not intended to be overwritten they must be suitably masked (set to 0xff).
Esptool.py does not take this into account, and erases a sector when any write to data within it is requested.
All the flash
chips I have tried all program "1" to "0". This means that a sector (SPI_FLASH_SEC_SIZE=4096 bytes) only need be erased
if any "0" bits within it need to revert to "1".
Various sorts of flash are used , some are described in Flash Chips
pushing upgrades
The bootloader provides the possibility of upgrading the program via the net.
In this case two alternative copies of the firmware are stored in flash
All initial external programming of the eeprom occurs via a serial port on the MPU. Finding
or setting the baud rate of user firmware can be troublesome, and often involves searching through th code, and/or
experiment. A common rate is 74880 baud.
The chip can be programmed/flashed and examined using esptool.py which is included in the sdk.
The boot rom enters uart boot mode when reset is activated with appropriate GPIO
settings.
Espressif provide two programming environments, RTOS and NONOS . Both of these are incorporated in the
Open-Sdk. The NONOS variant is a simpler timer driven environment, and was adequate for my purposes.
ESP8266 Hardware Platforms
Lots of low priced hardware is available, some cards such as the "Nodemcu 12E/F" or "ESP12E: include
a usb to serial converter and a 3.3 volt regulator; this serial converter also uses RTS to set the appropriate GPIO pin for booting .
These cards work mostly quite well, but some show flash eerom faults. I was caught by such a fault on my first
attempt - the eeprom fatigued after a few erase cycles.
Lower priced cards such as the ESP12F bare module have no USB interface or regulator, but have pads for I/O and shield for eerom and MPU. To program these cards
a separate serial interface and a 3.3 Volt power supply are needed. These can be programmed using a separate USB-serial adapter (cp210x etc) and are
probably the best option for multiple standalone IOT applications.
Even simpler boards such as the ESP-01 only have no shield and few pins. These suitable for applications where external RFI shielding is
provided, and where the main function is to provide wifi interfacing for another controller via the serial port
"Hello World" Firmware Using "C" Source Code
The file {sdk-path}/esp-open-sdk/examples/blinky/blinky.c is a good starting point. It may be necessary to change
the GPIO pin number to suit the card you are using. The next step is to try calling a few of the API's If this is successful it is worth building and flashing
esphttpd. Esphttpd is a classy little webserver written by
Jeroen Domburg. It is neatly written and gives a good straightforward example of how the ESP8266 is programmed - I definitely owe him a beer!
The default baud rate for debugging this program is 115200.
E.G. , assuming already flashed:
esptool.py flash_id;screen /dev/ttyUSB0 115200
will reset the program, and display transaction debug messages
Subroutines can be specified to run directly from RAM, or to be cached from the
much slower SRAM. There is not much RAM available, so only absolute essentials should stay in
RAM.
