Tag Archives: espressif

Compilation, Development, Software

ESP32 – IDF Sdk with Eclipse

2019-04-29 admin

After configuring the IDF development environment in the previous article

ESP32 – IDF Sdk

let’s see now how to use Eclipse as IDE for code development. Instructions are available at the link

Eclipse Setup

Download the C/C++ Eclipse for Linux

Eclipse Download

Unpack the file and move it to /opt/

tar -zxvf eclipse-cpp-2019-03-R-linux-gtk-x86_64.tar.gz
sudo mkdir /opt 
sudo mv eclipe /opt/

tar -zxvf eclipse-cpp-2019-03-R-linux-gtk-x86_64.tar.gz

sudo mkdir /opt

sudo mv eclipe /opt/

Run ecplise

/opt/eclipse/ecplise

1	/opt/eclipse/ecplise

Set the workspace for eclipse

Once the IDE is open, select File -> Import -> C / C ++ – -> Existing Code as Makefile Project

Press Next; on the next screen select the folder containing the Makefile of a sample project in the “Existing Code Location” field and choose CrossGcc as “Toolchain for indexer settings” as shown below

Once the project is loaded, using the mouse right button on the project name, select the properties option

Under C / C ++ Build -> Envinronment add the variable

BATCH_BUILD = 1

1	BATCH_BUILD = 1

Add the IDF_PATH variable pointing to the downloaded IDF SDK in the same section

IDF_PATH=~/Esp32/espressif/esp-idf

1	IDF_PATH=~/Esp32/espressif/esp-idf

Edit the PATH variable and add the path to the bin folder of the cross compiler /home/sviluppo/Esp32/espressif/esp/xtensa-esp32-elf/bin

Access “C / C ++ General” -> “Preprocessor Include Paths”; choose the Providers tab and click on “CDT Cross GCC Built-in Compiler Settings”

Replace $ {COMMAND}

with xtensa-esp32-elf-gcc

Choose now, always in the providers section, “CDT GCC Build Output Parser”

and insert at the beginning of the “Compiler command pattern” xtensa-esp32-elf-

Save the configurations.

The project settings should always be made by make menuconfig in the unix shell. Access the shell and set the LED to be switched on/off the value 2 as GPIO; this is because in our case the card is a doit whose design is illustrated in this document

SchematicsforESP32

cd ~/Esp32/espressif 
export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin 
export IDF_PATH=~/Esp32/espressif/esp-idf 
cd projects/blink 
make menuconfig

cd ~/Esp32/espressif

export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

export IDF_PATH=~/Esp32/espressif/esp-idf

cd projects/blink

make menuconfig

Access to Example configuration

and set the gpio value to 2

Save the configuration. Go back to Eclipse and proceed with cleaning with

and subsequent compilation with Project -> Build

To run firmware flash from eclipse;, select the project and with the right button choose Build Targets -> Create …

Enter flash as value in the target name field, leaving everything else as default

At this point we proceed to upload the image by double-clicking on the new flash item within the project targets

The settings to run the flash must be set with make menuconfig, as seen in the previous article

ESP32 – IDF Sdk

Compilation, Software

ESP32 – IDF Sdk

2019-04-07 admin

This article describes how to set the Espressif development environment for the ESP32.

From the link to the resources for the soc

https://www.espressif.com/en/products/hardware/esp32/resources

we access the guide for compiling the firmware on the Windows, OSX and Linux platforms

http://esp-idf.readthedocs.io/en/latest/get-started/index.html

In this article we use Linux Debian 9 as operating system, configured as described previously here

MicroPython – Python ib embedded devices

We use the IDF github. On Debian 9, with the user used to connect to the system, we create the Esp32 folder under the user’s Home and the espressif folder inside it

cd
mkdir Esp32
cd Esp32
mdkir espressif
cd espressif

mkdir Esp32

cd Esp32

mdkir espressif

cd espressif

Install the prerequisites

sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

1	sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

Download the cross compiler

wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1	wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Create the esp folder and unpack the toolchain

mkdir esp 
cd esp 
tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

mkdir esp

cd esp

tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Add the bin folder of the cross compiler to the PATH

export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

1	export PATH=$PATH:$HOME/Esp32/espressif/esp/xtensa-esp32-elf/bin

Add the user used for the operations to the dialout group

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

Clone the IDF repository from $HOME/Esp32/espressif

cd $HOME/Esp32/espressif
git clone --recursive https://github.com/espressif/esp-idf.git

1 2	cd $HOME/Esp32/espressif git clone --recursive https://github.com/espressif/esp-idf.git

Add the IDF_PATH environment variable

export IDF_PATH=~/Esp32/espressif/esp-idf

1	export IDF_PATH=~/Esp32/espressif/esp-idf

Create the project folder under $HOME/Esp32/espressif and copy an example from di IDF examples

cd $HOME/Esp32/espressif
mkdir projects
cd projects
cp -r $IDF_PATH/examples/get-started/hello_world . 
cd hello_world

cd $HOME/Esp32/espressif

mkdir projects

cd projects

cp -r $IDF_PATH/examples/get-started/hello_world .

cd hello_world

Run the configuration

make menuconfig

1	make menuconfig

Access Serial flasher config -> and set the connection parameters; in our case we leave the default

Save the configuration and build the firmware

make

make

To upload the firmware on the device run

make flash

1	make flash

To upload only the application run

make app-flash

1	make app-flash

while to build only the application run

make app

make app

To run the program monitor run

make monitor

1	make monitor

Here are the other examples available with sdk

https://github.com/espressif/esp-idf/tree/f586f5e/examples

The following link contains the references of the IDF API

http://esp-idf.readthedocs.io/en/latest/api-reference/index.html

You can also generate documentation from the github source. Go into ~/Esp32/espressif/esp-idf/docs/en

cd ~/Esp32/espressif/esp-idf/docs/en

1	cd ~/Esp32/espressif/esp-idf/docs/en

Install the prerequisites

sudo apt-get install python-pip python-sphinx doxygen

1	sudo apt-get install python-pip python-sphinx doxygen

sudo pip install sphinx_rtd_theme breathe sphinxcontrib.blockdiag sphinxcontrib.seqdiag sphinxcontrib.actdiag sphinxcontrib.nwdiag recommonmark

1	sudo pip install sphinx_rtd_theme breathe sphinxcontrib.blockdiag sphinxcontrib.seqdiag sphinxcontrib.actdiag sphinxcontrib.nwdiag recommonmark

Generate documentantion in html format

make html

make html

The documentation is available under _build / html.

In the next article we will configure Eclipse as IDE to build our applications

ESP32 -IDF Sdk with Eclipse

Compilation, Software

ESP32 – Nodemcu firmware compiling

2018-08-17 admin

After the compilation of the MicroPython firmware for ESP32

ESP32 – MicroPython compiling for ESP32

this article shows how to generate the Nodemcu firmware for the ESP32 MCU.

The firmware is not yet complete as the one existing for ESP8266.

The instructions can be found on the github at the link

https://github.com/nodemcu/nodemcu-firmware/tree/dev-esp32

The compilation documentation is available at the link

https://nodemcu.readthedocs.io/en/dev-esp32/en/build/

The operating system used is Debian 9 previously encountered for the esptool and Adafruit-ampy utilities

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Esp32 folder and inside this folder the nodemcu folder

cd
mkdir Esp32
cd Esp32
mkdir nodemcu
cd nodemcu

mkdir Esp32

cd Esp32

mkdir nodemcu

cd nodemcu

Clone the repository

git clone --branch dev-esp32 --recurse-submodules https://github.com/nodemcu/nodemcu-firmware.git nodemcu-firmware-esp32

