After many weeks the Netduino community BOCS project continues to float around the country. Netduino community members who wish to receive the BOCS can view more information on our community forum entry here. It’s progress can be seen on the map below which is periodically updated.

View BOCS Route in a larger map

Resources:

1. http://forums.netduino.com/index.php?/topic/2481-whats-in-the-magical-mysterious-box-of-crappy-surplus/

We have caused one LED to blink, now it’s time to up the stakes. Lets connect eight. We’ll also have an opportunity to stretch the Netduino a bit by creating various lighting sequences. This circuit is also a nice setup to experiment with writing your own programs and getting a feel for how the Netduino works. Along with controlling the LEDs we start looking into a few simple programming methods to keep your programs small.

for() loops – used when you want to run a piece of code several times. arrays[] – used to make managing variables easier (it’s a group of variables).

Parts Required

• Breadboard
• 8x 5mm Yellow LED (or any color you’d like)
• Jumper wire
• 8x 330ohm resistor (orange-orange-brown)

Project Code

using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;
 
namespace CIRC_02
{
    public class Program
    {
        //Arrays are groups of variables
        static OutputPort[] leds = new OutputPort[8];
 
        public static void Main()
        {
            //Setup all 8 LED OutputPorts, one for each connected pin
            leds[0] = new OutputPort(Pins.GPIO_PIN_D2, false);
            leds[1] = new OutputPort(Pins.GPIO_PIN_D3, false);
            leds[2] = new OutputPort(Pins.GPIO_PIN_D4, false);
            leds[3] = new OutputPort(Pins.GPIO_PIN_D5, false);
            leds[4] = new OutputPort(Pins.GPIO_PIN_D6, false);
            leds[5] = new OutputPort(Pins.GPIO_PIN_D7, false);
            leds[6] = new OutputPort(Pins.GPIO_PIN_D8, false);
            leds[7] = new OutputPort(Pins.GPIO_PIN_D9, false);
 
 
            while (true)
            {
                oneAfterAnotherNoLoop();
                //oneAfterAnotherLoop();
                //oneOnAtATime();
                //inAndOut();
            }
        }
 
        /// <summary>
        /// Will light one LED then delay for delayTime then light
        /// the next LED until all LEDs are on it will then turn them off one after another.
        /// This does not use a loop and is similar to the method used in CIRC-01
        /// </summary>
        static void oneAfterAnotherNoLoop()
        {
            int delayTime = 100;
 
            leds[0].Write(true);
            Thread.Sleep(delayTime);
            leds[1].Write(true);
            Thread.Sleep(delayTime);
            leds[2].Write(true);
            Thread.Sleep(delayTime);
            leds[3].Write(true);
            Thread.Sleep(delayTime);
            leds[4].Write(true);
            Thread.Sleep(delayTime);
            leds[5].Write(true);
            Thread.Sleep(delayTime);
            leds[6].Write(true);
            Thread.Sleep(delayTime);
            leds[7].Write(true);
            Thread.Sleep(delayTime);
 
            leds[7].Write(false);
            Thread.Sleep(delayTime);
            leds[6].Write(false);
            Thread.Sleep(delayTime);
            leds[5].Write(false);
            Thread.Sleep(delayTime);
            leds[4].Write(false);
            Thread.Sleep(delayTime);
            leds[3].Write(false);
            Thread.Sleep(delayTime);
            leds[2].Write(false);
            Thread.Sleep(delayTime);
            leds[1].Write(false);
            Thread.Sleep(delayTime);
            leds[0].Write(false);
            Thread.Sleep(delayTime);
        }
 
        /// <summary>
        /// Will light one LED then delay for delayTime then light
        /// the next LED until all LEDs are on it will then turn them off one after another
        /// 
        /// This does it using a loop which makes for a lot less typing.
        /// </summary>
        static void oneAfterAnotherLoop()
        {
            int delayTime = 100;
 
            for (int i = 0; i <= 7; i++)
            {
                leds[i].Write(true);
                Thread.Sleep(delayTime);
            }
 
            for (int i = 7; i >= 7; i--)
            {
                leds[i].Write(false);
                Thread.Sleep(delayTime);
            }
        }
 
