Sign in:

Thousands of Tiny Robots

The Modular Robotics Blog

So awesome. Remember a couple of months ago I wrote about playing around with flow-based programming in Pd? Well now, Miller Puckette, designer of the language (and of MaxMSP) is coming to Boulder to teach a month-long Summer course on interactive programming and digital music technology.

Miller Puckette
Miller. Photo from: http://pd-la.info/2011/05/thank-you/

 

The course starts the day after tomorrow and runs until August 7.  I feel a little envious: I wish I could join it somehow, but it’d be impossible with my travel schedule.

I’m proud of Mark Gross.  He’s the co-founder of Modular Robotics, you know, but for the last couple of years he’s been leading the ATLAS Institute at the University of Colorado just down the street from us.  All indicators (like this fact that this course exists, for instance) show that Mark is enjoying great success transforming ATLAS into a world-class program.

Alicia Gibb’s new book, Building Open Source Hardware, is awesome. It’s filled with interviews, case studies, discussions of licensing and manufacturing, and practical information about taking a project from idea to product.  If you’re interested in open hardware, you’ll want a copy.

I contributed a little piece to the book about FARKUS, the open source manufacturing robotics platform that we’re working on.  You can read it here while you’re waiting for your copy of the book to arrive!

13220-01

Do people on the internet bring you down?  It happens to me a lot.  I’ll read an article, and before I know it, my eyes will have wandered down into the comments, and I start to get upset with trolls, upset about how intolerant some people seem to be.  Upset with our education system, upset with stupidity, and even a little upset with there, their, and they’re.  Often upset about an oversimplification of complex things.  I try not to let this stuff get to me, but sometimes it’s hard, especially first thing in the morning.  I just don’t want to hear what random people on the internet have to say.

Shut Up   Chrome Web Store

So I use Shut Up, which is a lovely lightweight Chrome extension that removes all comments from web pages: YouTube, the Daily Camera (it’s our local Boulder, CO paper and has the worst comments ever), the Radavist (apparently I like pretty bicycles more than I like other people who like pretty bicycles), etc..  Shut Up misses a couple of sites and isn’t perfect, but it’s free.  Maybe you’ll find that it has a place in your life too.

It strikes me that this may seem antisocial.  Facebook’s article last week about “echo chambers” has made me a little more aware of the possibility of over-curating our inputs.  But eschewing web comments is not the same as reducing diversity, it’s reducing the volume of input from the whole diverse internet.  Toward what seems like, for me, a much more manageable flow.

Don’t worry, I haven’t forgotten about tiny robots.  Next Level Cubelets Part II soon!

I flew to Atlanta last week to give a talk at Mailchimp. Know them? If you don’t send emails to big groups of people, you probably wouldn’t, but if you do, you definitely do. Mailchimp is a mass-email service, but it’s wrapped in a cutesy, web 2.0 B2C-style design. They have millions of clients — we use them at modbot to send newsletters. If you’ve subscribed to get email updates for blog posts, look at the bottom of this email! Sent by Mailchimp.

I try pretty hard to ignore invitations that don’t appear to have a direct benefit for Modular Robotics. After all, there’s always a lot to do at the new shop. But the people at Mailchimp are totally awesome, and they offered to take me to dinner at Empire State South. So, 18 hours in Atlanta. Turns out it was completely worth it. For a SaaS company, the chimps there do a lot of playing in hardware. I got a great demo of the Freddie Mercury Project hardware in which they sent email from the stratosphere with a stuffed monkey. Etcetera.

Anyway, I talked about tiny robots and manufacturing and complexity. And also a little about evolution and faith, because why not? The slides from my talk definitely don’t stand alone as a presentation (if you weren’t there, you won’t get it) but for the archives, here they are (55MB PDF).

2015_mailchimp

What’s a robot?  Our working definition is that it’s a machine that Senses, Thinks, and Acts.  Cubelets and MOSS are pretty primitive robots; if you prefer Sense, Plan, Act, they probably won’t be offended.

Anyway, each Cubelet falls into one of the Sense, Think, or Act categories, and one of the main reasons that they seem primitive (compared to a mouse, say), is that they fundamentally work together based on simple, linear, one-to-one relationships.  Snap a Distance Sensor onto a Drive block, and the more the distance sensor detects, the faster the motor goes.  The less, the slower.  All of the Sense and Act Cubelets output basically linear values (or actions) based on their inputs:

linear

A linear, monotonic relationship like this makes simple, perfect, robotty sense, but doesn’t have a lot in common with the messy, biological irregularities and discontinuities that we find in systems that look alive.  What if we try something that’s not monotonic: a function that doubles back on itself.  How about an easy piecewise function that makes a triangle: y=x for x<0.5 and y=1-x for x>0.5.  At Wolfram Alpha, we can plot it like this:  Plot[Piecewise[{{x, x<0.5}, {1-x, x>0.5}}], {x, 0, 1}]

I used Cubelets Studio and a Bluetooth Cubelet to reprogram a Knob block to apply this transformation to any data that flows through it.  Then I added a Bar Graph so that I could see what was going on and got this:

Which is exactly right, but I want to use the full range of the bar graph, so I’ll make my triangle wave twice as tall by adding a simple 2x.  It works, and I know you can picture a full bar graph response so I’m not going to bother with a video.  Here’s the code:

  void loop()
  {
     int temp = get_knob();
     if (temp <= 127) {
        block_value = 2 * temp;
     } else {
        block_value = 2 * (255 - temp);
     }
  }

OK.  Now I’m going to switch it up a bit and flash (almost) the same code into a Distance sensor (swapping get_distance() for get_knob()) and build a little mobile robot.  It’s a differential drive robot with the modified Distance sensor controlling one motor, and a stock Knob controlling the other for easy tuning.  The Passive block is just for balance.

Hm!  This little robot looks like it’s attracted to the box but also careful to keep its distance.  Is it “thinking”?  Is it “intelligent”?  Maybe not, but it seems like we’re getting a little closer to intelligence here than we can do with a robot made out of stock Cubelets….

Modular Robotics is moving!  We’ve been in our current space for almost three years, and it’s time for an upgrade.  Three times the square footage, two times the ceiling height, and three times the number of bathroom stalls.  And for the first time, we’re not just using my truck to move!  Team modbot has arranged for a series of trucks, riggers for the SMT equipment, and a real moving company to move the office.  The elf team is currently working on moving the inventory.

DSC_0152

The new space is amazing.  It’s a former post office!  It’s a former Coca Cola bottling plant!  It’s super weird!  We’ve been working on a renovation with Tres Birds Workshop for the last six months and it’s finally ready; inspections are complete and the certificate of occupancy is in hand.  I won’t belabor the description since I’m confident that many blog-worthy shenanigans with forklifts and rollerskates will ensue, but it’s currently looking eerily empty.

modular robotics new space

While we’re making this transition, please note that our address has changed.  Send all boxes of chocolates, fruit baskets, or tiny robots in need of maintenance to:

Modular Robotics
1860 38th Street
Boulder, CO 80301

Modular Robotics co-founder Mark Gross was in a paragliding accident last Sunday.  He is not dead!  And he has balloons.

IMG_0544

Mark broke his back and a leg, but is stomping around with a cane and in great spirits.  He’s currently encased in a plastic insect shell thing so that his back doesn’t move too much while he heals from surgery.  Falling out of the sky onto rocks sounds pretty harrowing; in Mark’s words:

…one way to clear a tangle is to give a quick gentle tug on one of the tangled lines.  So I give a quick tug on the tangled right brake.   Whoa!  The wing collapses completely, and suddenly the glider steers left sharply in what is aptly and terrifyingly called a “spiral dive”.   Round and around heading for ground: Not much time to think, too low to deploy the reserve parachute, but somehow I get the left side inflated and flying again, but by now I’ve lost a lot of altitude and I’m swinging like a pendulum from the radical changes.   An instant later I swing into the ground.  Hard.

I’m letting you know about Mark’s accident here because he’s not a big social media poster and because he’s got a pretty big community who I know might want to be concerned.

I also wanted to make a little plea for you to be safe out there on your paragliders.  My friend Jacques hit the deck paragliding in the Himalayas in November, broke his back too, and was laid out flat in traction for a month in an Indian hospital.  That makes two for two — both of my paragliding friends have broken their backs falling out of the sky in the last six months.  I think that’s all of my paragliding friends, but if you’re number three, please exercise caution.

Modular Robotics is now 72 people, and 72, while not an objectively huge number, is sometimes overwhelming since it seems like only yesterday that we were 4 or 5 people. As we’ve grown, it’s seemed sometimes that things get crazy at a faster than linear acceleration: we’ll hire two people at once and everything will get four times crazier.

I think it feels that way because of graphs: because modbot is great big complex adaptive system. People are the nodes, and relationships are the edges. When we add one person to a ten-person team, we’re also adding ten more relationships and communication paths into the mix, and relationships are the nuanced pieces of our system that are messy and unpredictable. When things break at modbot, they usually break because of communication. It’s the edges.

Anyway, we decided a few months ago that we’d change our planning rhythm a little bit for 2015. Last year, we made a lot of projections for the whole year, and when things changed, our projections and actual results diverged wildly and the projections and planning models became less useful really quickly. For 2015 we’re planning and rebuilding our operating model quarterly, so to recap the first quarter and recalibrate for the next quarters, we decided to meet offsite for an immersive session that we called a Retreat, even though we weren’t running away from anything at all.

Eight of us drove West last Thursday morning for a play day in Winter Park and I joined the skiing group.  Snow conditions were poor (frozen-over old corn)  but the company was top-notch.  We were all ready to rock the bunny hill all day since it was Hiller’s second time ever on skis but he figured out pizza and french fries in five minutes and shredded the whole mountain.  The sky was pretty grey: Stu’s the only one of us who broke through, sporting rad purple gnargyle.

stu_gnargyle