1	git clone --branch dev-esp32 --recurse-submodules https://github.com/nodemcu/nodemcu-firmware.git nodemcu-firmware-esp32

To update the cloned repository follow the description on the compilation link, i.e.

cd nodemcu-firmware-esp32 
git pull origin dev-esp32 
git submodule init #only if repo was cloned w/o submodules init 
git submodule update --recursive

cd nodemcu-firmware-esp32

git pull origin dev-esp32

git submodule init #only if repo was cloned w/o submodules init

git submodule update --recursive

Go into nodemcu-firmware-esp32 folder and run

cd nodemcu-firmware-esp32
make menuconfig

1 2	cd nodemcu-firmware-esp32 make menuconfig

Enable the bluetooth in Component config–>Bluetooth

Enable various modules in Component config–>Nodemcu modules

In the flash settings we set the default values for our ESP32, Serial flasher config->

Save the configuration and exit. To build the firmware run

make

make

At the end of the compilation the command to upload the firmware is shown; the same operation is executed by simply running

make flash

1	make flash

For informations about the partitions of the various ESP32 versions, refer to the documentation

http://api-guides/partition-tables.html

In the next article we’ll show how to make an application using the Espressif SDK

ESP32 – IDF Sdk

Compilation, Software

ESP32 – MicroPython compiling for ESP32

2018-08-08 admin

We begin now a series of articles about the Espressif ESP32 MCU

ESP32 Wifi-Bluetooth Module

After having analyzed in the previous articles MicroPython for ESP8266, in this we start to treat MicroPython on ESP32.

The following shows how to generate the MicroPython image from the source code for the ESP32 board.

The operating system is Debian 9, previously encountered for the esptool and Adafruit-ampy utilities

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Micropython folder and inside this folder the esp32 folder

mkdir Micropython
cd Micropython
mkdir esp32
cd esp32

mkdir Micropython

cd Micropython

mkdir esp32

cd esp32

The MicroPython source code is available at the following link

Github Micropython

Instructions to build the firmware for the ESP32 are available at the link

MicroPython esp32

Clone the repository

git clone https://github.com/micropython/micropython

1	git clone https://github.com/micropython/micropython

Go into micropython/ports/esp32 folder

cd micropython/ports/esp32

1	cd micropython/ports/esp32

Run

make

make

The command releases the git hash for the supported espidf

At the time of our compilation the result is as follows

sviluppo@debian9:~/Micropython/esp32/micropython/ports/esp32$ make
Use make V=1 or set BUILD_VERBOSE in your environment to increase build verbosity.
The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.
See README.md for installation instructions.
Supported git hash: 3ede9f011b50999b0560683f9419538c066dd09e
Makefile:34: *** ESPIDF not set.  Stop.

sviluppo@debian9:~/Micropython/esp32/micropython/ports/esp32$ make

Use make V=1 or set BUILD_VERBOSE in your environment to increase build verbosity.

The ESPIDF variable has not been set, please set it to the root of the esp-idf repository.

See README.md for installation instructions.

Supported git hash: 3ede9f011b50999b0560683f9419538c066dd09e

Makefile:34: *** ESPIDF not set. Stop.

Go into /home/sviluppo/Micropython/esp32 folder and clone ESPIDF

git clone https://github.com/espressif/esp-idf.git
cd esp-idf

1 2	git clone https://github.com/espressif/esp-idf.git cd esp-idf

Checkout with the hash obtained above

git checkout 3ede9f011b50999b0560683f9419538c066dd09e

1	git checkout 3ede9f011b50999b0560683f9419538c066dd09e

Run

git submodule update --init

1	git submodule update --init

We follow the instructions at the link

Cross compiler

to install the cross compiler; install the prerequisites for building

sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

1	sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

Download the cross compiler

cd /home/sviluppo/Micropython/esp32
wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1 2	cd /home/sviluppo/Micropython/esp32 wget https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Create the esp folder under /home/sviluppo/Micropython/esp32

