[Matt] lives in South Africa, where homes have smallish crawlspaces (some only 30cm high!) that he can’t quite squeeze himself into. Even if he could, he probably wouldn’t: they’re apparently vacation homes for the local rats. He did, however, want to explore these spaces to get a better idea what’s going on inside, so he built a Windows Phone-controlled car with a Netduino and 3D-printed parts.
Such a specialized application requires unique parts, so [Matt] designed and 3D-printed the wheels and frame from scratch. You’ve probably noticed that the wheels aren’t your typical cylinders. The terrain [Matt] faces is sand, so the spiked shape provides better grip. The body’s design required extra attention because it holds the motors, the Netduino, the motor driver, and the battery.
A Bluetooth module connects to the Netduino and allows [Matt] to drive the car with his Windows Phone, and an inexpensive 5V LED board provides some light for those dark corners. How does it see once inside the crawlspace? It looks like [Matt's] getting to that part. His plan is to simply mount a second phone running Skype and watch the stream. Stick around after the break to see [Matt] use the car to both confuse and excite his dog.
Continue reading “3D Printed Netduino Remote Controlled Car”
The Netduino and other .NET Micro boards don’t seem to get much love, but that doesn’t mean they’re not able to use one of the coolest chips we’ve seen in a while. [Valkyrie] has written a driver for TI’s new CC3000 all-in-one WiFi chip, giving any .NET micro device a very small and very cheap WiFi connection.
A while back, [Chris Magagna] created a TI CC3000 library for the Arduino. [Valkyrie] fell out of his chair when he saw that post, as it meant the .NET Micro devices such as the Netduino could finally use this device. With a TI Launchpad and a logic analyzer, [Valkyrie] recorded all the SPI commands and responses eventually reconstructing the entire library.
As for how useful this is without any hardware, There’s already a CC3000 Gadgeteer module available from GHI Electronics.
This entire project could have been done as an app, drawing the maze and ball virtually on the screen. But that wouldn’t have been nearly as fun as what [Matt] accomplished. He built a little Labyrinth which responds to the accelerometer in his phone.
Take a close look at that handset. It’s not an Android, an iPhone, or a Blackberry. That thing is a Windows phone…. no, really! The phone doubles as a timer, which we think is a nice touch. It communicates with a Netduino which is both driving and monitoring the Labyrinth.
You may have noticed that the maze is hand-built rather than a modified commercial version of the toy. He mounted some hardboard on a pair of servo motors, then built up the maze on that surface. There is also sensing hardware that detects when the metal ball bridges two contacts. This gives us fond memories of our Minotaur’s Revenge build.
We’ve embedded the demo video after the break.
Continue reading “Smartphone controlled Labyrinth”
The Netduino, a dev board built around the .NET Micro framework with the goal of being compatible with Arduino shields just got a huge upgrade.
The new Netduino Plus 2 features an upgraded STM32 ARM Cortex-M4 uC running at 168 MHz, improving on the original Netduino’s ARM7 running at 47 MHz. In addition to some more processing power, the STM32-based microcontroller has twice the RAM and six times as much Flash memory. Also, Ethernet (10Mbps), a MicroSD card port, and of course compatibility with all Arduino shields – including the new Arduino ‘Revision C’ boards for the Leonardo – remains intact.
In keeping with the design goals of the Netduino, the new board uses the .NET Micro Framework running under Windows. It looks like OS X and Linux users won’t be left out in the cold for long, though; there’s a project to port the .NET Micro stuff over to Mono.
Tip ‘o the hat to [Jason] for sending this one in.
[Spork] over on the Netduino forums wanted to push the limits of what his little board could do. He put together a chronometer to measure the velocity of rifle rounds and Nerf darts using an Arduino-compatable CPLD shield.
The project is built around a pair of commercial CED M2 chronograph sensors; because people have the tendency to shoot through these sensors, they’re available as replacement units for much less than the cost of a complete chronograph setup. [Spork] couldn’t figure out a way for his Arduino clone to read pins with a resolution of 1 microsecond, so a Amani GTX CLPD shield was added to the build. This programmable logic chip takes the output from a chronometer sensor, starts a timer, waits for the second sensor to trigger, and stops the timer. From that, the velocity of just about any projectile can be calculated.
Of course, [Spork] needed to test his new device, so he took it out to the range and fired 25 rifle rounds through his chronometer. The result was a very nice, normal distribution centered around 2400 feet per second, exactly as would be expected. Although [Spork] didn’t test out low-velocity projectiles such as Nerf darts, we expect the same reliable results.
[Pete] has a cool new tutorial creating a re-imagining of the Atari classic “River Raid” for the PIX-6T4 micro controller based game system. The PIX is a netduino on a larger board featuring 2 analog controllers, a speaker, an sd card and an 8×8 monochrome LED display. With a resolution that low, it may make the good ole VCS look like a 360, but there is still a lot to learn about making a game at this low of a level.
The tutorial [Pete] has put together covers concept, gameplay, progression goals, screen handling and a boat load of code to show how it all goes together. Though this is for a C# based system many of the basics apply to just about any system you can imagine. So if you’re looking to learn how to handle graphics in C, sprite animation, collision, or randomly putting levels together out of tile blocks then you should take a look.
Join us after the break for a quick video.
Continue reading “Sixty4Racer an 8×8 Game”
[Fabien] wrote in to share a link to this RGB video display which he made. He’s got some pretty cool routines that make it more functional than you would think, but first we want to comment on the construction. He used an RGB strip, which makes this look like an incredibly simple build. The strip has a data and power bus running the length of it. You can it into smaller segments, then just solder jumper wires to reconnect the buses. That’s exactly what he did here, making it what must be the fastest method of putting together a display of this size (16×10 pixels).
It’s driven by a Netduino which easily addresses the LPD8806 drivers responsible for the LEDs. It gets input from a computer via Xbee, making it easy to include data from the net, or to push visualizations. The video after the break shows a [Van Gogh] self-portrait. Since 160 pixel resolution wouldn’t do it justice, the visualization software shows a zoomed in portion of the painting which is constantly panning to let you see the entire work. It’s a fabulous effect.
Continue reading “Video display from RGB strips makes it seem so easy”