        /// <summary>
        /// Will light one LED then the next turning off all the others
        /// </summary>
        static void oneOnAtATime()
        {
            int delayTime = 100;
 
            for (int i = 0; i <= 7; i++)
            {
                int offLED = i - 1;
                if (i == 0)
                {
                    offLED = 7;
                }
 
                leds[i].Write(true);
                leds[offLED].Write(false);
                Thread.Sleep(delayTime);
            }
        }
 
 
        /// <summary>
        /// This will turn on the two middle LEDs then the next two out
        /// making an in and out look
        /// </summary>
        static void inAndOut()
        {
            int delayTime = 100;
 
            //runs the LEDs out from the middle
            for (int i = 0; i <= 3; i++)
            {
                int offLED = i - 1;     //Calculate which LED was turned on last time through
                if (i == 0)
                {                       //for i = 1 to 7 this is i minus 1 (i.e. if i = 2 we will
                    offLED = 3;         //turn on LED 2 and off LED 1)
                }                       //however if i = 0 we don't want to turn of led -1 (doesn't exist)
                                        //instead we turn off LED 7, (looping around)
                int onLED1 = 3 - i;     //this is the first LED to go on ie. LED #3 when i = 0 and LED 
                //#0 when i = 3 
                int onLED2 = 4 + i;     //this is the first LED to go on ie. LED #4 when i = 0 and LED 
                //#7 when i = 3 
                int offLED1 = 3 - offLED; //turns off the LED we turned on last time
                int offLED2 = 4 + offLED; //turns off the LED we turned on last time
 
                leds[onLED1].Write(true);
                leds[onLED2].Write(true);
                leds[offLED1].Write(false);
                leds[offLED2].Write(false);
                Thread.Sleep(delayTime);
            }
 
            //runs the LEDs into the middle
            for (int i = 3; i >= 0; i--)
            {
                int offLED = i + 1;  //Calculate which LED was turned on last time through
                if (i == 3)
                {         //for i = 1 to 7 this is i minus 1 (i.e. if i = 2 we will
                    offLED = 0;        //turn on LED 2 and off LED 1)
                }                    //however if i = 0 we don't want to turn of led -1 (doesn't exist)
                //instead we turn off LED 7, (looping around)
                int onLED1 = 3 - i;       //this is the first LED to go on ie. LED #3 when i = 0 and LED 
                //#0 when i = 3 
                int onLED2 = 4 + i;       //this is the first LED to go on ie. LED #4 when i = 0 and LED 
                //#7 when i = 3 
                int offLED1 = 3 - offLED; //turns off the LED we turned on last time
                int offLED2 = 4 + offLED; //turns off the LED we turned on last time
 
                leds[onLED1].Write(true);
                leds[onLED2].Write(true);
                leds[offLED1].Write(false);
                leds[offLED2].Write(false);
                Thread.Sleep(delayTime);
            }
        }
 
    }
}

How It Works

This time we use an array of OutputPorts. The array is specified by the square brackets [] in the declaration. Also of note, the declaraction for ‘leds’ is outside of the void Main() function. This is necessary because we need to use that variables in all of our functions. If we declared it within the Main() function it would not be available to any other function.

By storing these values in an array we allow ourselves to simplify code using loop structures. It’s worth reading over the code for the oneAfterAnotherNoLoop() and oneAfterAnotherLoop() functions. These two functions produce identical output, however the latter is far simplier due to it’s use of loops.

Two additional functions, oneOnAtATime() and inAndOut() both produce other lighting effects. The code is fairly simple and is using simple math to determine which LEDs to turn on and off in a given loop iteration. You can change which function is run by commenting and uncommenting which function is called during the while loop within the Main() function.

Further Learning

1. Try all 4 lighting modes and compare the output to the code
2. Create a new lighting mode that turns only the odd LEDs on, then only the even ones
3. Invent your own lighting mode
4. Add a 9th LED and update the lighting modes to work with the additional OutputPort

LEDs (light emitting diodes) are used in all sorts of clever things which is why we have included them in this kit. We will start off with something very simple, turning one on and off, repeatedly, producing a pleasant blinking effect. To get started, grab the parts listed below, pin the layout sheet to your breadboard and then plug everything in. Once the circuit is assembled you’ll need to upload the program. Start a new Netduino project in Visual Studio and use the code example below to create your programs. Ensure you’ve selected the Netduino USB device to deploy to (see the other beginner tutorials for instructions) and run the program to deploy the program to your device.

Parts Required

• Breadboard
• 5mm Yellow LED (or any color you’d like)
• Jumper wire
• 330ohm resistor (orange-orange-brown)

Project Code

using System;
using System;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;
 
namespace CIRC_01
{
    public class Program
    {
        public static void Main()
        {
            //Create an Output port to control an LED on digital pin 13
            OutputPort led = new OutputPort(Pins.GPIO_PIN_D13, false);
 
            //A while-loop will make our code loop indefinitely
            while (true)
            {
                led.Write(false);
                Thread.Sleep(1000);
 
                led.Write(true);
                Thread.Sleep(1000);
            }
 
        }
 
    }
}

