Monitoring Software Builds With A Traffic Light

February 12, 2012 by Brian Benchoff 21 Comments

[JD] at isotope11 was looking for a way to get instant feedback whenever a developer broke a piece of software they were working on. After finding a 48 inch tall traffic light, he knew what he had to do. Now, the entire development team knows the status of their code from a traffic light hanging in the corner.

isotope11 runs a continuous integration server to do the quality assurance on their software projects. It’s a lot more flexible than the ‘compile and pray’ setup we’re used to, but then again C isn’t very well suited to test-driven development. When one of [JD]’s developers breaks a piece of code, the CI server will send a warning to an Arduino where all the electronic magic happens.

To light the traffic light, [JD] used a few relays to drive the 120 volt bulbs in the traffic light. The traffic light is very easy to read – red means something is broken, green means everything is alright, and yellow means a test suite is being run.

Check out the video of [JD]’s TDD visualization after the break.

Continue reading “Monitoring Software Builds With A Traffic Light” →

Build Your Own Self-driving Car

February 5, 2012 by Brian Benchoff 23 Comments

If you’ve ever wanted your own self-driving car, this is your chance. [Sebastian Thrun], co-lecturer (along with the great [Peter Norvig]) of the Stanford AI class is opening up a new class that will teach everyone who enrolls how to program a self-driving car in seven weeks.

The robotic car class is being taught alongside a CS 101 “intro to programming” course. If you don’t know the difference between an interpreter and a compiler, this is the class for you. You’ll learn how to make a search engine from scratch in seven weeks. The “Building a Search Engine” class is taught by [Thrun] and [David Evans], a professor from the University of Virginia. The driverless car course is taught solely by [Thrun], who helped win the 2005 DARPA Grand Challenge with his robot car.

In case you’re wondering if this is going to be another one-time deal like the online AI class, don’t worry. [Thrun] resigned as a tenured professor at Stanford to concentrate on teaching over the Internet. He’s still staying at Stanford as an associate professor but now he’s spending his time on his online university, Udacity. It looks like he might have his hands full with his new project; so far, classes on the theory of computation, operating systems, distributed systems, and computer security are all planned for 2012.

Program A Microcontroller Over The Internet

January 26, 2012 by Brian Benchoff 43 Comments

If you’ve ever wanted to program a microcontroller “in the cloud,” you might want to head over to Inventor Town, an online IDE that allows you to write and compile firmware for the MSP430 series of microcontrollers.

After logging in with your Google account, you’re presented with a ‘My Projects’ page. From there, you can make as many projects as you like for the MSP430x2231 or ~x2211 microcontrollers. The online editor has the vital keyword highlighting feature, but sadly not many of the more advanced text editor features, like a red underlined syntax errors. After you’ve written your code, press the compile button, download your .HEX file and upload to your board.

We’re surprised we haven’t seen something like this before. To us, this seems like the ideal basis for a github-style microcontroller code-sharing website. Any enterprising ATtiny fans want to take a crack at this one?

Thanks [Rob] for sending this one in.

Controlling An LED Matrix With An Android Phone

January 23, 2012 by Brian Benchoff 13 Comments

Even though everyone with a smart phone has a small, powerful computer in their pocket, we haven’t seen many applications of this portable processing power that use the built-in camera. [Michael] decided to change this and built an LED matrix that displays the data coming from the phone’s camera.

For the build, [Michael] used two 32×32 LED panels from Adafruit along with an IOIO and an Arduino. To build the Android app, [Michael] used the Android OpenCV computer vision library that grabs an image from the Android camera and downsamples it to 64×32 pixels. This data is transferred over a serial connection from the phone to the IOIO and again from the IOIO to the Arduino. Even though each frame is 1024 bytes, [Michael] still gets around four frames per second on his LED matrix display.

After the break you can check out the results of [Michael]’s build. The video is a little choppy because of the frame rate issue, but it’s still an interesting build in the Android software development category.

Continue reading “Controlling An LED Matrix With An Android Phone” →

Neural Networks Control A Toy Car

January 3, 2012 by Brian Benchoff 27 Comments

After taking the Stanford Machine Learning class offered over the Internet last year, [David Singleton] thought he could build something really cool. We have to admit that he nailed it with his neural network controlled car. There’s not much to the build; it’s just an Android phone, an Arduino and a toy car. The machine learning part of this build really makes it special.

A neural network takes a whole bunch of inputs and represents them as a node in a network. Each node in [Davids]’s input layer corresponds to a pixel retrieved from his phone’s camera. All the inputs of the input layer are connected to 64 nodes in the ‘hidden layer’. The nodes in the hidden layer are connected to the four output nodes, namely left, right, forward and reverse.

After training the network and weighting all the connections, [David] got a toy car to drive around a track. Weird, but it works. All the code is up on github, so feel free to take a look behind the inner machinations of a neural net. Of course, you could check out the video of [David]’s car in action after the break.

EDIT: We originally credited [icebrain] as the author. Our bad, and we hope [David] doesn’t hate us now.

Continue reading “Neural Networks Control A Toy Car” →

Two Player Space Invaders Via FPGAs

January 3, 2012 by Brian Benchoff 8 Comments

Last semester, [Peter], [Jared], and [Jeremy] took a course on embedded systems. They managed to turn out a very accurate copy of the classic Space Invaders in their class. Not wanting good code to go to waste, they decided to develop two player Space Invaders, and we wouldn’t mind testing it out.

The guys built their Space Invaders clone on a Virtex II dev board. Wanting a little more hardware development, they picked up a pair of RF trancievers so the two boards could communicate with each other. The rules of two-player Space Invaders is fairly simple; if you destroy an alien, there’s a 30% chance it will appear on your opponent’s screen. Hit the space ship that flies along the top of the screen, and 1 to 7 aliens will appear on the opponent’s screen. It’s a bit like two player Tetris where your victories bring about your friend’s downfall.

The guys put a really neat spin on an old game, and we’d love to try it out. Check out the guy on the left losing a game of Space Invaders to his lab partner after the break.

Continue reading “Two Player Space Invaders Via FPGAs” →

Calculating Pi To 10 Trillion Digits; The Last Number Is 5

November 28, 2011 by Brian Benchoff 44 Comments

In August, 2010, [Alexander Yee] and [Shigeru Kondo] won a respectable amount of praise for calculating pi to more digits than anyone else. They’re back again, this time doubling the number of digits to 10 Trillion.

The previous calculation of 5 Trillion digits of Pi took 90 days to calculate on a beast of a workstation. The calculations were performed on 2x Xeon processors running at 3.33 GHz, 96 Gigabytes of RAM, and 32 Terabytes worth of hard drives. The 10 Trillion digit attempt used the same hardware, but needed 48 Terabytes of disk to store everything.

Unfortunately, the time needed to calculate 10 Trillion digits didn’t scale linearly. [Alex] and [Shigeru] waited three hundred and seventy-one days for the computer to finish the calculations. The guys used y-cruncher, a multithreaded pi benchmarking tool written by [Alex]. y-cruncher calculates hexadecimal digits of pi; conveniently, it’s fairly easy to find the nth hex digit of pi for verification.

If you’re wondering if it would be faster to calculate pi on a top 500 supercomputer, you’d be right. Those boxes are a little busy predicting climate change, nuclear weapons yields, and curing cancer, though. Doing something nobody else has ever done is still an admirable goal, especially if it means building an awesome computer.