loading
 
This project allows you draw in the air letters, symbols or other shapes - as you like.
Controlled by the Arduino, the 7 simple leds blinking on and off - creating the illusion of floating text in the air.
This combination of simple components with a unique program, allows to create  this instructable.
 
 
 
 
Remove these adsRemove these ads by Signing Up

Step 1: Assembling the electronics

Picture of Assembling the electronics
K800_P1170757.JPG
K800_P1170749.JPG
K800_P1170763.JPG
K800_P1170769.JPG
K800_P1170768.JPG
Place the leds near the edge of the matrix, so the circle it draws will be as wide as possible.
Note the polarity of the leds to be oriented in the same direction.
(You can use leds in different colors as I did with the WOOOSH case).
 
Place the Arduino near the center of the matrix and mount it to the matrix.
I used simple wires for that.
Since the bottom part of the Arduino has some conductors - I used a piece of plastic sheet as an isolator from the matrix.
 
Connect one side of the leds to the IO of the arduino (ports 1-7, leaving port 0 for the trigger).
Use suitable resistors and connect the other leg of the leds to the ground.
I used the bottom rail of the matrix as a common ground.
I used 420 Ohm resistors.
 
 
 

Step 2: Installing the platform on the motor

Now that you have the main electronic installed, you can install it on the motor - that will rotate all the platform (the matrix).
What you need is a simple DC motor (preferable with a removable shaft adapter), a piece of wood and two small screws.
I marked on the wood the required width I needed, the location of the holes for the bolts and for the shaft from the motor.
Then I drilled and sawed upon the marks.
I used the holes in the matrix to attach the wood to the matrix - using the bolts.
Note that the bolts must be long enough to grab the matrix - without passing to the other side and damage the Arduino.
I have inserted the shaft adapter into the drilled hole  - using some force. The insertion planned to be "press fit" since the forces the shaft feels are not negligible.
 
 

Step 3: Installing the battery packs

Picture of Installing the battery packs
K800_P1170814.JPG
K800_P1170819.JPG
K800_P1170826.JPG
Since the platform is turning, and the Arduino needs its food (power) - the simplest way was to install the batteries on the matrix itself - so they will rotate together.
For that, I used two identical battery packs and placed them on the opposite sides of the board - so they will balance each other.
I used simple zip ties to mount it to the matrix.
Try to install the batteries (additional weight) as closer as possible to the rotation center.
That way - the balancing problems you'll have to deal with will be smaller.
 
After mounting the battery packs, connect the wires so the batteries will be in row, to reach 6 volts to operate the Arduino.
Think about a way to switch the board on and off.
I used the power plug to the arduino as my power switch - and later (when I got lazy of plugging it in and out) I have simply pulled up one of the power chord from the board.
 

Step 4: Fixing the motor to the world

Picture of Fixing the motor to the world
K800_P1170815.JPG
K800_P1170816.JPG
K800_P1170823.JPG
K800_P1170824.JPG
For fixing the motor to a stationary object, you have to use a rigid base, so it will hold the small (or big) vibrations of the rotation - especially before the balancing was completed.
I used a nice piece of wood and a C-clamp - mounting the wood to a solid table.
Then, I used the lid of a door lock and zip ties to mount the motor to the wood.
 
 

Step 5: Powering the motor

Picture of Powering the motor
K800_20140106_182247.JPG
The power source I used for the motor was an old Nokia charger.
I have changed its connector to be as a 9 Volts battery connector.
I used this connector because it allows you to snap on one of the terminals and then -  by turning the two connectors - you can connect and disconnect the other terminal.
 
 

Step 6: Balancing the rotating platform

Picture of Balancing the rotating platform
Once the system is installed and secured to the table, it can start turning.
In the beginning, allow the matrix to turn slowly, and see if everything is well muted and there is nothing loose.
When allowing to turn faster, be aware for any excessive vibrations (which will probably accrue in the beginning), caused by the weight being unbalanced around the turning center.
Try balancing the system by sliding the batteries to one way or another, until the vibrations decrease to minimal level.
You can also move the electric components for balancing - but it is more complicate and less efficient, since the mass of the batteries is significantly bigger (and simpler to move tham).

