Let’s review for a bit… for my final project concept I proposed making blinds that are opened and closed automatically according to the amount of sunlight striking the window.  From a comfort perspective, this makes total sense: when we are around the house, we’d like to have an optimal amount of sunlight during the day, but at night we’d like to have privacy.  Maybe some people would say that messing with blinds is a pain in the ass.  I don’t agree with that opinion, but here is what I think: automatically opening and closing blinds could have a profound effect on how you sleep and feel during the day.  I do a subscribe to the idea that comfort and productivity are optimally achieved only after a primal hierarchy of needs is met.  That is to say that to achieve mental flow, it is important for one to have his or her basic needs met, and one such need is to regulate your circadian rhythm by controlling exposure to sunlight.

What I am aiming to do is to create a proof-of-concept and example of a product that promotes quality of life by regulating exposure to sunlight in an appropriate way.

So, here is some documentation on how I got the blinds to work.

First, a list of parts:

• Aluminum frame (or some other strong, light-weight frame)
• Venetian blind parts (loop string, drum cradles, hex rod, blind drums, blind cord)
• Servomotor (capable of 180 degree range of motion)
• Solar powered battery supply
• Acrylic (for the enclosure and motor adapter)
• Custom circuit with ambient light sensor and PWM output for servomotor

Lucky for me, my sister had ordered custom blinds but got the wrong size.  So I shipped the blinds all the way from Cleveland, Ohio to the Media Lab and reverse engineered them. I looked up the anatomy of venetian blinds and thought about purchasing blind parts from this site. My approach was to reverse engineers the set that I had and try to implement the parts on my own one by one.  However, since I had a fully-working set and I am now a poor grad student, there was also great temptation to use as much as possible from the blinds so that I wouldn’t create waste.

Motor adapter cut by laser cutter from acrylic. These two component connects the servo to the hex rod.

I decided to first start by testing whether my servomotor would have enough torque to open and close the entire set.  So, I created a motor adapter for the servomotor to connect it to the hex rod.  I created a circle that attaches to the servo, and then cut another circle with a hexagonal slot in the center.  I tied the adapter together using metal wire.  This was cheap, worked well and it also allowed for some slack to account for the stopping behavior of the servo.  The layout for the custom circuit can be referenced in my output devices project.

Connected the gears using wire.

I was quite happy to find that the size of the servo I’d chosen would provide enough torque.  The next step was to modify the blind set and cut the loop string.  I had to remove the old manual mechanism used to tilt the blinds, and in order to make an aesthetic demo, I decided to shorten the loop string by nearly half the length.  I found that since the loop string was made from nylon, I could use a blow-torch to close the cut ends of the string and get rid of the fray, which was key to fixing the string.

String loop modified

Blinds had to be shortened to fit the presentation frame for demoing.

After shortening the string, the challenge was to create an enclosure.  I made a parametric enclosure out of blue acrylic, using SolidWorks.  The parameters depended on many things: fitting the dimensions of the servo, solar-powered battery, printed circuit board, aluminum chassis and position of the hex rod.  This was really tricky to get right, I had to use calipers to measure everything and make educated guesses about the press fit of the material, but eventually I came up with these laser cut designs.  Panels for the front, back, and bottom are all press fit.  The bottom panel screws to the aluminum enclosure.

Enclosure designed in SolidWorks, lasercut acrylic. Houses the motor and electronic components.

Servo in the enclosure

Next step was to modify the slats.  I spray-painted them black and then lasercut a design.  I wanted to place something minimal and iconic on the blinds.  Some people asked why I chose the circle… that’s because the shape is simple and symbolizes the sun.   Believe it or not, etching the circle was really tricky to do, as I had to measure the overlap and draw the circle regions that intersect with the overlap for each slat.  If you were to spread out the blinds and lay them flat, the design would look more like an oval.

Made a design in Rhinoceros of a circle interesection with overlapped blinds. I was able to calculate the design for each slat this way

Painted the slats using black spraypaint. Waited about 30-45 min to dry.

Used Raster mode on the laser cutter, at 100% speed and 40% intensity, it went through the paint and partially into the material.