cd /home/sviluppo/Micropython/esp32
mkdir esp
cd esp

cd /home/sviluppo/Micropython/esp32

mkdir esp

cd esp

Unpack the cross compiler in esp

tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

1	tar -zxvf ../xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

Add the binary folder of the cross compiler to the PATH envinronment variable

export PATH=/home/sviluppo/Micropython/esp32/esp/xtensa-esp32-elf/bin:$PATH

1	export PATH=/home/sviluppo/Micropython/esp32/esp/xtensa-esp32-elf/bin:$PATH

Go into the following folder

/home/sviluppo/Micropython/esp32/micropython/ports/esp32/

1	/home/sviluppo/Micropython/esp32/micropython/ports/esp32/

and create the makefile file with the following code inside

ESPIDF = /home/sviluppo/Micropython/esp32/esp-idf
#PORT = /dev/ttyUSB0
#FLASH_MODE = qio
#FLASH_SIZE = 4MB
#CROSS_COMPILE = xtensa-esp32-elf-

include Makefile

ESPIDF = /home/sviluppo/Micropython/esp32/esp-idf

#PORT = /dev/ttyUSB0

#FLASH_MODE = qio

#FLASH_SIZE = 4MB

#CROSS_COMPILE = xtensa-esp32-elf-

include Makefile

Go into the micropython folder available in /home/sviluppo/Micropython/esp32

cd micropython

1	cd micropython

Run

git submodule update --init

1	git submodule update --init

to add external dependencies.

Next step is the MicroPython cross compiler build

make -C mpy-cross
git submodule init lib/berkeley-db-1.xx
git submodule update

make -C mpy-cross

git submodule init lib/berkeley-db-1.xx

git submodule update

Finally we can build the ESP32 firmware with the following commands

cd ports/esp32
make

1 2	cd ports/esp32 make

The firmware is generated under ports/esp32/build with the name firmware.bin.

Proceed to load the firmware with the commands

make erase

1	make erase

In our case, the firmware upload was successful with the command

make deploy

1	make deploy

It is also possible to load the firmware.bin image with the commands

esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 erase_flash

1	esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 erase_flash

esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600  write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 firmware.bin

1	esptool.py --chip esp32 --port /dev/ttyXXX --baud 921600 write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 firmware.bin

where /dev/ttyXXX is replaced with the actual serial port to which we connect the ESP32 board.

In the next article we’ll compile the nodemcu firmware for ESP32

ESP32 – Nodemcu firmware compiling

Compilation, Software

MicroPython – MicroPython compiling for ESP8266 with additional modules

2018-07-04 admin

After the firmware build of the MicroPython firmware for esp8266 in the previous article

MicroPython – MicroPython compiling for ESP8266

we now show how build a module inside the firmware; this option optimizes the module execution and minimizes the size of the same on the device; the module is frozen into the firmware.

With the firmware compiled with the defaults, the following modules are available, listed in the REPL console with the command

help('modules')

1	help('modules')

Now let’s try to compile the firmware with the mqtt modules already inside. For this purpose, the module sources are copied to the umqtt folder under modules

micropython/ports/esp8266/modules/umqtt/simple.py
micropython/ports/esp8266/modules/umqtt/robust.py

1 2	micropython/ports/esp8266/modules/umqtt/simple.py micropython/ports/esp8266/modules/umqtt/robust.py

We proceed to recompile the firmware. From micropython/ports/esp8266 we run the following commands

make clean
make

1 2	make clean make

We can see from the compilation log, that these modules are placed in the frozen state

After uploading this firmware we obtain the following list of modules inside the firmware

It is also possible to create the firmware with the modules not compiled and optimized, by copying the sources in the scripts folder under esp8266; in the specific case the sources must be placed as shown below

micropython/ports/esp8266/scripts/umqtt/simple.py
micropython/ports/esp8266/scripts/umqtt/robust.py

