1. 1. The Processing console;
2. 2. An Arduino board;
3. 3. A breadboard;
4. 4. 3 BDX53F transistors;
5. 5. A 12V/1.5A adapter;
6. 6. 3 computer fans;
7. 7. 8 threaded bars;
8. 8. A couple of blue LEDs;
9. 9. Three flash lights;
   
10. 10. 9 laser pens.

First of all I had to fix the computers fans on an horizontal position. With the help of the threaded bars (4 for each fan) I screwed the fan on the desired position:

As I said before I needed 4 threaded bars for each fan in order to keep it horizontal. Here is a picture with the four bars into place:

What I did next is to attach a flash light on the bottom. The reason why I did this is because I wanted my installation to be viewed in a low light condition, but because the light emitted by the LED was too low during my testing, I decided to help the situation with the flashlights. Below a picture about how I attached the toarch into the structure:

Next thing was to attach somehow the 3 laser pens on top of the structure. To do this I used a couples of old computer adapter fans, and then stuck the laser pens on theyr grid. As you can see from the picture below, I had to put some tape around the lasers so that they would stay switched on for all the duration of the exibition:

On the next step I attached some lucid paper (blue) on the center of the fan. This will, together with the laserpens and the LED, give a better experience, by amplifying the different speeds of the fan. Here is a picture explaining this step:

Next step was to solder and stick on the top the blue LEDs, but unfortunately I forgot to take a picture of this point. Nevertheless below you will find a picture of the completed work ready to be started:

As you will notice, at the end I choose to put simple paper instead of the blue plastic sheet, this due to the fact that at high speed the blue plastic bumped on the threaded bar, producing this fastidious sound. Another thing that I decided to use in the end, was some mirrors on the base of each one of the structure, so that the effect would also be emphasized, and to place the fans at different heights so that it would be more understandable that they rapresented the three different frequency bands of the sound.

import krister.Ess.*;
import processing.serial.*;

// “bufferSize” defines the buffer used to read and
// process the signal from the microphone
int bufferSize;

// “steps” and “limitDiff” define the scale of the reading
int steps;
float limitDiff;

// numAverages defines the number of averages computed between
// the reading of all the frequency bands
int numAverages=3;

// the value of “Damp” defines on how similar and smooth should be
// the frequency band

float myDamp=.1f;

// “maxLimit” and “minLimit” define the lowest and the highest value
// of the reading scale
float maxLimit,minLimit;

// “bass”, “medium” and “high” are the variable that will store the
// output value to be sent to the Arduino board
int bass;
int medium;
int high;

// “myPort” is dedicated to the Serial port
Serial myPort;

// “myFFT” is dedicated to store the array with all the readings
FFT myFFT;

// “AudioInput” is the variable to store the audio
AudioInput myInput;

At this point I start with the setup of the stage, I initialize the libraries and call all the functions to read the audio

void setup () {
size(700,221);// start up Ess
Ess.start(this);

// set up our AudioInput
bufferSize=32;
myInput=new AudioInput(bufferSize);

// set up our FFT
myFFT=new FFT(bufferSize*2);
myFFT.equalizer(false);

// set up our FFT normalization/dampening
minLimit=.005;
maxLimit=.05;
myFFT.limits(minLimit,maxLimit);
myFFT.damp(myDamp);
myFFT.averages(numAverages);

// get the number of bins per average
steps=bufferSize/numAverages;

// get the distance of travel between minimum and maximum limits
limitDiff=maxLimit-minLimit;

frameRate(25);

myInput.start();
myPort = new Serial(this, Serial.list()[2], 115200);
}

I start by drawing on the stage the waveform and the spectrum