Step 7: Setting the trigger - where everything starts

Picture of Setting the trigger - where everything starts
K800_P1170842.JPG
K800_P1170839.JPG
The trigger is the sign sent to the Arduino to start the sequence of switching the leds on and off.
In order that the image created by the leds will be stable, the sequence must start at the same angle in the position of the matrix.
The trigger I made was two wires positioned close to each other - but not touching each other.
When the platform is turning, the tip of one of the wires collides with the C-clamp (which is Stationary). As a result, the wire moves a little and touches the other wire near it - closing a circuit and sending the trigger sign to the Arduino - starting the sequence.
Since the collision repeats in the same position of the matrix, the sequence will start every cycle in the same position, and the illumination of the lamps will repeat the trail of the previous round - creating a steady image.
 

Step 8: Programming the Arduino to animate in the air

Picture of Programming the Arduino to animate in the air
The program for the Arduino can be found in the following attached text file (or at the bottom of the step).
I have attached both programs - for the FUFU, for the INSTRUCTABLES and for the WOOOSH thing.
 
The program is basically a procedure that scans a matrix of ones and zeros and turning the leds on and off  accordingly.
Each letter is coded as a matrix, and stringing the Matrices (to one long matrix) gives you the whole text.
Each column of the matrix represent one of the 7 leds mounted in row.
Each row of the matrix represents the momentary state of all the 7 leds.
Running over all the rows - gives you the final shape of the letter / symbol.
In this program, each letter has "height" of 7 leds, and "width" of 7 "micro periods" (the time the leds holding their state before next the update).
 
It is a little tricky to make the trial and error of the letters and fonts you want to write - but eventually you should very nice results.
The idea  is to think of each led as it was a pixel which is propagating with the time and by turning it on and off, you are drawing images along the circle it runs in.
 
Below is the text of the program for the Arduino to write the "instructables".
 
 
 
int timer = 1;                  // The higher the number, the slower the timing.
int pinCount = 7;           // the number of pins (i.e. the number of leds)
int arryMax = 727;          // Number of total bits in the whole string
 
