Posts with «arduino» label

Video game head tracking with Wii Remote camera

While the Nintendo Wii has been on the market for well over 10 years, its controllers continue to provide a variety of tools for hacking. One component you may want to consider for your next hack is the camera from the Wii Remote, which senses the position of nearby infrared light spots and outputs them as X/Y coordinates via I²C.

While that may instantly set off multiple use ideas, if you need inspiration, be sure to check out this setup by Jack Carter. He mounted one of these cameras to the top of a computer screen, and uses it to track an IR LED mounted to the top of his headset.

From there, an Arduino Uno translates this information as joystick inputs to the computer, which is then configured to control an in-game camera as seen in the video here.

YouTuber creates an organ out of 44 Furbies

If you think Furbies have become extinct, think again, as musical hacker “Look Mum No Computer” has decided to revive a number of them to create his own Furby Organ.

To make this horrifying yet awesome instrument, he placed 44—yes, 44—of these strange creatures on top of an organ frame with a keyboard and several dials, along with a switch labeled ominously as “collective awakening.”

Each individual Furby is controlled by two Arduino Nano boards, and as you might imagine, the whole project took a massive amount of work to wire things together. You can see the incredible results in the first video below, while the second gives a bit more background on the device’s origin.

Arduino Blog 12 Feb 21:01

The Furby Organ

Sometimes you have an idea that is so brilliant and so crazy that you just have to make it a reality. In 2011, [Look Mum No Computer] drew up plans in his notebook for a Furby organ, an organ comprised of a keyboard and a choir of Furbies. For those who don’t know know what a Furby is, it’s a small, cute, furry robotic toy which speaks Furbish and a large selection of human languages. 40 million were sold during its original production run between 1998 and 2000 and many more since. Life intervened though, and, [LMNK] abandoned the Furby organ only to recently take it up again.

He couldn’t get a stable note out of the unmodified Furbies so he instead came up with what he’s calling the Furby Forman Fusion Synthesis. Each Furby is controlled by a pair of Ardunios. One Arduino sequences parts inside the Furby and the other produces a formant note, making the Furby sing vowels.

We love the label he’s given for what would otherwise be the power switch, namely the Collective Awakening switch. Flicking it causes all 44 (we count 45 but he says 44) Furbies to speak up while moving their ears, eyes, and beaks. Pressing the Loop switch makes them hold whatever sound they happen to be making. The Vowel dial changes the vowel. But you’ll just have to see and hear it for yourself in the videos below. The second video also has construction details.

Want to make a Furby do whatever you want? Check out how [Jeija] has reverse engineered one to take control of it.

Thanks for the tip, [Måns Almered].

Hack a Day 12 Feb 16:30

Recreate Optimus Prime’s blaster with Arduino

YouTuber Bob Clagett has dreamed of creating his own life-sized Optimus Prime ion blaster for years, and now after hours of 3D printing and finishing, he finally has something worthy of that universe.

While he opted to construct it in a 1:2 scale, it’s still an impressive physical build, looking comically large, but not entirely unwieldy as a full-sized 8-foot blaster would have been.

Inside, sound and lighting effects are controlled by an Arduino, which plays clips from the show and flashes in different patterns via an Adafruit sound board and RGB LED strip.

I wanted the blaster to play sounds and have lights come out of the barrel so I rigged up an Arduino Nano with an Adafruit sound board and amp that would cycle blaster sounds and lights when a button was pressed. And because there’s always more than meets the eye, I had a separate button that played just Transformers sound clips. To defuse the LED strip when the lights fired, I printed a semi-translucent disc that would stand-off from the sides so that sound could still escape, but the light would be diffused. I decided to mount all of the audio components in the barrel so that the cannon could be taken apart to charge the battery back.

You can see the entire process in the video below, or check out his post for a summary.

Pour Reception turns water into radio controls

Using a capacitive sensing arrangement, artists Tore Knudsen, Simone Okholm Hansen, and Victor Permild have come up with a way to interact with music with two glasses of water.

One pours water into a glass to turn the radio on. Channels can then be changed by transferring water from one glass into the other, and fine-tuned by touching the outside of container. Volume can even be adjusted by poking a finger into the water itself.

An Arduino Leonardo is used to pick up capacitive signals, and data is then sent a computer where a program called Wekinator decodes user interactions.

Pour Reception is a playful radio that strives to challenge our cultural understanding of what an interface is and can be. By using capacitive sensing and machine learning, two glasses of water are turned into a digital material for the user to explore and appropriate.

The design materials that we have available when designing digital artifacts expands along with the technological development, and with the computational machinery it is possible to augment our physical world in ways that challenges our perceptions of the objects we interact with. In this project, we aim to change the users perception of what a glass is – both cultural and technical.

You can see it in action below, and read more about project in its write-up here.

Scribble is an Arduino-controlled haptic drawing robot

As part of his master’s studies at Eindhoven University, Felix Ros created a haptic drawing interface that uses a five-bar linkage system to not only take input from one’s finger, but also act as a feedback device via a pair of rotary outputs.

“Scribble” uses an Arduino Due to communicate with a computer, running software written in OpenFrameworks.

For over a century we have been driving cars, enabling us to roam our surroundings with little effort. Now with the introduction of automated driving, machines will become our chauffeurs. But how about getting us around a road construction, or finding a friend in a crowded area? Or what if you just want to explore and find new places, will these cars be able to handle such situations and how can you show your intentions?