1 2	micropython/ports/esp8266/scripts/umqtt/simple.py micropython/ports/esp8266/scripts/umqtt/robust.py

The modules are always visible in the firmware, but not optimized, so if you need some module it is convenient to copy it on the device during the coding and in the last phase of the project compile the firmware with the frozen modules.

Compilation, Software

MicroPython – MicroPython compiling for ESP8266

2018-06-25 admin

After using in some examples the MicroPython firmware on the ESP8266 board

MicroPython – Nodes examples with DHT11, Relay and MQTT

this article shows how to generate the MicroPython firmware for the ESP8266 board.

The operating system used for this task is Debian 9, already encountered when we analyzed the esptool utility

MicroPython – Python on embedded devices

Log on with the operating system user on Debian 9, sviluppo in our case; under the home folder create the Micropython folder and inside this folder the esp8266 folder

mkdir Micropython
cd Micropython
mkdir esp8266
cd esp8266

mkdir Micropython

cd Micropython

mkdir esp8266

cd esp8266

The MicroPython source code is available at the following link

Github Micropython

Instructions to build the firmware for the ESP8266 are available at the link

MicroPython esp8266

Clone the repository

git clone https://github.com/micropython/micropython

1	git clone https://github.com/micropython/micropython

Download the cross compiler, as described here

Cross compiler

As indicated in the link above, download the source of the cross compiler always from the folder esp8266

git clone --recursive  https://github.com/pfalcon/esp-open-sdk

1	git clone --recursive https://github.com/pfalcon/esp-open-sdk

Install the prerequisites for building

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 sed git unzip bash help2man wget bzip2 libtool-bin

1	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 sed git unzip bash help2man wget bzip2 libtool-bin

Proceed to the build of the cross compiler with the following commands

cd esp-open-sdk
make STANDALONE=y |& tee make0.log

1 2	cd esp-open-sdk make STANDALONE=y \|& tee make0.log

At the end of the build add the binary folder of the cross compiler to the PATH envinronment variable

export PATH=/home/sviluppo/Micropython/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH

1	export PATH=/home/sviluppo/Micropython/esp8266/esp-open-sdk/xtensa-lx106-elf/bin:$PATH

Go into the micropython folder available under ~/Micropython/esp8266

cd ~/Micropython/esp8266/micropython

1	cd ~/Micropython/esp8266/micropython

Run

git submodule update --init

1	git submodule update --init

to add external dependencies.

Next step is the MicroPython cross compiler build

make -C mpy-cross

1	make -C mpy-cross

Finally we can build the ESP8266 firmware with the following commands

cd ports/esp8266
make axtls
make

cd ports/esp8266

make axtls

make

The firmware is generated under ports/esp8266/build folder with the name firmware_combined.bin.

Proceed to load the firmware with the command

esptool.py --port /dev/ttyXXX erase_flash

1	esptool.py --port /dev/ttyXXX erase_flash

where /dev/ttyXXX is repalced with the actual serial port to which we connect the ESP8266 board.

In our case, the firmware upload was successful with the command

make PORT=/dev/ttyUSB0 deploy

1	make PORT=/dev/ttyUSB0 deploy

It is also possible to load the firmware_combined.bin image with the command

esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect 0 firmware-combined.bin

1	esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect 0 firmware-combined.bin

In the next article we’ll analyze how to build the MicroPython firmware adding into the image additional MicroPython modules

MicroPython – MicroPython compiling for ESP8266 with additional modules

Development, Software

MicroPython – MicroPython program structure

2018-06-02 admin

After reviewing various development tools for MicroPython in previous articles

MicroPython – Development tools Ampy – Eric

MicroPython IDE uPyCraft

in this article we briefly describe the main features of MicroPython. In particular, we examine the documentation relating to the ESP8266, but the concepts can also be extended to the other boards.

The documentation on the ESP8266 soc and MicroPython is available at the link

ESP8266 MicroPython Documentation

