The ESP8266 is a remarkable piece of hardware. What we originally thought — and what was originally marketed as — a simple UART to WiFi bridge with Hayes modem commands has turned into one of the best embedded platforms around. It’s a powerful little microcontroller, it has WiFi, and it can send raw frames. That last bit is awesome, because it allows for some mischief or mirth making, depending on your point of view.

For his Hackaday Prize entry, [Tejas] is building a WiFi Jammer with an ESP8266. It’s a small device that is able to disconnect anyone from a WiFi AP. Should you build it? No. Can you? Sure, why not.

Wifi Hacking using ESP8266

Based on
NodeMCU ESP8266 Lua multi-mode WiFi hacking kit
https://hackaday.io/project/20072-wifi-hacking-using-esp8266

Once a luxury, sitting has now become an ailment. Have you yet wondered to just how many times in a day you sit or to what percentage of your day is consumed on bended knee? Making use of a resistance sensor and a NodeMCU ESP-12E, we are able to track our daily lethargy and display it in all of it’s aggregated misery. Amend as needed.

We love little tricks like this. Suppose that you want to generate an IR remote’s signal. It’s easy, because most of the codes are known. But it can be slightly harder because most IR remotes and receivers modulate the on pulses with a square wave at roughly 38 kHz for background lighting immunity.

With a competent PWM generator on a microcontroller, you can create this carrier modulation easily enough yourself. Set the PWM frequency to 38 kHz and the duty cycle somewhere in the 33%-50% range, and you’re set. But what if you don’t have a competent PWM generator? Such was the case that prompted [AnalysIR Blog] to fake it, with USART.

Here’s the trick. You set up the serial port to communicate at ten times the desired carrier frequency, and then transmit “special” data.

ESP8266 NodeMCU Backdoor uPWM Hack for IR signals
https://www.analysir.com/blog/2016/07/06/esp8266-nodemcu-backdoor-upwm-hack-ir-signals-using-uart/

Most posts we have read suggest that there is no PWM readily available on any of the supported platforms. As we have already shown with Arduinos and the Particle Photon we figured it would be possible to use a spare UART pin on the ESP8266 NodeMCU to achieve our goal.

This time we were successful and the ESP8266 NodeMCU Backdoor uPWM Hack for IR signals using works!

The Hack
Quite simple really – just set the baud rate to 10 times the desired Infrared carrier frequency and send a ‘magic’ 8 bit character to achieve the desired duty cycle. Of course we need to take the 1-start bit and 1-stop bit into account plus the 8 bits in each character.

In summary, sending the following characters will generate the associated duty cycle, as follows:

0xF0 – 50%
0xF8 – 40%
0xFC – 30%
0xFE – 20%
0xFF – 10%

This is more than sufficient for most, if not all IR systems, which would typically use 50% or more commonly 33%.

WiFiMCU
Design for IoT
Simplicity、Reliability：STM32F4+WiFi(Broadcom)+Lua
http://www.wifimcu.com/

WiFiMCU is developed based on EMW3165. Run the Lua script directly; operate hardware resource; achieve product prototypes. EMW3165 is a low-power embedded WIFI module, which is developed by the Shanghai MXCHIP Technology Co., Ltd. It incorporates a WiFi RF-Chip and a microcontroller based on STM Cortex-M4. The WiFi module includes a “self-hosted” WiFi network library and application components. In addition, It also provides 2M bytes of out-chip flash, 512K bytes of on-chip flash, 128K bytes of RAM and a rich peripheral resources.

I decided to design my own lamp using an analog RGBW LED strip. This board I designed will give you the tools to design your own WIFI controlled light source.

The board’s controller is run by the NodeMCU which is connected to a N-Channel MOSFET for each color of the RGBW LED strip. Trimpot for brightness and 2 user buttons (that can be setup to change modes, possibly) were also added. A 5v regulator was then added so the power can be shared with 9-12v input for the LED strip. The nodeMCU will be wirelessly updatable as well.

My idea is to have the nodeMCU be a web server for direct control via a web page. The site will have various configurations including color options, number of channels, animations (like fade effects) and a timer. I’d like to have it connect to MQTT server to integrate with larger servers such as openHAB.

Last time on Minimal MQTT, we used a Raspberry Pi to set up an MQTT broker — the central hub of a home data network. Now it’s time to add some sensor and display nodes and get this thing running. So pull out your ESP-8266 module of choice, and let’s get going.

DSCF8443For hardware, we’re using a WeMos D1 Mini because they’re really cute, and absolutely dirt cheap, but basically any ESP module will do. For instance, you can do the same on the simplest ESP-01 module if you’ve got your own USB-serial adapter and are willing to jumper some pins to get it into bootloader mode.