The raster on each blind went partially into the material to reveal something beautiful.  The slats looked so much better this way–and the circle gave that “reclaimed wood” feel, which I really enjoyed.

I knew that to make a good demo, I had to make a window frame, so I found some scrap 2×4′s and made a shoddy window frame with some L-brackets to hold up the aluminum frame.

Cut 2×4 material to make window frame.

Window frame completed, holding the aluminum frame

Solar-powered battery power supply on one side

Custom circuit running the servo on the other side

Then just had put the slats in one by one and here are the results

Ambilinds final result.

Video demo

The production shots are below

And that’s it!

Big ups to Matt Carney for the intro to mechanical design, and Jeff Duval for hooking me up with a servo and his great suggestions.

• ambient light sensor is placed under the glass table (works only with transparent table tops)
• object placed on top of region occludes light source from the sensor, causing light measurement to change in sensor
• sensor values are sent to laptop via FTDI/serial connection
• opens up a myriad of use cases for laptop user interface (trigger an event, know something about the environment)

I spent a lot of time thinking about the various use cases of such a device, but couldn’t come up with any uses that were compelling.  I’m sure there’s something to this, but since I couldn’t think of a good use case, I used this opportunity to learn how to use OpenFrameworks.

I took an OpenFrameworks sample, and just wanted to display some pretty visual output with the device.  Please contact me if you think of any good use cases for this scenario.

Below are some examples of how it works:

Tape roll is not covering the area

Tape roll is now covering the area

Perhaps it could be used to let you know if your desk is getting messy?  Or maybe it could be used as a monolithic switch or button for controlling something on your laptop (shuffle the current playing song, dim the screen, login/logout, etc.)

Here the OpenFrameworks rendering is red when there is no object

Now OpenFrameworks rendering responds to touch

Perhaps one could network many of these together, all over the table to determine the direction of light shining on the table.

Here’s what it looks like under the table

Another angle over the table

One could also create a color sensor, combining three of these with red/green/blue filters to get the predominant color of an object, which could be used to roughly identify objects.

One last example, no stapler detected

Now the stapler is detected

Truth is, all of these scenarios are easy to implement in software, but none of them seem worthwhile.

Two boards, both crappy

It’s been an interesting week.  Spent much time around the milling machines making various circuits and sad to report that some stuff hasn’t totally worked.  I am no stranger to networking, but I have never done anything with radio, which prompted me to attempt the hell-o-radio project.  But there were problems right off the bat.  I made two boards, but they were both ugly as hell.

It would seem that because so many people were milling PCBs this week, the endmills were worn and torn, making for poor fabrication with jagged traces and frayed copper everywhere.  Instead of milling another pair, I decided to take my chances by attempting to clean the PCBs well and review every trace to make sure there were no short circuits.

What a waste

Soldering took a long time, and I soldered both boards at once, maximizing time efficiency.  This way, if one mistake is made, at least the mistake will tend to be consistent across both devices.  There were many parts on hell-o-radio that were smaller than the friendly 1206 footprint, which made the operation much trickier.  After soldering, both boards were exhibiting problems.  The first board, which I was never able to get running, programmed fine but never worked and did not respond to the programmer again.  I’m working on debugging this one.  The second board did not respond to the programmer at all, so Amir suggested that I try to look at the board under the Mantis Elite 3D stereo microscope, and WOW! What an awesome piece of equipment.  Under 10x magnification, I was able to see a few problems with my solder: I had forgotten to solder some capacitor joints, and there were some traces that hadn’t milled properly and required scraping/cleaning.

Microscope was in stereo and exhibited motion parallax

What an incredible tool this Mantis microscope is! Not only does it give you a sense of depth, providing stereoscopic viewing, but if you move your head you get motion parallax in both horizontal and vertical dimensions!  Cool!  So, after analyzing under the microscope I was able to get the 2nd board working.  Not bad.

I spent a lot of time trying to debug the first board, but no luck.  Will continue to debug, but in order to fulfill my obligation to this project, as well as my final project, I decided to whip up something fast to prove that I could network my previous circuits.