At the link we can find all the informations necessary to implement the code on the card and the features of MicroPython as well as the differences compared to Python.

Here are the main points for coding in MicroPython:

MicroPython has a REPL (Read Evaluate Print Loop) console through the serial port to which the device is connected on which we can give the various MicroPython commands interactively.

The REPL console can also be accessed via connection to the IP address of the device by enabling the WEBREPL (Web Browser Interactive prompt) console

WebREPL Documentation

importing the webrepl package, enabling it and starting it at each device restart. To access the configured device, we can use the link

WEBREPL Access

or locally cloning it from github

git clone https://github.com/micropython/webrepl

1	git clone https://github.com/micropython/webrepl

At the start of the device the system runs boot.py and after main.py.

The MicroPython libraries are available on the github at the link

MicroPython libraries

Additional packages

The additional modules can be downloaded from the link of the libraries presented above or downloaded with the upip utility (Package Manager) from the REPL console if available in the Python Package Index (PyPI) repository

PYPI

as described below

upip

Below is a simple example that connects to the router and allows us to access the MicroPython console with the browser and WEBREPL.

boot.py code

#This file is executed on every boot (including wake-boot from deepsleep)
import esp
#esp.osdebug(None)
#Connects to the wifi AP providing a hostname, AP Name and passord
def do_connect():
    import network
    
    sta_if = network.WLAN(network.STA_IF)
    if not sta_if.isconnected():
        print('connecting to network...')
        sta_if.active(True)
		#Sets the device hostname
        sta_if.config(dhcp_hostname='ESP_TEST')
        print(sta_if.config('dhcp_hostname'))
		#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD
        sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')
        while not sta_if.isconnected():
            pass
    
    print('network config:', sta_if.ifconfig())
    
#Imports various modules for network, webrepl and garbage collector	
import gc
import webrepl
import network

do_connect()
webrepl.start()
gc.collect()

#This file is executed on every boot (including wake-boot from deepsleep)

import esp

#esp.osdebug(None)

#Connects to the wifi AP providing a hostname, AP Name and passord

def do_connect():

import network

sta_if = network.WLAN(network.STA_IF)

if not sta_if.isconnected():

print('connecting to network...')

sta_if.active(True)

#Sets the device hostname

sta_if.config(dhcp_hostname='ESP_TEST')

print(sta_if.config('dhcp_hostname'))

#CHANGE THE VALUES TO YOUR ACCESSPOINT NAME AND PASSWORD

sta_if.connect('ACCESSPOINT', 'PASSWORDACCESSPOINT')

while not sta_if.isconnected():

pass

print('network config:', sta_if.ifconfig())

#Imports various modules for network, webrepl and garbage collector

import gc

import webrepl

import network

do_connect()

webrepl.start()

gc.collect()

At the first access it is required to enable webrepl to be executed in the REPL console with the command

import webrepl_setup

1	import webrepl_setup

we can activate the service and the access password.

The procedure generates the webrepl_cfg.py file on the device.

After setting up and restarting, we access the web console by opening the locally cloned webrepl.html file with a browser

Pressing connect and after entering the password ,set in the initial setup, we access the console

Now we install from the WEBREPL console, for example, the stat module using upip

import upip 
upip.install("micropython-stat")

1 2	import upip upip.install("micropython-stat")

To paste commands execute Ctrl+A e Ctrl+V

In this case the package was taken from the PYPI repository, unpacked and installed on the device.

We have noticed that some modules, although available on the repository, give an error during installation with upip; these modules are installed directly without using the upip utility,but by downloading the library from the site listed above and transferring the code to the device.

Here is the link of the code shown above

Webreplsample

Another option available is to build the firmware with the required modules.

In the next article we will examine examples similar to what was done with LUA on ESP8266 in previous articles

MicroPython – Nodes examples with DHT11, Relay and MQTT

Development, Installation, Software

Micropython – Development tools Ampy – Eric

2018-05-29 admin