Currently there is no middle ground between the car taking the wheel or its driver, this is where Scribble comes in: a haptic interface that lets you draw your way through traffic. You draw a path and the car will follow, not letting you drive but pilot the car. Scribble lets you help your car when in need, and wander your surroundings once again.

You can learn more about Ros’ design in his write-up here, including the code needed to calculate and output forward kinematics to set the X/Y position, and inverse kinematics to sense user input.

Be sure to check it out in the video below piloting a virtual car through traffic with ease!

Debugging an Arduino with an Arduino

As every Hackaday reader knows, and tells us at every opportunity in the comments, adding an Arduino to your project instantly makes it twice as cool. But what if, in the course of adding an Arduino to your project, you run into a problem and need to debug the code? What if you could use a second Arduino to debug the first? That would bring your project up to two Arduinos, instantly making it four times as awesome as before you started! Who could say no to such exponential gains?

Debugging an ATTiny85

Not [Wayne Holder], that’s for sure. He writes in to let us know about a project he’s been working on for a while that allows you to debug the execution of code on an Arduino with a second Arduino. In fact, the target chip could even be another AVR series microcontroller such as a the ATTiny85. With his software you can single-step through the code, view and modify values in memory, set breakpoints, and even disassemble the code. Not everything is working fully yet, but what he has so far is very impressive.

The trick is exploiting a feature known as “debugWIRE” that’s included in many AVR microcontrollers. Unfortunately documentation on this feature is hard to come by, but with some work [Wayne] has managed to figure out how most of it works and create an Arduino Sketch that lets the user interact with the target chip using a simple menu system over the serial monitor, similar to the Bus Pirate.

[Wayne] goes into plenty of detail on his site and in the video included after the break, showing many of the functions he’s got working so far in his software against an ATTiny85. If you spend a lot of time working on AVR projects, this looks like something you might want to keep installed on an Arduino in your tool bag for the future.

Debugging microcontroller projects can be a huge time saver when your code starts running on real hardware, but often takes some hacking to get working.

Arduino and processing based GUI person counter

In this post, we will make arduino and processing based GUI person counter. For person counter, we are using infrared sensor (IR). It's output is digital and is fed to pin number 7 of arduino.

The connections are as follows:


Arduino Code:

int switchPin=7;
int ledPin=13;

void setup() {
pinMode(switchPin,INPUT);
digitalWrite(switchPin,HIGH);
pinMode(ledPin,OUTPUT);
Serial.begin(9600);
}

void loop() {
  if(digitalRead(switchPin))
    {
    while(digitalRead(switchPin));        
    Serial.print(1,DEC);
    }
  else
    {
    Serial.print(0,DEC);
    }
    delay(100);
} 

Processing Code:

import processing.serial.*;

Serial port;
int val;
int count=0;
PFont f;                           // STEP 1 Declare PFont variable

void setup()  {
    size(400,400);
    noStroke();
    println(Serial.list());  // print list of available serial port 
    port=new Serial(this,Serial.list()[0],9600);        
    f = createFont("Arial",16,true); // STEP 2 Create Font
 }
  
void draw()  {
  if(0<port.available())
  {
    val=port.read();
  } 
    background(204);
    println(val);

  if(val==48)
{     fill(255,0,0);   // red
  rect(50,50,300,300);  // green
}
  else if(val==49)
{     fill(0,255,0);   // green
  rect(50,50,300,300);  // green
  count++;
}

  textFont(f,30);               
  fill(0);                         
  text("Number of Person is: " + count , 30, 30);
//text(count, 100, 100);
delay(100);

 }

/* END OF CODE */

The Via Libris is a Book that Leads You to Treasure

The VIA LIBRIS is a paperback-sized book that leads its user to a predetermined location using a special compass dial and clues.

Read more on MAKE

The post The Via Libris is a Book that Leads You to Treasure appeared first on Make: DIY Projects and Ideas for Makers.

Circuit Bent Casio SK-1 gets an Arduino Brain

The Casio SK-1 keyboard is fairly well-known in the “circuit bending” scene, where its simple internals lend themselves to modifications and tweaks to adjust the device’s output in all sorts of interesting ways. But creating music via circuit bending the SK-1 can be tedious, as it boils down to fiddling with the internals blindly until it sounds cool. [Nick Price] wanted to do something a bit more scientific, and decided to try replacing his SK-1’s ROM with an Arduino so he could take complete control it.

Replacing the ROM chip with header pins.

That’s the idea, anyway. Right now he’s gotten as far as dumping the ROM and getting the Arduino hooked up in place of it. Unfortunately the resulting sound conjures up mental images of a 56K modem being cooked in a microwave. Clearly [Nick] still has some work ahead of him.

For now though, the progress is fascinating enough. He was able to pull the original NEC 23C256 chip out of the keyboard and read its contents using an Arduino and some code he cooked up, and he’s even put the dump online for any other SK-1 hackers out there. He then wrote some new code for the Arduino to spit data from the ROM dump back to the keyboard when requested. In theory, it should sound the same as before, but with the added ability to “forge” the data going back to the keyboard to make new sounds.

The result is what you hear in the video linked after the break. Not exactly what [Nick] had in mind. After some snooping with the logic analyzer, he believes the issue is that the Arduino can’t respond as fast as the original NEC chip did. He’s now got an NVRAM chip on order to replace the original NEC chip; the idea is that he can still use the Arduino to reprogram the NVRAM chip when he wants to play around with the sound.

We’ve covered some pretty fancy circuit bent instruments here in the past, but if you’re looking for something a bit easier to get your feet wet we ran a start-to-finish guide back in the Ye Olden Days of 2011 which should be helpful.