Arduinos (and Other AVRs) Write To Own Flash

July 3, 2015 by Elliot Williams 52 Comments

In this post on the Arduino.cc forums and this blog post, [Majek] announced that he had fooled the AVR microcontroller inside and Arduino into writing user data into its own flash memory during runtime. Wow!

[Majek] has pulled off a very neat hack here. Normally, an AVR microcontroller can’t write to its own flash memory except when it’s in bootloader mode, and you’re stuck using EEPROM when you want to save non-volatile data. But EEPROM is scarce, relative to flash.

Now, under normal circumstances, writing into the flash program memory can get you into trouble. Indeed, the AVR has protections to prevent code that’s not hosted in the bootloader memory block from writing to flash. But of course, the bootloader has to be able to program the chip, so there’s got to be a way in.

The trick is that [Majek] has carefully modified the Arduino’s Optiboot bootloader so that it exposes a flash-write (SPM) command at a known location, so that he can then use this function from outside the bootloader. The AVR doesn’t prevent the SPM from proceeding, because it’s being called from within the bootloader memory, and all is well.

The modified version of the Optiboot bootloader is available on [Majek]’s Github. If you want to see how he did it, here are the diffs. A particularly nice touch is that this is all wrapped up in easy-to-write code with a working demo. So next time you’ve filled up the EEPROM, you can reach for this hack and log your data into flash program memory.

Thanks [Koepel] for the tip!

Logic Noise: Ping-pong Stereo, Mixers, And More

July 2, 2015 by Elliot Williams 15 Comments

So far on Logic Noise, we’ve built up a bunch of sound-making voices and played around with sequencing them. The few times that we’ve combined voices together, we’ve done so using the simplest possible passive mixer — a bunch of resistors. And while that can work, we’ve mostly just gotten lucky. In this session, we’ll take our system’s output a little bit more seriously and build up an active mixer and simple stereo headphone driver circuit.

For this, we’ll need some kind of amplification, and our old friend, the 4069UB, will be doing all of the heavy lifting. Honestly, this week’s circuitry is just an elaboration of the buffer amplifiers and variable overdrive circuits we looked at before. To keep things interesting we’ll explore ping-pong stereo effects, and eventually (of course) put the panning under logic-level control, which is ridiculous and mostly a pretext to introduce another useful switch IC, the 4066 quad switch.

At the very end of the article is a parts list for essentially everything we’ve done so far. If you’ve been following along and just want to make a one-time order from an electronics supply house, check it out.

If you’re wondering why the delay in putting out this issue of Logic Noise, it’s partly because I’ve built up a PCB that incorporates essentially everything we’ve done so far into a powerhouse of a quasi-modular Logic Noise demo — The Klangorium. The idea was to take the material from each Logic Noise column so far and build out the board that makes experimenting with each one easy.

Everything’s open and documented, and it’s essentially modular so you can feel free to take as much or as little out of the project as you’d like. Maybe you’d like to hard-wire the cymbal circuit, or maybe you’d like to swap some of the parts around. Copy ours or build your own. If you do, let us know!

OK, enough intro babble, let’s dig in.

Continue reading “Logic Noise: Ping-pong Stereo, Mixers, And More” →

DNS Tunneling With An ESP8266

July 1, 2015 by Elliot Williams 51 Comments

There’s a big problem with the Internet of Things. Everything’s just fine if your Things are happy to sit around your living room all day, where the WiFi gets four bars. But what does your poor Thing do when it wants to go out and get a coffee and it runs into a for-pay hotspot?

[Yakamo]’s solution is for your Thing to do the same thing you would: tunnel your data through DNS requests. It’s by no means a new idea, but the combination of DNS tunneling and IoT devices stands to be as great as peanut butter and chocolate.

DNS tunneling, in short, relies on you setting up your own DNS server with a dedicated subdomain and software that will handle generic data instead of information about IP addresses. You, or your Thing, send data encoded in “domain names” for it to look up, and the server passes data back to you in the response.

DNS tunneling is relatively slow because all data must be shoe-horned into “domain names” that can’t be too long. But it’s just right for your Thing to send its data reports back home while it’s out on its adventure.

Oh yeah. DNS tunneling may violate the terms and conditions of whatever hotspot is being accessed. Your Thing may want to consult its lawyer before trying this out in the world.

