To begin with, it has node.js baked right into its Ångström Linux OS.  This node.js installation is extended with a “Wiring-like” API.  Then add the fact that BB “sketches” (for lack of a better term) are edited right in your favorite browser, using the Cloud9 IDE.  Cloud9 is clean and simple and it supports the essential IDE features that you might expect — a decent editor with code colorization, management of the files that comprise a project, an interactive debugger etc.  The idea of a web-enabled physical computing platform that is itself programmed using a web interface seems so obvious and so “right” that it feels like it was always meant to be.   Pure elegance meets sheer genius.

At any rate, the fact that this puppy is an outstanding physical computing platform with righteous networking capabilities makes it about the perfect platform for Internet Of Things architectures, so that’s where I’m focusing for now.

Since I have a background in process control systems and a bit of a bias towards Philly-grown tech,  I settled on NimBits for my back-end.  It has all the attributes of a real process control historian with a cloud architecture and some nice bells and whistles to boot.  Since NimBits counts an XMPP based API among its various access methods, I wrote a little study to see if I could send IMs using node.js.  Turns out it’s incredibly simple (check out the picture)  This app doesn’t push stuff to NimBits (yet), but it’s only a half-step away from it — and being able to have a physical computing platform send you IMs is pretty darn useful in its own right.

Keep an eye out here for more Beagle Bone and Internet Of Things stuff.  We live in fascinating times!

There were so many wonderful things it was hard for me to pick a favorite. That is, until I hit the Ultimaker Booth. Ultimaker is another open source 3D printer offshoot of the RepRap Project. Erik de Brijn, Martijn Elserman, and the rest of their team have been hard at work perfecting v1 of the Ultimaker (and now Ultimaker+). The quality of this machine continues to amaze me (I’ve seen a previous beta version in person at Botacon). New this year, when mixed up with the newest firmware Marlin (which was recently ported to 3D FDM printers and is based on GRBL, the same firmware codebase picked to run Lasersaur), the Ultimaker is able to get insanely high resolution prints. You can get the Marlin firmware for RAMPS and RepRap from HERE on Github.

Erik gave me one of the high res Yoda prints (Thanks Erik!) which I put under the microscope last week. You can see with the scale bar… we have 162 pixels = 1 mm. The average layer height in that pic is around 12 pixels, or 0.074 mm (That is 74 microns). And that orangey low res looking thing on the left? That’s not a print… that’s my finger. Click the image to see in higher detail!

Apologies to my buddy Dave Durant, but Ultimaker just beat your high res Cupcake record. And they’ve gotten even thinner layer heights than those, recently. Join their google group to learn more and stay apprised of the latest.

w0w. The future for FDM is so bright. Really Amazing.

Although motor control is potentially a vast and complex topic, with highly specialized branches, the basics are fairly easy to learn — and they’ll take you pretty far.   So … we’ll be prepared to present the following items:

• DC motors
• H-bridge circuits — these let puny microcontrollers run fairly powerful motors
• Stepper motors — just a little more complex to program than DC motors and they use H-bridge circuits too
• Quadrature Encoders — these are a  simple and accurate way to read the position of something

We’ll also try to discuss some organizational items — like the logistics of future workshops and the use of the MMMM GitHub, so that we can build up assets collectively, share them with the world and manage changes and contributions in a free-and-easy-but-organized way.

If you are coming , please bring:

• Yourself — If you’re a newb, welcome — If you’re an MCU Yoda, then attend you must and wisdom to newbs impart
• Some ideas
• A laptop if you have one
• You may want to install VMWare Player or VMWare Fusion before you arrive
• An MCU development kit if you have one or …
• Some money if you don’t.  We’ll have some development kits that you can buy.  Plan on at least $10 for the kits and some parts that you can use for small learning projects.
• A bread-board if you want to build some live circuits to keep.  We’ll have breadboards to loan, but if you want to take one home, it has to be one that arrived with you.

