DIY Lego Slit-Scan 2001 Stargate

October 3, 2015 by Elliot Williams 20 Comments

[Filmmaker IQ] has a bunch of great tutorials on the technical aspects of making movies, but this episode on copying the stargate Stanley Kubrick’s famous 2001: A Space Odyssey using Legos is a hacker’s delight.

The stargate in 2001 is that long, trippy bit where our protagonist Dave “I’m sorry Dave” Bowman gets pulled through space and time into some kind of alternate universe and is reborn as the star child. (Right, the plot got a little bit bizarre.) But the stargate sequence, along with the rest of the visual effects for the film, won them an Academy Award.

Other examples of slit scan animations you’ll recognize include the opening credits for Doctor Who and the warp-drive effect in Star Trek: TNG.

Continue reading “DIY Lego Slit-Scan 2001 Stargate” →

Embed With Elliot: Interrupts, The Ugly

October 2, 2015 by Elliot Williams 47 Comments

Welcome to part three of “Interrupts: The Good, the Bad, and the Ugly”. We’ve already professed our love for interrupts, showing how they are useful for solving multiple common microcontroller tasks with aplomb. That was surely Good. And then we dipped into some of the scheduling and priority problems that can crop up, especially if your interrupt service routines (ISRs) run for too long, or do more than they should. That was Bad, but we can combat those problems by writing lightweight ISRs.

This installment, for better or worse, uncovers our least favorite side effect of running interrupts on a small microcontroller, and that is that your assumptions about what your code is doing can be wrong, and sometimes with disastrous consequences. It’s gonna get Ugly

TL;DR: Once you’ve started changing variables from inside interrupts, you can no longer count on their values staying constant — you never know when the interrupt is going to strike! Murphy’s law says that it will hit at the worst times. The solution is to temporarily turn off interrupts for critical blocks of code, so that your own ISRs can’t pull the rug out from under your feet. (Sounds easy, but read on!)
Continue reading “Embed With Elliot: Interrupts, The Ugly” →

Numato Opsis: FPGA-based Open Video Platform

October 2, 2015 by Elliot Williams 49 Comments

Imagine that you’re running a conference and you want to do a professional job recording the speakers and their decks. You’ll need to record one video stream from the presenter’s laptop, and it’d be nice to have another of the presenter taken with a camera. But you also need to have the presenter’s screen displayed on a projector or two for the live audience. And maybe you’d like all of this dumped down to your computer so that you can simultaneously archive the presentation and stream it out over the Internet.

That’s exactly the problem that the hdmi2usb project tries to solve on the software side for open-source software conventions. And to go with this software, [Tim Ansell] has built the Numato Opsis FPGA video board, to tie everything together. What’s great about the platform is that the hardware and the firmware are all open source too.

Because everything’s open and it’s got an FPGA on board doing the video processing, you’re basically free to do whatever you’d like with the content in transit, so it could serve as an FPGA video experimenter board. It also looks like they’re going to port code over so that the Opsis could replace the discontinued, but still open source, Milkimist One video effects platform.

One thing that’s really cute about the design is that it reports over USB as being a camera, so you can record the resulting video on any kind of computer without installing extra drivers. All in all, it’s an FPGA-video extravaganza with a bunch of open-source software support behind it. Very impressive, [Tim]!

Cardboard Robot Deathmatch

September 29, 2015 by Elliot Williams 21 Comments

Fighting robots are even more awesome than regular robots. But it’s hard for us to imagine tossing all that money (not to mention blood, sweat and tears) into a bot and then watching it get shredded. The folks at Columbia Gadget Works, a Columbia, MO hackerspace had the solution: make the robots out of cardboard.

The coolest thing about building your robots out of cardboard and hot glue is that it’s cheap, but if they’re going to be a modest scale, they can still be fairly strong, quick to repair, and you’re probably going to be able to scrounge all the parts out after a brutal defeat. In short, it’s a great idea for a hackerspace event.

Continue reading “Cardboard Robot Deathmatch” →

Quantum Computing Kills Encryption

September 29, 2015 by Elliot Williams 79 Comments

