Macroscopic engineering: It begins

The goals

Maximizing my work space, keeping my work area visually clean and ready for other tasks even when I'm in the middle of a project, and building something that's not a weapon of any sort (see accelerator and giant laser if you don't know my history here).

It's a table. You hit a button on the side of your table and the surface is automatically whisked away and a clean new table is brought to you. You want the old table surface back? Just hit the button and it comes back out of filing.

Implementation option 1

A set of shelves all stacked above each other. There are rods that go through each shelf to hold them all level and steady. Each shelf can translate along those rods up and down. When stored away, you might have surfaces #1,2,3 all pushed up toward the ceiling. When you hit the button for #2, #1 and #2 both slide down. 3# stays high. You can now work on #2. Their positions are driven by different threaded rods. Each of the threaded rods is actually only connected to one shelf. You turn the rod for that shelf and the shelf moves either up or down depending on the direction you turn the rod. A computer handles the coordination of which rods should turn and when. The problems with this design: You can't put your feet under the table while working on it because there might be other tables in the way. Similarly, there might be more overhead killing your headroom. Finally, each shelf will need limit switches, bearings, a rod and a motor. Essentially, the cost scales with the number of shelves. If the set of all those things was $200/shelf then a 6-shelf table is already $1200. Kinda steep.

Implementation option 2 (pictured)

There is a series of shelves actually on shelves. A table surface that can move vertically goes to the level of the shelf it wants, grabs and pulls that shelf onto the table's surface and then returns to the worker's level. This time there's leg room and head room. But the table is now twice as deep. However, there is often equipment you want access to regardless of which project you're doing. That can be stored on the shelf that's already at worker-level so it's not a total waste of the added depth. This system will also create a potentially less stable surface (the shelf is just resting by virtue of gravity). It does, however, scale well. The grabber can be quite complex and expensive since there's only 1 of it for all the tables.

So I considered/attempted drawing the entire thing in open-scad to really flesh everything out before I began working on it. I still very much believe that cad drafting is an excellent way to work. Openscad, however, requires significant mental computationally for the relatively minimal gain of general drafting. You must pay strong attention the whole time and even then it's still tedious. Also, the visualization system has never been it's strong suit. On the plus side, the parameterization is excellent. But that can't redeem it's value in this task. Not sure what alternative I'll use. Perhaps paper.

zoom = 1;

tableDepth=18*zoom;

tableWidth=12*4*zoom;

tableSlideGap = .5*zoom; //Also takes into account the angle thickness

tableSurfaceHeight = 1*zoom;

tableSeparation = 10*zoom;

numberOfTables = 3;

bearingOD = 0.866 * zoom;

bearingID = 0.315 * zoom;

bearingWidth = 0.275*zoom;

controlBoxHeight = 12*1*zoom;

sBarHorizDistance = tableSlideGap+tableWidth;

sBarThickness = 0.25 *zoom;

sBarWidth = 2 *zoom;

tablesTotalDistanceBetween = tableSeparation + tableSurfaceHeight;

tablesHeight = ((numberOfTables-1) * tablesTotalDistanceBetween) + sBarWidth;

sBarLength = tablesHeight + controlBoxHeight;

rollerTrackWidth = 1*zoom;

fBarBearingBuffer = .5 * zoom;

fBarBearingDistance = 10 * zoom;

fBarBearingPostLenght = (0.5 * zoom);

fBarBearingPostExtra = 0.5 * zoom;

fBarThickness = 0.25 * zoom;

fBarWidth = 3.5 * zoom;

fBarLength = fBarBearingBuffer * 2 + fBarBearingDistance;

fBarGap = 0.25 * zoom;

fBarXStandoff=fBarGap+sBarWidth+fBarThickness/2;

fBarYStandoff=fBarGap+sBarWidth+fBarThickness/2;

//----FETCHER----

module angle(width,length,thickness)

{

union()

{

cube([width,thickness,length]);

cube([thickness,width,length]);

}

}

module fBarRollerAngle()

{

angle(fBarWidth,fBarLength,fBarThickness);

}

module fRoller()

{

rotate([90,0,0])

{

translate([0,0,(fBarBearingPostLenght+fBarBearingPostExtra+bearingWidth)/2])

cylinder(h=fBarBearingPostLenght+fBarBearingPostExtra+bearingWidth,r=bearingID/2,center=true);

translate([0,0,fBarBearingPostLenght+bearingWidth/2])

cylinder(h=bearingWidth, r=bearingOD/2, center=true);

}

}

module fRollerSet()

{

translate([bearingOD/2,0,0])

fRoller();

translate([-bearingOD/2-sBarThickness,0,0])

fRoller();

}

//The inner bar has it's back against zero, the outer bar has it's inner part exactly measured to the gap.

module fBarRollerSide()

{

translate([fBarXStandoff,fBarYStandoff,0])

rotate([0,0,180])

fBarRollerAngle();

//Bottom set

translate([fBarXStandoff-fBarThickness,0,fBarBearingBuffer+bearingOD])

rotate([0,0,-90])

fRollerSet();

translate([sBarThickness,fBarXStandoff-fBarThickness,fBarBearingBuffer])

rotate([0,0,0])

fRollerSet();

//Top set

translate([fBarXStandoff-fBarThickness,0,fBarLength-(fBarBearingBuffer+bearingOD)])

rotate([0,0,-90])

fRollerSet();

translate([sBarThickness,fBarXStandoff-fBarThickness,fBarLength-(fBarBearingBuffer)])

rotate([0,0,0])

fRollerSet();

}

module fBarStaticArms()

{

translate([fBarXStandoff,fBarYStandoff-fBarWidth,fBarLength])

rotate([0,90,0])

angle(sBarWidth,tableDepth,sBarThickness);

}

module test_sideMounting()

{

angle(sBarWidth,fBarLength,sBarThickness);

fBarRollerSide();

}

module fetcher()

{

fBarStaticArms();

fBarRollerSide();

translate([0,-sBarHorizDistance,0])

rotate([0,0,-90])

fBarRollerSide();

}

//fetcher();

//----MAIN TABLE----

module shelfAngle() //TODO: replace this with the higher-level angle

{

union()

{

cube([sBarWidth,sBarThickness,tableDepth]);

cube([sBarThickness,sBarWidth,tableDepth]);

}

}

module leftShelf()

{ rotate([0,-90,0])

shelfAngle();}

module rightShelf()

{ rotate([90,0,0])

leftShelf();}

module shelfSet()

{

translate([sBarWidth-rollerTrackWidth,0])

{

rightShelf();

translate([0,-sBarHorizDistance,0])

leftShelf();

}

}

module verticleAngle()

{

union()

{

cube([sBarWidth,sBarThickness,sBarLength]);

cube([sBarThickness,sBarWidth,sBarLength]);

}

}

module mainTableStand()

{

//Verticles

verticleAngle();

translate([0,-sBarHorizDistance,0])

rotate([0,0,-90])

verticleAngle();

//Need to have some overlap with the front angle iron

translate([-tableDepth+sBarWidth-rollerTrackWidth,0,0])

{

verticleAngle();

translate([0,-sBarHorizDistance,0])

rotate([0,0,-90])

verticleAngle();

}

//Shelves

for( shelfN = [0 : numberOfTables-1])

{

translate([0,0,controlBoxHeight+(shelfN*tablesTotalDistanceBetween)])

shelfSet();

}

}

module totalSetup()

{

mainTableStand();

fetcher();

}

//translate([0,0,-20])

totalSetup();