nodemcu – Squix – TechBlog

ESP8266: NodeMCU Motor Shield Review

Daniel Eichhorn — Sat, 12 Sep 2015 10:08:00 +0000

If you want to engage with your ESP8266 into robotics there is now an almost ready-to-go solution: the NodeMCU Motor Shield. If my research is correct then it was the Doctors of Intelligence & Technology (http://doit.am/) who created it and also are offering some LUA code to get started. This post shares my experience with the motorshield and also with a two engine “Smart Car” kit that nicely combines with the motorshield.

Motorshield

If you want to drive motors with your ESP8266 you have to be careful. The General Purpose Input/Output (GPIO) pins of the ESP8266 (as well as the similar Arduinos) don’t allow you to draw the amount of current required for a motor. But how to do that? You could build something on your own by using a few electronic components (transistor, capacitor, etc) or you could just pick something off the shelf that does exactly that for you. That’s where the Doctors of Intelligence & Technology and their motor shield comes in. It is designed to carry a NodeMCU V1.0 on its back. Note: the motor shield won’t fit for a NodeMCU V0.9! It has convenient terminals to attach two two-ways motors (or according to some source one stepper motor). It also has terminals to attach the power source that drives the motors and the NodeMCU. And as a clever addition you can decide to have just one power source for both motors and NodeMCU by setting a jumper accordingly.

One of the two terminals (Vin for NodeMCU) can be cut off with a power switch which saves you from taking out the batteries.

Besides the terminals there are also male pins which lead out GPIO 0-8 (in NodeMCU terminology), the reset pin, the analog/digital converter, the UART pins and the SPI pins.

NodeMCU V1.0 Powershield

A sign on the PCB makes it easy enough to plugin the NodeMCU the correct way: just make sure that the antenna of the ESP8266 and the antenna symbol on the motor shield are on the same side.

Smart Car Kit

The Smart Car Kit is the ideal companion for the NodeMCU if you want to get started into WiFi controlled cars or robotics. Some vendors even sell it in one big package for about USD $22 (see here). It comes with 2 two-ways motors with reduction gear, two main wheels and one support wheel, a chassis, a battery pack for 4 AA cells and additional screw driver.

You can put everything to getter within just about 15 minutes once you have figured out where the parts have to go. I only had two issues with the kit: while you might be able to attach the wires to the engine without soldering I would recommend that you do this with a soldering iron. The other (bigger) problem was the supporting wheel. It turns easy enough around the axis of the wheel itself but the z-axis which should adjust when the car makes a turn is not working so smoothly. This can have the effect that even if both motors go at the same speed the supporting wheel is stuck in a weird position and keeps your car to pull to one side. I solved this by using some duct tape and fixing the wheel at the “forward” position. This might be suboptimal for turning but works good enough on smooth floors. It might be a problem though on soft carpets but I haven’t tried that.

The Smart Car Kit

Bringing it together: the WiFi Car

The next step was to put all the pieces (Smart Car, battery pack, NodeMCU V1.0 and Motor Shield) together. The holes of the motor shield fit perfectly into the holes of the acrylic chassis and the kit comes with enough screws and nuts to attach it. Also the battery pack can be screwed easily onto the chassis. The way I placed the components onto the chassis left only little space between the motor shield and the battery pack which made it hard to attach the wires with the terminals.

Programming the Car from the Arduino Environment

The inventors of the kit have sample code for LUA on their website. But I decided to try to program the car with the Arduino IDE. And that is really easy: 4 pins control the engines. Pins 4 and 5 (Arduino Terminology) control the speed of the engines with PWM in a default range of 0..1023 while pins 0 and 2 define the direction the engines will turn. 0 is backwards and 1 is forward but this might depend on who you wired the engines up to the shield. In my case I had to swap the wires of one of the two engines so a “1” would symbolise the same direction for both engines.

First I wrote a little Arduino sketch to test if everything was working alright and if I understood the interface correctly. From there I incrementally improved the code and I’m now able to steer it with any device with a modern browser, a built in accelerometer by just balancing the device in the direction I want to car to move. While it is still far from perfect it works surprisingly well: a javascript program reads out the accelerometer of the controlling device (e.g. an iPhone) and sends AJAX requests to the WiFi connected Smart Car. These commands are then taken to steer the motors.

In this scenario a big part of the logic is in the javascript code. While this could be hosted on the ESP8266 EEPROM I decided to load it from an external server which makes it really easy to program: I only have to change the file on the remote server. The ESP8266 firmware remains unchanged for most of the time.

To connect to the device you only have to find out the IP that has been assigned to the NodeMCU. Then open that IP in your Smart Phone browser and move level your device to steer the car.

Here is a little video of that setup:

Source Code:

https://github.com/squix78/esp8266-projects/tree/master/arduino-ide/wifi-car

Shopping List:

Complete Kit from Banggood (~USD $23)
Motor Shield for NodeMCU V1.0 (~USD $5.30)
Kit NodeMCU + MotorShield (~USD $11.60)
Smart Car Kit (~USD $12)

ESP8266 contribution from Zurich to #FIFAgate: At least data is not corrupt!

Daniel Eichhorn — Thu, 28 May 2015 09:34:00 +0000

I recently discovered the Node Red tool and almost immediately fell in love. I was about to write something like that myself when I found out about it and so far it does everything the way I would expect it: you could call it if-this-than-that for your home automation/internet of things projects.

I needed a high activity Twitter hash tag. What could be more
active today than #FIFAgate?

My first little project was to pass on a twitter feed through MQTT to a NodeMCU ESP8266 module with an attached OLED display. It was super easy and even more versatile than I expected. I can now shift away the logic from the ESPs which are always short on RAM to the central node running on a Raspberry Pi. The stream can then easily be setup in the browser. As soon as you press “deploy” the changes will become visible on the OLED display.

The twitter flow: get the tweets from twitter, beautify them a little
throttle the news feed to not overload the ESP and send them to the
ESP over MQTT.

The data flow: Twitter, Node Red, NodeMCU (Lua), Oled display

ESP8266 Projects: Internet Connected WeatherStation with beautiful icons

Daniel Eichhorn — Sat, 23 May 2015 14:10:00 +0000

Since I learned how to create pictures and display them on these wonderful OLED displays I wanted to build something useful with it. Once you know about all the pieces, putting them together is quite easy.
The icon, temperature and humidity are updated every 10 minutes from http://openweathermap.org/, then parsed into a JSON object.

SSD1306 128×64 with the web based weather station.
The data is fetched from openweatherchannel.com.
It also displays the last update time.

Wiring

Source Code

By the way, the WeatherStation Kit is available at the shop: https://shop.squix.ch

ESP8266, NodeMCU: how to create xbm images for displaying on OLED 128×64 I2C Displays

Daniel Eichhorn — Thu, 21 May 2015 18:51:00 +0000

Do you know these wonderfully cheap SSD1306 based OLED displays with the crispy display? For a while now the NodeMCU Lua firmware for the ESP8266 supports them and has a rich feature set to draw lines, circles and even bitmaps.
One way to draw bitmaps is in the XBM format, which is originally a text based format and they can be directly included into C code:

#define clouds_width 60
#define clouds_height 60
static unsigned short clouds_bits[] = {
   0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
   0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
   ...
   0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
   0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
   0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 };

When looking at the examples on the NodeMCU Github page the xbm file looks a bit different:

fff ffff 3fff ffff ff3f e0e0 ffff 3fe3
e1ff ff3f f3f1 ffff 3ff3 f1fe bf37 f311
1c1f 30f3 0108 8c20 f301 00c0 39f3 81c7
c139 f3c1 c7c9 38f3 c1c3 193c e389 0198
3fc7 1800 083e 0f3c 701c 303f fffc 8731
ffff bfc7 2301 0000 c623 0300 000e 30ff
ff3f 1f3c ffff 3fff 3fff ff3f ff3f ffff
ffff 3fff ffff ff3f

[the_ad_placement id=”inpostplacement”]

So how to you get your images in the right format? The NodeMCU Api documentation for drawXBM gives a good hint, but I had to apply a minor tweak which turns out to simplify things further:

Go to: http://www.online-utility.org/image_converter.jsp
Select MONO aus Output format AND press “Select format” (Who has invented THAT UI???)
Upload your image. I was succesful with a monochrome PNG file, whereas the XBM only resulted in an error.
Upload the created MONO file to your ESP8266 and use it with a code like this:

-- setup I2c and connect display
function init_i2c_display()
     -- SDA and SCL can be assigned freely to available GPIOs
     sda = 5 -- GPIO14
     scl = 6 -- GPIO12
     sla = 0x3c
     i2c.setup(0, sda, scl, i2c.SLOW)
     disp = u8g.ssd1306_128x64_i2c(sla)
end

function xbm_picture()
     disp:setFont(u8g.font_6x10)
     disp:drawStr( 0, 62, "Rainy   8C")
     disp:drawXBM( 0, -5, 60, 60, xbm_data )
end

function bitmap_test(delay)
     file.open("clouds.xbm", "r")
     xbm_data = file.read()
     file.close()

      disp:firstPage()
      repeat
           xbm_picture()
      until disp:nextPage() == false

      tmr.wdclr()
end

init_i2c_display()
bitmap_test()

SSD1306 OLED 128×64 display,
connected to a NodeMCU DevKit V1.0

You just need to connect four pins of the display

to the NodeMCU

Update 11 June 2015 – Batch Processing

In case you have many images to convert to xbm you might consider installing imagemagick and do it with a few lines on the command line. This example assumes that you want to resize your source png’s into xbm format of 60×60:

mogrify -resize 60x60 +dither -format xbm *.png
cat *.xbm | sed s/static/const/ | sed s/=/PROGMEM=/  > icons.h

You will still need to do a bit of hand processing, for instance adding the PROGMEM command, so the images can be handled more efficiently.

Source

https://github.com/squix78/esp8266-projects/tree/master/simple-oled-example

Shopping Links:

White on Black Display, 128×64 on Banggood: http://www.banggood.com/0_96-Inch-4Pin-White-IIC-I2C-OLED-Display-Module-12864-LED-For-Arduino-p-958196.html?p=6R31122484684201508S

ESP8266 module comparison: ESP-01, ESP-05, ESP-12, ESP-201, Test Board and NodeMCU

Daniel Eichhorn — Mon, 16 Mar 2015 01:05:00 +0000

In this post I will guide you through the jungle of available modules based on the ESP8266. This is not a complete list of available modules but a selection of the ones I could test and review. If you think that I have been missing out on one important module please let me know.Every module here as some advantages and disadvantages, depending on the targeted application. If you are planning to to use a module as Wifi shield for an Arduino you might pick a different type than if you´re planning a standalone node. Other aspects are breadboard compatibility, availability of pins, need for external components such as a serial-to-usb adapter as well as size and costs.

The following tables summarise this post, if you are too much in a hurry to read the whole article:

Comparison of Raw Modules

	ESP-01	ESP-05	ESP-12	ESP-201	Testboard

GPIO Pins	2	-	11	11	11
ADC	-	-	1	1	1
Antenna	PCB	PCB	PCB	External/PCB	PCB
USB-To-Serial	No	No	No	No	No
Breadboard friendly	Medium	Good	Bad	Good	Bad
Form factor	Small	Small	Medium	Big	Very Big
Price	~$3	~$3	~$3	~$3	~$6.50
Application	Simple Standalone mode or wifi shield for Arduino	Wifi Shield	Standalone	Standalone	Prototyping
Where to buy?	Banggood	Banggood	Banggood	Banggood	Banggood
Detail Post	Post	-	-	Post	Post

Comparison of Development Modules

	NodeMCU V0.9	NodeMcu V1.0	Wemos D1 Mini	Wemos D1 R2	LoLin V3 NodeMcu Board
Branded	NodeMCU	DOIT	Wemos	Wemos	LoLin

GPIO Pins	11	11	11	11	11
ADC	1	1	1	1	1
Antenna	PCB	PCB	PCB	PCB	PCB
ESP8266 Module	ESP12 (AI-Thinker)	ESP12E (AI-Thinker)	ESP12E (Wemos)	ESP12E (Wemos)	ESP12E (Ai-Thinker)
USB-To-Serial	Yes	Yes	Yes	Yes	Yes
Serial Chip	CH340G	CP2102/CH340G	CH340G	CH340G	CH340G
Breadboard friendly	Bad (covers many pins)	Very Good	Very Good (after soldering)	Bad (Arduino Form Factor)	Bad (Covers many pins)
Form factor	Big	Big	Medium	Very Big	Big
Price	~$6.40	~$6	~$6	~$6.50	~6.50
Application	Development Beginner	Development Beginner	Development Advanced (soldering required)	Development Form compatibility with Arduino Shields	Development Beginner
Where to buy?	Banggood	Banggood Gearbest Aliexpress	ThingPulse Banggood Aliexpress	Banggood	Banggood
Detail Post		Post

[toc]

ESP-01

This is probably one of the most popular modules, although it is by far not the most convenient one. With its small form factor (24.75mm x 14.5mm) it fits nicely into any enclosure. Two GPIO pins are led out and can be used to control periphery. With proper wiring and a serial-to-usb adapter you can also easily flash alternatives firmwares on it. By default it comes with one of the different versions of the AT firmware which allows you to use it in combination with an Arduino. One of the biggest problems of this module is the placement of the pin posts which makes it impossible to plug it directly into a bread board for prototyping: the two rows of posts are so close to each other that you would get a short-cirtcuit. However you can still use this module on a breadboard: either build a bread-board adapter or use female-to-male dupont wires to wire the module to your bread-board.
Update: There are now also versions of the ESP-01 available with 1MB Flash, compared to the earlier 512MB

ESP8266 ESP-01 module

ESP-05

This module is very simple and has one purpose only: use it as mini wifi shield together with your Arduino or similar micro controller. There are different versions available: a four pin version that only has 3.3V, GND, RX and TX. Over the later ones you talk with your Arduino. Another version has an additional reset pin which allows you to manually or programatically reset the module.

This module nicely fits into a breadboard since the module has only one row of pin posts. But (and there is always a but) you are stuck with the delivered firmware unless you are willing to do some lead cutting and soldering of some pins. According to the forums not all boards come with the same AT firmware version.

ESP8266 ESP-05 module

ESP-12

This module allows you to access many features of the ESP8266: 11 GPIO pins, one analog-to-digital converter (ADC) with a 10 bit resolution. It also lets you easily configure deep-sleep mode which (according to this source) lets you run the module for 3 years on two AA batteries. With one drawback: it is not breadboard friendly at all. As for the modules previously described here the antenna is a track on the PCB which delivers good results for Wifi sensitivity.
But to use it for prototyping you´ll have to build something around the module. You can order these breadboard adapters or build one yourself, like my colleague Andi did:

ESP8266 ESP-12 plus self made bread board adapter
(thx to Andifor the picture)

There is also an almost-ready breadboard adapter available here.
Thanks to its good availability and the rich access to the chip pins it is also widely used for aggregated modules, such as the test board I describe later in this post or the first version of the NodeMCU module. If you are planning to use the ESP8266 as a stand alone node the chances are good you will end up with this module in one way or the other.

[the_ad_placement id=”inpostplacement”]

ESP-201

Originally named as ESP-12 this module has come to popularity as ESP-201 after the name clash had been discovered. In good old BASIC line adressing style the creators apparently wanted to make sure that no other name clash would occure and added a safety distance to the numbering scheme;-)

