{"id":1948,"date":"2020-01-15T23:49:09","date_gmt":"2020-01-15T15:49:09","guid":{"rendered":"https:\/\/www.techcoil.com\/blog\/?p=1948"},"modified":"2020-05-12T14:13:56","modified_gmt":"2020-05-12T06:13:56","slug":"how-to-setup-micropython-on-your-esp32-development-board-to-run-python-applications","status":"publish","type":"post","link":"https:\/\/www.techcoil.com\/blog\/how-to-setup-micropython-on-your-esp32-development-board-to-run-python-applications\/","title":{"rendered":"How to setup MicroPython on your ESP32 development board to run Python applications"},"content":{"rendered":"

When my friend Youssef<\/a> shared a link to MicroPython<\/a>, I kept it at the back of my mind. Since I had found some time to sharpen my saw, I decided to take a look at it.<\/p>\n

If I get familiar MicroPython, then I can perform machine learning magic with an AIOT board like Sipeed Maixduino Kit<\/a> with greater ease.<\/p>\n

Given that in mind, here are the steps that I took to setup MicroPython on my ESP32 development board<\/a> to kickstart my learning. <\/p>\n

In case you wish to setup MicroPython on your ESP32 development board to run Python applications, read on to find out more.<\/p>\n

Downloading a copy of MicroPython for your ESP32 development board<\/h2>\n

First and foremost, we will need to download a copy of the MicroPython binary for our ESP32 development board. Therefore, head over to MicroPython's download section for ESP32 boards<\/a>. For example, I had chosen to download esp32-idf4-20200115-v1.12-68-g3032ae115.bin<\/strong> into the ~\/micropython\/images<\/strong> folder on my computer.<\/p>\n

Installing a USB to UART bridge driver on your computer<\/h2>\n

In order to get the binary file onto our ESP32 development board, we will need a USB to UART driver. For example, if your development board has a CP210x chip to handle serial communication, you can install one of the CP210x USB to UART Bridge VCP Drivers from Silicon Labs<\/a>. If you enable ESP32 development on your Arduino IDE<\/a>, then you will have already installed the driver.<\/p>\n

Preparing a Python environment with esptool installed<\/h2>\n

After your computer is able to communicate with your ESP32 development board, get a copy of esptool<\/a>. Since a Python virtual environment helps us isolate Python dependencies for different applications, you may want to install your esptool into one of them.<\/p>\n

Given these points, let's install our esptool into a Python 3 virtual environment. If you are using a linux or unix environment, this is how you can create a virtual environment for your Python 3 application with python3-venv in Linux or Unix<\/a>. However, if you are using Windows, this is how to create a Python 3 virtual environment in Windows 10<\/a>.<\/p>\n

Since I am using a Mac to create this tutorial, I first create a Python 3 virtual environment with the following command:<\/p>\n

\r\npython3 -m venv ~\/micropython\/tools-env\r\n<\/pre>\n
After the virtual environment is created, I then activate the environment within my terminal session with the following command:<\/p>\n
\r\nsource ~\/micropython\/tools-env\/bin\/activate\r\n<\/pre>\n
When the virtual environment is activated, I then install esptool with the following command:<\/p>\n
\r\npip install esptool\r\n<\/pre>\n
After the pip installation completes, we will be able to use the esptool by running the following command:<\/p>\n
\r\nesptool.py\r\n<\/pre>\n
When you do so, you will see the help menu in the output.<\/p>\n
Getting the MicroPython binary onto your ESP32 development board<\/h2>\n
At this point in time, you will have the necessary tools to get MicroPython onto your ESP32 development board.<\/p>\n
First, erase everything from your ESP32 board's flash with the following command:<\/p>\n
\r\nesptool.py --chip esp32 --port \/dev\/tty.SLAB_USBtoUART erase_flash\r\n<\/pre>\n
After the flash is erased, run the following command to put the MicroPython binary that you have downloaded onto your board:<\/p>\n
\r\nesptool.py --chip esp32 --port \/dev\/tty.SLAB_USBtoUART --baud 460800 write_flash -z 0x1000 ~\/micropython\/images\/esp32-idf4-20200115-v1.12-68-g3032ae115.bin\r\n<\/pre>\n
When the command completes, you will be able to run Python codes on your ESP32 board via MicroPython.<\/p>\n
Verifying your MicroPython setup on your ESP32 development board<\/h2>\n
So how can we know if MicroPython is correctly installed on our ESP32 development board?<\/p>\n
When MicroPython is correctly installed, we will be able to access the REPL over serial with a terminal emulator program.<\/p>\n
For example, you can use the screen command if you are running macOS:<\/p>\n
\r\nscreen -port \/dev\/tty.SLAB_USBtoUART 115200\r\n<\/pre>\n
After you ran this command, you may find a blank screen. When you see the blank screen, hit Enter<\/strong> and you should be able to get the REPL prompt. If you want to see the MicroPython trace, then you can press Ctrl-D<\/strong> to initiate a soft reboot. At this point in time, you can try running some Python codes on the REPL:
\n\"Using<\/p>\n
Finding out the installed modules on your MicroPython installation<\/h2>\n
If you wish to find out the modules that are available with your MicroPython installation, you can enter the following command:<\/p>\n
\r\nhelp('modules')\r\n<\/pre>\n
When I do so in my MicroPython REPL, I got the following output trace:<\/p>\n
\r\n__main__          gc                uctypes           urequests\r\n_boot             inisetup          uerrno            uselect\r\n_onewire          machine           uhashlib          usocket\r\n_thread           math              uhashlib          ussl\r\n_webrepl          micropython       uheapq            ustruct\r\napa106            neopixel          uio               utime\r\nbtree             network           ujson             utimeq\r\nbuiltins          ntptime           umqtt\/robust      uwebsocket\r\ncmath             onewire           umqtt\/simple      uzlib\r\ndht               sys               uos               webrepl\r\nds18x20           uarray            upip              webrepl_setup\r\nesp               ubinascii         upip_utarfile     websocket_helper\r\nesp32             ubluetooth        upysh\r\nflashbdev         ucollections      urandom\r\nframebuf          ucryptolib        ure\r\nPlus any modules on the filesystem\r\n<\/pre>\n
Given that, you can then check out MicroPython's libraries documentation<\/a> on how to use them.<\/p>\n
Before continuing with this post, quit your terminal emulator program and make sure that it does not lock the serial driver to your board. <\/p>\n
If you are using screen, you can press Ctrl-A+K<\/strong> to kill the session terminal. If you press Ctrl-A+D<\/strong> instead, then you will need to terminate your screen session cleanly<\/a>. <\/p>\n
Getting Python scripts onto your ESP32 board<\/h2>\n
At this point in time, you can find boot.py<\/strong> when you run the following Python codes in your MicroPython REPL:<\/p>\n
\r\nimport os\r\nos.listdir()\r\n<\/pre>\n
When you setup MicroPython on your ESP32 board, it will run boot.py<\/strong> on every boot, including wake-boot from deep sleep, and main.py<\/strong> after that.<\/p>\n
Therefore, in order to run your own Python scripts on your ESP32 board, you need to get these two files into your ESP32 board. <\/p>\n
Installing Remote MicroPython shell on your Python virtual environment<\/h3>\n
The Remote MicroPython shell<\/a> is a useful tool to help us get our own Python scripts onto our ESP32 board. Therefore, you may want to install it into your Python environment with the following command:<\/p>\n
\r\npip install rshell\r\n<\/pre>\n
Using rshell to connect to your ESP32 development board<\/h3>\n
After you have installed rshell into your Python virtual environment, run the following command to connect it to your board:<\/p>\n
\r\nrshell -p \/dev\/tty.SLAB_USBtoUART -b 115200\r\n<\/pre>\n
When rshell is able to connect to your MicroPython instance on your ESP32 board, you should see output similar to the following:<\/p>\n
\r\nUsing buffer-size of 32\r\nConnecting to \/dev\/tty.SLAB_USBtoUART (buffer-size 32)...\r\nTrying to connect to REPL  connected\r\nTesting if ubinascii.unhexlify exists ... Y\r\nRetrieving root directories ... \/boot.py\/\r\nSetting time ... Jan 15, 2020 15:19:09\r\nEvaluating board_name ... pyboard\r\nRetrieving time epoch ... Jan 01, 2000\r\nWelcome to rshell. Use Control-D (or the exit command) to exit rshell.\r\n<\/pre>\n
At this point in time, you will be able to use rshell to access the filesystems of your computer and your ESP32 board. Since the root folder of your ESP32 board is mapped to \/pyboard<\/strong>, you can list its contents via the following command call:<\/p>\n
\r\nls \/pyboard\r\n<\/pre>\n
When you do so, you will find boot.py<\/strong> in the output. <\/p>\n
Copying files into your ESP32 development board via rshell<\/h3>\n
Given that the root folder of our ESP32 board is mappe to \/pyboard<\/strong>, we can use the cp<\/strong> command within rshell to get files into the board.<\/p>\n
For example, if we have ~\/micropython\/codes\/boot.py<\/strong> on our host computer, we can run the following command to get it into the ESP32 board:<\/p>\n
\r\ncp ~\/micropython\/codes\/boot.py \/pyboard\/boot.py\r\n<\/pre>\n
We can also copy everything in a folder onto the ESP32:<\/p>\n
\r\ncp ~\/micropython\/codes\/* \/pyboard\/\r\n<\/pre>\n
\"How<\/p>\n\n