Recall that for the input devices project, I switched to using the ATTINY84, and the reason why was because you could fit 8K (double the amount) of program than the ATTINY44. I had to do this to send serial data to my PC from the device, so that I could measure light levels of the day/night.  For my output device, I simply added an ISP header for servo remote control.

Fabduino + SoftwareSerial

This week, I also milled a Fabduino, which is essentially a poor man’s Arduino.  Great! I can now talk to as many of my boards as I have pins available on the Fabduino, thanks to the trusty SoftwareSerial library provided by Arduino.

RS-232 done in software, Arduino style

How does it work?  Simple.  Follow the Fabduino instructions on how to make the board and burn the bootloader.  For your low tech ATTINY boards, you can install Arduino with the instructions listed here.

Connect your ATTINY board to the Fabduino, with VCC and GND pins of Fabduino on the respective VCC and GND pins of the ATTINY FTDI header.  You can use any of the GPIO pins on the Fabduino with change interrupt support, connect two pins from it to ATTINY GPIOs for Tx/Rx.  Just make sure that your Tx/Rx pins are switched so that Tx from one board is connected to Rx of another, and vice-a-versa.  Use 9600 baud rate for testing and crank it up if you really need to.  For example, my Fabduino code for talking to the ATTINY on pins 10 and 11 would look something like the following:

const int rxPin = 10;
const int txPin = 11;

SoftwareSerial mySerial(rxPin, txPin);

void setup () {
mySerial.begin(9600);
}

void loop() {
if(mySerial.available())
{
//serial read/write code goes here
//Use mySerial.read(); or mySerial.readLine(); to read until the new line character
//and mySerial.write() and mySerial.writeLine() respectively.
}
}

So, in conclusion:

• SoftwareSerial is cool, it allows you to create a serial port from pins in software.  That means you can get ATTINY boards to talk to each other in Arduino. Super cool.
• Made two radios, one failed.
• Done just in time for Thanksgiving.
• Mantis Elite stereo 3D microscopes are out of this world

Here’s some closing pictures

This servo was hacked to spin continuously

Not much to document here, except that I made a minor modification to my input devices circuit by adding an ISP header attached to ground and a couple of pins for controlling a servomotor.

There are a few different types of motors to choose from when considering output devices.  I initially designed my circuit to drive a servo, because with a servo you can set the exact position using PWM.  I thought this would be advantageous for my final project since the open/close blinds form one range of continuous values, and it requires knowing the current position of the motor.

As light increases (daytime) servo spins more and more in clockwise direction

One of the limitations of the servo, however, is its limited range in turning.  After playing around with a set of blinds, I realized that tilting blinds fully usually requires many turns of the tilt wand.  I was able to pick up a hacked servo from someone at the lab so that it could turn continuously.

Of course, hacking the servo creates another problem: having continuous rotation means that it will not be easy to determine the position of the motor!

As light decreases, servo spins in counter-clockwise direction

More problems!

For my final project, I will need to implement a method for determining the position of the servo.  Most likely will have to alter the circuit to add a current meter to a pin.  Will document that in future posts.

Here are the circuits for reference:

Luckily, for my final project proposal, what I need is a component that is well-understood and readily available for surface mounting: a phototransistor.  A phototransistor can be used to measure the intensity of light striking the sensor, which I can use to roughly determine the level of daylight outside.  With this circuit, I can control a motor to open window blinds to let the right amount of sunlight in at appropriate times of day, but as it gets darker, the blinds will close more and more until at total darkness they will close, for privacy.