It is currently my preferred module for prototyping since it is breadboard friendly and offers similar access to the chip pins as the ESP-12 does. I say breadboard friendly with two remarks: the four pins at the head of the module keep you from directly plugging the module into a breadboard. But you can easily bend them to ninety digrees or unsolder them and place them on the upper side of the module. The second note is that the module itself hides many pins of the bread board for direct access and leaves only one row visible on each side of the module. If you need more you will have to extend a 5-pin row by connecting it to annother row on your breadboard. The board comes with a printed PCB antenna but also with a connector for an external one. This makes this module also a perfect candidate if you need to bridge a longer distance with your Wifi module. You can then easily replace the package wire antenna with a high-gain antenna and improve the sensitivity even farther.

ESP8266 ESP-201 with pin-out description

Test Board

There are various test boards available. Check the links and view the picture below to see what I´m describing here. This test board comes with a battery pack and various preconfigured LEDs and one light dependent resistor connected to the ADC. It integrates an ESP-12 as described earlier in this post and makes all the pins available to your convenience. It also has a jumper which you can set when flashing a new firmware. The board comes with a voltage regulator that steps down the 4.5 Volt from the battery pack to the 3.3V that the ESP8266 needs. You can easily replace the battery pack with the power lines of a USB connector, as I described here.

