There’s a school of thought that says that to fully understand something, you need to build it yourself. OK, we’re not sure it’s really a school of thought, but that describes a heck of a lot of projects around these parts.
[Tim] aka [mitxela] wrote kiloboot partly because he wanted an Ethernet-capable Trivial File Transfer Protocol (TFTP) bootloader for an ATMega-powered project, and partly because he wanted to understand the Internet. See, if you’re writing a bootloader, you’ve got a limited amount of space and no device drivers or libraries of any kind to fall back on, so you’re going to learn your topic of choice the hard way.
[Tim]’s writeup of the odyssey of cramming so much into 1,000 bytes of code is fantastic. While explaining the Internet takes significantly more space than the Ethernet-capable bootloader itself, we’d wager that you’ll enjoy the compressed overview of UDP, IP, TFTP, and AVR bootloader wizardry as much as we did. And yes, at the end of the day, you’ve also got an Internet-flashable Arduino, which is just what the doctor ordered if you’re building a simple wired IoT device and you get tired of running down to the basement to upload new firmware.
Oh, and in case you hadn’t noticed, cramming an Ethernet bootloader into 1 kB is amazing.
Speaking of bootloaders, if you’re building an I2C slave device out of an ATtiny85¸ you’ll want to check out this bootloader that runs on the tiny chip.
Hackaday regular [befinitiv] wrote into the tip line to let us know about a hack you might enjoy, wireless UART output from a bare STM32 microcontroller. Desiring the full printf debugging experience, but constrained both by available space and expense, [befinitiv] was inspired to improvise by a similar hack that used the STM32 to send Morse code over standard FM frequencies.
In this case, [befinitiv]’s solution is both more useful and slightly more legal, as the software uses the 27 MHz ISM band to blast out ASK modulated serial data through a simple wire antenna attached to one of the microcontroller’s pins. The broadcast can then be picked up by an RTL-SDR receiver and interpreted back into a stream of data by GNU Radio.
The software for the STM32 and the GNU Radio Companion graph are both available on Bitbucket. The blog post goes into some detail explaining how the transmitter works and what all the GNU Radio components are doing to claw the serial data back from the ether.
[cover image cc by-sa licensed by Adam Greig, randomskk on Flickr]
Most of the DIY smartwatch projects we feature here on Hackaday aren’t exactly what most people would consider practical daily-use devices. Clunky designs, short battery life, limited functions: they’re more a wearable display of geek cred than they are functional timepieces. Oddly enough, the same could be said of many of the “real” smartwatches on the market, so perhaps the DIY versions are closer to the state-of-the-art than we thought.
But this ESP8266 smartwatch created by [Shyam Ravi] is getting dangerously close to something you could unironically leave the house with. It’s still missing an enclosure that prevents you from receiving PCB acupuncture while wearing it, but beyond than that it has a more than respectable repertoire of functions. It even seems to be a fairly reasonable size (with the potential to be even smaller). All that with a total build cost of less than $20 USD, and we’re thinking this might be a project to keep an eye on.
Not content with a watch that simply tells the time, [Shyam] added in a weather function that pulls the current conditions for his corner of the globe from the Yahoo weather API and displays it above the time and date on the watch’s multi-color OLED display when the center button is pressed. Frankly, given the state of DIY watches, that would already have been impressive enough; but he didn’t stop there.
The left and right buttons control Internet-connected relays which [Shyam] uses to turn his lights and air conditioner on and off. When he presses the corresponding button, the watch will even display the status of the devices wherever his travels might take him.
A smattering of DIY watches pass by our careful gaze, though it’s been a while since we’ve seen an ESP8266 watch. More recently we’ve seen an Arduino watch, and some downright gorgeous analog creations.
Continue reading “A Multifunction ESP8266 Smartwatch”
One of the most famous pieces of computer-generated music is the Deep Note, the audio trademark for THX. It begins with a dozen or so voices, randomly tuned between 200 and 400 Hz, then glissandos to a frequency spread of three octaves. Put that through a few thousand watts of a speaker system, play it before Jedi, and the audience will be listening.
The original THX Deep Note was created on hundreds of thousands of dollars worth of hardware running 20,000 lines of code, but that was in 1983. Now we have cheap microcontrollers, so of course, you can now fit the Deep Note in your pocket. You can even make it a game. That’s exactly what [Bob] did with his Deep Synth. It’s the Deep Note, in a Game Boy-ish format.
The hardware for this build is the 1Bitsy 1UP, a retro-inspired handheld game console from [Bob]’s friend [Pitor]. Onboard the 1Bitsy is an STM32 F4 running at 168 MHz with a 2.8″ LCD, SD card reader, and the traditional Game Boy control scheme. All the games are up to you.
[Bob] wrote an audio driver for the 1UP, but needed a good audio demo. Since the Deep Note was a good enough demo for Lucasfilms, it would obviously be a good enough demo for a microcontroller. In far less than 20,000 lines of code, [Bob] made the 1UP polyphonic, and it was surprisingly fast enough to synthesize around thirty oscillators. It actually sounds like the Deep Note, too. You can check out a video (and audio) of that after the break.
Continue reading “Turning The Deep Note Into A Game”
There are a few different ways of getting firmware onto one of AVR’s ATtiny85 microcontrollers, including bootloaders that allow for firmware to be updated without the need to plug the chip into a programmer. However, [casanovg] wasn’t satisfied with those so he sent us a tip letting us know he wrote an I2C bootloader for the ATtiny85 called Timonel. It takes into account a few particulars of the part, such as the fact that it lacks a protected memory area where a bootloader would normally reside, and it doesn’t have a native I2C interface, only the USI (Universal Serial Interface). He’s just released the first functional version for the ATtiny85, but there’s no reason it couldn’t be made to work with the ATtiny45 and ATtiny25 as well.
Timonel is designed for systems where there is a more powerful microcontroller or microprocessor running the show (such as an ESP8266, Arduino, or even a board like a Raspberry Pi.) In designs where the ATtinys are on an I2C bus performing peripheral functions such as running sensors, Timonel allows the firmware for these peripheral MCUs to be updated directly from the I2C bus master. Embedded below is a video demo of [casanovg] sending simple serial commands, showing a successful firmware update of an AVR ATtiny85 over I2C.
Continue reading “I2C Bootloader for ATtiny85 Lets Other Micros Push Firmware Updates”
The breadboard microcontroller experimenter has a host of platforms to work with that can be had in the familiar DIP format. Old-school people can still find classic 8-bit platforms, the Ardunisti have their ATMegas, and PIC lovers have a pile of chips to choose from. But ARM experimenters? Out of luck, because as we have previously reported, popular past devices such as the LPC810 in a DIP8 package are now out of production.
News comes from China though of a tiny ARM Cortex M0 for pennies that may not be in a DIP8, but is in almost the next best thing. The Synwit SWM050 can be had in a TSOP8, which though it’s not quite as friendly as its larger SOIC8 cousin, is still easily solderable onto a DIP8 adaptor for breadboard use. Spec-wise it’s 5 V tolerant, has an 8 kB FLASH and 1 kB of RAM, 6 GPIOs, and can clock away at a not incosequential 36 MHz.
We have [Sjaak] to thank for the discovery of this device, and for doing a lot of work including getting some die shots taken to dig up and make sense of the Chinese documentation, and to provide some dev tools should anyone want to play with it. There’s even a small breakout board for the experimenter unwilling to design their own.
Earlier this year we marked the passing of the DIP8 version of the LPC810 microcontroller, and for those mourning it we made an important point. It’s now normal to use one of the vast array of single board computers instead of a bare microcontroller, you might wish to ask yourself why you would do so.
Thanks [Ziew] for the tip.
We were contacted by [morbo] to let us know about a project on the AdaCore blog that concerns programming a PicoRV32 RISC-V softcore with Ada. The softcore itself runs on a Lattice ICE40LP8K-based TinyFPGA-BX FPGA board, which we have covered in the past.
The blog post describes how to use the Community edition of the GNAT Ada compiler to set up the development environment, before implementing a simple example project that controls a strip of WS28212b RGB LED modules. There are two push buttons changing the animation and brightness of the lights.
The source can be found at the author’s Github repository, and contains both the Ada source and the Verilog source for the PicoRV32 softcore. To build the project one needs the GNAT compiler, as well as the open-source iCE40 development tools to compile the softcore.
There is a video demonstrating the finished example project, that we’ve placed below the break.
Continue reading “Programming A RISC-V Softcore With Ada”