After the uPyCraft intallation in the previous article

MicroPython – IDE MicroPython uPyCraft

let’s now look at other tools available for the development in MicroPython for various platforms.

This article shows the operations to be performed on Windows and Linux.

First Python package to install is Ampy (Adafruit MicroPython Tool)

ampy

The tool is available in the python repositories, so it can be installed using the pip tool.

In Windos run in a dos command prompt

pip install adfruit-ampy

1	pip install adfruit-ampy

Similarly in Linux run in a shell

sudo pip3 install adafruit-ampy

1	sudo pip3 install adafruit-ampy

The available commands are listed running

ampy --help

1	ampy --help

Ampy allows the transfer, creation, viewing, and execution of files on the device.

As for the IDE you can install Eric, generic Python IDE

Eric

Eric does not allow communication from the IDE with the device as seen with uPyCraft; this task is delegated to Ampy. For the installation proceed as follows:

For Linux Debian 9 just run

sudo apt-get install eric

1	sudo apt-get install eric

The tool is available among the development tools; at the first execution it requires default settings

We define the workspace location

and we have the access to the IDE

For Windows download the zip

Eric

Unzip the zip into a folder from which we run it; install the prerequisites

pip install pyqt5-tools
pip install qscintilla

1 2	pip install pyqt5-tools pip install qscintilla

Perform the eric installation at this point by double clicking on install.py

The program checks the prerequisites and completes the installation

Clicking twice on eric6.py or running eric6 from a dos command prompt we run the program in the same way as seen for Linux Debian

In the next article we will briefly examine how a MicroPython program is structured

MicroPython – MicroPython program structure

Development, Installation, Software

Micropython – MicroPython IDE uPyCraft

2018-04-27 admin

After installing the firmware on the Nodemcu esp8266 DevKit board

MicroPython Firmware

let us now examine a development tool can be suitable for the development of Python code.

A tool that allows both to write code and upload it to the device is uPyCraft

uPyCraft

The tool currently works for Windows and from version 0.30 is also available for Linux; the source code is available at the link

uPyCraft Source

Here are the steps for Windows and Linux.

Windows

Once downloaded the package we must run it as an administrator; the installation of the Monaco font is required

After the font installation, we have the access to the IDE

We set the Location in Tools->Preferences->Language Location

and the serial port paramenters in Tools->Preferences->Serial

We plug the device into an USB port and set the serial port on uPyCraft

We choose the device type; in this case it is ESP8266

By clicking on the connection icon we access to the device and view the files on it

The firmware installation expands on the device only the Python file boot.py

The tool allows to download examples of MicroPython code for the board, blink.py for example

Clicking the “Download and Run” button we load the code onto the device and run it

In this example the led of the Nodemcu DevKit blinks.

Linux

The tool is similar in the Linux version; once downloaded the package to which we have to assign the execution right we run it. We must assign to the user the access to the serial port with the command, already seen above

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

In our case, on Debian 9, we have the following screens similar to what we saw on Windows.

In the uPyCraft IDE

We set the Location in Tools->Preferences->Language Location

and the serial port paramenters in Tools->Preferences->Serial

We plug the device into an USB port and set the serial port on uPyCraft

We choose the device type; in this case it is ESP8266

By clicking on the connection icon we access to the device and view the files on it

The firmware installation expands on the device only the Python file boot.py

The tool allows to download examples of MicroPython code for the board, blink.py for example

Clicking the “Download and Run” button we load the code onto the device and run it

As in Windows the led of the Nodemcu DevKit blinks..

In version 0.30 for Windows we noticed some bugs, so for this operating system we continue to use the uPyCraft version 0.29.

Further informations about uPyCraft can be found at the following site

uPyCraft Documentation

In the next article we will discuss another Python development tool

MicroPython – Development tools Ampy – Eric

Installation, Software

MicroPython – Python on embedded devices

2018-04-26 admin

In this article we begin to treat MicroPython