I see two kinds of applications for this board: run a standalone node somewhere without a wired power adapter is the first only from the attached battery pack. You can use a tiny bread board if you need to connect sensors to the test board and even glue it on the module. Just make sure to not cover the PCB antenna for better antenna reception.

The second application is to quickly test program code with the simplified periphery of the many LEDs and the light dependent sensor which is connected to the ADC. Update: I have this board running on the 3 AA batteries for more than 1000 hours (>40days) already. See the article here

ESP8266 test board with pin-out description

NodeMCU module V0.9 (Outdated)

This module is somehow quite different from the modules described earlier in this post. It comes with all you need to get started since it already has a built-in serial-to-usb adapter and comes with a micro USB plug for power supply and for programming the module.

I had high hopes on this module since in theory it should make development of applications based on the ESP8266 much easier: less wiring is required compared to any of the other modules, you need neither an external power supply nor a serial-to-usb adapter and two switches allow for easy resetting the module and booting it into flash mode. And it nicely fits into a bread board and lets you wire periphery with the fewest amount of wires imaginable.

Reality looks currently a bit different: on my Mac I could not flash the module with the built in serial-to-usb adapter even after installing the latest driver available. I then had to fall back to an external serial-to-usb adapter. For me this was not a big issue since I don´t flash new firmwares that often and I was already in possession of an external serial converter. After I had flashed the latest version of the NodeMCU Lua firmware I could use the built-in converter just fine. The second problem is that the current form factor of the module covers all the pins on a bread board in the area of the module. To use the pins you will have to insert bridges which lead from under the module to a visible part and insert the module again. And you can only to this for a limited number of pins.

