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.
As the story goes, years ago [Matt Evans] was wooing the beautiful and talented [Jen]. There were many suitors vying for her hand; he would have to set himself apart. The trouble was, how to convince her that persisting in the relationship was the best and only course? What did he have to offer? Of course many of us know the answer; having wooed our own significant others with the same thing. Incredible and unrepentant nerdiness.
So! He toiled late into the night, his eyes burning with love and from the fumes of solder smoke. For her he would put his wizardry to work. At the wave of a hand would write songs of adoration in the air with nothing but light. The runes of power, all typed out in the proper order, would be held by a ATiny. A CR2032 coin cell provided the magic pixies which would march to its commands, delivering their spark to the LEDs in the right order.
He etched the board, wrote the code, and soldered the components. He encased it in his finest box of crystal clear plastic and black static foam, a gift of the samples department of the Maxim corporation.
Presumably the full moon was high in the air when he presented the box. He took it out and waved it with a flair. Poetry floated there in front of her eyes. It read, “Jen is cool!”. A few years later, they were married.
A few years ago, a strange little chip showed up on Seeed Studio one day. It was the ESP8266, originally sold as a serial to WiFi adapter. Since then, the microcontroller in this wee WiFi module was discovered, and the ESP8266 has been the breakout module for hundreds of Internet of Thing modules, and other wireless baubles.
The company behind the ESP8266, Espressif, wasn’t sitting on their laurels for the last few years. They’ve been working on a followup to the ESP8266. It’s the ESP32, and it’s faster, has more peripherals, better WiFi, and Bluetooth LE. Since Christmas, we’ve been ogling this chip. Now, it’s finally out. You can buy an ESP32 right now. Consider the ESP32 released.
Almost exactly two years ago, the forerunner of the ESP32 was released, allowing anyone to blink a LED from the Internet for five dollars. There was a catch with the release of the ESP8266, and that was documentation. Documentation in English did not exist, and it took Espressif a while to realize the hit they had on their hands. Even now, with a proper English datasheet from Espressif, we don’t know if the ESP8266 has 5V tolerant pins. Documentation was an issue for the ESP8266, but it didn’t really matter because someone on the Internet figured it out.
History doesn’t repeat itself, but it is the franchise with the most reboots. There’s some documentation for the ESP32, but it’s far from complete. There’s a CAN bus peripheral in the ESP32, but no one knows what pins it’s attached to. There are some secrets hidden away, but no one is at liberty to discuss them. No one outside Espressif has any idea if the specs are real. This will, of course, change in the next month or so, but only due to the tireless work of electronics enthusiasts the world over.
Right now, there are several listings on the usual online outlets including Espressif’s Taobao shop and Seeed Studio offering either bare ESP32 chips or modules based on this WiFi Bluetooth wonder. These modules include the ESP-Wroom-32 (PDF) that is seemingly based on the ESP31 test modules released late last year and the ESP3212, a module based on the popular ESP8266-12. There are also bare chips floating about.
As far as any new information regarding the ESP32 is concerned, don’t expect much. It’s released, though, and in a month or so the work of documenting this supposed wonderchip will begin.
Although they’re not available to everyone quite yet, we have two ESP-32 modules in hand, and [Elliot] is currently slogging through installing the toolchain and getting everything working. Watch this space, because we’re going to have an Introduction to the ESP-32 post up shortly.
[Scott Baker] wanted to take on a new retrocomputing project. He decided to build an RC2104. Lucky for us, he documented everything along the way. In addition to the main board, [Scott] built bus monitoring and debugging tools, a front panel, a real time clock, an analog to digital converter, and a speech synthesizer.
You can follow along in the 8-part post that includes videos. He started with the basic kit:
- CPU – The Z80
- ROM – 27C512 64 KB ROM, selectable in 8KB banks
- RAM – 62256 32 KB RAM
- Clock – 7.3728 Mhz crystal that drives a 74HC04 hex inverter (for the CPU and the UART)
- Serial I/O – MC68B50 UART
In addition, he picked up a digital I/O board.
A while back, [cnlohr] needed a USB keyboard and mouse. His box ‘o junk didn’t hold this particular treasure, and instead of hopping on Amazon like a normal geek or venturing into the outside realm on a mid-level ‘store’ quest like a normal person, [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.
If you’re keeping track, [cnlohr] has now brought Ethernet and USB to a tiny microcontroller that can be bought for a few bucks through the usual online outlets. If you’d like to build your own ESP USB stick, all the files are over on the Gits.
Thanks [lageos] for the tip.
One of the first frustrating situations a beginning microcontroller programmer will come across is the issue of debouncing switches. Microcontrollers are faster than switches, and the switch has yet to be built that can change state in zero time like they can on paper. This hurdle is easily overcome, but soon we are all faced with another issue: filtering noise from an analog signal. Luckily [Paul Martinsen] has put together a primer of three different ways to use an Arduino to filter signals.
The first (and fastest, simplest, etc.) way to filter an analog signal is to sample a bunch of times and then average all of the samples together. This will eliminate most outliers and chatter without losing much of the information. From there, the tutorial moves on to programming a running average to help increase the sample time (but consume much more memory). Finally, [Paul] takes a look at exponential filters, which are recursive, use less memory, and can be tweaked to respond to changes in different ways.
[Paul] discusses all of the perks and downsides of each method and provides examples for each as well. It’s worth checking out, whether you’re a seasoned veteran who might glean some nuance or you’re a beginner who hasn’t even encountered this problem yet. And if you’re still working on debouncing a digital input, we have you covered there, too.
If you have ever spent a while delving into the bare metal of talking to the I/O pins on a contemporary microprocessor or microcontroller you will know that it is not always an exercise for the faint-hearted. A host of different functions can be multiplexed behind a physical pin, and once you are looking at the hardware through the cloak of an operating system your careful timing can be derailed in an instant. For these reasons most of us will take advantage of other people’s work and use the abstraction provided by a library or a virtual filesystem path.
If you have ever been curious enough to peer under the hood of your board’s I/O then you may find [Ken Shirriff]’s latest blog post in which he explores the software stack behind the pins on a BeagleBone Black to be of interest. Though its specifics are those of one device, the points it makes have relevance to many other similar boards.
He first takes a look at the simplest way to access a Beagle Bone’s I/O lines, through virtual filesystem paths. He then explains why relying so heavily on the operating system in this way causes significant timing issues, and goes on to explore the physical registers that lie behind the pins. He then discusses the multiplexing of different pin functions before explaining the role of the Linux device tree in keeping operating system in touch with hardware.
For some Hackaday readers this will all be old news, but it’s safe to say that many users of boards like the BeagleBone Black will never have taken a look beyond the safely abstracted ways to use the I/O pins. This piece should therefore provide an interesting education to the chip-hardware novice, and should probably still contain a few nuggets for more advanced users.
We’ve seen a lot of [Ken]’s work here at Hackaday over the years, mostly in the field of reverse engineering. A few picks are his explanation of the TL431 voltage reference, a complete examination of the 741 op-amp, and his reverse engineering of the 1970s Sinclair Scientific calculator.
We appreciate [Fustini]’s tip on this story.
BeagleBone Black image: BeagleBoard.org Foundation [CC BY-SA 3.0], via Wikimedia Commons.