That’s about it — see you all Monday.  To whet your appetite, there is some prototype code below for reading a quadrature encoded position detector (not really elegant enough for a final effort, but it’s a start).  We’ll have you writing stuff like this in no-time.

This code is part of an effort to turn salvaged InkJet printers into motion controllers.  Most of these positioners let you position an InkJet head to within 1/600 inch — they’re fast, accurate, compact, surprisingly strong … and dirt-cheap.

#include  <msp430x20x2.h>

#define LED0 BIT0
#define LED1 BIT6
#define PHASE1 BIT1
#define PHASE2 BIT2
#define PHASE_MASK 6
#define PHASE_SHIFT 1

int state;     // used to hold current state of encoder bits (00, 01, 10 or 11) 
int lastState; // used to hold previous state of encoder bits (00, 01, 10 or 11)
int pos;  // used to count steps. A 1/150" encoder (the most common kind) yields 600 steps per inck. 

// -- prototype of common bit of code used to compute the present state value 
void updateState(void);

int main(void)
{
	WDTCTL = WDTPW + WDTHOLD; // Stop watchdog timer 
	// --- set up some initial values 
        pos = 0;
	P1DIR &= ~(PHASE1 + PHASE2); // Set P1.1 and P1.2 as inputs 
        P1DIR |= (LED0 + LED1); // Set P1.0 and P1.6 to outputs. These are the LEDs on a LaunchPad. 

	// --- get initial conditions so that the first interrupt 	
 // has the right "edge" values and so that position calculations are based on feasible transitions 
        updateState();
	lastState = state;

	P1IFG &= ~(PHASE1 | PHASE2); // clear interrupt flags for P1.1 and P1.2 
        P1IE |= (PHASE1 | PHASE2); // P1.1 and P1.2 interrupt enabled 
	__enable_interrupt(); // enable all interrupts 	
 for(;;)
	{ /* just loop forever and let the interrupts do all the work */ }
}

// updateState() calculates updates for the edge detectors used in the interrupts 
// and also updates the "lastState" variable
void updateState(void){
	state = P1IN & PHASE_MASK;

	if (state & PHASE1)
		P1IES |= PHASE1; // PHASE1 high, then interrupt on falling edge 
        else
		P1IES &= ~PHASE1; // PHASE1 low, then interrupt on rising edge 
	if (state & PHASE2)
		P1IES |= PHASE2; // PHASE2 high, then interrupt on falling edge 
        else
		P1IES &= ~PHASE2; // PHASE2 low, then interrupt on rising edge 

	// ---"right-justify" state so that it is in the range 0..3
       state =  (state >> PHASE_SHIFT);
}

// Port 1 interrupt service routine #pragma vector=PORT1_VECTOR
__interrupt void Port_1(void)
{
    updateState();

    // --- test for all clockwise incremental cases     
 // if we stepped clockwise, then increment the position 
    if ( (lastState == 0 & state == 2)
       ||(lastState == 2 & state == 3)
       ||(lastState == 3 & state == 1)
       ||(lastState == 1 & state == 0)){
         pos++;
    }
    // --- If we didn't move clockwise, then we must have moved counter-clockwise     
 // so decrement the position 
    else{
        pos--;
    }

    // --- record last state 
    lastState = state;

    // --- update LEDs just to help debug 
    // use "state" as intermediate variable so that we can see the output value in the debugger easily 
    // This is just so that we can see the encoder signal. No functional purpose. 
    state = state + ((state << 5) & 0x40);
    P1OUT = state;

    // --- clear the interrupt flags 
    P1IFG &= ~(PHASE1 | PHASE2); // clear interrupt flags for P1.1 and P1.2 
}

The parts are cold cast bronze, this means Enrique painted several layers of bronze powder into his molds and then cast them with resin. What came out were the brown parts you see in the pictures and video below.

This 3D printer rocks. The RepRap 3D printing project still has a lot of rough edges, but that’s why we love it. We’ll have BronzeBot on exhibit at the next RepRapWorldTour in Baltimore, and then back in Philly in August to do it again.