Due to the higher price of this module you will most likely use this module during development time. Once you have completed the software and all the required external components you might use one of the other modules or you will design a completely new module which integrates all the required components

At the time of this writing only the first version of the NodeMCU module is available and that is what I´m reporting here. In the next few days (or weeks) the team that created the first module will publish an improved version which will fix the mentioned problems of the first version. I´m looking forward to test the new version as soon as it becomes available. Once these issues have been resolved this module certainly has all it takes to become an interesting all-in-one alternative to an Arduino based internet-of-things node. UPDATE: don’t order this version anymore, consider the NodeMCU V1.0 instead (see below)

ESP8266 NodeMCU module (version 0.9)

NodeMCU module V1.0

A few weeks ago the NodeMCU team published their new design and I have to say that it is a huge improvement over the first issue. I tested it with both the NodeMCU LUA firmware and the Arduino IDE. It incorporates the new ESP-12E module with 4MB of flash memory and also has a few more pin-outs.

Compared to the V0.9 variant the V1.0 is more narrow and leaves one row of pins on each side on a standard breadboard which is just perfect for prototyping. Another nice feature is the fact that you don’t even have to press the reset/flash button combination in the Arduino IDE to upload a new version of your code. Somehow the board or the software handle this automagically. And with the latest published version of the Arduino/ESP8266 board configuration you can configure upload speed to 921600 baud with which the upload finishes just within a few seconds.