I’ll gloss over the details on how to use the Roland Modela MDX-20 milling machine (for that you can refer to the first PCB fabrication project. However, I did take this opportunity to experiment with design techniques, and arrived at a circuit that I’m very happy with.

First, from my previous posts (design a circuit and embedded programming), I was struggling to get the RGB LED to light up properly.

Soldered a via tip on the front, and cut the wire from the back

I’m happy to report that the issues have been resolved: I can now fade and switch red, green, and blue at will.  Debugging the issue proved a pain because, as it turns out, there were actually TWO bugs in the circuit, which both contributed to form bizarre symptoms.

The first issue was that the pins on the LED were mislabeled.  In the fab EAGLE library, the anode and green pads are swapped.  I had already determined this and rectified the issue, but was still seeing a pesky issue: I could only fade one color, while the others acted like switches (on/off).

Vias must be connected to the ground plane

I determined that the fading for two of the colors wasn’t working because I had connected them to pins on the ATTINY that did NOT support PWM.  In order to fade LEDs, you have to be able to generate a waveform and alter the duty cycle.  This can be done in software, but better to just connect the LED to a PWM pin.

After the ISP is connected to the pins on the ATTINY chip, that only leaves 1 PWM free! OH NO, wat do, wat do? Turns out you can use most of the ISP pins as GPIO (something which I hadn’t thought about and didn’t hear Neil mention in class).  After I made this discovery, I was quite happy!

Finally, the finishing touch was to create a ground plane.  This time, I wanted to make my routing easier and didn’t want to use any bridges.  Further, I wanted space to place a couple of pads to pins on the ATTINY, I could use these pins for output devices (to drive a motor, for example), without having to redesign the whole thing.

A ground plane appears

Finally, as documented in my embedded programming project, I used the High-Low Tech Guide on programming an ATTINY with Arduino.

Phototransistor level is reported through LED–yellow means daytime

Phototransistor says it’s night time (purple color)

One final word, since I wanted all of these nifty features AND wanted serial communication via FTDI, I had to substitute the ATTINY-44 for the ATTINY-84, which is the same but can store 8KB of instruction.  This is because you have to use the software serial libraries, which take a lot of space.  ATTINY does not have a hardware serial port, so you must use a software solution.

For posterity, here are the resources:

With the embedded program, I can use the button on the circuit to calibrate night time/day time light values.  Theoretically I should just be able to do this once in the morning and once in the evening, and the blinds will shut according to the amount of light visible outside!

This week was pretty hectic, and I really needed the weekend time, so I decided on something simple: make “shoes” for my bike.  I just need something to rest my bike on so it doesn’t move and scuff up the beautiful hardwood on my apartment floor.

I took some measurements of my bike wheel, and made this simple design to fit the exact dimensions of my bike tires. I struggled to choose whether to mold the negative (shown here) or the positive of the mold.

Some classmates suggested that it wouldn’t make a difference, but I believe that I ended up paying a heavy price for this as the composite came out less than desired.

At any rate, I made it through to the end with something functional, but learned many lessons, which I will document below.

I used Rhinoceros to make the design, and exported to STL.  From there, I used Partworks 3D to create the ShopBot toolpath.  Since I didn’t have many fine features, I opted for the 0.5″ ball-end endmill and for the final toolpath, I chose 15% passover (although that may have been overkill).

I was pleased with the foam cutout and was ready to move on the next step.

I could have opted for a better cutout of the burlap with laser cutter, but that would have taken a lot of time, which I didn’t have.  So, I just sort of eye-balled it and made an approximate cut with slits along the corners of the prism.

Next, I prepared the solution of epoxy and used the porous plastic material  between the burlap and breathable layers.

The technique is to layer the material as follows (from bottom to top): foam, breathable layer, porous plastic, three layers of burlap with epoxy coating, porous plastic, breathable layer.  Note that I also added colored string on the last layer of burlap for decoration.

Phew! It was ready and we turned on the vacuum.  Since I did not use the negative, the vacuum would not suck the burlap into the groove properly because of the size.  So I made an approximate male part out of foam and stuck it in there to make sure that the groove formed properly.

After 12 hours, it was ready and looked like this.  The following pictures how I dismantled it.

There it is, folks.   Not the prettiest thing, but it is a bike shoe.  Something unintentional which I quite liked was the sucking in visual effect that is seen by the placement of colored string.  Reminds me of those examples of the warping of space-time fabric due to strong gravitational forces a la theory of relativity.

I’m not trying to claim that I’ve stumbled onto something great that could change the world, but I may have.

]]> http://www.ermaldreshaj.com/mas.863/8-composites-bike-shoes/feed/ 0 http://www.ermaldreshaj.com/mas.863/7-embedded-programming/ http://www.ermaldreshaj.com/mas.863/7-embedded-programming/#comments Wed, 30 Oct 2013 04:24:44 +0000 Ermal Dreshaj http://www.ermaldreshaj.com/mas.863/?p=280 Given that I’ve got some experience in embedded programming, I thought I would use this project as an opportunity to learn how to use something more high-level (Arduino).