Slideshow:

We whipped up a Wiring-ish wrapper for the MSP430 a while back in order to simplify the task of porting Arduino libraries for use with MSP430 microcontrollers.  It turns out, we weren’t the only ones that thought of it.  PJ spotted a post on Hack A Day where someone unveiled something remarkably similar, and that post resulted in at least two other folks besides us posting their similar ideas — so there are at least four of these wrapper libraries out there.

Naturally, we’d like to think that ours is the best of the bunch, and the best named too — TIWrap.  Seriously, though, we seem to be genuinely different in that that we have bundled in actual libraries ported from Arduino, such as the HD44780 and MAX7221 libraries.  There are some piezo buzzer libraries and we expect to add some Charlieplexing utilities soon.  You can get a copy of TiWrap here.

The demo above is a “Fancy Flashlight” concept proposed by Matt Torbin.   It’s just one MSP430, two LEDs, a button and a bit of code which you can find in the TiWrap examples.

And in case the title left you puzzled …

PLA bushing sliding on precision ground 8 mm rods is actually quite smooth movement. I don’t think it can go as fast as the original Sells Mendel (which was ball bearings sliding over the rods), but it’s only half the printed parts and the z-axis is much smoother motion too. I will try oiling or greasing the bushings to try to get smoother and faster motion without losing steps. So definitely some tradeoffs but overall a super awesome bot. The Prusa is also fully parametric and entirely made from OpenSCAD. All sources are available on github FTW.

As this is the first bot I built that I actually own, I named this awesometown after my HS science teacher, Mr. Sloate, who really got me into Biology and now, robotics for Biology.

What will we print next?

We won!

Great news, The Citizen Science Quartely just picked the winner for the Open Science Design Contest, and:
WE WON!!!!!!!!1111!!111one

You can read more about the original entry HERE.

We’ll be using the Ponoko gift certificate to design a housing for the electronics and make it more kit-able. Bench Science FTW!

And definitely check out the Kickstarter for The Citizen Science Quarterly. It’s shaping up to be a really interesting mix of Bench Science in the DIY spirit. From the Kickstarter page:

“We’d like to create a magazine for the scientist in all of us.

It will have simple How-To’s, like extracting the DNA of a strawberry using kitchen materials. But on the next page could have a paper on the validity of using Bacillus Subtillus as a model organism. We’d feature extraordinary citizen scientists who are doing extraordinary things in abnormal labs (aka garages, closets, etc). We’d also give legal and safety tips to inform and protect citizen scientists from some of the dangers they could run into.”

Open Source Orbital Shaker

Here is my entry for the Open Call for Open Science Equipment Contest.

I did this with help from Mike, Jack, Rob, Adam and others right here at Hive76. Thanks everyone!

Details and all source files for this project are available on Thingiverse.

The deadline for submission is December 15th, so if you have an idea for open source equipment you still have some time to submit your entry to the contest!

Open Source Orbital Shaker from jmil on Vimeo.

Chris building a BoomCase

Our entire building at 915 Spring Garden is taking part in Open Art Studios this weekend, and we’ll be there too!

Almost 30 studios will be open to the public, including Hive76! There’s a ton of different medias people use, everything from textiles to clays to electronics.

Come join us on Saturday and Sunday, December 4th and 5th, from noon – 5 pm at Hive76. We’ll also be upgrading our MakerBot with a new MK5 Extruder so we’ll be printing in tip-top shape again soon!

…

It was weird to hit the Wednesday Hive Open House and see a handful of original MSP430 projects.  The video above is an LED chaser effect that Chris Thompson whipped up based on concepts from the first session of the MSP430 class.  As the old saying goes — teach a geek to fish and you’ll soon have LED encrusted fish.

Speaking of LEDs, here’s a Morse Code blinker project that Chris did.  Mostly a cut & paste job, but if nothing else, it makes the point that there are plenty of  MSP430 code samples out there and that it’s relatively easy to use them once you know the tools.

Audience

…