All in all, this is the long awaited development board that you want to have and play with. The price is slightly higher than with the other boards, starting from around $8 for a potential clone, but it is totally worth it because you are saving all the additional hardware like serial-to-usb converter.

New improved version of the NodeMCU V1.0.
Now fits very nicely on a breadboard and also the Serial-To-USB
converter works very well.

I created a Fritzing part for the NodeMCU V1.0 that you
can use to draw up your circuits. Read all about it here

Summary

Which module suits you best depends on your application. If the price and small form factor is important for you and you are looking for a stand alone module with just two GPIO pins, the ESP-01 is your candidate. If you just want cheap Wifi connectivity for your Arduino you might go for the ESP-05. The ESP-12 might be interesting if you have periphery based on SPI or I2C bus or if you just many GPIO pins and you are not afraid of a bit of soldering. The ESP-201 is good for solder-free prototyping on a bread board and allows you to access almost all pins of the ESP8266 chip. But you´ll still need an external serial-to-usb converter and a power supply. In case you want it even easier and the slightly higher price is not a problem I would recommend the NodeMCU V1.0 module for you. The following table summarises this post:

Raw Modules

	ESP-01	ESP-05	ESP-12	ESP-201	Testboard

GPIO Pins	2	-	11	11	11
ADC	-	-	1	1	1
Antenna	PCB	PCB	PCB	External/PCB	PCB
USB-To-Serial	No	No	No	No	No
Breadboard friendly	Medium	Good	Bad	Good	Bad
Form factor	Small	Small	Medium	Big	Very Big
Price	~$3	~$3	~$3	~$3	~$6.50
Application	Simple Standalone mode or wifi shield for Arduino	Wifi Shield	Standalone	Standalone	Prototyping
Where to buy?	Banggood	Banggood	Banggood	Banggood	Banggood
Detail Post	Post	-	-	Post	Post