How It Works

First an instance of an OutputPort is declared, named ‘led’ and tied to GPIO pin 13, which is where we connected the LED. It’s initial value is set to false (off).

An endless loop then cycles between two states. led.Write(true); sets the pin to HIGH which turns on the LED, likewise turning it to false turns off the pin and LED. Thread.Sleep(1000); instructs the microcontroller to “sleep”, or wait, for 1000 milliseconds, 1 second.

Results

Further Learning

1. Make the flashing faster or slower
2. Make the flashing durations different (on for 2 seconds, off for 1)
3. Connect the LED to a different IO pin on the netduino and change the code to work with the new pin
4. Connect a second LED which is on when the first one is off

The BOCS  project has reached it’s first member after being mailed a few days late. The map below will track it’s journey.

View BOCS Route in a larger map

Just finished packing up the BOCS (Box of Crappy Surplus), a traveling ‘exchange program’ for miscellaneous maker materials. The exact contents of the box aren’t being listed but instead will be discovered as people hopefully find them useful and talk about the interesting projects they’re doing with them.

The box will be mailed Monday (9/17/11) to it’s first recipient Arron.

The “Box of Crappy Surplus”, or BOCS, is a fun, community building experiment based on The Great Internet Migratory Box of Electronics Junk for Netduino community members. The premise is simple, as electronics enthusiasts, makers, tweakers and tinkerers we all develop small stockpiles of near-worthless junk. Not trash mind you, but the miscellaneous bits and pieces of projects long forgotten and put away. A handful of screws, the wheel bearings that didn’t quite fit your robot, the bag of resistors that turned out to be not quite the right value. If anyone is as much of a pack-rat as me you likely have boxes of this type of stuff, too wasteful to throw away, too few to try selling on eBay.

The BOCS is, as TGIMBoEJ puts it, a ‘mobile lending library’ of components. Unlike some other similar boxes we’ll provide slightly more structure. The goal is to send the box in multiple loops, back and forth across the USA. Each person who registers will receive the box in random order, and be responsible for sending the box to the next person. Flat rate boxes from the USPS keep shipping costs to a minimum and there will be no other costs to participate. Cost for a medium sized box will be approximately $10.50 and supports up to 20 pounds, labels can be easily printed from the USPS website. If the box grows too large we’ll need a ‘large’ box which will cost closer to $15.00 to ship domestically.

Rules are less important than fun, but some guidelines are below:

• What can I expect to find in the BOCS? What should I put in?
  The ‘theme’ of the box is electronics and general ‘maker’ materials. Resistors, switches, buttons, wires, wheels, screws, gears, integrated circuits, small hand tools, interconnects, and who knows what else are things you could find in the box, plus anything someone along the chain thinks you might find useful. I’d prefer people use their imagination and put anything they thing another maker could find useful in the box than to create a list of ‘expected’ items.All USPS regulations regarding priority mail service should be followed, and common sense should be used. Let’s avoid batteries which could short out, liquids which could spill, and things of that nature as we..
• How much can I take from the BOCS? How much must I contribute?
  There’s again no particular rules here. A sheet will accompany the box that we ask all people to briefly note what they took and contributed. A general rule is to replace what you take with something equally “cool”. I think if we all concern ourselves with monetary value of items then the point of the box will be lost. If you think you can use the item, or a few items, take them. We want this to be a community project so we do ask that you update us regarding any cool things you build with box items.
• Who do I send the BOCS to when I’m done?
  To try and maintain some semblance of privacy, each person will receive via email the address of the next person on the chain. We’ll also try and confirm all addresses prior to shipping to reduce the chances that the box is “lost” at an out of date address.

Okay, I want to participate, what happens next?

We’re (mostly) keeping it to Netduino community members. Visit this thread to look for any updates to the rules. Send me a private message via the forums with your mailing address. Your address will only go to the person who sends the box to you.

What do I do when I receive the box?

First, take some free stuff! Try to only take items you think you can use, and the key here is for everyone to take what they think is fair. Put some items in the box that you no longer need. The items can be anything ‘maker’ related, can be new or used, so long as they’re functional. If there are multiple parts to a single item make sure they’ll stay together by using a small ziplock bag. Make sure to label what the item is if it’s not obvious, might as well throw your screen name on the label so whoever receives it knows who to thank!

Update the box status, use the same forum thread you used to signup, that’s where we’ll update community participation. Or contact me directly and I can do so for you. This is about community building, so let us know what items you kept and what you have in mind for them!