Previously, I designed a circuit with a push-button and an RGB LED, although I could only get 1 or 2 LEDs to light up.  I thought maybe the problem was that the LED anode was incorrectly marked on the Eagle library module.  To try and rectify this, I switched the green LED and anode pin on the design.  Above is the revision 6 design of the circuit.

Still, no luck

I practiced my milling technique enough times, however, so now I’ve become really well-versed with the Modela.  Anyway, here’s the code to fade:

// Ermal’s Button Code
const int buttonPin = 8; // the number of the pushbutton pin
const int redPin = 2; // the number of the LED pin
const int greenPin = 7;
const int bluePin = 3;

// variables will change:
int buttonState = 0; // variable for reading the pushbutton status
int counter = 0;
int reverse = false;

void setup() {
// initialize the LED pin as an output:
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);

// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
digitalWrite(buttonPin, HIGH);
}

void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.
// if it is, the buttonState is LOW:
if (buttonState == LOW) {
if(counter >= 255)
reverse = true;
else if(counter <= 1)
reverse = false;
// turn LED on:
counter = reverse ? counter-= 4 : counter+=8;

//fades only the green LED, while RED and BLUE are OFF
setColor(255,counter,255);

}
else {

// when button is off, it will fade back to the dimmest state without being off
counter = counter <= 1 ? 1 : counter – 4;
// turn LED off:
setColor(255,counter,255);
}

delay(16);
}

void setColor(int red, int green, int blue)
{
analogWrite(redPin, red);
analogWrite(greenPin, green);
analogWrite(bluePin, blue);
}

For reference, here’s the final board design

That’s it!  Please refer to the previous circuit design for additional information and background on what this is and what it does.

I’m always inspired by things of function, and this year was the first time we students were allowed to make a mold out of metal.  Of course, as it was my first molding and casting experience, I didn’t want to get too crazy.  So I opted to make a simple bottle opener following my self-branding theme.

I won’t go over how to use the shopbot, this was done very well in this tutorial by Jin Joo. I do have to give a lot of props to Basheer Tome, as he helped me take my final design through all the stages of the tutorial and helped explain to me all of the nuances of using the small ShopBot.

Here are some images of what the mold looks like on the wax block after milling process with the ShopBot.  Note that I accidentally broke the wall while trying to get the block free from the wooden base.  Oops.

Making the mold out of the wax cutout was a bit more complicated.  Will Patrick and I stayed up into the late hours to make the perfect mixture of MoldMax 60, which is a high-temperature silicone mold (absolutely necessary for casting metal).  This has a 3-to-100 part mixture component, so it isn’t the easiest stuff to get just right.  Someone had stolen the scale from the molding and casting room, abut we were able to find another scale and made the mixture and poured into our wax block.  Since I broke the wall off my block, I used duct tape to cover one side.

Finally, casting was the best part.  I used the supplied aluminum alloy ingots, which was melted at 700 deg F in an oven, then poured the contents directly into the mold.  I poured a bit too much, so the opening of the bottle opener was covered in the metal, rendering it unusable.  As a result, I tried to pour from the top, similar to how a two-sided cast is done, by cutting a sprew and a vent hole on top.

After some sanding and filing down, I got great results from the first one.  I actually regret that I cut the sprew, and I only did it because I thought I wouldn’t be able to get rid of the excess metal without destroying the cast.  As it turns out, some handy work with a file was all I needed to get the metal down to a good-looking and functional state.

And voila, they work!

Using Eagle, I traced the nets from the board image and created my own circuit, adding a push button and RGB LED as shown below:

Next step was to make the layout.  I have some tips here:

• Try to connect component pins on the side closest to the micro-controller.
• That means place the components adjacent to the pins on the micro-controller that the component uses.
• Change grid settings in Eagle.  Mine were too sparse, so I couldn’t run wires appropriately.  A good rule of thumb is to use the endmill size as your grid step.
• Run traces underneath components to maximize space
• Use the angled-wire tool when possible

