{"id":212,"date":"2017-05-03T06:23:45","date_gmt":"2017-05-03T13:23:45","guid":{"rendered":"http:\/\/www.kenwalger.com\/blog\/?p=212"},"modified":"2019-01-18T16:42:32","modified_gmt":"2019-01-19T00:42:32","slug":"micropython-and-nodemcu-esp8266","status":"publish","type":"post","link":"https:\/\/www.kenwalger.com\/blog\/iot\/micropython-and-nodemcu-esp8266\/","title":{"rendered":"MicroPython and the NodeMCU ESP8266"},"content":{"rendered":"

In a previous post<\/a>, I looked briefly at MicroPython<\/a> and it’s place and role in the Internet of Things (IoT) arena. In this post, I’d like to walk through the process of getting a NodeMCU<\/a> ESP8266 device flashed and up and running with MicroPython. Then we’ll do the, almost required, IoT version of “Hello World”… a blinking LED light.<\/p>\n

There are multiple micro-controller options available for using MicroPython so why, you may ask, have I decided on the NodeMCU? First and foremost they are inexpensive. You can find the NodeMCU ESP8266 development boards on eBay<\/a> for under $5.00.\u00a0Granted that is from a factory overseas, but for under $10.00 you can get one on Amazon<\/a>. The second reason I like this board, in particular, is that it has LED lights built into the board so I don’t necessarily need to break out LED bulbs and resistors. Another big plus is that it is WiFi ready and with MicroPython that means that one can set up a web interface with the board and also readily make truly connected projects without additional hardware.<\/p>\n

All that said and done I’ll be using a basic NodeMCU ESP8266<\/a>\u00a0device for this tutorial. Feel free to use a different physical device with the same chip, just know that some settings\u00a0may<\/em> be different based on the physical device configuration. The board has a USB interface which, when connected to a PC provides power.<\/p>\n

Firmware<\/h3>\n

We obviously need to get a copy of the MicroPython firmware. It comes in a .bin<\/code> file format that can be loaded directly to the ESP8266 device and can be downloaded from the MicroPython site here<\/a>. For this tutorial, I will be using the esp8266-20170108-v1.8.7.bin<\/code> version of firmware. You will want to download that to your computer and remember where\u00a0it is saved.<\/p>\n

Now we need to deploy the firmware to our device. If you are using the above-mentioned board, deploying the firmware should be relatively straight forward. If you are using a different ESP8266 board, check with the manufacturer of your board for the proper flashing technique. For the rest of us, we will want to start with the esptool<\/a> and use it to move the firmware over to our device. The tool can either be downloaded from GitHub directly or can be installed using pip with:<\/p>\n

python -m pip install esptool\n<\/pre>\n
This version of esptool supports Python version 3.4 or newer.<\/p>\n
Serial Ports<\/h4>\n
Once we have that installed on our system and the device connected via the USB port, we should, for best practice, clear the device by erasing its current state. Assuming that the port name of the device is COM4<\/code>, we can accomplish that with the following command:<\/p>\n
esptool.py --port COM4 erase_flash<\/pre>\n
Just substitute COM4 for whichever communication port your particular device is using. It may be something similar to \/dev\/ttyUSB1<\/code> on a non Windows machine and from a terminal port, you can use the command ls \/dev\/tty.*<\/code> to detect the port. Also, depending on your ESP8266 device you might need to install the USB to UART Bridge VCP Drivers<\/a>\u00a0the be able to detect the device via a serial connection. Once the device has been flashed (it takes less than 10 seconds on my machine) we upload the firmware to the device with the following command:<\/p>\n
esptool.py --port COM4 --baud 460800 write_flash --flash_size=detect 0 esp8266-20170108-v1.8.7.bin\n<\/pre>\n
The filename of the firmware should match the downloaded firmware. Assuming you don’t get any errors during the flashing process, you now have a NodeMCU ESP8266 device running MicroPython. Pretty slick, eh?<\/p>\n
Serial Terminal<\/h3>\n
We can now connect to the device using a serial terminal tool, like PuTTY<\/a> for Windows, the screen program on Mac, or something like picocom for Linux. I’ll be using PuTTY since I’m currently on a Windows 10 machine.<\/p>\n
We’ll want to select our serial port again, in my case it is COM4 and set the speed, or baud rate, to 115200. Then we can open the connection and we should be prompted with a Python read-evaluate-print-loop (REPL) interface as shown:<\/p>\n
\"\"<\/a><\/p>\n
We can start entering in Python commands on the device itself. Let’s have our device do the IoT version of “Hello World” and turn on one of the on-board LED lights. These lights are controlled through General-Purpose Input\/Output (GPIO) pins and there are two of them on board. GPIO 2\u00a0controls a small blue\u00a0LED on the board.<\/p>\n
In the REPL then, we want to be able to turn the light on and off. That can be done by altering the state (electrical charge) provided to the GPIO pins, typically by changing the state from low to high and back to low.<\/p>\n
Here is something that I discovered when working with this particular LED and GPIO setting and board. On this board, the LED on GPIO 2 (and 16 for that matter) is wired between the pin and the power, so when we set the pin state to low, the light is activated, and when set to high, it is off. There is active development on this issue and firmware updates may have already addressed the issue. However, if one connects an external LED light to, say GPIO 5 along with the required resistor (~300+ ohms), we get the expected light on with a high state, and off with a low state.<\/p>\n
MicroPython code – Try it Out!<\/h3>\n
Okay, so technical issues aside, let’s look at the code necessary to turn on our LED. First, we’ll need access to the board’s hardware. We can import a package called machine<\/code> which provides the necessary software interface. Then we can change the state of a given GPIO pin…<\/p>\n
>>> import machine\n>>> pin = machine.Pin(2, machine.Pin.OUT)\n>>> pin.high() \u00a0# light off\n>>> pin.low() \u00a0# light on\n>>> pin.high() # light off again\n<\/pre>\n
There we have it! We have taken a NodeMCU 8266 device, flashed it with MicroPython, accessed it through the serial port, and with minimal code, turned the on-board LED lights on and off.<\/p>\n
Congratulations on your first venture into IoT and Python! There is a lot more that can be done with this $5.00 board and I think I will spend some time experimenting with it a bit. I’ll post my results and findings here as I work through the process.<\/p>\n
\n
Follow me on Twitter @kenwalger<\/a> to get the latest updates on my postings.<\/em><\/p>\n\"Facebook\"<\/a>\"twitter\"<\/a>\"reddit\"<\/a>\"linkedin\"<\/a>\"mail\"<\/a>","protected":false},"excerpt":{"rendered":"
In a previous post, I looked briefly at MicroPython and it’s place and role in the Internet of Things (IoT) arena. In this post, I’d like to walk through the process of getting a NodeMCU ESP8266 device flashed and up and running with MicroPython. Then we’ll do the, almost required, IoT version of “Hello World”… … Continue reading “MicroPython and the NodeMCU ESP8266”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":197,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"pmpro_default_level":"","_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[27,28],"tags":[36,35],"yst_prominent_words":[903,249,327,274,321,132,908,902,900,905,1449,319,257,239,314,317,328,324,904,901],"class_list":["post-212","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-iot","category-micropython","tag-esp8266","tag-nodemcu","pmpro-has-access"],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/www.kenwalger.com\/blog\/wp-content\/uploads\/2017\/04\/micro-python-e1493094682987.png?fit=125%2C125&ssl=1","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p8lx70-3q","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/posts\/212","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/comments?post=212"}],"version-history":[{"count":16,"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/posts\/212\/revisions"}],"predecessor-version":[{"id":1003,"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/posts\/212\/revisions\/1003"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/media\/197"}],"wp:attachment":[{"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/media?parent=212"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/categories?post=212"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/tags?post=212"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/www.kenwalger.com\/blog\/wp-json\/wp\/v2\/yst_prominent_words?post=212"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}