void draw() {
background(0,0,255);

// draw the waveform

noStroke();
fill(255,128);

// draw the spectrum

for (int i=0; i
rect(10+i,10,1,myFFT.spectrum[i]*200);
}

Then we start to calculate the averages. As I set up the numAverages to be 3, the loop will continue as long as the “i” variable will not reach the number of 3. I declare the variable “tuning”, that I always use as a multiplier in case the signals that I get become too low. Than I draw 3 rectangles, each one set to be tall as the average of the first, second and third frequency range.

// draw our averages
for(int i=0; i)

{
int tuning=74;
fill(255,128);
rect(10+i*steps,10,steps,myFFT.averages[i]*200);
fill(255);
rect(10+i*steps,(int)(10+myFFT.maxAverages[i]*200),steps,1);
rect(10+i*steps,10,1,200);

Now, I start to retrieve the final values that I have to send to the board. I transform the value into an integer, as the “myFFT” variable was decleares as a float, and multiply the result by the “tuning” variable, that I can easily adjust if I should need to do so. I print everything on the Processing console for debugging, and then send the values to Arduino. Note that I added 33 to the “bass” variable, 108 to the “medium” and 183 to the “high”. I did so because Arduino will read the range between 33 and 108 and assign the value to the pin dedicated for the bass fan.

int bass = int(myFFT.averages[0]*tuning);
int medium = int(myFFT.averages[1]*tuning);
int high = int(myFFT.averages[2]*tuning);
println(byte(bass+33));
println(medium+108);
println(high+183);
myPort.write(byte(bass+33));
myPort.write(byte(medium+108));
myPort.write(byte(high+183));
}

At the end I call the function that reads the input from the soundcard

public void audioInputData(AudioInput theInput) {
myFFT.getSpectrum(myInput);
}

The Processing code is also finished! Let’s build the structure: Link!

First of all I declare the “incomingByte” variable, which will be the variable that will store perhaps the incoming bytes from the Processing console. I declare also the variable “tuning” that will serve as a multiplier to fine tune the output from Arduino to the fans. Finally, I initialize the serial port and set the baud rate to the maximum.

byte incomingByte;
int tuning = 6;
void setup()
{
Serial.begin(115200);
}

I set the Arduino board on a listening status. I start the conditional that act as a switch. If serial data arrives, than go to the next section.

void loop()
{
if (Serial.available())
{

While receiving the serial data (the function Serial.available() gives me the response about the reception of serial data), I read the serial port and store the first byte coming into the “incomingByte” variable. I then, transform it into an integer, ready to be written on the PWM pin of Arduino.

while (Serial.available())
{
incomingByte = Serial.read();
// Transform the byte into a numeric value
int pointer=int(incomingByte);

Here I start the sub selection. As I said, because I did not find out a way to send multiple bytes from Processing all at once, I set Processing in a way that will output the signal for the bass on a range of numbers that go from 32 to 107, the medium from 108 to 182, and the high frequency from 183 to 255. I omitted bytes values from 0 to 32 because they are special characters, and often gave my errors during the reading. So, if Arduino receive a byte for the bass (between 32 and 107), with a proportion, I calculate the percentage of a range between 0 and 255, which is the output available for the analogWrite function, related to the range that I set in Processing which goes from 0 to 74. I used the proportion on this way: 255:x=y:74. Because I know the value of y, that is the numeric value of the incomingByte variable, then is easy to find the value of x, which is given by the following operation: 255/74*x. I added, at the end, the tuning variable, which is the multiplier of the result given by the operation, just in case values where too small to make the fans turn around. Once I get the final value, this number is sent to the desired pin using the Arduino function analogWrite(number_of_pin, value_between_0_and_255) that output the signal using the technique of the Pulse Width Modulation, used by digital devices to simulate analog output. More information about PWM can be found here: Link.

// Range for bass
if (pointer > 32 && pointer < 107) {
int incomingInt = int(incomingByte)-33;
int bass = (255/74*incomingInt) * tuning;
analogWrite(9,bass);
}

// Range for medium
if (pointer > 108 && pointer < 182) {
int incomingInt = int(incomingByte)-107;
int medium = (255/74*incomingInt)* tuning;
analogWrite(10,medium);
}

// Range for high
if (pointer > 183 && pointer < 255) {
int incomingInt = int(incomingByte)-183;
int high = (255/74*incomingInt)*tuning;
analogWrite(11,high);
}
}
}
}

Finish! I close the conditional statements, and the loop status and upload everything into Arduino. Let’s get to the Processing code now: Link!

This circuit can be used as an amplifier to switch on and off a DC motor and to regulate its spinning speed with a PWM source generator. In my case the PWM generator would be the PIN 9, 10 and 11 from the Arduino board.

Given that the adapter that I will use to drive my 3 computers fan has a voltage of 12V and an intensity of 1,5A, a common npn transistor would not do the job and burn quite fast. From the datasheet, you can see that the BDX53, the transistor that I chose is used to drive small drills, for example, so perhaps it would be quite good for the completion of my project. The diode, put in parallel, is used to control and limit the extra tensions that can be generated by the adapter that would damage the transistor. A good one to use is the 1N4007. The regulation of the spinning speed of the motor is set by the frequency and duration of the on and off status of the PWM, but you don’t have to worry about, as the calculation would be made by the Arduino board. You should only write analogWrite on the code, together with the output pin chosen and an integer between 0 and 255 (e.g. “analogWrite(9, 255)” would set up the maximum output. I hav found out that PWM frequency of on and off status vary beetwen 20.000 and 30.000 Hz, so that the board does not produce any sound that can be heard by the human hear.

Below you will find a scheme to explain how PWM works. The faster the frequency between the on and off status is, the higher is the faked analog voltage output. The slower it is, the lower the voltage.

Below an image on how to connect the BDX53F to the circuit:

And here is how it looks completely built for all the three PWM channels of Arduino:

One is ESS and the other one is Sonia. I tried Sonia first but I found out that it reads the signal but has no maximum value, so you can’t really measure the percentage of the volume or of the peaks of a certain frequency band because you don’t have any fixed point to compare your values against. There is an addition to this library which is called Sonia Helper.

To male things simpler I tried out the ESS library and it gave me what I wanted. Together with an FFT reader, it comes packed with an equalizer, so that is easy to divide bands of frequency and have a representation of music divided by frequency rather than spectrum, and that is a more common experience to be read by our eyes rather than showing the spectrum. So I will use the average between three sound frequency, the high, medium and bass, and translate them into an amplified experience of the movement of the air through our mouth, with the help of the three fans. As I said before, Arduino alone is not enough to drive the three fans, so my next step is to build a sort of amplifier driven by the outputs of the Arduino board

What we have to do here is to build a little amplifier. I will try with simple npn transistors, and see what happens. I have been told that probably they would burn up and that I would have to buy a more powerfull type. Here is a picture of one of the three fans that I will be using on my project:

Instead of having the toys fly when they receive the message from the radio controller, I will stop them, control them directly with the Arduino board and make something else fly. Another problem that I encountered is that the piezoelectric pad needs to be amplified to produce a sensible voltage signal change, and the value will only be read for fractions of seconds so the visible output will not be so spectacular.

So, what I thought is to use a microphone instead of the beating pads. Extract three different frequencies of the source spectrum, and drive three computer fans instead.

Let’s go back to work.

So I rebuilt the radiocontroller, to try without computer or messy wires, and then I got the bad new. It is made to be controlled only by on and off. If you put the trigger halfway, the outpt wont change. That is why it was so difficult to keep it in position.

Below is a picture of the piece of the radiocontroller board that should control the output power. I did notice before, and I suspected it, but I wanted to try with the tester first.

The trigger part is nothing more than a switch, unfortunately, or at least on this model.

Forgive me for the bad graphic design, but here is what. If the trigger stays on the green part, the toy flyes, if on the red part it stays on the floor.

I don’t know if I should try with another model or remake the plan for the project.

Here is the flying toy complete package. Is made by the radio controller, the flying toy itself and a charger for the battery that is inside the disc.

On this picture, the radiocontroller after I opened it. Differently than what I thought, the trigger does not command a potentiometer, but uses this strange technique on which three tracks of the board are short circuited together. Quite strange, I will have to find out how id does work.

On this last picture, a close-up of the radiocontroller circuitry, and of the trigger that commands the action.

Let’s see what i get.

In the website also some tutorials on how to interface Arduino with the program.

Read more here: vvvv