The table-non-table (or TNT) is a slowly moving stack of paper supported by a motorized aluminum chassis. The paper is common stock (similar to photocopy paper). There are close to 1000 stacked sheets of paper per table-non-table, which rest on the chassis about one half-inch from the floor. The movement of the table is in short durations (5-12 seconds) that occur once during a longer period of time (a random selection between 20 to 110 minutes).

The table-non-table can be used in many different ways. You can stack things on top of it, you can use it as a coffee table, you can stand on it, sit on it, or you can use the paper for any purpose you want. It’s functionality is quite simple: it moves around slowly. But its purpose is open for you to explore!

The table-non-table was developed by the Everyday Design Studio.

The main components of the table-non-table are an aluminum chassis on wheels, a stack of white paper, 2 motors and wheels and the electronics to direct the motors movement.

Step 1: Materials You Will Need

For this project, the following are the materials we used:

Physical chassis:

Aluminum sheet ¼ inch thick
4 Metal Ball Casters 3/8” ( https://www.sparkfun.com/products/8909 ) You’ll also need bolts to attach them with (as they come with nails), so 2 screws and nuts each.
Screws
3 C brackets to hold the power cord
2 wheels to attach to motor (our wheels were made to order, but stuff here should work: https://www.servocity.com/html/wheels___tires.html )
A way to attach each wheel (We purchased set screw hubs, and I think our wheels were fitted to them: https://www.servocity.com/html/hubs__couplers___adaptors.html )
1 square Aluminum block for the top (1.5 x 1.5 x 1.8 inches)

Paper:

1000 sheets of white photocopy (common stock) paper of 17.5 inch x 22.5 inches

Electronics:

2 motors: 1 RPM Gear Motors: https://www.servocity.com/html/1_rpm_gear_motor.html
Motor Mounts (2 for each motor) : https://www.servocity.com/html/aluminum_clamping_motor_mount.html#.VjE0ACtSVaY
Wires for connecting everything together
1 protoboard (perf board)
Power cord to the wall: For us, this was two parts: The plug and a cord (as we really wanted a white cord)
Arduino Uno microcontroller: is an open-source computer hardware and software company, project and user community that designs and manufactures microcontroller-based kits for building digital devices and interactive objects that can sense and control the physical world.
SN754410 Motor driver IC: Features two H-bridges that can be used for bidirectional control of two DC motors or to control a single stepper motor. http://ca.mouser.com/ProductDetail/Texas-Instruments/SN754410NE/?qs=AMJt07B76uuZ4Fb3eRjJ6A%3D%3D
LM7805 Voltage Regulator: Regulate input voltage from a input source (e.g Wall AC outlet) into a stable 5V output source.
Capacitors: 2 x 10uf electrolytic capacitor
Data Logging Shield (+ corresponding tutorial): https://www.adafruit.com/products/1141
SD Card (goes in the data logging shield)

Step 2: Tools You Will Use

For this project, we used the following tools:

CNC to cut the aluminum pieces (or someone who can do it for you)
Press and the die to cut the paper (or someone to do it for you)
Screw driver to assemble the aluminum chassis
Tap and die for making the threaded holes
Soldering iron
Solder
Diagonal cutters
Needle nose pliers
Breadboard (for testing)
Helping hands
Computer to program and write the code

Step 3: Making the Aluminum Chassis

The aluminum chassis is the base for the table-non-table. It supports the paper that is stacked on top of the table-non-table and also encloses the motors and electronics that enable it to move. The shape is simple, it can be broken down into 5 parts:

the chassis plate, which is the same size as the paper (17.5 x 22.5 inches)
the box to hold the electronic components (17.5 x 5.25 x 1.67 inches)
the top cube to hold the rest of the paper (1.5 x 1.5 x 1.8 inches)
a door under the table-non-table to have access to the electronic components
and 4 small metal ball casters that serve as balancing wheels for the table-non-table.

The overall process consisted of cutting the pieces to size and to assemble them with screws.

First, we needed to cut the aluminum plate to the appropriate sizes for each piece. We found a metal shop near us and sent them the drawings. We let them do the cutting and the assembly as well, which was done with screws.

The steps were the following for the assembly:

A- Screw together the box for the electronics

B- Screw the box for the electronics to the bottom plate

C- Add the square post with screws

D- Use screws to fit the door in place

The last step, which we did ourselves, was to attach the small metal ball casters to the chassis. We used small screws to attach them, one on each corner.

Attached is the drawing for the dimensions of the chassis as well as the SolidWorks files for the parts and assembly.

table-non-table-SolidWorks.zip
Download

Step 4: Cut the Paper to Size

The next step is to get the paper ready to fit on the table-non-table. The idea is that the paper is simply stacked on the chassis and with the middle box for electronics and the square post the paper does not move around. For this reason, the tolerance between the sizes in the holes in the paper and the size of the aluminum parts need to have minimal tolerance so that they are really tight together, while still not tearing the paper.

We used white common stock photocopy paper for the table-non-table, which resulted in having around 1000 pages on the chassis. If you choose another type of paper, it might be more or less, depending on the thickness of the paper you choose. The important part is that the paper arrives at the same height as the middle post on the top.

To source the paper, we contacted a local company that was able to cut our paper to size (17.5 x 22.5 inches).

After that, we needed to find someone that could cut the interior holes to fit around the chassis parts. We found a company that was able to make die cuts and to cut to size for us. We sent them those drawings to show the dimensions and positions of the holes. Each hole was centered. The rectangle was 17.75 x 5.5 inches and the square is 1.5 x 1.5 inches.

PS: We had some issues with our dimensions and communication between the making of the aluminum chassis and the die cutting of the paper. It ended up that the bottom sheets of paper had holes that were about 1/8 inch to small. This meant that we had to recut by hand, with the laser cutter each sheet. This took a very large amount of time! So if you can cut it right the first time, great!!

dimensions-diecut.pdf
Download

Step 5: Build the Circuit With the Electronics

Here are the steps to build the circuit with the electronics. We are working on making a Fritzing diagram and a more elaborate description of steps. This is the overall strategy:

Plug the Data logging shield on top of Arduino and insert SD card
All the components will be soldered on a perf board
Solder SN754410 motor driver IC on to the perf board
Solder Voltage regular with corresponding capacitors and solder wire between the Motor driver IC and voltage regulator
Solder two DC motor to the output pin of the SN754410 IC
Connect the Motor Driver IC with Arduino with corresponding pins on the Arduino

Step 6: Program the Table-non-table

The Arduino code for the TNT has three main functions:

Create a random path for the TNT
move along that path in random intervals and
log movement on a SD card.

You can find the Arduino code below. All you need to do is to download the code and upload it to your Arduino board. If you want to modify the code, here is a more detailed explanation for the single steps.

First of all, the space the TNT moves in is limited because it is attached to a power cord. Therefore its movement cannot be completely random because it might run out of cord or, if the motors are strong enough, it could unplug itself. Since we still wanted the movement to appear random we decided to program a logic that creates a random path for the TNT. But once it reached the end of the path, it will backtrack its steps to its original position. And after the TNT returned to its original position the code will generate a new random path for the TNT. This way the movement is still random, but it also ensures that the TNT will stay within a certain area since it is always returning to its starting point.

The path itself can contain of any number of steps but we decided to work with 6 steps in total. 3 steps to a random position and three steps back to the starting point. Each step can be one of 8 programmed movements: Forward, Right, Left, Spin Right, Spin Left, Reverse Right, Reverse Left, and Backward. Every time our code creates a new path it will select three random movements and store them in an array. It will then go ahead and determine the steps needed to go back to its original position.
For example, let’s assume the random path consists of the following sequence: Left, Spin Right, Forward. The code will then determine that the steps to return to the start are: Backward, Spin Left, Reverse Right.

While the code creates the route for the TNT, it also determines for how long each step will be executed. The duration can vary between 5 and 12 seconds while the code makes sure that every step and its counterpart will run for the same time. For instance: if the step ‘Forward’ from the previous example gets executed for 8.5 seconds, the step ‘Backward’ will also be executed for 8.5 seconds.

Now the TNT is ready but the single steps aren’t executed right away. The code puts in a random delay before executing every single step. These delays range from 20 to 110 minutes. Unlike the steps and the time for each step, every single delay is different which adds to the ambiguity of the movement.

Lastly the single steps are being recorded on a SD card plugged into the Datalogger shield. The shield also enables us to read the current time which we use to record along with the single steps and their timing.

_20150608_Fast.zip
Download

Step 7: Upload the Code From Your Computer to the Arduino

To upload a code to your Arduino Board you need to connect it to your PC/Laptop with a USB cable. Once it is connected open your code in the Arduino IDE (available under arduino.cc) and select your board under Tools > Board. Next select the ComPort your Arduino Board is connected to. You can do so under Tools > Port. Next click the ‘Upload’ icon in the Arduino IDE or click Sketch > Upload. If everything is correct the code will be uploaded to your board and the Arduino IDE will inform you when the process is done.

You can also find detailed instructions on how to upload code to the Arduino including throubleshooting on the official arduino page - https://www.arduino.cc/en/Guide/Environment

Step 8: Put the Electronics in the Chassis

Now, we will start the assembly of the electronics with the aluminum chassis.

A- Find a way to fit all of the electronics in, and you can try to add sound dampening things if you want to. We also wrapped our circuit in a sheet of soft plastic to prevent from shorting.

B- Pass the cord in the appropriate hole towards the power supply box.

C- Screw the negative and positive wires to the power supply box.

D- Use c-clamps to attach the power cord to the chassis.

Step 9: Adding the Motors to the Chassis

A- Screw the c-clamps to the motors and the c-clamps to the chassis.

B- After this, make sure your motors are turned so that they are sticking out the right amount (we had offset motors, if you use centered motors, this won’t work).

C- Thread the wire for the motors coming from the circuit and solder them on the motors.