We rented a super-cool, super-weird house in Tabernash to use as home base.  We took Myers Briggs personality tests, cooked dinner together, ate fajitas, got a little drunk on red wine, and played charades until late.  All good.

At 8am Friday morning, we settled in for a marathon day of strategic planning.  Eight of us spent ten hours in a big rented living room talking about our product lines, manufacturing strategy, hiring plans, etc.   And it was awesome.  No one talked over each other.  No one interrupted.  Everyone facilitated a section and took turns taking notes for the group.  We were productive, respectful, and functioned like a well-oiled machine.

I started this post wondering about communication and team complexity.  We’ve had some glitches at modbot as we’ve grown, and at times, it seems like we function and work together with results that are less than the sum of our parts.  My main goal for the Retreat was simply to work on communication, soft social skills, and team-building with this group, and I’m pleased to report that I was tremendously impressed with the results.

Christie sent me this photo of one of our walk-and-talk breaks at the Retreat and I absolutely love it.  At first glance, I thought, “wow, Eric, look at you!  What a super business photo.  Looking like such a leader!”  Upon further reflection, I realized that everyone else in the picture is moving forward and I’m the only one who’s walking backward and falling into various holes and obstacles.  Allegorically or otherwise, maybe I should turn myself around and focus on where we’re headed.

2015-retreat-walk-and-talk

A few weeks ago Jon Hiller showed some ideas for next-level robot programming at our weekly engineering meeting.  We got to talking about boxes-and-arrows programming or “visual” programming or whatever you might want to call it.

We’re pretty into visual programming.  Cubelets take visual programming to the extreme and make it tangible.  When you snap Cubelets together, you’re snapping little plastic blocks of programming to each other, and they immediately begin to pass data.  But we like visual programming in the traditional sense too — the MOSS Scratch extension has proven to be popular not only for our users and our education team, but also for our design team: engineers at Modular Robotics usually default to Scratch when mocking up new robots and behaviors because it’s fast and easy to use.

Now we’re looking at some ideas for more accurately representing the Sense-Think-Act flow of robotics programming, and we’re playing with boxes-and-arrows language ideas.  This isn’t new: LEGO Mindstorms has a boxes-and-arrows language that’s based on LabVIEW, but it’s based on the notion of a single, centralized brain (not the distributed model of Cubelets and MOSS), and, of course, there’s the common sentiment that LabVIEW just straight sucks and is something to be learned for a control systems class, complained about, and then promptly forgotten.

In my world, Max/MSP is the benchmark for boxes-and-arrows programming.  My friends at Sketching in Hardware use it to program physical devices and prototypes.  My electronic music friends use it for synthesis, sound design, and elaborate rule-based IDM, even embedding Max inside Ableton Live.  Max has been around since the mid-1980s!

Funny thing is, I had never played with Max.  I referenced it in my dissertation, I’ve seen a bunch of demos, and I get the concepts, but it’s $400 for a license.  Now, the people behind Max also built Pd, a free and open-source boxes-and-arrows language, and I tried to build a mini granular synthesizer in Pd a few years ago, but the documentation is sparse, the tools aren’t polished, and I ended up never completing the project.  Max, the polished commercial product, has a 30 day free trial, though, so I thought I’d give it a go.  Here are the results of my two hour experiment.

es-dumb-sequencer

This little patch is a simplistic step sequencer, and it works!  The toggle switch on the upper left triggers both the BPM calculation on the right and the main metronome.  The metronome sends beats to a counter that breaks them up into groups of 8 (two measures of quarter notes, say) and the select object splits each of the 8 beats into a unique output.  Squiggly lines, that I like to think are virtual cables on my modular sequencer, connect the beats to MIDI codes for a hi-hat (55), bass drum (50) and snare (40), the makenote object turns those into a complete MIDI note with note-off, velocity, and duration, and the noteout object triggers the internal synth on my Macbook.  Beats!

I learned some things by playing.  Patches flow from top to bottom, and each input and output on a particular object does something different.  Lines can transmit various data types from the simple pulse called a bang to integers or audio signals.  Max, and the whole boxes-and arrows paradigm, seem to inherently enable and encourage thinking in terms of parallel processing and distributed nodes of computation.  Instead of a huge page of procedural C, we’ve got a visual map of the code structure in front of us and can dig in atomically to the modules.

This is a little scary.  Remember Flash?  I used to write a lot of Flash in the early 2000s and it was great for hacking little graphic web things together.  You’d embed code into the window, into objects, into special tweening scripts, anywhere you’d want it.  And that worked fine until it was time to debug, and 400 code snippets in 400 different places quickly became a nightmare.  I worry about the same thing happening in a giant Max patch, but at least the main flow chart provides a clear overview of the whole system.  Managing complexity rears its head again as a hard problem.

I thought I’d share this because I learned something about visual programming.  Because I finally played with a thing that I’ve been talking about for ten years.  Because I think it might be a great way to get kids thinking and playing with Finite State Machines!  And because my Max free trial only has 17 days left so I better play with my dumb sequencer while I can.