Finally, check your email/forum PM’s/whatever, I’ll have sent you the address you’re meant to send the box to next. If I didn’t, make sure you ask, we don’t want the box to get stuck or lost. Print a label at USPS’s website, slap it on the box, and bring it to any post office.

That’s it! If all goes well will do this multiple times, growing the list each time. We’re limiting this first round to personal friends, and Netduino community members. Anyone with positive or neutral forum standing who has been a member for at least 60 days can ask to be on the list. The first 20 members who asked to be included will be on this initial round.

Superglue does not work on cellophane, not well anyways. Spent a number of frustrating hours finishing up my window decoration with little pieces that wouldn’t quite stick. I found it very important to rough up the surface of the wood before trying to glue anything at all, which I did with a small wood file. While I was doing that I carved a small vertical groove to run fishing line through.

Finished and unfinished side ready for assembly

Tools for the job, glue, cellophane, tweezers, lasercut butterfly

I started by using my original cutting document from the computer and filling in cells with colors until it looked right. I then one color at a time would lay down some glue and press a piece of cellophane over the glue. After some time, and with plenty of trial and error I would get it to stick well enough to then cut the cellophane away from where I didn’t need it.

Had a small issue with some of the glue getting onto the plastic and drying opaque white, but most of it came off fairly easily. I strung the 3 finished items onto a string for hanging.

If anyone’s interested in doing a similar project, here is the .eps file I sent to Ponoko for cutting.

Received my first order from Ponoko, the designs are those I discussed in my previous entry about lasercutting. The designs are for a simple window-hanging and came out very well. Ponoko ships you the full sheet, not just the objects you design, which are first I thought was a waste of shipping, but the material is quite light and I don’t imagine it would be any cheaper to ship without the scrap included. Also the scrap material was good for testing stains/paint/etc on before potentially damaging your lasercut parts.

I didn't notice at first that there was a paper backing on both sides of the material, once I did it became much easier to separate my parts

Separating the parts and removing all the little pieces of cut bamboo showed off how intricate the cuts were, and how impossible it would have been to do by hand

It took a little time but eventually I got all the parts separated, all the parts were perfectly cut and symmetrical. One side of the material looked more ‘burnt’ than the other side, but my understanding is that this is soot, not burnt material, and can be cleaned off. I planned to paint my creation so aside from wiping it down to remove anything on the surface I didn’t really try to clean it up.

Hard to tell but this is all 6 of the objects stacked up in a single column

The final project will see the wood painted black with colored cellophane filling in each cell, the objects will be glued back to back, creating 3 final butterflies, and hung from fishing line. Currently in the process of painting.

First black coat of paint applied

I really want my own laser cutter.

I’m at that point in my hobbyist tinkering where the things I want to make are too complex to create by hand, but are too infrequent to be worth investing serious money in to buy larger tools. A few months ago someone had given me the link to Ponoko, an online based fabrication company dealing with 3d printing, laser cutting, and more recently CNC routing. I wanted to try out their services for awhile, but didn’t have any projects that required their services, so I did what I usually do, made my life more difficult and costly by inventing a project I didn’t need to do.

I decided to make a hanging window ornament using a lasercut butterfly pattern and colored cellophane. Hobby cellophane I bought from Stuff4Scrapbooking.com, 30×60″ rolls were a mere $1.57 each and shipping was reasonable (when I tried to purchase these items from the same store’s Amazon marketplace, the item price was the same but shipping was applied per-item, making it far more expensive). I picked a few colors not having an exact plan in mind.

Laser cutting uses vector based drawing, which defines a series of paths for the laser to follow. I downloaded Ponoko’s starter kit for Illustrator, a drawing program I already had but hadn’t used much, and read over their list of requirements and tips. Within an hour or so, using a piece of stock art as a template, I’d produced the following:

It look a little practice to use the drawing tools to get the curves I wanted, to join the points to create completely enclosed paths, and to mirror the pattern correctly. There’s also some requirements from Ponoko involving not making features too small, but none of the initial design seemed to violate any of these rules. I settled on a light colored bamboo as my material, duplicated my design to fit 6 butterflies on a single P2 sized board (15.1″ x 15.1″), uploaded it to get an immediate price quote (~$50 for materials, cutting, and shipping). One thing I noticed is that “laser time” outweighs material cost significantly, so optimize your designs if you can to reduce the number of, and length of your cuts.

It took about two days for Ponoko to approve my designs, an additional two days to approve the materials and mark the order “ready to make”, then another two or three days for it to be actually cut and shipped.

The package is now in the hands of UPS and I await delivery to see how my items turned out.