We’re using the NodeMCU firmware because it’s quick and easy to get running. But you’re not stuck with NodeMCU if you want to go it alone: MQTT has broad support. [TuanPM] ported over an MQTT library to the native ESP8266 SDK and of course there’s espduino, a port for an Arduino-plus-ESP combo. He also ported the MQTT module to NodeMCU that we’ll be using today. Thanks, [TuanPM]!

Head over to NodeMCU custom builds and build yourself a custom firmware with only the modules compiled in that you need. Here, I’ve included dht, file, gpio, mqtt, node, tmr, uart, wifi, and ws2812.

To upload the NodeMCU firmware to the ESP8266, I use esptool.py, which should work on any platform that Python runs on.

MQTT in NodeMCU

So let’s get a little experience with MQTT on the NodeMCU platform. The online documentation is pretty good, so open that up to follow along. The MQTT library centers around the mqtt.Client() object and its methods, connect(), publish(), subscribe(), and close(). When you create the client, you can also register some callback functions that you’d like to be triggered by certain events, namely connect, offline, and message for when the client connects, goes offline, or receives a message.

If you’ve got your broker set up from last time, let’s send it some messages and monitor them on the broker. Open up a window on the Pi and type mosquitto_sub -h localhost -v -t home/#.

The node’s MQTT client needs an ID, keepalive time in seconds, username and password, and a clean-session flag. Connecting to the server can be as simple as specifying its IP address, and publishing takes the usual topic, message, QoS, and retain flags.

The client code continually listens for messages or state changes, and sends the appropriate strings to the client:on() function that then runs your code when the named event occurs. It’s a lot like the way Javascript uses callbacks, if you’ve done any of that.

The WeMos module I used has DHT-11 and DHT-22 shields available. The sensor is hooked up to NodeMCU pin D4, which is GPIO2 in the ESP8266 datasheet. The NodeMCU DHT library docs for using the DHT units are short and sweet, with one function that you’ll care about, dht.read().

As mentioned above, NodeMCU runs many commands asynchronously. That means that we can’t just write code that says “do this, wait for a return value, and then do that” like you often do in C or C++, because the first function doesn’t block. Everything happens almost at once. The upside of this is that we call m:subscribe() and it just runs in the background. The downside is that when we don’t want everything happening at once, we need a timer.

Say we want to publish the temperature of our sensor every ten seconds. We set a repeating timer, for ten seconds, that calls our publishing function, and we’re done. The timer command runs as soon as it is called, but the function that the timer contains is only called periodically

Typing code directly into the nodes clearly won’t do. We need to store our code on the device. NodeMCU has an emulated filesystem that we can use to upload our code to.

Anyway, the ‘standard’ way of compiling programs for this neat little chip involves installing a cross-compiling toolchain on a Linux computer (or VM), and then using a dedicated tool to flash your program to the ESP8266.
As you can guess, this can quickly get tiring if all you want to do is blink an LED… but then I stumbled upon NodeMCU and Domoticz.

NodeMCU is an open-source firmware and development kit that helps electronics enthusiasts to prototype IoT products within a few Lua script lines. Concretely, it is a firmware you can flash to any ESP8266 board, which will then interpret a text file which contains your commands.

Getting data isn’t particularly useful if it can’t correctly be stored and displayed to the user.
Domoticz is a Home Automation System that lets anyone monitor and configure various devices like lights, switches, various sensors/meters like temperature, rain, wind, UV and much more. It is open source, can be installed on Linux, Windows and embedded devices.
In my case I had it installed on my usbarmory and could access it in my browser in less than 10 minutes. You’ll find Domoticz main user manual here.

In the Domoticz interface, simply add a virtual device of “light/switch” type and use this domoticz.lua script

Second Small Project: DHT22 Temp & Humidity Sensor

Third Small Project: Sleep Cycle Monitor

Fourth Small Project: Switching on Lights by Tapping on Furniture

Doing More with NodeMCU and Domoticz

As you can guess I’ve shown here basic examples of the capabilities of the NodeMCU + Domoticz combo. Domoticz allows much more complex actions using scripts which can be triggered by the output of your installed sensors.
In my case I’m only using the monitoring capabilities of Domoticz, even though its main purpose it to automatize your complete home!

Do you have loved ones who live far away? Or do you just want an interesting starter ESP8266 project to get your feet wet? If the answer to either of these questions is “yes”, we’ve got just the project for you. [Craig Lindley] built a “thinking of you” button-and-LED display device that helps people keep in touch, in a very simple way.

We like the minimalism of the design. One party presses their button, electrons flow, WiFis WiFi, data travels through a set of tubes, and an LED far away glows a pre-arranged color.

The code is available in a zip file
http://www.craigandheather.net/misc/Lindley_ThinkingOfYou.zip

Thinking Of You Page
http://www.craigandheather.net/celethinkingofyou.html

The ToY devices are built using an inexpensive module called a NodeMCU Amica that incorporate a ESP8266-12 WiFi module with embedded application processor.