MicroPython

an implementation of Python3

Python

for embedded devices.

Various images are available on the MicroPython website for different devices, including the modules esp8266 and esp32

MicroPython Dowloads

We start our tests with a Nodemcu esp8266 DevKit

Nodemcu Devkit

We proceed to load the firmware on this card.

The Micropython site also refers how to load the firmware on the cards; these informations are available at the link

MicroPython Tutorial for esp8266

To load the firmware we always use the tool esptool, also available on the Python repository.

To be able to use it, we need to install Python3 on our development platform. Here are the steps to follow for Windows and Linux.

Windows

For windows we must first install the Python3 environment, available at the following link

Python for Windows

In our case, we downloaded the version 3.6.4 for 64-bit systems. We installed the package with administrative rights

After proceeding to add Python in the Path we click “Install Now”

After the installation, we open a dos command propmt and check the installed Python version

Always from the dos command prompt we proceed to the installation of esptool with the command

pip install esptool

1	pip install esptool

At this point we can proceed to the MicroPython firmware upload on the Nodemcu esp8266 DevKit. Of course, it is necessary to have the serial-ttl drivers installed for your DevKit model on Windows. Now go into the folder where the firmware has been downloaded and run the following commands from the dos command prompt

esptool.py --port COMPORT erase_flash

1	esptool.py --port COMPORT erase_flash

Proceed to load the firmware

esptool.py --port COMPORT --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

1	esptool.py --port COMPORT --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

Once the firmware is installed we log on the Python console using, in our case with the nodemcu card DevKit, the same port already used to load the firmware.

On Windows we can use Putty

Putty

and set the serial connection to 115200 baud rates

Linux

For Linux we use the Debian 9 distribution, but the procedure can be extended to other distributions. After installing Debian 9 , similar to version 8

Debian 8

we proceed to the installation of Python3 and esptool from a Linux shell

sudo apt-get install python3
sudo apt-get install python3-pip

1 2	sudo apt-get install python3 sudo apt-get install python3-pip

Add the user used on Debian to the dialout group

sudo usermod -a -G dialout USER

1	sudo usermod -a -G dialout USER

In our case, using sviluppo as a user, the command is as follows

sudo usermod -a -G dialout sviluppo

1	sudo usermod -a -G dialout sviluppo

Let’s move on to install the Python esptool package

sudo pip3 install esptool

1	sudo pip3 install esptool

We can then proceed with the installation of the firmware in the same way as done on Windows.

We check on which serial port the card is available (ttyUSBX)

We perform a flash erase and firmware upload

esptool.py --port /dev/ttyUSBX erase_flash

1	esptool.py --port /dev/ttyUSBX erase_flash

esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

1	esptool.py --port /dev/ttyUSBX --baud 460800 write_flash --flash_size=detect -fm=dio 0 firmware.bin

To log on the DevKit we use screen

sudo apt-get install screen

1	sudo apt-get install screen

Here is the manual of the tool

Screen Manual

screen /dev/ttyUSB0 115200

1	screen /dev/ttyUSB0 115200

To detach from screen press

Ctrl+a+d

Ctrl+a+d

instead to resume run

screen -r

screen -r

To quit screen

killall screen

1	killall screen

Once connected you get the same result as Windows

In the next article we will begin to see which IDEs can be used to create and load our Python code

MicroPython IDE uPyCraft

Micro Devices

Tag Archives: espressif

ESP32 – IDF Sdk with Eclipse

ESP32 – IDF Sdk

ESP32 – Nodemcu firmware compiling

ESP32 – MicroPython compiling for ESP32

MicroPython – MicroPython compiling for ESP8266 with additional modules

MicroPython – MicroPython compiling for ESP8266

MicroPython – MicroPython program structure

Micropython – Development tools Ampy – Eric

Micropython – MicroPython IDE uPyCraft

MicroPython – Python on embedded devices

Blog about embedded devices