I got interested interested in ESP8266 WiFi module after reading New Chip Alert: The ESP8266 WiFi Module (It’s $5) article. Why is it cool? It’s a WiFi module with an SOC, making it somewhat similar to TI’s CC300. ESP8266 is an UART to WiFi module that you can pick for less than $5 USD.
ESP8266 is a really cheap and easy way to connect any small microcontroller platform (for example Arduino) wirelessly to Internet. The microcontroller on the module takes care of all the WiFi, TCP/IP stack, and the overhead found in an 802.11 network. It’s addressable over SPI and UART, making this an exceptionally easy choice for anyone wanting to build an Internet of Things thing. You can use AT commands to connecyt to WiFi networks and open TCP connections without need to have TCP/IP stack running in your own microcontroller: You can simply connect any microcontroller to this module and start pushing data up to the Internet. This might be why it seems that ESP8266 has pretty soon become every hacker’s favorite WiFi chip.
The ESP826 module I bought from Electrodragon is simple having only the ESP8266 IC and one other IC in it. The WiFi antenna is integrated to circuit board. The whole module is just size of post stamp.
The other side of the he module des not have any components, just 8 pins I have attached wires to in this picture.
There’s a catch, right, there’s always a catch on the cheap products. One thing is that ESP8266 pretty much doesn’t exist outside China. Ordering from China is not a problem nowdays, but when all the documentation is in Chinese, that can be a problem. But fortunately there has been projects to get ESP8266 translated data sheet.
I had enough information, so I need to get one module to test. I ended up ordering ESP8266 module from Electrodragon (check module data). ESP8266 from Banggood.com would have been cheaper bit taken longer time to get because ESP8266 module was listed to out of stock at the time.
The module and IO pins run at 3.3V. For testing I used USB To RS232/TTL PL2303HX Cable Adapter and 5V to 3.3V regulator module to do the connection. I used separate 3,.3V regulator module because I wanted to guarantee that the module can get enough current (over 200 mA on peaks) (some other USB-serial adapter ICs have 3.3V regulators built in them but can’t give enough current out). Wi07c ESP8266 module data and different project examples got me started pretty well.
Test commands at 115200-N-8-1 serial port settings:
AT+RST
AT+CWMODE=1
AT+CWJAP=”SSID”,”PASS”
AT+CWJAP=”AndroidAP”,”XXXX”
AT+CIPSTART=”TCP”,”www.epanorama.net”,80
AT+CIPSEND=0,n: Where n is the length of the request string.
AT+CIPCLOSE
The results with those were promising. Wiring ESP8266 to your favorite microcontroller platform has pretty much everything you would need to do with an Internet of Things thing. That’s good enough, but things are even better.
It has turned out that it is possible to do run your own coode on the module itself: An SDK for the ESP8266 WiFi Chip turns the ESP8266 into something much better than a UART to WiFi module; now you can create a Internet of Things thing with just $5 in hardware. You can write the software using C programming language and GCC compiler to processor in the module (80MHz Tensilica). Included in the SDK are sources for an SSL, JSON, and lwIP library, making this a solution for pretty much everything you would need to do with an Internet of Things thing. Looks interesting, I just have to find time to test that out…
Review articles on ESP8266
First impression on the ESP8266 serial-to-WiFi module
The Current State of ESP8266 Development
Review on the new and cheap esp8266 WiFi module – video
The Current State of ESP8266 Development
Sites on ESP8266 information:
translation of the datasheet and AT command set
Project pages:
Using the ESP8266 module
A Development Board for the ESP8266
ESP8266 and PL2303HX-gpio adventures
Update Firmware ESP8266Cloud Update - also video
A Proof of Concept Project for the ESP8266
The ESP8266 Becomes a Terrible Browser
ESP8266 Retro Browser – Accessing a web site with an ESP8266 serial WiFi module and an Arduino Mega
Keep an Eye on Your Fermenting Beer with BrewMonitor
An ESP8266 Based Smartmeter
Checking Email With The ESP8266 – reads the subject and sender lines from the latest email and displays it on an LCD
ESP8266 Wifi Temperature Logger – using the ESP8266 and Arduino to update a remote Thingspeak server
Adding wifi to a desk lamp with the Wi07C (ESP8266)
Places to order:
ESP8266 module from Electrodragon
SDK:
An SDK for the ESP8266 WiFi Chip
The ESP8266 SDK is finally here – along with a VirtualBox image with Ubuntu that includes GCC for the LX106 core
Source code examples:
331 Comments
Tomi Engdahl says:
ESPeasy
The ESP Easy firmware can be used to turn the ESP module into an easy multifunction sensor device for Home Automation solutions like Domoticz. Configuration of the ESP Easy is entirely web based, so once you’ve got the firmware loaded, you don’t need any other tool besides a common web browser.
We need to replace the existing firmware with the ESP Easy firmware. We provide a (Windows only) flashtool to make this process an easy job.
http://www.esp8266.nu/index.php/ESPEasy
http://www.esp8266.nu/index.php/Tutorial_Domoticz_Switch
To be able to communicate with devices like the ESP, we have to add virtual hardware to Domoticz.
If you have your ESP board loaded with ESP Easy firmware, powerup the unit and an Access point named “ESP_0″ should appear. Connect to this access point and browse to http://192.168.4.1
Configure at least the following settings to get you started:
SSID
WPA
Protocol Domoticz HTTP
Controller IP = your Domoticz server IP
Controller Port = your Domoticz server port, default should be 8080
Select “Switch Input” and enter the IDX found earlier in Domoticz
Now toggle GPIO-0 pin high and low and the light bulb in Domoticz should turn on/off accordingly!
(if you’re using a NodeMCU board, you just have to toggle the “flash” button)
https://domoticz.com/
http://www.banggood.com/DIY-Wi-Fi-Wireless-Switch-For-Smart-Home-With-ABS-Shell-p-1019971.html page says “I flashed ESPeasy on it, and it works great.”
Tomi Engdahl says:
Sarah Jeong / Motherboard:
Oracle v Google trial, which is based on the notion that APIs are copyrightable, hinges on a judge and jurors who don’t have a firm grasp of FOSS philosophy — The problem with Oracle v. Google is that everyone actually affected by the case knows what an API is, but the whole affair …
In Oracle v. Google, a Nerd Subculture Is on Trial
http://motherboard.vice.com/read/in-google-v-oracle-the-nerds-are-getting-owned
The problem with Oracle v. Google is that everyone actually affected by the case knows what an API is, but the whole affair is being decided by people who don’t, from the normals in the jury box to the normals at the Supreme Court—which declined to hear the case in 2015, on the advice of the normals at the Solicitor General’s office, who perhaps did not grasp exactly how software works.
In a world where Silicon Valley is coming into dominance, Oracle v. Google is an unusual instance in which the nerds are getting totally owned by the normals. Their judgment on the technologies they have birthed is being overridden by old people in black robes; their beloved traditions and mythologies around free and open source software are being scoffed at by corporate stiffs in suits as inconsistent hippie nonsense.
Silicon Valley wants to live in a world of its own, where it sets its own rules and writes its own laws. Oracle v. Google does little to change its mind that this is only right and fair.
And to be fair to Oracle attorneys, although the copyleft idealism of the free and open source software movement infects Silicon Valley at its very foundation, Silicon Valley is a capitalist enterprise, and has always had an ambivalent relationship with FOSS.
Oracle v. Google is the revenge of the normals, bringing a hammer down on the customs and practices that the nerds decided for themselves.
Tomi Engdahl says:
ESP Swiss Knife
https://hackaday.io/project/11869-esp-swiss-knife
This battery powered device is a all-in-one toolbox : WiFi AP, 3D printer remote, clock, serial console, sensors hub, and many more…
When I’m working outside my basement, I often need the same tools :
- an arduino + laptop for rapid prototyping
- a wifi access point to easily connect my wireless “devices” (laptop, homebuilt robot, ESP-devices, 3d printer…)
- multimeter / logic analyzer / serial monitor for rapid debugging
- a DSLR intervalometer
…
This is a whole suitcase of tools already…
The device is built around a ESP8266 (ESP-12E actually) and a SSD1306 I2C OLED display. It is battery powered (4xAA for the moment). 2 buttons are used to navigate the interface and activate functions (I may add 2 more buttons and a buzzer later).
Tomi Engdahl says:
Find The Source: WiFi Trangulation
http://hackaday.com/2016/05/29/find-the-source-wifi-trangulation/
Michael] was playing with his ESP8266. Occasionally he would notice a WiFi access point come up with, what he described as, “a nasty name”. Perhaps curious about the kind of person who would have this sort of access point, or furious about the tarnishing of his formerly pure airspace, he decided to see if he could locate the router in question.
[Michael] built himself a warwalking machine. His ESP8266 went in along with a GPS module interfaced with a PIC micro controller. It was all housed in an off the shelf case with a keypad and OLED screen. He took his construction for a nice calming war walk around the neighborhood and came home with a nice pile of data to sort through.
WiFi Triangulation
Triangulate access points using an ESP8266 and a GPS module.
https://hackaday.io/project/11611-wifi-triangulation
ESP8266 I saw it again…
The AT+CWLAP (List Access Points) command return the AP names, their MAC address and the RRSI: Received signal strength indication. I had immediately the idea to try to triangulate that nasty router. So I hooked up a PIC18F25K22 with a GPS module, a ESP8266 (ESP-07 with an external antenna) and an OLED color display. Then I went for a walk…
Tomi Engdahl says:
Continuous Delivery for Your ESP8266
http://hackaday.com/2016/06/08/continuous-delivery-for-your-esp8266/
There’s nothing to be ashamed of. It’s a problem we all have. You change your code a lot — you can’t help it, you just need to tweak one last little bit. And then you have to go downstairs, fetch your ESP8266 module, plug it in to your computer, flash the new firmware in, and then run back down and re-install your wine-cellar temperature monitor. If only there were a way to continuously update your ESP8266 over the air, pulling new code down from your GitHub repository, automatically running your test suite on it, and then pushing it off to the ESP.
OK, it’s ridiculous overkill, but [Daniel] strung together a bunch of open-source continuous integration tools and made them work with the ESP8266. A simple PHP script connects the ESP to the rest of the web infrastructure.
[Daniel] says the word “security” in the same way that gin aficionados whisper “vermouth” over their Martinis. Which is to say, there is none. But for a home solution, or if you want to play around with continuous development, it’s a good start.
ESP8266: Continuous Delivery Pipeline – Push To Production
http://blog.squix.org/2016/06/esp8266-continuous-delivery-pipeline-push-to-production.html
The integration of the ESP8266 framework into the Arduino IDE brought ease of use for development. This was further improved when firmwares could be pushed over the local network to the test devices with the direct over-the-air feature. But what if your ESP8266 devices are no longer in your own network? How can you then update all the devices which are running an older version of your firmware? The Arduino/ESP8266 crew also has an answer for that: the ESPhttpUpdate class lets you download the latest firmware from a web server and replace the old one, required that the available flash memory is twice the size of the firmware.
Continuous Delivery for the ESP8266
We won’t go as far as Continuous Deployment in this post but I want to show you a nice workflow for Continuous Delivery. The workflow I’m describing here is using freely available tools assuming that you are working on an open source project.
The Continuous Delivery process – Developer commits to Github. Travis builds commits. If the developer tags a build as a release Travis will upload the firmware to Github. The ESP’s will frequently check with the PHP script if they are up-to-date. The PHP script on the other hand will use the Github API to compare the ESP tag version with the latest release
I have to admit, it is a relatively complicated workflow.
Tomi Engdahl says:
Wired Networking For The ESP8266
http://hackaday.com/2016/07/01/wired-networking-for-the-esp8266/
The ever popular ESP8266 is popping up in more and more projects. There are CNC controllers, blinkey WiFi lighting, and downright bizarre WiFi to Ethernet bridges. [Cicero] has thrown his hat into the ring with one of these Ethernet-enabled ESP8266 builds, and right now everything works, it’s simple to put together, and cheap to build.
Astute readers will notice we’ve seen something like this before. A few months ago, [cnlohr] discovered the Ethernet controller in the ESP8266. This was, by every account, the hard way of doing things. [cnlohr] was driving the Ethernet directly through the ESP’s I2S bus. [Cicero]’s project does not. It uses the cheap ENC28J60 SPI to Ethernet adapter to put the ESP on a wired network. Is one solution better than the other? That’s arguable. Is one solution much simpler than the other? Yes, [Cicero]’s work allows anyone to add Ethernet to the ESP8266 with a few resistors and a module that costs $3 from the usual online shops.
Ethernet connectivity to an ESP8266 via an ENC28J60
https://github.com/Cicero-MF/esp_enc28j60
This project adds the ENC28J60 to the ESP8266, and allows Sprites HTTPD functionality via a wired connection.
Allows for concurrent connections to the ESP, both via wired connection and wireless to serve the HTTPD proje
Tomi Engdahl says:
Avoiding Exercise with an ESP8266 and Blynk
http://hackaday.com/2016/07/11/avoiding-exercise-with-an-esp8266-and-blynk/
[Mike Diamond] was tired of climbing down (and back up) 40 stairs to check his mailbox. He decided to create a mailbox alert using the ESP8266 to connect to his WiFi. The idea was simple: have the ESP8266 monitor when the mailbox flap opened using a magnet and a reed switch. As always, though, the devil is in the details. [Mike] got things working with a little help and shares not only the finished design but how he got there.
To handle the sending of e-mail, [Mike] used the Blynk app. You often think of Blynk as a way to build user interfaces on an Android or iOS device that can control an Arduino. In this case, though, [Mike] used the library with the ESP8266 and had it send e-mail on his behalf.
ESP 8266 Mailbox Notifier using DeepSleep and Blynk
http://www.whatimade.today/esp-8266-mailbox-notifier-using-deepsleep-and-blynk/
22 June 2016 on ESP8266, Battery, reed Switch, 18650, blynk, deepSleep, mailbox, antenna, U.FL to SMA cable, laptop, low-power, ESP8266-07, notifier, Normally Open, Normally Closed, arduino IDE, BC557 PNP Transistor, IOT
My problem is that I need to descend about 40 steps to get to the mailbox and like so many others obsessed with cheap Chinese electronics, this means constantly running up and down to see if my latest acquisitions have arrived.
Assessing the scenario, he nodded wisely. “It shouldn’t be complicated,” he confirmed. Such words coming from an expert were very encouraging – but didn’t take me far towards my goal. He assured me he’d be on hand if I got stuck.
Blynk
One day, while fiddling, I read about Blynk. Apparently, smart programmers had done the work for me, and all I needed was to:
download the blynk libraries to the Arduino IDE
put the app on my phone
set my board
add a few buttons
get an authentication key from the blynk app
flash the ESP
Even for the non-professional it was very easy, and by the evening’s end, I was controlling an ESP-connected LED from my phone.
My mailbox has a metal flap. The postman opens it, drops the mail inside and walks away.
I thought of using a motion sensor, and even a light sensor, but neither seemed as sensible as a simple magnetic switch (reed switch) that would sense when the flap moved. Such switches are very common in burglar alarms, usually attached to a door or window.
A couple of evenings later I had my first prototype built. I used the ESP 01, attaching the reed switch to GPIO 02. The only other component was a 10k pulldown resistor. My very simple Sketch was taken from the ESP8266 Standalone example in the Arduino (ESP) Blynk library.
The sketch waits for activity on GPIO 2. If it senses something, Blynk sends me an email. It’s that simple.
This very simple setup worked perfectly. Each time I moved the reed switch, Blynk sent me an email.
Why it’s not practical
The problem was, to make it work, the ESP needed to be powered at all times, and it was constantly attached to my WiFi. This meant it needed a substantial power supply (the ESP’s WiFi consumes a relatively large current), and it could never be disconnected.
Explaining my problem to a friend, he told me the ESP can be put to sleep. In theory, I could install the apparatus in the mailbox and it would remain dormant, consuming almost no current. It would only wake up when the switch was activated, and only for the time taken to log on to my WiFi and send the email. As soon as it had done this (about 10 seconds – even less with a static IP), it would go back to sleep.
I played around with this, and to my delight, I managed to put my ESP to sleep.
For my mailbox alert, I didn’t need the ESP to go to sleep for a specified time. Instead I needed it to go to sleep and wake at the “flick of a switch.”
This, it turned out, was more complicated than I thought
My Normally Open reed switch – which was generally closed because of the magnet’s proximity – would trigger the ESP from its dormant state. It would then fire up, connect to my WiFi, send me an email, then go back to sleep. It would then wait for the next occurrence. Thanks to Amir, the circuit and Sketch are build so that even if the mailbox flap doesn’t return to its place, the ESP will go to sleep. It will only be triggered again by the re-opening of the reed switch.
In addition to sending an email, using the ESP’s analog port, a couple of resistors, and a nifty bit of code, the email received also includes the battery voltage – a very significant addition if you’re using unregulated 18560 Lithium-Ion batteries (see below) that mustn’t fall much below 3v.
Connecting the battery through two resistors, (32K,10K) and between them connect the Analog input of the ESP.
Blynk
http://www.blynk.cc/
First drag-n-drop IoT app builder for Arduino, Raspberry Pi, ESP8266, SparkFun boards, and others
Blynk is a Platform with iOS and Android apps to control Arduino, Raspberry Pi and the likes over the Internet.
It’s a digital dashboard where you can build a graphic interface for your project by simply dragging and dropping widgets.
It’s really simple to set everything up and you’ll start tinkering in less than 5 mins.
Blynk is not tied to some specific board or shield. Instead, it’s supporting hardware of your choice. Whether your Arduino or Raspberry Pi is linked to the Internet over Wi-Fi, Ethernet or this new ESP8266 chip, Blynk will get you online and ready for the Internet Of Your Things.
http://www.blynk.cc/getting-started
Emergency Button for 7$, Arduino, WIFI and ESP8266
http://www.instructables.com/id/Emergency-Button/
Deep sleep and wake up using interrupt
https://github.com/esp8266/Arduino/issues/1488
Tomi Engdahl says:
Micropython Binaries for the ESP8266 to be Released
http://hackaday.com/2016/07/11/micropython-binaries-for-the-esp8266-to-be-released/
MicroPython is a Kickstarted project that brings Python to small, embeddable devices. As part of the terms of the Kickstarter, supporters were to get exclusive access to binary builds, with a few exceptions. Now it looks like the ESP8266-version is going to be added to the binary list. This is awesome news for anyone who enjoys playing around with the popular WiFi chip.
https://www.kickstarter.com/projects/214379695/micropython-on-the-esp8266-beautifully-easy-iot/posts/1626478
Tomi Engdahl says:
Baby Monitor Rebuild is also ESP8266 Audio Streaming How-To
http://hackaday.com/2016/07/15/baby-monitor-rebuild-is-also-esp8266-audio-streaming-how-to/
[Sven337]’s rebuild of a cheap and terrible baby monitor isn’t super visual, but it has so much more going on than it first seems. It’s also a how-to for streaming audio via UDP over WiFi with a pair of ESP8266 units, and includes a frank sharing of things that went wrong in the process and how they were addressed. [Sven337] even experimented with a couple of different methods for real-time compression of the transmitted audio data, for no other reason than the sake of doing things as well as they can reasonably be done without adding parts or spending extra money.
ESP8266-based DIY wifi baby monitor
https://perso.aquilenet.fr/~sven337/english/2016/07/14/DIY-wifi-baby-monitor.html
The objective is, of course, to be able to listen to the sounds of the baby remotely. There are two devices: the transmitter and the receiver.
The transmitter must:
capture sound in the room it is in
decide if that sound is loud enough to wake up the receiver
transmit sound data over wifi to the receiver
The receiver must:
receive sound over wifi
amplify it and play it on speaker
have a button to force sound transmission
In addition, both devices must be cheap, and “wife-proof”, that is, look good enough for her not to even notice that it is not a commercial product, so she doesn’t get the slightest opportunity to complain about yet another duct-tape project (scroll down to the pictures to see the irony).
Tomi Engdahl says:
Two Great Radios Taste Great Together
http://hackaday.com/2016/07/15/two-great-radios-taste-great-together/
[Johan Kanflo] sent us his latest recipe: a blend of one part RFM69 sub-gigahertz radio transceiver with one part ESP8266 module. The resulting dish looks absolutely delicious!
We’re all charmed with the ease of use that the ESP8266 brings to the table — plug it in and you’re talking to your existing WiFi network — but we hate the power consumption for battery-powered applications. WiFi is a power hog. And although ISM-band radio modules make point-to-point communications cheap and power-saving, getting them to talk with your computer takes an adapter.
So [Johan] combined the two radios and made a sweet ISM-radio-to-WiFi bridge. His demo application takes whatever data is sent over the ISM band and pushes it to an MQTT broker on his WiFi network. Hardware and firmware are up on GitHub.
https://github.com/kanflo/espism/tree/master/hardware/v2
https://github.com/kanflo/espism/tree/master/mqtt_sniffer
Bridging ISM radio and wifi for lunch money
http://johan.kanflo.com/bridging-ism-radio-and-wifi-for-lunch-money/
Tomi Engdahl says:
Your ESP8266 Needs More Memory
http://hackaday.com/2016/07/16/your-esp8266-needs-more-memory/
We just got through reviewing MicroPython on the ESP8266, and one of the main takehomes is that our ESP modules need more flash memory. You may be in the same boat — the earliest (and cheapest) modules on the market only had 512 kB of flash. For over-the-air programming, or to give you some more space for fancier programs, you’re going to want 1 MB or even 4 MB.
The solution? Just buy a new flash chip and solder it on. This is especially easy if you’ve got an ESP-01, ESP-03, or ESP-11 modules where the flash chip is exposed. Desolder, resolder, done. It can be a little trickier for those modules with a tin can around chips, but that’s nothing that a little hot air can’t fix.
32Mb ESP01 and Sonoff
http://tech.scargill.net/32mb-esp01/
Some time ago I passed comment in here about converting an ESP-01 to 32Mb (or 4MB). And here it is in the flesh – a 32Mb ESP-01 – and also – at last – Sonoff Upgrades.
Now, why would you want to do all of that? I would suggest only if you happen to have lots of ESP-01 units lying around – and I’ll bet quiet a lot of you do. As for the Sonoffs – well, put it this way, I just ordered another 10 chips!
I stopped using the ESP-01 a while ago because the standard 4Mb (512K) of FLASH was simply no longer good enough. Richard of RBOOT fame set me using using his RBOOT program so I could easily flash my home control code (see Home Control 2016 and Blowing the Home Control 2016 Code). Partly because I keep adding new stuff and partly because of the size of the Espressif SDK, Although my code will still run in an ESP-01, it certainly won’t OTA (remote over the air programming). And so my little ESP-01 boards have been sitting gathering cobwebs. The Sonoff mains controllers on the other hand are VERY useful but it annoys the hell out of my that my software is now too big for the limited FLASH in these units – at least, for doing OTA remote updating anyway. All of that, for me, is now history.
Tomi Engdahl says:
Planespotter Spots Planes, Tracks Destinations
http://hackaday.com/2016/07/17/planespotter-spots-planes-tracks-destinations/
Ever looked up in the sky and wondered where all of those planes above you were going? [Daniel Eichhorn] no longer has to, thanks to his ESP8266-based Planespotter.
He built this nifty device to grab the details of the flights he sees taking off from Zurich airport. It’s a neat build, running on an ESP8266 that receives ADS-B data from ADS-B Exchange. This service allows you to query the ADS-B data with a specific location.
ESP8266 based Plane Spotter – How To
http://blog.squix.org/2016/07/esp8266-based-plane-spotter-how-to.html
Tomi Engdahl says:
Never Gonna Give Up Free WiFi
http://hackaday.com/2016/07/19/never-gonna-give-up-free-wifi/
What do people all around the world want most? Free WiFi. And what inevitable force do they want to avoid most, just after death and taxes? Rick Astley. As a getting-started project with the ESP8266, Hackaday.io user [jaime] built a “free WiFi portal” that takes advantage of people’s deepest desires. Instead of delivering sweet, high-bandwidth connectivity, once you click through the onerous terms and conditions, it delivers you a looped GIF with background music.
And all of this on $4 worth of hardware, with firmware assembled in the cloud and easily available to anyone.
ESP8266 Mobile Rick Roll Captive Portal
A fun project to Rick Roll friends or strangers wirelessly.
https://hackaday.io/project/12709-esp8266-mobile-rick-roll-captive-portal
Tomi Engdahl says:
Ask Hackaday: Is The ESP8266 5V Tolerant?
http://hackaday.com/2016/07/28/ask-hackaday-is-the-esp8266-5v-tolerant/
The ESP8266 is the reigning WiFi wonderchip, quickly securing its reputation as the go-to platform for an entire ecosystem of wireless devices. There’s nothing that beats the ESP8266 on a capability vs. price comparison, and this tiny chip is even finding its way into commercial products. It’s also a fantastic device for the hardware tinkerer, leading to thousands of homebrew projects revolving around this tiny magical device.
In every technical document, summary, and description of the ESP8266, the ESP8266 is said to be a 3.3V part. While we’re well into the age of 3.3V logic, there are still an incredible number of boards and hardware that still operate using 5V logic.
ESP8266 is 5V-tolerant after all?
https://hackaday.io/page/2024-esp8266-is-5v-tolerant-after-all
It seems that the ESP8266 GPIO pins are 5V-tolerant after all, or at least protected from 5V input. I’m not sure of this, but look for yourself. In the “GPIO” section of the PDF
All digital IO pins are protected from over-voltage with a snap-back circuit connected between the pad and ground. The snap back voltage is typically about 6V, and the holding voltage is 5.8V. This provides protection from over-voltages and ESD. The output devices are also protected from reversed voltages with diodes.
(edit) Even the 5V tolerant parts should use a resistor in series with the input pins, so the current does not exceed the capacity of the clamping diodes. Such current is around a few milliamps, hence the resistors are typically in the range of hundreds of ohms ( R >= [5-3V3]/Iclampmax).
A further reading on the ESP8266 datasheed shows that the I/O pins are protected for voltages up to 6Volts
Usiing a series resistor in the 100Ohm range should work ok. The other problem is that driving a 3.3V signal to a 5V pin may not be recognized as HIGH
https://hackaday.io/project/11922-home-automation-on-the-cheap using the ESP8266 connected directly to an arduino TX RX without level converters. I have been using it this way with both ESP-01 and ESP-12 without problems. Use this info at your own risk but for me works well.
Tomi Engdahl says:
Wi-Servo: Wi-fi browser controlled servomotors (with Arduino + ESP8266)
http://www.instructables.com/id/Wi-Servo-Wi-fi-Browser-Controlled-Servomotors-with/
This instructable shows how to control some servomotors remotely in a wi-fi network, using an ordinary internet browser (Firefox, for instance). This might be used in several applications: toys, robots, drones, camera pan/tilt, etc.
The motors were attached to an Arduino Uno, which connects the wi-fi network through a ESP-8266 module. The control interface was designed with HTML and jQuery.
Tomi Engdahl says:
Hacklet 118 – Infrared and Universal Remote Controls
http://hackaday.com/2016/07/30/hacklet-118-infrared-and-universal-remote-controls/
We start with [Harikrishna] and zmote. Zmote is an open source WiFi enabled, infrared, 360° remote control. That’s a mouthful. It might be easier to say it’s an ESP8266 and some IR LEDs. An ESP-01 module connects the device to WiFi and provides the 32-bit processor which runs the show. Learning functionality comes courtesy of a TSOP1738 modulated infrared receiver. The beauty of the Zmote is in the software. REST and MQTT connectivity are available. Everything is MIT licensed, and all the code is available on Github.
zmote
Wi-Fi Universal Remote using the ESP8266
https://hackaday.io/project/7858-zmote
zmote is the world’s simplest Wi-Fi Universal Remote. Hook it up to a USB power supply, place it anywhere in your living room, join it to your Wi-Fi network, and control all your gadgets from anywhere using any browser.
zmote uses ESP8266 Wi-Fi chip. More specifically, it uses the ESP-01 module.
Tomi Engdahl says:
Hackaday Prize Entry: A WiFi Swiss Army Knife
http://hackaday.com/2016/08/07/hackaday-prize-entry-a-wifi-swiss-army-knife/
As you would expect, this WiFI Swiss Army Knife is powered by the ESP8266 and features a tiny OLED display and a bunch of buttons for the UI. With this, [Daniel] is able to perform a deauth attack on a network, kicking anyone off the network, provided this device already has the MAC address of the victim.
ESPTool
A WiFi Security Swiss Army Knife
https://hackaday.io/project/12869-esptool
The ESPTool is a convenient Tool to test your WiFi Security against attackers. It can demonstrate how easy it is to crack a WiFi Password or jam your WiFi so you can’t access the internet. This Tool is designed for education and self-tests.
Tomi Engdahl says:
DNS Tunneling: Getting The Data Out Over Other Peoples’ WiFi
http://hackaday.com/2016/08/07/getting-the-data-out-over-other-peoples-wifi/
[KC Budd] wanted to make a car-tracking GPS unit, and he wanted it to be able to phone home. Adding in a GSM phone with a data plan would be too easy (and more expensive), so he opted for the hacker’s way: tunneling the data over DNS queries every time the device found an open WiFi hotspot. The result is a device that sends very little data, and sends it sporadically, but gets the messages out.
This system isn’t going to be reliable — you’re at the mercy of the open WiFi spots that are in the area. This certainly falls into an ethical grey zone, but there’s very little harm done. He’s sending a 16-byte payload, plus the DNS call overhead.
TOWL – Telemetry over Opportunistic WiFi Links
http://www.phreakmonkey.com/2016/08/towl-telemetry-over-opportunistic-wifi.html
Can you build a “LoJack” style asset tracking capability using open WiFi hotspots?
The proliferation of cheap, lightweight WiFi embedded (“IoT”) devices made me wonder. The WiFi association stack, DHCP client stack, et al. has to be incredibly lightweight and simple to fit in the firmware on, say, an ESP8266. If you programmed one to scan, find an AP, associate, get an address, and send a single packet – would it be able to do it fast enough to report its location from a moving vehicle?
“But wait,” you say, “there really aren’t that many open APs these days. Most of them are captive or paywall portals, or at least make you agree to some goofy ToS.”
Right, but as has been pointed out multiple times by multiple people all the way back to Dan Kaminsky’s DNS tunneling talk in 2004 – hotspots diligently resolve DNS queries. All you have to do is base32 encode the data you want to send in the hostname of a valid DNS record request, and set up a DNS server for a subdomain (under a domain you own) to catch the queries.
If it works, you get near real-time telemetry over opportunistic WiFi links using DNS recursion! Think: “low cost LoJack with no data subscriptions”.
I used the Digistump Oak variant of the ESP8266 prototype boards. I like the fact that it can be flashed OTA, which proves to be useful once the device is deployed in something like an automobile.
Digistump Oak – Telemetry over Opportunistic WiFi Links (ESP8266)
https://github.com/phreakmonkey/towl
Server
You’ll need to add an NS record to the DNS table of a domain you control, designating a subdomain namesrever for the TOWL telemetry query catcher.
E.g. if you own the domain “MyDomain.com”, you could designate a server to receive the TOWL queries by creating a NS record for “TOWL.MyDomain.com”, pointing at the server you intend to run the catcher on. If said server is at IP address 1.2.3.4, then that record looks something akin to:
TOWL IN NS 1.2.3.4
Run the PoC code on the designated server. Be sure to configure both the TOWL devices and the server code for the “TOWL.MyDomain.com” domain name. (See README under each directory for instructions.)
Tomi Engdahl says:
[CNLohr], ESP8266, USB…
http://hackaday.com/2016/08/09/cnlohr-esp8266-usb/
[CNLohr] just can’t get enough of the ESP8266 these days — now he’s working on getting a version of V-USB software low-speed USB device emulation working on the thing. (GitHub link here, video also
he wrote routines in C, compiled them using the Xtensa GCC compiler, and backed out the assembly. The end result is a mix of the two: assembly when speed counts, and C when it’s more comfortable.
All in all, it’s a very iterative, experimental approach to coding, learning, and hacking.
Software-only ESP8266 USB Device
https://github.com/cnlohr/espusb
Tomi Engdahl says:
magicShifter 3000: An Over-Engineered POV Stick with a 15-Year Journey
http://hackaday.com/2016/08/22/magicshifter-3000-an-over-engineered-pov-stick-has-come-a-long-way/
3 hackers, 16 LEDs, 15 years of development, one goal: A persistence of vision display stick that fits into your pocket. That’s the magicShifter 3000. When waved, the little, 10 cm (4 inches) long handheld device draws stable images in midair using the persistence of vision effect. Now, the project has reached another milestone: production.
The design has evolved since it started with a green LED bargraph around 2002. The current version features 16 APA102 (aka DotStar) RGB LEDs, an ESP-12E WiFi module, an NXP accelerometer/magnetometer, the mandatory Silabs USB interface, as well as a LiPo battery and charger with an impressive portion of power management.
After experimenting with Seeedstudio for their previous prototypes, the team manufactured 500 units in Bulgaria. Their project took them on a roundtrip through hardware manufacturing.
Over all the years, the magicShifter has earned fame and funding as the over-engineered open hardware pocket POV stick.
https://hackaday.io/project/9668-magicshifter-3000
Tomi Engdahl says:
Software USB On the ESP8266
http://hackaday.com/2016/09/03/software-usb-on-the-esp8266/
[cnlohr] decided to turn an ESP8266 into a USB keyboard and mouse. How hard could it be? The ESP doesn’t support USB, but bitbanging hasn’t stopped him before. The end result is a USB stack running on the ESP8266 WiFI module.
[cnlohr] has been working for about a month on this USB implementation for the ESP, beginning with a logic analyzer, Wireshark, Xtensa assembly, and a lot of iteration. The end result of this hardware hacking is a board based on the ESP8285 – an 8286 with integrated Flash – that fits snugly inside a USB socket.
This tiny board emulates low-speed USB (1.5 Mbps), and isn’t really fast enough for storage, serial, or any of the fancier things USB does, but it is good enough for a keyboard and mouse. Right now, [cnlohr]’s ESP USB device is hosting a webpage, and by loading this webpage on his phone, he has a virtual keyboard and mouse on a handheld touchscreen.
Wifi Controlled USB Mouse and Keyboard (ESP8285)
https://www.youtube.com/watch?v=FPBzOaLbWhM
Software-only ESP8266 USB Device
https://github.com/cnlohr/espusb
Tomi Engdahl says:
Run a RepRap on an ESP8266
http://hackaday.com/2016/09/06/run-a-reprap-on-an-esp8266/
What can’t the little $5 WiFi module do? Now that [lhartmann] has got an ESP8266 controlling the motors of a 3D printer, that’s one more item to check off the list.
What’s coolest about this project is the way that [lhartmann] does it. The tiny ESP8266 has nowhere near the required number of GPIO pins, the primary SPI is connected to the onboard flash memory, and the secondary SPI is poorly documented and almost nobody uses it. So, [lhartmann] chose to use the I2S outputs.
I2S is most often an audio protocol, so this might at first seem like a strange choice. Although I2S sounds like I2C, it’s really essentially an SPI protocol with a fourth wire that alternates to designate the right or left channel. It’s actually just perfect for sending 16×2 bits of data at high data rates.
[lhartmann] takes these 32 bits and feeds them into four shift registers, producing 32 outputs from just the four I2S data lines. That’s more than enough signals to run the stepper motors.
Controlling a RepRap with ESP8266 and no Arduino
http://forums.reprap.org/read.php?2,594898
I believe I found a way to use just an ESP8266 module to control the stepper drivers directly. This post explains how.
Tomi Engdahl says:
Reverse Engineering and Networking The A/C Remote Control
http://hackaday.com/2016/09/08/reverse-engineering-and-networking-the-ac-remote-control/
IoT has become such an polarizing, overused term. But here it is in its essence: [zeroflow] had a thing (his airconditioner) and he needed to put it on the Internet.
For his contribution to this modern vernacular atrocity, he first had to build an IR debugging tool and reverse engineer the signals coming from the air conditioner’s remote. He wrote up a really good summary of the process, and worth reading. He loads up an IR library onto an Arduino and dumps the resulting 32 bits of information to his computer.
Next he throws an array of IR LEDS and an ESP8266 onto a bit of protoboard. After writing some code, available on GitHub, he could set the temperature of his room from anywhere on the planet
Steps of the reverse engineering
https://github.com/zeroflow/ESPAircon/wiki/Steps-of-the-reverse-engineering
https://github.com/zeroflow/ESPAircon/wiki
Tomi Engdahl says:
Overhauling The ESP8266’s Flash Memory Handling
http://hackaday.com/2016/09/09/overhauling-the-esp8266s-flash-memory-handling/
If you’ve ever corrupted a flash memory on a power failure, you’ll be glad to hear that the ESP8266 SDK implements a very secure and almost infallible read/write management for its flash memory. The catch: It’s also very wasteful. For a single memory block of stored data, three memory blocks of physical flash memory are occupied. [Peter Scargill] enlightens us with a better solution.
When the ESP8266 writes data to its external flash memory, for example during an OTA update, it can’t simply overwrite the block holding the currently running program — it needs to write that data to a second block. Once the write operation is complete, it must keep track of which block holds the current data. For this, the ESP8266 SDK employs a third block, in which it stores the pointer to the current block. However, besides the block pointer, that third block stores no useful data.
It’s a deliberately wasteful technique that’s extremely useful for bulletproof firmware updates, but for storing additional data in the flash memory, you’d want a more efficient method.
Espressif Save to FLASH–an alternative
http://tech.scargill.net/espressif-save-to-flash-an-alternative/
To clarify – The ESP can make use of 1 meg of FLASH for program space, plus another meg if using OTA (online updating) – that is- the second meg is used to upload a new program while the original is still running. In addition Espressif use a tiny bit at the very top of whatever size FLASH you have. I’m going to talk here about those units with 4MB of FLASH – for example the very popular and cheap ESP-12 and variants. If you had a unit with MORE memory then this could be expanded. LESS and this isn’t worth reading.
Tomi Engdahl says:
Simple Clock from Tiny Chip
http://hackaday.com/2016/09/11/simple-clock-from-tiny-chip/
If you haven’t jumped on the ESP8266 bandwagon yet, it might be a good time to get started. If you can program an Arduino you have pretty much all of the skills you’ll need to get an ESP8266 up and running. And, if you need a good idea for a project to build with one of these WiFi miracle chips, look no further than [Ben Buxton]’s dated, but awesome, NTP clock.
ESP8266 based NTP Clock
http://www.buxtronix.net/2015/12/esp8266-based-ntp-clock.html
Given that the device is primarily a WiFi / network device, the clock had to interface with the network, and what better than to have it as an NTP client. I also had a spare 4 digit LED display, and the 3-wire interface works perfectly with the 4 GPIO pins broken out on the ESP-1.
An so began my design for this clock. A brief overview of what I envisaged for it:
Synchronised over NTP (Network Time Protocol, RFC 5905)
Browser based configuration of WiFi credentials, NTP settings, etc.
Configuration saved into non volatile memory.
Single button to enter AP mode for configuration.
IP Address display (again, single button)
Indication of NTP sync loss.
Absolute minimal component count.
As this was also a learning exercise, the development was not a straight-forward linear process.
The clock hardware is really really simple. I doubt it could be distilled down to anything less than the following components:
ESP-1 module.
4-digit 7 segment display (SPI interface) [this Sure Electronics one]
LM1117 3.3v regulator.
10uF bypass cap
PCB mount pushbutton switch
Tomi Engdahl says:
ESP8266 sleep/wake switch
A method to turn the ESP8266 itself on and off with a single switch
https://hackaday.io/project/14808-esp8266-sleepwake-switch
IOT devices running on batteries may need an on off switch. To reduce part count, I have though of a way to allow for the ESP 8266 to sleep and wake using only one extra resistor a switch and two GPIO.
Tomi Engdahl says:
Hackaday Prize Entry: Neopixel Pocket Watch
http://hackaday.com/2016/09/15/hackaday-prize-entry-neopixel-pocket-watch/
A timepiece is rather a rite of passage in the world of hardware hacking, and we never cease to be enthralled by the creativity of our community in coming up with new ones.
Today’s example comes from [Joshua Snyder], who has made a pocket watch. Not just any pocket watch, he’s taken the shell of a clockwork watch and inserted a ring of Neopixels, which he drives from an ESP8266 module. Power comes from a small LiPo battery, and he’s cleverly engineered a small push-button switch so that it can be actuated by the knob from the original watch.
Neopixel pocket watch
https://hackaday.io/project/13353-neopixel-pocket-watch
Pocket watch with neopixel display and esp8266
Tomi Engdahl says:
WiFi-enabled microcontroller — check. Ubiquitous smartphones and established protocols to communicate with other devices on the network — absolutely. It’s an incredible time to be a hacker.
Television infrared remote codes are fairly well documented and easy to sniff using tools like Arduino — in fact the ESP IR firmware for this is built on [Ken Shirriff’s] Arduino IR library.
ESP8266 TV remote for Homekit
http://www.instructables.com/id/ESP8266-TV-Remote-for-Homekit/
ESP8266-03 TV remote board.
Can control with Homekit, or any TCP socket client.
Powered from 5V with micro USB connector.
Infrared remote library for ESP8266: send and receive infrared signals with multiple protocols.
https://github.com/markszabo/IRremoteESP8266
Based on: https://github.com/shirriff/Arduino-IRremote/
Tomi Engdahl says:
An ESP8266 in Every Light Switch and Outlet
http://hackaday.com/2016/09/20/an-esp8266-in-every-light-switch-and-outlet/
[Hristo Borisov] shows us his clever home automation project, a nicely packaged WiFi switchable wall socket. The ESP8266 has continuously proven itself to be a home automation panacea. Since the ESP8266 is practically a given at this point, the bragging rights have switched over to the skill with which the solution is implemented. By that metric, [Hristo]’s solution is pretty dang nice.
It’s all based around a simple board. An encapsulated power supply converts the 220V offered by the Bulgarian power authorities into two rails of 3.3V and 5V respectively. The 3.3V is used for an ESP8266 whose primary concern is the control of a triac and an RGB LED. The 5V is optional if the user decides to add a shield that needs it.
It’s all controllable from command line, webpage, and even an iOS app; all of it is available on his GitHub.
https://github.com/hborisov/
Switcher – A WiFi Open Source Power Switch and Socket Based on ESP8266
http://hristoborisov.com/index.php/projects/switcher-a-wifi-open-source-power-switch/
This is my latest project – The Switcher, a Wifi, open source, power switch and socket.
Built with modularity in mind – It can be mounted as a wall lights switch or used as a standalone power socket. Switcher gives the ability to control your lights, or any other household appliance, wirelessly over the wifi network and the Internet! There is a dedicated iOS App and web interface which can be used with any browser! You can build your own designs to make unique wall light switches for your house.
The switch uses the prominent ESP8266-01 module, an Arduino program, a 3D printed box and modules. It is free and open source, so you can build and modify it on your own!
At the center of the circuit is the ESP8266 module. Pins 2 (Rx), 3 (RST), 4 (GPIO0), 5 (CH_PD), 6 (GPIO2) are pulled high to prevent booting the ESP into programming mode. This requires “inverting” the GPIO pins programmatically.
The firmware is very simple. It is written in C++ (Arduino) and uses several libraries from the Arduino/ESP8266 project. Additionally I am using the Adafruit NeoPixel library to control RGB LEDs for the on/off indicator.
Switcher – A WiFi Open Source Power Switch and Socket
https://github.com/hborisov/switcher_cpp
iOS App
https://github.com/hborisov/switcher_ios
Tomi Engdahl says:
Hackaday Prize Entry: Theia IoT light-switch
http://hackaday.com/2016/09/24/hackaday-prize-entry-theia-iot-light-switch/
There are it seems no wireless-enabled light switches available in the standard form factor of a UK light switch. At least, that was the experience of [loldavid6], when he decided he needed one. Also, none of the switches he could find were open-source, or easy to integrate with. So he set out to design his own, and the Theia IoT light switch is the result.
In adapting a standard light switch, he was anxious that his device would not depend on the position of the switch for its operation. Therefore he had to ensure that the switch became merely an input to whichever board he designed, rather than controlling the mains power. He settled upon the ESP8266 wireless-enabled microcontroller as the brains of the unit, with a relay doing the mains switching.
Theia IoT light-switch
An easy, cheap and open source way to add IoT to a light switch.
https://hackaday.io/project/12661-theia-iot-light-switch
Mose says:
You ought to take part in a contest for one of the
best sites on the web. I will recommend this web site!
Tomi Engdahl says:
Hackaday Prize Entry: Under Cabinet LED Lighting Controller
http://hackaday.com/2016/09/27/hackaday-prize-entry-under-cabinet-led-lighting-controller/
His solution is to make a wireless controller for all his home LED strips, under the command of a web app from his Android tablet. An ESP8266 and a set of MOSFETs provide the inner workings, and the whole is presented on a very compact and well-designed purple OSH Park PCB reflow soldered on a $20 Wal-Mart hotplate and set in a plastic enclosure. The web interface is still in development, but has a fairly simple CSS front end for the ESP8266 code. All software, the schematic, and BoM can be downloaded from the Hackaday.io page
Under Cabinet LED Lighting Controller
An ESP8266 is used to control a 12VDC or 24VDC string of white or RGB LED’s.
https://hackaday.io/project/12797-under-cabinet-led-lighting-controller
planning Neurologue says:
I don’t even know how I ended up right here, but I thought this publish was good.
I do not recognize who you’re however certainly you’re going to a well-known blogger
for those who aren’t already. Cheers!
code de promotion says:
Great article.
may lam mat says:
Excellent way of telling, and good post to take facts about my presentation subject matter, which i
am going to deliver in school.
Tomi Engdahl says:
Running LISP on an ESP8266
http://hackaday.com/2016/10/14/running-lisp-on-an-esp8266/
LISP is a polarizing language. Either you love it or you hate it. But we’ll put aside our personal preferences to bring you a good hack. In this case a LISP environment running on an ESP8266. [Dmitry] is on the “love it” side of the fence — he’s been waiting for an excuse to code up a LISP interpreter for a while, and he found one in the ESP8266.
there-is-always-a-way-2Actually, [Dmitry] is running LISP inside JavaScript, which is itself presumably coded up in C, before it’s assembled to run on an ESP8266.
Let’s Run Lisp on a Microcontroller
http://dmitryfrank.com/articles/lisp_on_mcu
Tomi Engdahl says:
JavaScript for the ESP8266
http://hackaday.com/2015/09/27/javascript-for-the-esp8266/
This build is based on the Espruino firmware, a JavaScript interpreter for microcontrollers. This interpreter runs on dozens of different microcontrollers, but being the latest, greatest, and most popular new microcontroller platform means a new solution for the ESP is very, very exciting.
Javascript for ESP8266 (Espruino and Smart.js)
http://www.esp8266.com/viewforum.php?f=44
Tomi Engdahl says:
WarWalking With The ESP8266
http://hackaday.com/2016/10/23/warwalking-with-the-esp8266/
[Steve] needed a tool to diagnose and fix his friend’s and family’s WiFi. A laptop would do, but WiFi modules and tiny OLED displays are cheap now. His solution was to build a War Walker, a tiny handheld device that would listen in WiFi access points, return the signal strength, and monitor the 2.4GHz environment around him.
The War Walker didn’t appear out of a vacuum. It’s based on the WarCollar Dope Scope, a tiny, portable device consisting of an off-the-shelf Chinese OLED display, an ESP8266 module, and a PCB that can charge batteries, provide a serial port, and ties the whole thing together with jellybean glue. The Dope Scope is a capable device, but it’s marketed towards the 1337 utilikilt-wearing, The Prodigy-blasting pentesters of the world. It is, therefore, a ripoff. [Steve] can build his version for $6 in materials.
The core of the build is an ESP-based carrier board built for NodeMCU.
Code to make an ESP8266/NodeMCU Wifi Scanner / Dope Scope
https://github.com/stevemcquaid/War-Walker
Tomi Engdahl says:
Web Matrix Control Proves Power of ESP8266
http://hackaday.com/2016/11/01/web-matrix-control-proves-power-of-esp8266/
LED matrix projects are all over the place, but this one is interesting for its simplicity: it’s an LED matrix that is driven straight from an ESP8266 board. [Ray] put it together as a quick project for his students to teach the basics of LED programming.
It’s built using a WS2812 LED matrix board he designed himself and his own ESPToy ESP8266 dev board. But the gist of the hardware is simply an ESP8266 and some WS2812’s. Where this gets interesting is with the user interaction side of things. The ESP makes WiFi and web serving easy, and [Ray] has build a simple HTTP GET API into the firmware. This is a great combination for the web dashboard and JavaScript-based animation programs
WiFi-enabled Color LED Matrix using ESP8266 and WS2812 LEDs
http://rayshobby.net/wifi-color-led-matrix/
Tomi Engdahl says:
ESPCLOCK
NTP-enbling a cheap $2 Ikea analog clock using ESP-12/NodeMCU/Arduino
https://hackaday.io/project/16742-espclock
In this project, I connected a cheap $2 Ikea analog clock to the ESP-12/NodeMCU dev module and synchronized the clock time with NTP time (localized with Google Maps Timezone API). On startup, simply connect to the device configuration AP and configure your Wi-Fi login credentials and physical clock time. The config web page will capture your current location automatically using HTML5 Geolocation and use that to automatically figure the local time and DST offset via the Google Maps Timezone API.
In an ideal world, all clocks should synchronize with the network and deal with daylight saving hell automatically. Not only that, they should run for at least a year on a single AA battery and cost around the same price as current clocks.
In this project, I try to NTP-enable a cheap $2 Ikea RUSCH wall clock using a ESP-12E dev module. This project was inspired by another blog post that explores controlling the Lavet motor in a typical analog quartz clock using an Arduino.
setup is extremely simple. Connect to the device configuration access portal and enter 1) Wi-Fi credentials 2) clock face time. Hit “Save” and the device should take care of the rest.
The clock will sync within a few seconds of NTP time, take care of DST automatically and only cost a few dollars more due to the low cost of ESP12/ESP8266. The only problem that remains is the practical need to run this clock from the mains. Even when connected to a 10,000mha battery pack, it will only last for about 6 to 7 days
Once the development environment is set up and running, we need to take apart the Ikea clock and solder 2 jumper wires to the clock mechanism
3m car polish kit says:
Nice post. I learn something totally new and challenging on websites I stumbleupon every day.
It’s always interesting to read through articles from other writers and use a little something from their web
sites.
Tomi Engdahl says:
ESP Clock Needs More Power
http://hackaday.com/2016/11/10/esp-clock-needs-more-power/
[Victor-Chew] is tired of setting clocks. After all, here we are in the 21st century, why do we have to adjust clocks (something we just did for daylight savings time)? That’s why [Victor] came up with ESPClock.
Based on a $2 Ikea analog clock, [Victor] had a few design goals for the project:
Automatically set the time from the network
Automatically adjust for daylight savings time
Not cost much more than a regular clock
Run for a year on batteries
The last goal is the only one that remains unmet. Even with a large battery pack, [Victor’s] clock runs out of juice in a week or so.
ESPCLOCK
NTP-enbling a cheap $2 Ikea analog clock using ESP-12/NodeMCU/Arduino
https://hackaday.io/project/16742-espclock
In this project, I connected a cheap $2 Ikea analog clock to the ESP-12/NodeMCU dev module and synchronized the clock time with NTP time (localized with Google Maps Timezone API). On startup, simply connect to the device configuration AP and configure your Wi-Fi login credentials and physical clock time. The config web page will capture your current location automatically using HTML5 Geolocation and use that to automatically figure the local time and DST offset via the Google Maps Timezone API.
Tomi Engdahl says:
Launitor Saves You From Accidentally Smelly Clothes
http://hackaday.com/2016/11/10/launitor-saves-you-from-accidentally-smelly-clothes/
[domiflichi] is human and fallible. So he can’t be blamed for occasionally forgetting the laundry in one of the machines and coming back to a less than stellar result. However, while fallible, he is not powerless.
What if his washer/dryer could email or text him about his laundry? It seemed simple enough. Add a vibration sensor to the side of the machine along with some brains. When the load is done it will bother him until he comes down to push the button or There Will Come Soft Rains.
Launitor – Laundry Monitor
http://jamienerd.blogspot.fi/2016/10/launitor-laundry-monitor.html
Requirements
As usual, there were some requirements I had:
It should be portable for if/when we get a new washer/dryer
No permanent changes/modifications should be made to the machines
Should be cheap
Should require as little user-intervention as possible
Easy to use, and have visual cues as to what’s going on with them
So how does this thing work, anyway?
This is a very simple device to use – when nothing is going on, the LEDs are off. If it detects enough vibrations in a certain amount of time (both amount of vibrations and time are easily adjustable in code), it starts blinking the corresponding LED to visually show that the washer (or dryer) is running. When it realizes that the machine is done running, it turns the LED solid, and sends you an email. If you have the option enabled in the code, it will keep sending you an alert via email every X (also adjustable in code) amount of minutes. After you remove your clothes, just push the corresponding button to reset it so that it will start watching for the next load!
Tomi Engdahl says:
ESP8266 Lullaby
http://hackaday.com/2016/11/11/esp8266-lullaby/
The ESP8266 is certainly a versatile device. It does, however, draw a bit of power. That isn’t really surprising, though, since you would expect beaming out WiFi signals to take a little juice. The trick is to not keep the device on all the time and spend the rest of the time in deep sleep mode. [Marco Schwartz] has a good tutorial about how to use this mode to run for “years” on a battery.
[Marco] notes that even using a 2500 mAh LiPo battery, he only gets about 30 hours of operation without sleep. By putting the chip in sleep mode, the current consumption drops from about 88 mA to just over 8 mA. That’s still high, though, because the board has a power LED! By removing a jumper or cutting a trace (depending on the board), you can drop the current draw to about 0.08 mA (80 uA) when it’s not doing anything.
The code for the example is on GitHub.
How to Run Your ESP8266 for Years on a Battery
https://openhomeautomation.net/esp8266-battery/
How to Run Your ESP8266 for Years on a Battery
https://github.com/openhomeautomation/esp8266-battery
Tomi Engdahl says:
“Alexa, Make My ESP8266 Do Something”
http://hackaday.com/2016/11/23/alexa-make-my-esp8266-do-something/
The Amazon Echo and its diminutive Dot cousin have the handy feature of being able to control some home automation devices. If you own the right manufacturer’s hardware you can bend your home to your will using the power of your voice alone.
[Xose Pérez] had been sidestepping this problem by using a server running a set of scripts emulating a Belkin WeMo device, which Echo supports. The server could issue commands to his microcontrollers, but he wanted more. Why not cut out the middle man to incorporate the WeMo emulation directly on the ESP8266 that did the work?
He took the Fauxmo Python WeMo emulator he had been using, and ported it to an ESP8266 library that can be incorporated in existing code to make it appear to the world as a WeMo device.
Emulate a WeMo device with ESP8266
http://tinkerman.cat/emulate-wemo-device-esp8266/
My daughters love to talk to (or with) my Amazon Dot in their funny English: “Alexa, hello!”, “Alexa, li-on!” (actually “light on”). It’s so easy to use it to switch on/off things at home using the fauxmo python script by Maker Musings. In his post about Amazon Echo and Home Automation more than a year ago he explains how he reverse-engineered the protocol of the WeMo switches that Alexa supports.
I also have a server running the fauxmo script with an MQTT handler to control some of the Sonoffs I have at home, but this morning I woke up thinking: why should I use an external script to control my devices if I can code it in the firmware?
Tomi Engdahl says:
The ESP: A New 1kB Contender Appears
http://hackaday.com/2016/11/30/the-esp-a-new-1kb-contender-appears/
The ESP8266 is officially checking into the Hackaday 1kB Challenge. Doing something meaningful in 1kB of compiled code is tricky; modern SDKs like the ones often used for ESP8266 compile even the simplest programs to nearly that size. If you want to use this hardware in your 1kB Challenge entry, I have a solution for you!
Tomi Engdahl says:
The Joy of the ESP8266 and Blynk
http://hackaday.com/2016/12/01/the-joy-of-the-esp8266-and-blynk/
I also find it hard to pass up a bargain. So when I saw a robot kit at the local store that had been originally $125 marked down to $20, I had to bite. There was only one problem. After I got the thing home, I found they expected you to supply your own radio control transmitter and receiver.
I didn’t have anything handy.
However, I did have a few ESP8266 modules handy. Good ones, too, from Adafruit with selected 5 V I/O compatibility and an onboard regulator. I started thinking about writing something for the ESP8266 to pick up data from, say, a UDP packet and converting it into RC servo commands.
Seemed like a fair amount of work and then I remembered that I wanted to try Blynk. If you haven’t heard of Blynk, it is a user interface for Android and Apple phones that can send commands to an embedded system over the Internet. You usually think of using Blynk with an Arduino, but you can also program the embedded part directly on an ESP8266. I quickly threw together a little prototype joystick.
Inside Blynk
The GUI part of Blynk is really simple. You build a screen, add widgets and tap them to configure them. The joystick has some basic configuration items
When you create a Blynk app, you generate a long hex number that identifies your application. That number is the key to connecting your microcontroller to the user interface.
The basic steps are easy:
Open Blynk and create a new project
Select a project name and the type of hardware you’ll use
The software will show you an “auth token” (the long hex number)
You can write the number down or press a button to have it sent to your e-mail (much easier)
Press the create button and you’re done
Next Steps
To complete the joystick project, you’ll need to tackle the following issues:
Programming the Blynk firmware into the ESP8266
Communicating with the Blynk user interface from your custom code
App Control With Ease Using Blynk
https://hackaday.com/2016/03/10/app-control-with-ease-using-blynk/
Tomi Engdahl says:
ESP8266s without the big SDK “nosdk8266″
https://www.youtube.com/watch?v=AWT2w7v9szs
If you’re thinking “no wifi? no problem!” then this hack is for you! nosdk8266 allows you to use your ESP8266 with very, very little overhead. This enables rapid development cycles, crazy high speeds and more I/D RAM than you’ve ever imagined. You’ll still need the esp open sdk, but not a ton more!
The ESP: A New 1kB Contender Appears
http://hackaday.com/2016/11/30/the-esp-a-new-1kb-contender-appears/
Github: http://github.com/cnlohr/nosdk8266
Tomi Engdahl says:
WebSockets for awesome on the ESP8266
https://www.youtube.com/watch?v=8ISbmQTbjDI
Websockets are … just … awesome. So, I started implementing them on the ESP8266. The configuration interface on my esp8266ws2812spi tool uses them so does ColorChord:
WS2812I2S: https://github.com/cnlohr/esp8266ws28…
ColorChord: http://github.com/cnlohr/colorchord
Tomi Engdahl says:
Remote Wifi Sniffing Station with an ESP8266
https://www.youtube.com/watch?v=_GQMZg_5FPE
http://hackaday.com/2016/04/01/ethernet-controller-discovered-in-the-esp8266/