Imagine a world where the most widely-used cryptographic methods turn out to be broken: quantum computers allow encrypted Internet data transactions to become readable by anyone who happened to be listening. No more HTTPS, no more PGP. It sounds a little bit sci-fi, but that’s exactly the scenario that cryptographers interested in post-quantum crypto are working to save us from. And although the (potential) threat of quantum computing to cryptography is already well-known, this summer has seen a flurry of activity in the field, so we felt it was time for a recap.

How Bad Is It?

If you take the development of serious quantum computing power as a given, all of the encryption methods based on factoring primes or doing modular exponentials, most notably RSA, elliptic curve cryptography, and Diffie-Hellman are all in trouble. Specifically, Shor’s algorithm, when applied on a quantum computer, will render the previously difficult math problems that underlie these methods trivially easy almost irrespective of chosen key length. That covers most currently used public-key crypto and the key exchange that’s used in negotiating an SSL connection. That is (or will be) bad news as those are what’s used for nearly every important encrypted transaction that touches your daily life.

Continue reading “Quantum Computing Kills Encryption” →

Minimal Mighty Mite

September 29, 2015 by Elliot Williams 23 Comments

If you’re getting started building your own ham radio gear, it’s hard to imagine a more low-tech transmitter than the Mighty Mite, but [Paul Hodges, KA5WPL] took it one step further and rolled his own variable capacitor. (That’s the beer can with tape and alligator clips that you see on the left.)

A Mighty Mite is barely a radio at all. One transistor, capacitor, crystal and inductor in the form of a bunch of wire wrapped around a pill bottle form a minimalist oscillator, and then by keying this on and off with a switch, you’re sending Morse code. [Bill Meara], of the Soldersmoke Podcast, has been a passionate advocate of the Mighty Mite, suggesting that it can be made by scrounging the 3.57954 MHz colorburst crystal from an old analog TV set, which tunes the radio to a legal frequency for ham radio operators. (It will also probably work with other low-MHz crystals from your junkbox, but it won’t necessarily be legal.)

If the crystal is “easily” scavengeable, and the rest of the radio is easily home-made, the tuning capacitor (obtainable from old AM/FM radios) can become the sticking point. So [Paul] cut up two aluminum “beverage” cans, wrapped the inner one in electrical tape, hooked up wires and made his own variable capacitor. By sliding the cans in or out so that more or less of them overlap, he can tune the radio to exactly the crystal’s natural frequency.

If you’re interested in building a Mighty Mite, you should definitely look at the topic on Soldersmoke. There are more build instructions online as well as plans for an optional filter to take off the harmonics if you’re feeling ambitious.

If you’re not a Morse code wiz, we can’t help but note that you could replace the key with a simple FET (we’d use a 2N7000, but whatever) and then you’ve got the radio under microcontroller control. Scavenge through Hackaday’s recent Morse code projects for ideas, and we’re sure you’ll come up with something good.

Continue reading “Minimal Mighty Mite” →

Let’s Make Robots Changes Hands: Kerfuffle Ensues

September 25, 2015 by Elliot Williams 69 Comments

There’s been a bit of a shakeup at Let’s Make Robots (LMR).

LMR is possibly the most popular DIY robotics website around and was started up by a fun-loving Dane, [Frits Lyneborg]. It grew a large community around building up minimal robots that nonetheless had a lot of personality or pushed a new technical idea into the DIY robotics scene. [Frits] says that he hasn’t had time for DIY robotics for a while now, and doesn’t have the resources to run a gigantic web forum either, so he worked out a deal to let the Canadian hobbyist supply company Robot Shop take it over.

LMR has always been a little bit Wild-West, and many of the members quite opinionated, and that’s been part of its charm. So when the new corporate overlords came in, set up “Rules” (which have seemingly been downgraded to “suggestions”) and clarified the ownership of the content, some feathers were ruffled.

A few weeks later, everything looks to be settling back down again. (Edit: Or has it?!? See the comments below.) We wish LMR all the best — everyone loves robots, and LMR is a tremendous resource for the newbie interested in getting into DIY robotics on the cheap. More than a few LMR posts have been featured here at Hackaday over the years. Among our favorites are this drumming rover, a clever 3D printed gripper, and this wicked bicycle-style balancer.