int ltr8c1[] = {                //Decleration of the array - one long array of all the string
                                             // Writing "instructables"
// letter "i"  (4)                  //Looking at the matrix, top to bottom, you receive the F letter.
 
1,1,1,1,1,0,1 ,
0,0,0,0,0,0,0 ,  
0,0,0,0,0,0,0 ,                  //This line of zeroz separates the letter just completed fromt he next letter - by turning all the leds off.
0,0,0,0,0,0,0 ,  
// letter "n"   (8)
 
1,1,1,1,1,1,1  ,
0,0,0,0,1,1,0 ,
0,0,0,0,0,1,1 ,
0,0,0,0,0,0,1 ,
0,0,0,0,1,1,0 ,
1,1,1,1,1,0,0  ,
0,0,0,0,0,0,0  ,     
0,0,0,0,0,0,0 ,  
// letter "s"   (9)
 
0,1,0,0,1,1,0,
1,1,0,0,1,1,0,
1,0,0,1,0,0,1,
1,0,0,1,0,0,1,
1,0,0,1,0,0,1,
1,1,1,0,0,1,0,
0,1,1,0,0,1,0,
0,0,0,0,0,0,0 ,  
0,0,0,0,0,0,0,  
 
// letter "t"   (9)
 
0,0,0,0,0,1,0,
0,0,0,0,0,1,0,
0,0,0,0,0,1,0,
0,1,1,1,1,1,1,
1,0,0,0,0,1,0,
1,0,0,0,0,1,0,
0,1,0,0,0,1,0,
0,0,0,0,0,0,0 ,  
0,0,0,0,0,0,0,  
 
// letter "r"    (9)
 
1,1,1,1,1,1,1,
0,0,0,0,1,1,0,
0,0,0,0,0,1,1,
0,0,0,0,0,0,1,
0,0,0,0,0,0,1,
0,0,0,0,0,1,0,
0,0,0,0,1,1,0,
0,0,0,0,0,0,0 ,  
0,0,0,0,0,0,0,  
 
// letter "u"    (8)
 
0,1,1,1,1,1,1  ,
1,1,0,0,0,0,0 ,
1,0,0,0,0,0,0 ,
1,0,0,0,0,0,0 ,
1,1,0,0,0,0,0 ,
0,1,1,1,1,1,1  ,
0,0,0,0,0,0,0  ,     
0,0,0,0,0,0,0 ,  
// letter "c"    (9)
 
0,0,1,1,1,0,0,
0,1,1,0,1,1,0,
1,1,0,0,0,1,1,
1,0,0,0,0,0,1,
1,0,0,0,0,0,1,
0,1,0,0,0,1,0,
0,1,0,0,0,1,0,
0,0,0,0,0,0,0 ,  
0,0,0,0,0,0,0,  
 
// letter "t"    (9)
 
0,0,0,0,0,1,0,
0,0,0,0,0,1,0,
0,0,0,0,0,1,0,
0,1,1,1,1,1,1,
1,0,0,0,0,1,0,
1,0,0,0,0,1,0,
0,1,0,0,0,1,0,
0,0,0,0,0,0,0,  
0,0,0,0,0,0,0 ,  
// letter "a"    (9)
 
0,0,1,0,0,1,0,
0,1,0,1,0,0,1,
1,0,0,0,1,0,1,
1,0,0,0,1,0,1,
0,1,0,0,1,0,1,
0,1,1,0,1,0,1,
1,1,1,1,1,1,0,
0,0,0,0,0,0,0 ,  
0,0,0,0,0,0,0,    
 
// letter "b"    (9)
 
1,1,1,1,1,1,1,
0,1,0,1,0,0,0,
1,0,0,0,1,0,0,
1,0,0,0,0,1,0,
1,0,0,0,0,1,0,
0,1,0,0,1,0,0,
0,0,1,1,0,0,0,
0,0,0,0,0,0,0 ,  
0,0,0,0,0,0,0,   
 
// letter "l"   (4)
 
1,1,1,1,1,1,1 ,
0,0,0,0,0,0,0,  
0,0,0,0,0,0,0,   
0,0,0,0,0,0,0 ,  
// letter "e"    (9)
 
0,0,1,1,1,0,0,
0,1,0,1,0,1,0,
1,0,0,1,0,0,1,
1,0,0,1,0,0,1,
1,0,0,1,0,0,1,
1,0,0,1,0,1,0,
0,0,0,1,1,0,0,
0,0,0,0,0,0,0 ,  
0,0,0,0,0,0,0,  
 
// letter "s"   (8)
 
0,1,0,0,1,1,0,
1,1,0,0,1,1,0,
1,0,0,1,0,0,1,
1,0,0,1,0,0,1,
1,0,0,1,0,0,1,
1,1,1,0,0,1,0,
0,1,1,0,0,1,0,
0,0,0,0,0,0,0   };
 
 
 
int add = 0;
int inPin = 0;
 
int state = HIGH;         // the current state of the output pin
int reading;                  // the current reading from the input pin
int previous = LOW;    // the previous reading from the input pin
 
long time = 0;               // the last time the output pin was toggled
long safedelay = 50;   // A safety delay to avoid flickering due to multi triggering.
 
 
void setup() {                                                                                                   // Program for writing INSTRUCTABLES
  int thisPin;
 
  for (int thisPin = 0; thisPin < pinCount; thisPin++)  {                                          // use a for loop to initialize each pin as an output. The array elements are numbered from 0 to (pinCount - 1).
    pinMode(thisPin+1, OUTPUT);
   }
  pinMode(inPin, INPUT);                                                                                                          // initializesinitializes pin "0" as an input pin - used for the trigger pin.
}
 