Development Modules (with Serial Converter)

	NodeMCU V0.9	NodeMcu V1.0	Wemos D1 Mini	Wemos D1 R2	LoLin V3 NodeMcu Board
Branded	NodeMCU	DOIT	Wemos	Wemos	LoLin

GPIO Pins	11	11	11	11	11
ADC	1	1	1	1	1
Antenna	PCB	PCB	PCB	PCB	PCB
ESP8266 Module	ESP12 (AI-Thinker)	ESP12E (AI-Thinker)	ESP12E (Wemos)	ESP12E (Wemos)	ESP12E (Ai-Thinker)
USB-To-Serial	Yes	Yes	Yes	Yes	Yes
Serial Chip	CH340G	CP2102/CH340G	CH340G	CH340G	CH340G
Breadboard friendly	Bad (covers many pins)	Very Good	Very Good (after soldering)	Bad (Arduino Form Factor)	Bad (Covers many pins)
Form factor	Big	Big	Medium	Very Big	Big
Price	~$6.40	~$6	~$6	~$6.50	~6.50
Application	Development Beginner	Development Beginner	Development Advanced (soldering required)	Development Form compatibility with Arduino Shields	Development Beginner
Where to buy?	Banggood	Banggood Gearbest Aliexpress	ThingPulse Banggood Aliexpress	Banggood	Banggood
Detail Post		Post

Applications/ Development Kits

I have to admit, this is a bit of shameless advertisement;-). But if you came here because you are interested in IoT and you are probably getting started you might profit from a ready-to-go development kit. One of my most successful projects with the ESP8266 is the WeatherStation. It displays current weather information and forecasts it downloads frequently from the web on a beautiful OLED display. And this is just the starting point. You can use the included libraries to display data from other sources (stock information, sport results, etc) available on the net. And: I sell it as a development kit in my shop. ESP8266 WeatherStation with shipping available to almost all countries.

The WeatherStation Kit displaying a 3-day forecast

The components included in a WeatherStation Kit:
NodeMCU V1 with 4MB flash, 128×64 pixels OLED display,
USB cable and jumper wires. Available now in the shop:
ESP8266 WeatherStation

ESP8266: ESP-201 breakout board review

Daniel Eichhorn — Sat, 07 Feb 2015 19:57:00 +0000

Today finally a new package from China arrived containing an ESP8266-ESP201 bought on aliexpress. I had ordered two pieces and each came in a little plastic bag and stuck in protective foam. The bag also contained a tiny antenna that can be plugged into the connector on the board.

Pin layout to your convenience: when plugged into a breadboard
you cannot read the labels on the lower side of the PCB
Please Note: GPIO15 remains connected even after flashing

Board

I ordered the ESP-201 board because I was looking forward to finally own an ESP8266 module which was compatible with my bread board. Annoyingly the connectors for power supply and serial connection are placed in a way which by default doesn’t fit into a normal breadboard. You can however use pliers to bend the four pins in a 90 degree angle so that you can attach the connectors right to it (see picture):

ESP8266 ESP-201: bend TX, RX, 3.3V and GND
pins to fit the module into a bread board

Another annoying design mistake is that the labels for most of the pins are on the bottom side of the PCB. You can’t read the labels when the module is sitting on the bread board. Because of this I drew up the pin layout above. I hope it will help you…