Embed With Elliot: We Don’t Need No Stinkin’ RTCs

July 1, 2015 by Elliot Williams 68 Comments

A lot of microcontroller projects out there need some sense of wall-clock time. Whether you’re making (yet another) crazy clock, logging data, or just counting down the time left for your tea to steep, having access to human time is key.

The simplest solution is to grab a real-time-clock (RTC) IC or module. And there’s good reason to do so, because keeping accurate time over long periods is very hard. One second per day is 1/86,400 or around eleven and a half parts per million (ppm), and it’s tricky to beat twenty ppm without serious engineering.

Good RTC ICs like Maxim’s DS3231, used in the Chronodot, can do that. They use temperature correction logic and a crystal oscillator to get as accurate as five parts per million, or under half a second per day. They even have internal calendar functions, taking care of leap years and the day of the week and so on. The downside is the cost: temperature-compensated RTCs cost around $10 in single quantity, which can break the budget for some simple hacks or installations where multiple modules are needed. But there is a very suitable alternative.

What we’re looking for is a middle way: a wall-time solution for a microcontroller project that won’t break the bank (free would be ideal) but that performs pretty well over long periods of time under mellow environmental conditions. The kind of thing you’d use for a clock in your office. We’ll first look at the “obvious” contender, a plain-crystal oscillator solution, and then move on to something experimental and touchy, but free and essentially perfectly accurate over the long term: using power-line frequency as a standard.

Continue reading “Embed With Elliot: We Don’t Need No Stinkin’ RTCs” →

The Alexanderson Transmitter: Very-low Frequency Radio Rides Again!

June 27, 2015 by Elliot Williams 44 Comments

Is your ham radio rig made of iron and steel? Is it mechanically driven? Classified as a World Heritage Site? We didn’t think so. But if you’d like to tune in one that is, or if you’re just a ham radio geek in need of a bizarre challenge, don’t miss Alexanderson Day 2015 tomorrow, Sunday, June 28th

The Alexanderson Transmitter design dates back to around 1910, before any of the newfangled tube technology had been invented. Weighing in at around 50 tons, the monster powering the Varberg Radio Station is essentially a high-speed alternator — a generator that puts out 17.2 kHz instead of the 50-60 Hz that the electric companies give us today.

Most of the challenge in receiving the Alexanderson transmitter broadcasts are due to this very low broadcast frequency; your antenna is not long enough. If you’re in Europe, it’s a lot easier because the station, SAQ, is located in Sweden. But given that the original purpose of these behemoths was transcontinental Morse code transmission, it only seems sporting to try to pick it up in the USA. East Coasters are well situated to give it a shot.

And of course, there’s an app for that. The original SAQrx VLF Receiver and the extended version both use your computer’s sound card and FFTs to extract the probably weak signal from the noise.

We scouted around the net for an antenna design and didn’t come up with anything more concrete than “few hundred turns of wire in a coil” plugged into the mic input. If anyone has an optimized antenna design for this frequency, post up in the comments?

Thanks [Martin] for the tip!

Embed With Elliot: I2C Bus Scanning

June 25, 2015 by Elliot Williams 15 Comments

A lot of great ICs use I2C to communicate, but debugging a non-working I2C setup can be opaque, especially if you’re just getting started with the protocol/bus. An I2C bus scanner can be a helpful first step in debugging an I2C system. Are all the devices that I think should be present actually there and responding? Do they all work at the bus speed that I’m trying to run? If you’ve got an Arduino or Bus Pirate sitting around, you’re only seconds away from scanning your I2C bus, and answering these questions.

Continue reading “Embed With Elliot: I2C Bus Scanning” →

Really, Really Retro Computer On An FPGA

June 23, 2015 by Elliot Williams 10 Comments

[Daniel Bailey] built himself a scaled-down clone of a very early computer in an FPGA. Specifically, he wrote some VHDL code to describe the machine in question, a scaled-down clone of the Manchester Small-Scale Experimental Machine with an 8-bit processor and a whopping 8 bytes of RAM, all of which are displayed on an LED screen. Too cool.

That he can get it to do anything at all with such constraints amazes us. Watch him program it and put it through its paces in the video below the break.

Continue reading “Really, Really Retro Computer On An FPGA” →