A Cardboard Televisor (with Arduino and LEDs)

Recently I saw a documentary about the history of the television. And to my surprise they showed that there existed a mechanical television before the well known CRT televisions.

Those mechanical televisions or televisors were pretty smart and simple.
A CRT is simply an electron beam that scans a surface covered with a luminescent phosphor line by line. And the intensity of the beam is then directly proportional with the whiteness of that particular spot on the screen.

A televisor works in a very similar way. But instead of an electron beam, holes are used. Holes in a spirally pattern on a disk scan a small area as the disk rotates. After that particular area an electrical lamp varies its intensity. Bright means a bright spot wherever a hole is located.

There are some videos on youtube from people who have built other televisors. With more lines and far better image quality than this one. (but they aren't made out of cardboard)

This instructable documents the build of such a very small 24 line televisor completely from scrap cardboard, scavenged electronic parts a laptop and an arduino.
The image quality is very, very low but it is built out of cardboard and it has only 24 lines.
But it was a fun build.
If you want a good display, there are much better alternatives, (pretty much everything is a better alternative).

A lot of things that I did here were a first for me so I had to improvise and will have missed out on probably much more efficient solutions. So, expect some very naive approaches.
But the final result kind of works and can display something in a recognisable way. (But that's about it)
I have updated some things and mentioned what could be done better.




This is the general structure of the instructable:

Step1: Materials
Step 2-8: Building the cardboard hardware of the televisor.
Step 9: Building a led lamp.
Step 10: Making a speedometer to register the rotating speed of the disc.
Step 11: Writing a program to convert normal photo's/images to a sound file. (to modulate the lamp)
Step 12: The electronics.
Step 13: Arduino to control the speed of the disc.
Step 14: Results


Have a good read. And thank you to the people in the comments who gave a lot of good advice.

Step 1: The Materials

The body
The Device itself is made out of white, pressed cardboard.
Most of it is of 0.8 - 1 mm thick. This cardboard is easy to cut and quite strong.

The disc
The disc is also made out of cardboard but a thicker and stiffer piece. ~1.6 mm thick.
However I think it would be best if something else is used such as wood or plastic. Because this cardboard likes to flex and bend and as you will see the disc must enter in a narrow split and this bending can cause friction.

The electronics
Three simple circuits are made. Two require a MOSFET to switch the larger currents.
A single rail op amp is used to amplify the audio signal.
More on the electronics in step 12.
LEDs are used as the light source of the televisor.

An Arduino
An arduino is used to control the motor speed.

A laptop
To convert images to audio and play them to drive the LEDs.

Step 2: The Disc

An important part of the televisor is the disc.

As mentioned in the intro, the disc has several small holes and each one scans a line of a certain area as they pass over a small window (see next step).

To maximise the usable size of the window it is most convenient to place the holes in the area close to the edge of the disc. Each hole is made on a different concentric circle with a small phase difference in such a way that as the disc turns, only one hole is visible at a time in the window.

I have used inkskape to make a template to easily locate the positions of the holes.
The radius of the disc is 20 cm since that is about the largest size that can be printed on A4 paper.
The disc has 24 holes each separated with a phase of 14.8° because this makes the interval between the last and first hole a bit larger than the rest.  The original idea was to make a camera and the consistent, periodic dark interval could have been used to recognise the transition to a new frame image. But in the case of the televisor it is mostly useless, but it can ease with manually tuning the rotation speed of the disk.

The locations of the holes are marked by a series of 24 red circles.  This series is then rotated 14.8° repeatedly.  Note that in each set of red dots only one hole should be drilled. The others should be ignored . (counting is less work than deleting all those extra unused dots)

This template is printed out (don't convert it to jpg or an other non-vector format because the dots are so small that they will be blurry if you print them.) and cut out.

With a compass, a circle of the same size is drawn on a piece of cardboard. 1.6 mm thick Mat cardboard. (it is maybe better that something stiffer than cardboard is used for the disc) and this is cut out too.

The template is placed on top of the disc and secured with some tape. 

Each hole must represent one line of the image, so each hole must be on a different concentric circle.  The most convenient is a spiral pattern (it is not per se required, but if not, thenthe order must be remembered). So, in the first line the first dot is marked , the second line the second dot ...

The marking happens by pressing a needle point in the dead centre of the dots.
The visible indentations made by the needles can now be used to drill out the holes.

The disc must of course spin around. This will be done with the aid of a small electro motor.  A broken propeller was still attached to the motor and the extension used to keep the propeller on, could be used to attach the disk.


(I have also uploaded the svg file, you can find it below)

Step 3: The Window

The disc will turn and the holes will pass in front of a small window.  Behind the window a lamp (see further)  is located which will shine trough the window via hole that is located there to the observer.  The brightness of the lamp then directly translates into the brightness of the spot of the image where ever the hole happens to be located at the time.

First of all, the window is not per sé necessary. But if the window is not present, the image is just repeated (and shifted a line) above and below the middle image. Look here for an example of that. The televisor in that video is in color and is very good.  Don't expect that good quality for my small televisor.

The purpose of the window for me is to keep the light somewhat contained and to eliminate those extra frames.

Remember the small extra shape in the template of the previous step, this is the shape of one frame and thus the ideal window. Due to the fact that the holes move on circular paths, the shape isn't rectangular but rather cut-off circle segments.  In this way each hole traverses the area in the same amount of time. (it is easier to modulate the image in this way than to calculate in variable traversing times. And in the primitive way I convert images later on, this will cause some distortion, mainly due toe the fact that my disc is so small).

The frame of the window consists out of two circular discs (the shape is completely arbitrary) each 5.5 cm in diameter in which the cut-off circle segment shape is cut out. Note that I have elongated the shape a bit towards the centre. This can be done without problems. The vertical (left and right) boundaries are defined by the extension of the holes.  The horizontal (top and bottom) ones are not (because the holes turn on a disc).

Two of these disks are needed. One in front and one behind of the spinning disc and the windows themselves must be aligned.
They are painted black to reduce internal reflections (that was mainly a concern when I still intended it to be a camera).

The  disc must be free to spin between those windows so, the outer edge of the spinning disc is marked and a moon shaped spacer is made (4.5 mm thick in my case) so that the two discs can be glued together with much room for the free movement of the spinning disc.
Look at the pictures to actually intuitively know what all this explanation is about.

Note that in the final result only one hole is visible in the window and that all holes systemically scan the surface of the window. (or rather a part of it since I extended the window)

Step 4: The Motor Holder

The motor that spins the disc must of course be secured to something.
For this, some sort of arm is made.  This arm will extend from a yet to be made main body (that holds the window) to the motor.
Forgive me, but for this thing I did not measure a lot, it grew more or less organicly and I shaped as it seemed fit at the moment. 
And it is by far not the most efficient form.
Look at the schematic in the pictures, this step concerns the green stuff.  The schematic should bring over the ideas that went in this arm.

The general picture is this:
A small cylindrical hole that holds the motor is required (the shape of the hole is completely dependent on the geometry of the motor.  And a large cylindrical hole is needed trough which the internal structure and light of the televisor will go. The only requirement is that the window is entirely visible trough it (I have cut a bit of the 'finer' part of the window since the window is too large there). See next step to see what happens with the larger tube.
The small holes should fit tightly around the motor so that he needn't be glued in, but is held there by friction alone.

Three of these shapes are made with each large hole the same size. The smaller holes depend on the geometry of your motor.

Look at the pictures, especially the schematic.  The schematic is not exactly to scale but contains all elements. (except the spacers)

1 Blue =  window
2 Green =  motor arm
3 Pink  =  motor

(used in next step)
4 Black = tube
5 Orange = tight fit rings
6 Yellow = disc

Step 5: Assembly

The window is still loose but will be attached on a tube (nr 4 ) .  This tube will then be inserted into the opening in the motor arm.

For the tube, a piece of cardboard  of about 7 cm * circumference of the hole in the motor arm. (you have to measure that, that's why there is a caliper in the pictures and you know 'Diameter x pi').

This piece of cardboard is then bent into a tube and painted black.

This tube will be inserted into the hole in the motor arm, but to do this as tight as possible, two extra rings (which are trimmed to the shape of the motor arm (5(orange) in schematic) ) are made.  These will be glued on the opening of the motor arm so that the tube can be inserted very tightly without being glued in.

Onto the tube another fine ring (most upper nr 5 in schematic)  is slid  (and glued) at the very end. This is just to increase the surface of the end of the tube.  Onto the tube with the help of the ring the window discs are then glued in such a way that the circle segment hole is completely inside the tube. (look at the pictures)

The tube is then inserted into the motor arm and since no glue is needed there, the position of the window can be tuned and tweaked so that when the disc is attached to the motor, it can turn freely between the window discs.

If all this is done with some care, the disc should be able to turn freely and when looking trough the tube the holes should cross the window one by one. (and as soon one hole disappears, the other one should appear immediately except for he last and first hole. )

Step 6: The Lens

Since this was originally intended as a camera, a movable lens was required in order to focus an image.
However, the camera idea is abandoned and the lens is not per sé required.

However, since the displayed image is quite small, a lens might not be a bad idea and it looks good.

A lens is mounted in two telescopic tubes to allow some crude movement (again not needed since it is no longer a camera).

A rectangle the size of 4.6cm  x the circumference of the lens is cut and bent into a tube.
Some small strips are cut in pieces, these will form a small barrier in which the lens is secured (without glue).
And finally a larger strip is cut with a length equal to the circumference of the tube (so, larger than that of lens alone because of the thickness of the cardboard).
The small securing strips are glued in two lines onto the cardboard so that when the tube is closed, the lens can be secured between those lines and some of the strips stick out and allow for the tube to be securely glued together.
The larger strip is glued around the outside of the tube. This will prevent the lens tube from sliding too far in the other tube (look at the pictures, you will see).

This lens tube will then slide into a slightly larger tube which is in its turn glued onto the window. (the front side now).

The same as the previous tube.
A piece of cardboard of 2.5 cm x the circumference of the first tube is cut out and bent into a tube.
A smaller ribbon is again glued on the outside. This just increases the area of the tube in order to glue it more effectively on the window.

The outer tube is then glued onto the window and the lens tube is inserted when dry.

Step 7: The Outside Wall

Since the lens is quite heavy and is attached to the window and the window itself is only held together on one side with a moon shaped spacer, the entire thing flexes a lot.
Therefore, it is best to reinforce everything with a strong outer wall.

This outer wall will again be a tube with the same radius as that of the window discs. 

Two discs with the same diameter of the window discs are made.  These will serve as the front and back of the outer wall tube.
At the front, the lens tube should be sticking out.  So in one of the discs a hole with the diameter of the lens tube is cut.  Note that the discs are parallel with the window discs and that the lens tube is not perfectly aligned (it is aligned with the hole in the window). So, a little caution is needed with cutting out those holes. (the shape should resemble that of a solar eclipse with a small moon).
The same for the back, a hole with the diameter of the back tube is cut out, again being aware of the position of the tube.
I made the opening for the back tube a bit too large, that's what the extra black strip is for. Also, the back tube is not yet glued together but is held together by the rings and opening in the motor arm.  It also looks better when you first glue on this strip.

Those two rings are then glued in place so that the front ring is aligned with the window discs and the large curve of the motor arm and the back ring.

Then the outer wall is simply a bent piece of cardboard with the width equal to the distance between the front and back ring and the length the outer circumference of those rings (or window discs).

Carefully an opening for the motor arm and a slit where the disc enters are made. This can be easily done on sight with a pencil.

The outer wall tube is then painted red and glued in place.

Since the motor arm is now the ugliest bit, an extra cover is made but this time for the motor arm. The hole is unnecessary but it adds some complexity. (see last picture of this step, in the next step this cover can be seen painted black and glued on the motor arm.

Step 8: The Cap

The back tube is still open.

A removable cap is made.
The cap is very simply a cardboard strip with the circumference of the back tube as length.  This strip is then bent into a circle and glued around a small disc. I used a disc that was cut out while making the large opening of the motor arm.
An extra small piece of cardboard is glued on to secure everything.

The inside is painted black (I was still going for the camera). And the outside red.

The cap can then be placed on the tube (not glued!).

Step 9: The Lamp

A televisor needs a light source that can change its intensity in order to produce an image.

As a light source I use 6 red LEDs. It doesn't really matter what colour or what kind of light.  (if you use a RGB LED for example and you modulate the red , green and blue separately you can easily construct a colour screen, but I will use the sound jack from my laptop to drive the LEDs , so I only have 2 separate channels (Stereo, one right and one left ear). And I will only use one, so one colour.)

The LEDs are used in parallel, their cathode and anode are soldered on two circular pieces of copper wire.  A small one in the middle for the cathodes and a larger ring for the anodes.

The rings  are mounted on a small cardboard disc with a diameter equal to the inner diameter of the back tube. A small wire is soldered on each copper lead.

Six holes are made in an other cardboard disc of the same size. (inner diameter of the tube)  The LEDs are pushed trough those holes.  Some aluminium foil is glued on the cardboard (not the LEDs) to reflect the light going backwards.

Then, a fine ring is cut out of cardboard and on that ring some fine tissue paper is glued this is to diffuse the ligt so you don't see 6 bright dots. The ring gets 4 legs so that it resembles a table and the legs of this table are then glued on the disc with the aluminium foil.
Some thin cotton wool is inserted to scatter the light even more.

Then Finally the table is then wrapped in a layer of aluminium foil to reflect light going sideways. (remember I painted the tube black, because scattering on the walls would have been bad for a camera, but for the televisor as much light as possible is needed.

Step 10: The Speedometer

The final thing to add to the device itself is some sort of sensor to monitor the rotation speed.
Because I will modulate my images at 12 fps, the disc must spin with 12 revolutions per second. And there is need of a way to monitor that speed.

A simple and primitive way of doing this is to have two wires sticking out and a conductor mounted on the disc. Every time the conductor touches the two wires they are connected and this signal can be detected with e.g. an arduino.

It just consists out of a piece of cardboard that can glide in a holder (to move the wires closer or further) it has a vertical part in which the wires are held onto the spinning disk .  And an extra piece of cardboard then secures the wires a bit more

Here is a simple schematic of the detector.

This is then glued on top of the motor arm.
An extra piece of aluminium foil is then glued onto the disc to make the actual connection between the two wires.

Step 11: Converting Images to Sound!

In order to play something on the televisor, an image (film consists out of separate images) must be modulated into a varying light intensity of the LEDS inside the televisor.

As each hole traverses the window, the varying intensity of the LEDs determines the intensity of that particular location wherever a hole is located at the moment. Thus the image is formed line by line.

I have already said that the intensity of the LEDs will be controlled as an audio device.  This is just simply audio coming out of a headphone jack of my laptop into an amplifier to the LED. (more on that later)
So, the program needs to convert the whiteness of the lines to a voltage in the audio output of my laptop.
Basicly a sound file must be created and played, it is as simple as that.

In order to do this, an image is taken and divided into 24 columns (each one represents a hole crossing the window).  Then each line is converted into a greyscale image.
The whiteness or intensity is calculated like this:

Each pixel has a red, green and blue value,  together they form the specific colour you see. To convert  these red, green and blue values into the general intensity perceived from the eye, following formula is used:

                                                                              intensity = 0.29*Red + 0.71*Green + 0.08*Blue.

This is because the sensitivity of the eye differs for different colours. (Also, note that in the wikipedia article there are 2  formulas, but since I came upon the second one the most, that's the one I'm using. And it was determined for use in televisions so it is most appropriate (but it doesn't matter which one of the two is used, there isn't much difference)
Note that I immediately store the intensity in an array of 'shorts' this is because a short is 2 bytes or 16 bits long which is the resolution I use for my wav file.

There are now 24 arrays of intensities which have to be put in a WAV file. Depending on the sample speed, these arrays are binned.
E.g to build my WAV file, I want to play it at a sample speed  of 44100 Hz which is the most common sample rate.  And the disc takes 1/12 seconds to revolve.  And each hole traverses the window during the period that the disc needs to rotate 14.8 degrees, so one 14.8/360 part of a rotation.  So, simply following formula is used:

                                             amount_bins =  SPS * (Rotationperiod) * (fraction of rotation a hole is visible) 

This amounts to 151 (rounded) bins in my case.
So, in simple terms, the image is now divided into 151 rows and 24 columns.  And all the parts are averaged internally so you end up with a greyscale image of 24 by 151 pixels. 


From this converted image the 24 rows (each one an array of 151 numbers) are then stitched together after each other to form an array of 24*151  = 3624 numbers or samples.  When this data is put in the WAV file, it will play the sound that is needed to produce an image.

BUT , one revolution of the disc takes 1/12th of a second and with a sample rate of 44100 Hz this accounts to 3675 samples. So, you see that there are 51 numbers not used.  And this is totally fine since that is just that small piece of unused space on the disc if you look at the template of the hole positions in one of the first steps.

This is basicly all the important stuff.
Now the data is simply put in a WAV file.  I refer to this page on the WAV soundfile format to know in detail the arrangements of the bytes.  You will clearly recognise everything from that page in the makeWav() function (and the printInfo() fuction)  in the file 'wavreader.cpp' .  I just simply binary print all the stuff they say.

What you end up with is an audio file.  If the disc from the televisor is spun up to the right speed and the sound file is played (repeated a 1000 times for ease) then the image can be clearly seen skimming across the screen. 


So, first of all for the program itself  I use Magick++ because ImageMagick is incredibly powerful and easy to use. I was very delighted that it also provided an image editing library for C++ called Magick++.
All the reading and writing of pixels was done with this library.  There is a lot of explanation on how to install and use it on their main page, for linux, mac and windows.

Secondly I an old small piece of cod that I have written a long time ago.  I wanted to read the data from a WAV file so I wrote a wavreader. Beware that it is some dirty code (remember the warnings).  It is a mix of C and C++, it works fine but it isn't right.
The problem was (and still is) that I don't know how I can have an fstream as a member in a class. Or something easy that permanently remembers at what position it is at in a file. So I went C style and used a simple file pointer.


So, I use Linux and this is the compile command that works:

    g++ -O3  -o image main.cpp wavreader.cpp `Magick++-config --cppflags --cxxflags --ldflags --libs`

(if you try it, you will see 3 warnings that some return values are ignored, it's not that bad, just solving them adds some (for me) useless stuff to some really small functions).  (and the -O3 is a bit for speed, but it doesn't matter since I haven't tried this program with huge batches of pictures)

Of course you can use your favorite GUI just beware that it isn't a normal flag. I've never seen this before, but Magick++-config is something that automaticly prints out the flags hence the ` ` symbols.
And in qtCreator for example you have to add this line to the pro file:
QMAKE_CXXFLAGS += $$system(Magic++-config --cxxflags --cppflags)
(which is weird, that's why I made it it in Codeblocks where you could just add the stuff litteraly as it appears in the compile command)


To actually use the program you just type:

   ./image Saturn.jpg 

(which is in my case the saturn image from wikipedia) After a quarter of a second or so, the image above this page is returned together with the audio file (below).
Look at the picture of the audio file in the audio, you can clearly recognise the left side of the ring in the double peaks! (Saturn.wav)






If you give two images as argument, the program stitches them together automaticly: (and names the .wav as the first argument)
e.g. 

   ./image Saturn.jpg face.jpg

(the face was that from René from 'Allo 'Allo! )
This gives then following wav file: (again named Saturn.wav)




But to demonstrate the capabilities of this little program lets examine this gif:  (got it from here)
You can then get with Imagemagick all the separate frames. If you place them into a folder and unleash the image program onto them you get a bunch of converted images from which you can make a new gif:



(I have converted all the converted images back together in a gif, this doesn't happen automaticly)
But more important the program also returns the entire wav file from which you can see an excerpt below . You can easily recognise the separate frames. (it is zoomed in)








Something weird that I can't explain immediately is that it doesn't work with images that are already in grayscales.
Also if large areas of completely white or completely black pixels are present, it doesn't work eiter.


Update:  If all the above is a bit too technical, or if you have problems with compiling or installing the libraries, I've added the executable in a zip below.  (so, unzip and run it if you trust me)
However, I've noticed that it doesn't work on windows, which is annoying. It isn't as trivial as I thought it would be.

Step 12: Electronics

The all the electronic components were mounted on a breadboard.
I am absolutely not an authority concerning electronics, so read everything with a sceptical mind because the things I did are probably not the best.  (but it works)

All the stuff on the breadboard actually consists out of 3 separate simple circuits, one to drive the LED's, one to power the motor, and a small debounce capacitor to handle the contact of the speed meter.

The LEDs

The idea is to control the current to the LED's with the aid of a MOSFET.  The mosfet I use is a N-channel logic level Power Mosfet. (a NTB18N06L (scavenged from a power supply, they are surface mount, hence the blue wires attached to them)) The fact that it is a 'Logic Level' Mosfet is that it can be opened completely with normal microcontroller voltages (5 V). In other Power Mosfets it is usually something of 20 V.

The signal coming out of an audio jack is amplified via a non inverting operational amplifier circuit.  This circuit has the purpose of extending the amplitude of the 'sound' from 0 to 5 V.  This amplified signal then goes to the gate of the MOSFET where it then accordingly controls the current flowing trough the LEDs.

But there is a small problem, look at this detail of the datasheet of the NTB18N06L:

As you can see, in Figure 2, the MOSFET actually starts opening from about 2V . The first ~0.7 V are lost anyway because they are LED's  and then there is an additional ~1.3 V lost because the MOSFET doesn't even open itself at such a low voltage.
So the dynamic range is from 2 - 4.5 V.
That's why I amplify the signal a factor 4.7 (a 47 kOhm  with a 10 kOhm resistor in the feedback circuit). Together with some tweaking of the volume of the laptop you can get the most important fluctuations in that sweet spot.
The result of this all is then that the darker spots will be completely black and some of the brighter spots will be completely red.
(Or you could use more and complicater electronics to get a better result) (or something simple I didn't think of).

Below is a schematic of the circuit used to drive the LEDs.  Beware, this is a bad and highly unefficient circuit. (read the comment after this picture)





As suggested in the comments, a better solution would be to use feedback.Look at the comment made by mr. ccrome for his  schematic.  This is one of these these beautiful solutions that I have completely missed. It would have allowed way better light-dark range.



The motor

This is perhaps something that had to be also done differently.
The schematic I used can be found in a forum topic in which was asked how to drive a motor/heater.  Someone shows a schematic on which someone replies that it will work fine. And that's what I did.

As a power source I use a normal 9V battery.
But watch out with those, I once wired him up wrongly and my laptop fell out. Luckily nothing is broken, but beware.

However, with pwm, you only have 256 steps for the output and this is perhaps a bit too coarse to precisely control the motor speed.
Secondly the fact that it is pulse width modulated means that there is a pulse.  And the motor is screwed to a large cardboard disc. So next to being a spinning disc  it is a loudspeaker that emits an annoying loud pitch.

See in next step how the motor speed is controlled.


The rotation contact

This is the most simple , it is simply a pull up resistor (10k)  and a debounce capacitor on one lead of the 'detector' and other lead connected to  ground.
So, when the aluminium on the disc touches the two wires, contact is made which pulls down the digital input of the arduino which can be read out.

It is simply a switch.   (Look at this page on how to debounce a switch  to see a schematic)

Step 13: The Speed Control

An arduino is used to control the motor speed.
This is done with feedback from the speedometer.

First of all, pulse width modulation is used to control the power to the motor.  This pulse width modulation is simply switching on and off the power supply very fast. If the 'on' pulses are short compared to the 'off' pulses, the average over time of the current supplied to the motor will be low. If the 'on' pulses are longer than the 'off' pulses, the power will be large.

The arduino has several analogue outputs that use PWM.  These outputs have a resolution of 256 with 0 being no power and 256 completely open.

The task of the program on the arduino is to find the right value in order to let the disc turn as close to 12 revolutions per second. (or 1 revolution in 0.083.. s)
In each revolution the aluminium strip connects the two wires acting as a digital swich that the arduino can read out with a digital pin. As explained in the previous step a pull up resistor is used, so when the arduino sees the that the digital pin goes from 'HIGH' to 'LOW' it can know that the wheel has made one revolution.

With the function micros() the delay between those pulses can be measured. This delay is then the period of one revolution.

Feedback means that the arduino can adjust the power supplied to the motor. If it happens that the period is too large, the power can be increased to speed up the motor. If the period is too short it can reduce its speed.

After each adjustment the arduino waits till the disk and turning motor get to an constant speed.  The motor is perhaps a bit too small for this disc and it requires some time to reach its full speed. 
If the arduino wouldn't wait till the disc is spun up, it would increase its power with each rotation and when the disc finally reaches the correct speed it will still be accelerating which causes the arduno to lower the power way too much. So a sort of oscillation emerges.
This oscillation can be reduced if the arduino waits till the disk reaches a constant speed and thereafter adjusts if necessary.
To know if the disc is spun up, the arduino looks at differences in delays.  If it should be accelerating and if suddenly a period larger than the previous is observed, it knows that the disc isn't accelerating anymore but  its speed is more affected by its environment than the motor.

The code can be found below in a zip file.


And finally there is a small Python program. It isn't  necessary, you can easily replace the first 'if statement' in the loop by some code for a push button. (actually in earlier pictures you can see a potentiometer since I don't have a button naar me. And I simply did an analogread. Just an example) It is just handy to start and stop everything from my laptop.
The code is also included below.  (there seems to be a problem with the <pre> </pre> tags.

Just running the program starts the motor.
And as you can see in the first picture, the  power starts at 80, goes to ~110 and then fluctuates a bit around 90. The fact that there is still an oscillation in the beginning is caused by the fact that the think almost shakes itself apart and the arduino thinks that the disc is spun up by some corrupted values.
But, as you can see in the second picture it does work more  or less, the period stabilises itself aroud 83 ms. It takes some time but it does work!

Step 14: Spinning and Results

Then at last everything comes together.

I originally wanted to play the wav files directly from e.g. python program.
Each time the wires connect on the disk the arduino would send a signal to the python program. And upon receiving the signal the python program would play the wav file after a delay of some micro seconds.  This would ensure a stable image even if the disc speed wasn't 100% correct.

And I have composed an image out of two frames (the annoying difference in frame rate makes that the left side is visible in one frame and the right side in the other...)
But it gives you an overview of the image quality.
(remember that it is a bit better in real life, the camera doesn't pick it up very well.
(Also, the red back ground is from the red led of the camera itself, so normally it is a black background)

In the mean time I use a more primitive technique. I use audacity to repeat the signal 5000 times and let it play...

It works, but I am not very happy with it. As the speed changes a bit, the image starts moving across the screen.  Following is an animated GIF of what the fiew looks like.  (actually in real life it surprisingly looks a lot better, the camera does not pick the low light intensity of the LED's trough the holes up very well. And like any other persistance of vision display there is a problem with the frame rates.

The gif perhaps takes a while to load.



Sadly enough the gif didn't work.  It is hardly recognisable. And completely unrecognisable in a video.
But Saturn is clearly visable, so I am fairly happy!




It was a fun build for me, I hope you liked it!