The bottom side of the ESP201. As
you can see, the pins are nice labeled,
just on the wrong side

Flashing Firmware

It took me a while until I figured out that I also had to connect GPIO15 to ground in order to get the board running. After that flashing worked fine and I could transfer the NodeMCU firmware without further problems to the chip.

Available Pins

It seems that all the usual pins are available. See this table here for mapping from the labels on the bottom of the field to the once often used in forums and other sources: https://github.com/esp8266/esp8266-wiki/wiki/Pin-definition

Especially noteworthy is the availability of the T_OUT pin which is the analog-digital-converter (ADC). I’m not 100% sure what the D0,D1, D2 and D3 pins are for. It might be that the are used for the SDIO mode, where you boot from a SD card.

Antenna

The board appears to have a built-in antenna but also offers a connector to the antenna that came with the package. The following table shows the average signal strength of (anonymized) access points in my neighbourhood after running the wifi.sta.getap command on the lua firmware 100 times. Once with the external antenna and once without:

	# of access point listed		avg signal strength [dbm]
	w/ ext antenna	w/o	w/ ext antenna	w/o
AP-1	100	97	-70	-82
AP-2	93	18	-88	-92
AP-3	2	0	-92	n/a
AP-4	94	1	-86	-94
AP-5	4	0	-93	n/a
AP-6	16	0	-89	n/a
AP-7	99	97	-80	-84
AP-8	19	0	-91	n/a
AP-9	5	0	-92	n/a
AP-10	100	100	-31	-32
AP-11	100	100	-31	-32
AP-12	98	87	-89	-91
AP-13	40	0	-92	n/a
AP-14	4	0	-91	n/a
AP-15	1	0	-91	n/a
AP-16	16	0	-93	n/a
AP-17	13	0	-93	n/a
AP-18	81	92	-89	-92
AP-19	22	0	-90	n/a
AP-20	47	38	-91	-92
AP-21	99	75	-78	-89
AP-22	95	87	-81	-89
AP-23	6	0	-90	n/a

As you can see, 12 access points were not even visible without the external antenna. All others had significantly worse signal strength without antenna. I realize that this test is not highly scientific but it might give you an idea how valuable the external antenna is.

Chip

My two boards are equipped both with the newer ESP8266EX chip. If anybody knows what the difference is to the version without “EX” please let me know. Nodemcu’s node.info() returns these values:

flashisize	flashmode	flashspeed
512	0	40000000

Quality

The board looks well processed but one of the two pieces came with pins not 100% perpendicular to the PCB. However, this doesn’t affect usage since both rows of pins are equally skewed.

Summary

If you don’t mind adapting some of the pins with pliers you get a great test board for a really good price (I paid $4.69, by now it’s even cheaper). Once adapted the module fits nicely into a bread board and you have one row of connectors left on each side of the board. It is a pity that the pins are only labeled on the bottom side but that might be changed in the future. However, for a price only slightly higher than a ESP-01 it is a pretty good module and has many pins more broken out as well. Especially the ADC offers new possibilities for experimentation. Just remember that the ADC measures values between 0 and 1V. The external antenna and the connector on the board is another aspect on the plus side. It is quite impressive how much more sensitivity this 15cm wire yields.

ESP8266, Arduino, Raspberry Pi: introduction to IoT hardware

Daniel Eichhorn — Wed, 04 Feb 2015 19:04:00 +0000

Checkout my presentation about IoT:

ESP8266 with web update: NodeLua, a Spark.io like ESP8266 firmware

Daniel Eichhorn — Sun, 04 Jan 2015 13:07:00 +0000

The ESP8266 chip is really something: cheap and with its Wifi interface capable for Internet-of-Things tasks. You can get boards on Aliexpress for as little as $3, shipping to Europe or US included! OK, so you ordered one, waited (possibly) a few weeks and then it arrived! What do you do with it? How do you program it? I covered a few possibilities in my previous posts: you can use your Arduino and talk with AT commands to the ESP8266, thus saving a lot of money compared to a Wifi shield that often costs $60.- or more. Then you can try to run the ESP8266 standalone. Download the SDK from Espressif (the manufacturer of the chip) and setup your build tool chain and write your own first program in C(++) and write this new firmware to the chip. Or you go for one of the various all-purpose firmwares that allow you to write code directly executed on the chip. I tested two firmwares of this last type in my previous posts: NodeMCU and Frankenstein firmwares. While you write LUA scripts that get interpreted on the chip for the NodeMCU firmware, you get something similar to a busyBox command line interface on the Frankenstein firmware.
I played around with the NodeMCU firmware for a while but you have to upload files to the chip line by line and often the transfer gets interrupted in the middle. It got a little bit better when I switched to a dedicated power supply. But still, uploading code is cumbersome and takes too much time.