void loop() {                                                                                                                                //Here starts the loop of the actual sequance
  reading = digitalRead(inPin);
  if (reading == HIGH && previous == LOW && millis() - time > safedelay) {      // Checking if there was a trigger. If yes and teh safety delay from the last trigger has passed, it starts the sequance.
    time = millis();                                                                                                                    // A time counter (miliseconds) - coults the safety delay time.
    for (int add = 0; add < arryMax; add=add+7) {                                                             //The "add" varible points at the relevant row - untill reaching the end of the matrix.
      for (int thisPin = 0; thisPin <= pinCount; thisPin++) {                                  //The varible "this pin"  points at the relevant column
        if (ltr8c1 [thisPin+add] ) {digitalWrite(thisPin+1, HIGH); } else {digitalWrite(thisPin+1,LOW);}  //if the relevant cell of the matix equals to 1, turn on the relevalnt led. Otherwise (if equals 0) - turn off led.
        }
     delay(timer);                                                                                                                       // Keep the current state for a while.
     for (int thisPin = 0; thisPin <= pinCount; thisPin++) {
       digitalWrite(thisPin+1,LOW);
       }
     }
  
   }
   previous = reading;
}
 

Step 9: Tips and notes

Picture of Tips and notes
Letter A.JPG
Font.JPG
Drawing trail.JPG
Balancing.JPG
Some points to think of...
Before you start to build the project, take a moment to think about the constrains and requirements of it so you'll get the best results.

For example:
- The system is turning so...
... how are you going to spread the components on the board?
... how will you bring the power to the rotating electronics?
... how will you balance the system and make it turn without vibrations?
 
how will you make the trigger to start the sequence in the same location?
 
In any case - wishing you good luck and enjoy the instructable :-)

hi every one...... i need schematic of wooshing leds

What schematic do you need?

All you need is connecting from each I/O to a led (through a suitable resistor) and to the ground.

The reset is commanding the I/O to open send the dignal to the suitable led in the suitable time.

And one more I/O is from the trigger.

Thats all the schematic.

i made it but its not wrking. so if u have schematic of these all c0nnections pls send me

kshowell1 year ago

Cool Project

yonskiboy (author)  kshowell8 months ago

10X :-)

<3

cefn1 year ago

Really nice project. If you want a generic (and slightly-better compressed) mechanism for writing any ascii characters in a variety of fonts, we invite you to rip off our POV code, which uses an 8-LED font derived from the Commodore 64, http://shrimping.it/shrimp/project/pov/ . We also have a collection of other fonts with different pixel heights which we extracted through an automated process from freely licensed TTFs http://shrimping.it/shrimp/project/pov/font/ as described at http://stackoverflow.com/questions/12988915/how-to-extract-bitmap-data-from-ttf-bitmap-typeface-for-a-pov-display

rseiyu1 year ago

Can it be done with a PIC instead of the arduino?

yonskiboy (author)  rseiyu1 year ago

I think it can, I'm don't know what are the I/O of the PIC, but it surely can run this simple program...

willi11311 year ago
hey I build this thing today and it is really awsome! I used space invader- starships instead of letters and it worked nicely. good job
yonskiboy (author)  willi11311 year ago

Hey, that's great :-) glad to hear that.

It would be great if you could send me some pictures of how you have assembled it and the resulting images...

I used 8 LED's in a row to get the starships in full size. The motor im using is a brushless stepper-motor I salvaged from a laser printer. The trigger is also from the salvaged printer (button which get pushed every round)

Thank you this project made my last 2 days :-)

IMG_20140121_085712.jpgIMG_20140121_085753.jpgIMG_20140121_085738.jpgspaceinvaders.jpg
yonskiboy (author)  willi11311 year ago
Wow... that's awesome :-)
Really great.
Did you use an external controller for the stepper motor or you just used the electronics on the original board of the printer?

the motor has an onboard driver which allows me to power it with up to 40V clockwise. It can reach up to 2100 rpm so i use a (variable) resistor to control the motor speed (so i can put every image on full size by increasing the motor speed). ;)

cgrrty1 year ago

Very nice !

This is excellent! Love the main image too :D

yonskiboy (author)  jessyratfink1 year ago

Thank you :-)

I even considered animating the robot - but there was not enough room for that ;-)