I got really sick of running wires on the layout tool in eagle, so I decided to have some fun by putting in my own design patterns, as well.

I sent that black and white PNG to the modela and here’s what came out:

Unfortunately, I broke my first one trying to plug in the FTDI, here’s what happened:

Luckily I made two.  I used my programmer from a previous project, and after soldering the parts on again, I was able to program it by burning the arduino boot loader and voila!

I made the LED fade from 1 to 255 in Arduino code when the user presses the button.  When the user lets go, the LED dims back from the current value to 1.  Couldn’t get the green channel to work, just red and blue for now.  Will debug later to figure out what’s going on.

Tips on getting arduino to work:

• Download the hardware packages for ATTINY44 arduino bootloader here
• Use the “USBTinyISP” programmer in Arduino, if you are on Windows 7 or 8, download the drivers here
• For Windows 8, you will need to do an advanced startup and disable driver signing once just to install the drivers
• Select Arduino menu Tools -> Board -> ATTINY44 (external 20 MHz clock)
• Select Arduino menu Tools-> Programmer -> USBTinyISP
• Select Tools -> Burn Bootloader
• If you’ve got the right serial port selected under tools, you may now test your Arduino code.
• To enable pull-up resistors on pins, make sure in the setup() call of your Arduino sketch that you set the pin to HIGH using digitalWrite(), e.g.:

pinMode(buttonPin, INPUT);
digitalWrite(buttonPin, HIGH);

What’s the solution to my napping problem?  For this project, we were tasked to “make something big”, and I figured I would design a simple cot for myself that could be easily assembled and disassembled at will.  I decided to use this project as a way to learn how to use Solidworks and get more experience on press-fit design practices, so I made it a parametric design of a cot (a cot which is custom-tailored to the user).  I call it peaCot.

The parameters (made as global variables in the solidworks design projects) are as follows:

• Material Thickness – Must know this for press fit, as sheets of OSB will vary, but also maybe someone would desire to use plywood, or other, more rigid material.
• User Height – With no shoes on
• User Width – Measured at the widest point (usually the shoulders)
• Width Padding – Can be set otherwise, but for comfort I set the padding to 10cm on each side
• Height Padding – Also can be changed, but for default was set to 15cm on top and bottom
• Bed Height – This can be changed, too, but default of 30cm

Filing down the sides of cutouts for OSB is a good idea

Making the design was not so challenging… but, making the design rigid and sturdy was quite challenging.  Initially I made the design with only the legs running across the width.   This was problematic because the structure would sway along the length really badly–it was unusable.  Also to note, my first attempt at press-fit failed as well because the spacing on the slots did not match the thickness of the material.  Not to worry! Since the design was made parametrically, all I had to do was change the global variable associated with the thickness of the material, and POW! all the slots were sized appropriately.

Cutting the design on the shop bot was incredibly fun, albeit at times daunting.  I was really worried that I would hurt myself and forget steps along the process.  But, the process is pretty basic–mount the oriented strand board (OSB) on the sacrificial layer, change your drill to appropriate size (1/4″ was fine for cutting through, I used 1/8″ for engraving), zero the shopbot x,y, and z coordinates, create toolpaths of your design, send to the shopbot, start the drill and GO!

I have to pause here for a brief moment and document how much I LOVED using this start button.  Talk about great design–pressing this button makes one feel like a KING. I wish all devices had these buttons.  My only regret was that I never had to use the big red STOP button.  But I guess that is for the better.

Hey you–pssst… wanna feel like a KING? Just press this.

Engraving should be done with an 1/8″ endmill to get the path around the text

After cutting, I had to cut over the slats twice to free them from the OSB, because I changed out the OSB for a new one, and the new one was really warped.  In the future, I would cut my slats along the longer side of the board, instead of the shorter side.  The reason for this is because OSB is usually warped or curved along the short side, which made all of my slats funky and curved.

Assembly was easy and straight-forward.  I correctly gauged the slots and they fit with enough pressure to hold and maintain rigidity throughout the cot.  Unfortunately, the slats feel too weak to sleep on.  They ought to be milled from something harder, or perhaps doubled up to get more support.