A better way of programming…

What I really wanted is a web based IDE like the one used on the Spark.io platform. The Spark Core is an Arduino compatible chip which initially will be connected to your Wifi network. Once connected it can be programmed in the browser: you use the same code as you’d use for an Arduino, save the file and choose “Flash it to my Spark Core” and bang! your Spark Core gets updated! But of course there is a catch: a Spark Core costs around $39.- and this is a lot more than the $3 for a ESP8266 board. But thanks god there are skilled people in the world. Harold Mars is developing something very similar for the ESP8266!

NodeLua

He called his platform NodeLua (apparently not related with NodeMCU) and offers a nice web IDE and one click deployment to the ESP8266, once it you have successfully burned the firmware and connected the device to your Wifi network.

You can even activate a specific ESP8266 to send debug output back to the browser. Another nice feature is the cloud feature: with only two lines of code you can send or receive data from the chip to or from the cloud. This lets you log the humidity in a room with just a few lines to a web chart!

While I think NodeLua is looking very promising it doesn’t yet offer the whole feature set of the NodeMCU firmware. The TCP client and server methods are currently disabled. I also tried to get my DHT22 humidity sensor working, without success.

I hope Harold will continue the great work he has started. It is so much more fun to program in NodeLua’s web IDE than going through the hassle of the Uploader tools like ESPlorer needed for the NodeMCU firmware…

Summary

There are many ways to set the ESP8266 to use. My current favourite is the NodeLua firmware which lets you program the device in the browser and lets you update it with one simple click. But not all features of the NodeMCU are available yet on the NodeLua firmware, so give it some time (or just give it a try;-))

ESP8266: Internet connected baby nightlight for less than $10

Daniel Eichhorn — Sun, 28 Dec 2014 11:39:00 +0000

A while ago a wanted to build one of those nightlights for my daughter that tell her when to sleep and when to call for the parents: an orange light behind a sun depicts the day, a blue light behind a moon the night. My first attempt was based on a Spark Core which is a bit pricy (~$40) to just connect to the internet to synchronise the time.
Playing with the ESP8266 I needed an actual project to use it and the nightlight came in handy. It uses both GPIO pins available on the ESP8266-ESP01 and calls google.com to synchronise the time every 30 minutes as soon as the device is connected to the access point. I currently still need an Arduino but just as power source and debugging tool. So the actual components are:

plastic box (from food delivery)
black paper as mask
sun and moon downloaded and printed from the internet
cardboard from a cereal box to shield the LEDs
2 LEDs (orange and blue)
a mini bread board
an ESP8266
2 resistors
some jumper wires

Prepare the ESP8266

First you need to put the LUA firmware from nodemcu on the ESP8266. I described in this post how it is done. Once this is done you can use the Esplorer to transfer lua files to the ESP8266.

Check out the code and adapt it

Checkout the two lua files from here and adapt them to your needs. Especially your access point and credentials need to be set in the init.lua file. If you’re not living in the GMT+1 timezone you’ll also need to adapt your offset in the nightlight.lua script. In the current version the day/night phases can only be set within the code, but this might change in the future. There is a lightweight webserver available for the lua firmware which might allow setting the time through a web browser.

Transfer the files to the ESP8266

The current version of the firmware crashes and restarts the unit if you try to call the dofile function for a non-existing file. Since the init.lua scripts calls the nightlight.lua script transfer them in the appropriate order (first nightlight, then init). Note: I had some cases where the module would connect to the AP and receive an IP but would further fail to call the google server to get the time. This only happened after clean updates of the firmware and disappeared after a short while.

Sources

Lua firmware
Esplorer (ESP8266 IDE)
ESP8266 example for google time client (thanks to GeoNomad)