Meet the Custom RoboBrrds!

Wednesday, June 19th, 2013

Here are the custom RoboBrrds that we created for some of the backers of the Indiegogo campaign (who backed at that level or above) :)

custom_robobrrds_1

Here is a video of them all flapping their wings and working:

Let’s dive in to what each RoboBrrd is about!

This one was supposed to be a ‘horse theme’. We weren’t exactly sure what that was supposed to be like when combining it with a RoboBrrd, but we came up witha nice sunset-esque colour pallet:

custom_robobrrds_10

custom_robobrrds_9

A penguin themed RoboBrrd! Definitely one of my favourites, check it out:

custom_robobrrds_11

custom_robobrrds_8

This RoboBrrd’s theme was to be simply, blue and white. Almost like a blue jay! There are stripes on it so that it can speed through the air very quickly:

custom_robobrrds_12

custom_robobrrds_7

And last but not least… a very special fancy RoboBrrd with the Brrds Nest front face! It was a blast to decorate this one:

custom_robobrrds_13

custom_robobrrds_6

We sent them on their way flying to their masters earlier this week! Some may have already received them by now. Bye bye Brrds!

custom_robobrrds_packed_

It was a pleasure to make these four customized RoboBrrds. They took a lot of time and effort, but definitely worth while. THANK YOU for backing the RoboBrrd Indiegogo campaign! :D

We posted two new updates on the RoboBrrd Indiegogo campaign, be sure to check them out if you are interested!

(this was originally posted over on the RoboBrrd.com blog)

Please help us make more robot creatures & interesting things!

Monday, June 17th, 2013

As many people here reading this know, we really enjoy making robot creatures! It’s our passion, we want to eventually create a world where these robot creatures can interact together and with humans.

One of the problems that we’ve run in to right now is that we don’t have much money to spend on different robot parts. We want to make bigger robots with more actuators and sensors- for a different interactive experience. But, we get stuck on creating little things. It becomes extremely difficult to earn money when we are spending much of our time on creating these robots.

We need your help to support our robot building activities and experiments. With your help, we will be able to make more crazy robots. We will also be trying to save money for Maker Faire NY, 2013.

We set up a page on Patreon, where you can donate towards each interesting thing that we make. Please check it out and share it with your friends!

Here is a video that we created as well:

The donations will only be taken out once we publish a final interesting thing, so you will be sure that we are at least making cool things and sharing them with the world. :D There are different reward levels too, and you can read more details on the page here.

With the donations, here’s an example of a few of the things we want to get: (not all at once though)
- Many standard servos
- DC motors
- Power supplies … to power the robot
- Flora starter pack
- Beaglebone Black
- Stuff to etch own circuit boards
- More filament
- Making Things Move (a book)

I really hate asking for money / free things, but my goal is that one day I won’t have to (and I’ll be able to help others). It gets really hard to earn money when we spend so much time on the robots, and all of the money from the RoboBrrd Store goes towards (barely) paying the bills. I had to skip a really cool Mini Maker Faire this weekend that was only ~4 hours away, because I didn’t have enough money for the transportation. I haven’t had any luck with techy jobs because they say I’m too inexperienced and just flat-out not good enough.

Anyway, we’ve been working on some interesting things lately. A modification to the sugru experiment worked, so now we have a working tentacle mechanism! We’ll be blogging more about this later.

As always, we massively appreciate your support- donations or not. It means a lot to have people interested in the things we make when the rest of the world just doesn’t really understand us. THANKS!

Buddy 4000 + BLE App (work in progress)

Wednesday, June 5th, 2013

We’ve been long awaiting the days when communicating to our robots from an iOS device would involve less jumping through hoops! BLE on the newer iOS devices is pretty sweet.

Here is a video demo of our app interacting with Buddy 4000 using BLE!

We’ve been working on this off and on for a few months. Actually, half of the core functionality was finished a while ago (sending data from the iOS device to the robot). The BLE module we were using wasn’t configured properly to send data from the robot to the iOS device, and we didn’t have a TI CC debugger needed to re-program the BlueGiga chip so yeah… When we heard that @sectorfej had new modules in his InMojo store, we quickly bought one!

Here is the BLE module (wires are 5V, GND, TX, RX):

ble_buddy_wip 004

There’s a great BGLib library for this module that has all sorts of features packed in to it. There wasn’t much documentation about sending data… Here’s how to do it:

  1. ble112.ble_cmd_attributes_write(20, 0, data_len_var, data_var);

The number 20 is the hard part. We couldn’t figure out where to find the info about this number or anything… so we iterated from 0-49 to find it! You might have to do the same for yours as well. Just keep an eye open on Xcode for when data is received on the app side, and then narrow down the numbers until you find the one that works.

We didn’t show this in the video, but we use sending data from the robot to the app for triggering sounds. Specifically owl and fart sounds. (Yes, this might be the most complex fart app to date). It works better with RoboBrrd, as it has sensors that can be used to trigger the sounds.

Anyway, most of the ‘core functionality’ of the app is involved with this (below) and the communication. We can even make it auto connect to a particular device (as you saw in the video), which makes the experience even more seamless.

ble_buddy_wip 003

Here is how auto-connection is done. We save the UUID and name of the device, then check if we see that specific one:

  1. - (void) connectToDefault {
  2.     // ok, let’s try this
  3.    
  4.     if(connected) return; // already connected don’t do anything
  5.    
  6.     NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
  7.     NSString *givenUUID = [userDefaults objectForKey:defaultDeviceUUIDKey];
  8.     NSString *givenName = [userDefaults objectForKey:defaultDeviceNameKey];
  9.     //CBUUID *zeeUUID = [CBUUID UUIDWithString:givenUUID];
  10.     CFUUIDRef zeeUUID = CFUUIDCreateFromString(kCFAllocatorDefault, (CFStringRef)givenUUID);
  11.    
  12.     int i = 0;
  13.     for(CBPeripheral *periph in allPeripherals) {
  14.        
  15.         if(periph.UUID == zeeUUID) {
  16.             NSLog(@"same UUID");
  17.             if([periph.name isEqualToString:givenName]) {
  18.                 NSLog(@"same name – let’s try to connect");
  19.                 self.peripheral = periph;
  20.                 [bleManager retrievePeripherals:[NSArray arrayWithObject:self.peripheral]];
  21.             }
  22.         }
  23.        
  24.         i++;
  25.     }
  26.    
  27. }

Sometimes specific BLE modules have certain service UUIDs and characteristic UUIDs that you can only send data to. We’ve never experienced a problem with ‘spamming’ everything (yet), but we built in this feature just in case. This is when data is being sent from the app to the robot.

  1. CBUUID *uuidService;
  2.     CBUUID *uuidChar;
  3.    
  4.     int ss = [selectedShield intValue];
  5.    
  6.     switch (ss) {
  7.         case 0: {
  8.             // any
  9.             uuidService = [CBUUID UUIDWithString:roboBrrdServiceUUID];
  10.             uuidChar = [CBUUID UUIDWithString:roboBrrdCharacteristicTXUUID];
  11.         }
  12.             break;
  13.         case 1: {
  14.             // kst
  15.             uuidService = [CBUUID UUIDWithString:kstServiceUUID];
  16.             uuidChar = [CBUUID UUIDWithString:kstCharacteristicTXUUID];
  17.         }
  18.             break;
  19.         case 2: {
  20.             // dr kroll
  21.             uuidService = [CBUUID UUIDWithString:drkrollServiceUUID];
  22.             uuidChar = [CBUUID UUIDWithString:drkrollCharacteristicTXUUID];
  23.         }
  24.             break;
  25.         case 3: {
  26.             // redbear
  27.             uuidService = [CBUUID UUIDWithString:redbearServiceUUID];
  28.             uuidChar = [CBUUID UUIDWithString:redbearCharacteristicTXUUID];
  29.         }
  30.             break;
  31.         default:
  32.             break;
  33.     }
  34.    
  35.    
  36.     for(CBService *aService in self.peripheral.services) {
  37.         if([aService.UUID isEqual:uuidService] || ss == 0) {
  38.             for(CBCharacteristic *aCharacteristic in aService.characteristics) {
  39.                 if([aCharacteristic.UUID isEqual:uuidChar] || ss == 0) {
  40.                     [self.peripheral writeValue:sendData forCharacteristic:aCharacteristic type:CBCharacteristicWriteWithResponse];
  41.                 }
  42.             }
  43.         }
  44.     }

This also allows us to do certain actions for different shields. While going through the example code for the RedBear BLE shield, we noticed it needed a ‘reset’ (or something). We haven’t tested this yet, but hopefully it will make the RedBear one work:

  1. if([selectedShield intValue] == 3) { // redbear shield is weird
  2.        
  3.         CBUUID *uuidService = [CBUUID UUIDWithString:redbearServiceUUID];
  4.         CBUUID *uuidChar = [CBUUID UUIDWithString:redbearResetRXUUID];
  5.         unsigned char bytes[] = {0×01};
  6.         NSData *d = [[NSData alloc] initWithBytes:bytes length:1];
  7.        
  8.         for(CBService *aService in self.peripheral.services) {
  9.             if([aService.UUID isEqual:uuidService]) {
  10.                 for(CBCharacteristic *aCharacteristic in aService.characteristics) {
  11.                     if([aCharacteristic.UUID isEqual:uuidChar]) {
  12.                         [self.peripheral writeValue:d forCharacteristic:aCharacteristic type:CBCharacteristicWriteWithResponse];
  13.                     }
  14.                 }
  15.             }
  16.         }
  17.        
  18.     }

The above is called whenever data is received by the app- eg:

  1. peripheral:didUpdateValueForCharacteristic:error:

When it is all working, it’s really fun to interact with the robot in this way!

ble_buddy_wip 002

There are still some wonky things that happen. For example, if you send too much data- or if you send it at the same time. Sometimes we don’t even know what we did and it will just disconnect (though thanks to our code, it re-connects quickly and without interrupting the user). This happens infrequently, so it might be odd cases.

Special thanks to @macisv, who at SecondConf last year taught me lots about BLE and let me experiment with it! And of course @sectorfej for making this great module that we used :)

Now for the hard part: completing and releasing it. It’s kind of weird, even though we are using this quite often… we have kind of come to dislike this interaction (of pressing and holding buttons) because it’s quite boring. So we’re not sure yet if this one will be finished, or if we’ll be trying something else, perhaps with more gestures and such.

ble_buddy_wip 001

More fun coding ahead! :D

Lightning LoL Necklace Wearable

Monday, June 3rd, 2013

lightning_lolnecklace_11

Here was a quick project that I created in time for C2MTL. It’s a simple, blinky, 3D printed, wearable electronic. We wanted to wear something that would be interesting and a conversation starter (it worked!).

We used the LoL Shield for the source of the blinkiness:

lightning_lolnecklace_3

Underneath, controlling it, is a Diavolino. The velcro is added on to make it stay in place while inside the chassis:

lightning_lolnecklace_4

This is what the main body of the necklace looks like, it was modelled in Autodesk Inventor:

LolNecklace

It was printed out as all one piece, took about 2 hours:

lightning_lolnecklace_2

The LoL Shield & Diavolino fit in nicely:

lightning_lolnecklace_7

There was a LDR poking out the side as well. We didn’t end up using it though (not enough time to code something):

lightning_lolnecklace_8

Now with the faceplate glued on, it looks pretty sweet!

lightning_lolnecklace_10

Battery pack attached behind:

lightning_lolnecklace_1

Here is a short video of it in action:

(aside: here’s a video about what ‘What the Box?!’ is)

The inspiration for the face plate idea came from Buddy 4000. We noticed that the light can shine though its plastic, because of the low infill percentage, so figured the same would be true if the design was only 4 layers (and 2 layers on the lightning bolt).

There was one point where this whole project didn’t work. When soldering the Diavolino and LoL Shield together, the height must have slipped- which caused the reset button to always be pushed. Somehow we were able to desolder this… even though it was tightly squished between the two. Phew!

The battery life lasted throughout the day. There were a few times when the rain almost got to it, but luckily it kept on working.

One of the most interesting ideas that the necklace brought forward was raised to me during a conversation (which was about a discussion people were having about the necklace). The idea went something like this:

The necklace is my ‘currency’ for discussions with people. It makes people interested and want to know more.

Unfortunately we didn’t have time to delve into this ‘currency for discussions’ idea further, but it sounds quite interesting. It’s almost like as if the wearable becomes exchanged for a moment of curiosity, which can then be exchanged for a discussion.

I wonder if all wearable electronic projects are like this- if people come up to you just because it’s something different and want to know more. Perhaps more world-wide friendliness & curiosity could be an unexpected result from wearable electronics!

So, it worked and we were able to get people to talk to us. :D I extremely recommend this to other shy/not-exactly-social people.

To be honest, I never really considered wearable electronics that interesting. Now, after seeing the social aspect of it first hand… it’s kind of fascinating! I may want to try a project or two with a Flora or Lilypad. ;)

The LoL Necklace can be found on Thingiverse here (thing:98078), with the .stl and raw Inventor files (except we removed the lightning bolt, feel free to come up with your own design!).

Sugru Experiment

Saturday, June 1st, 2013

sugru_experiment_3

A few weeks or so ago, @sailindaze suggested for the tentacle mechanism, Sugru could be used as the ‘hinge’ part, since it will be springy. @sugru caught our discussion and offered us some free Sugru! I received mine the week when I was at C2MTL, so as soon as I came back it was pretty awesome to get started with it.

They have a great tutorial video about moulds and sugru here. Definitely check it out if you want to try a similar experiment.

The first step was to create the model of the mould! We created this in Autodesk Inventor:

TestMouldAssy1-4

Instead of going full out with printing the entire vertebrae for the tentacle, we decided to go with ‘hubs’ first.

sugru_experiment_2

The moulds printed nicely- except for the extruded guiding parts (they snapped off). It wasn’t too big of an issue:

sugru_experiment_4

One of the tricks to moulding sugru is adding some dish soap to the mould prior to adding the sugru.

sugru_experiment_6

This is what the sugru looks like, after opening the package!

sugru_experiment_7

Added the sugru to the hubs:

sugru_experiment_8

Packed it into the mould:

sugru_experiment_9

After compressing a few times and taking away the excess material- tada!

sugru_experiment_10

What the moulds look like after:

sugru_experiment_11

The final result:

sugru_experiment_12

After waiting 24h for it to set, it was time to test it out. First I tried bending it, and it broke:

sugru_experiment_14

All the way across:

sugru_experiment_15

It kind of pulled apart when picking at it, and it was still not set in the middle:

sugru_experiment_16

So that experiment #1 didn’t work out too well. I wasn’t entirely sure if it was because of the hubs having sharp corners, or maybe because of the strain relief indents being too much… or maybe there was just too much sugru and it couldn’t move very well.

Time to redesign for experiment #2!

SugruMould-Try2

This time, it was much smaller and the pieces less sharp.

sugru_experiment_17

Adding the sugru to the hubs:

sugru_experiment_18

Adding the sugru to the mould:

sugru_experiment_19

After compression:

sugru_experiment_20

Final result:

sugru_experiment_21

There was some extra sugru, so I tried this as well:

sugru_experiment_23

The resulting moulds:

sugru_experiment_24

After waiting 24h for it to set… it was really hard to bend it, but same issue:

sugru_experiment_25

Totally snapped!

sugru_experiment_26

The 3D printed hubs are breaking…

sugru_experiment_27

Inside the moulded piece:

sugru_experiment_28

Broken-z0rz:

sugru_experiment_29

It’s too bad that the experiments didn’t work. We thought the sugru was going to be a lot springier, rather than tearing when it was bent. The sugru itself is pretty durable- for repairing things we would highly recommend it ;) Thanks to Sugru for the free sugru, otherwise we wouldn’t have been able to try this experiment!

If anyone has any suggestions for what material to try for this sort of thing, or any ideas on how to do a better try at an experiment, please let me know!

Also, if it is of any help to anyone, the sugru experiment files (.stl and raw Inventor) can be found on Thingiverse here (thing:97104).

RobotGrrl EYE50 C2MTL

Sunday, May 19th, 2013

We are selected as a top 20 finalist in the EYE50 competition, a part of C2MTL.

Here is the video that we submitted:

Our big idea starts on a small scale: working on building the experience needed to create anything from your imagination, using DIY robots. These will be the toys for the future, where everyone can learn by making, tinkering, soldering, and programming.

Read more about our project on the EYE50 Intel Platform page and the C2 EYE50 page.

More info about the EYE50 competition here:

C2-MTL, in partnership with Intel, is seeking the EYE50, the 50 Emerging Young Entrepreneurs who will transform the world and shape the future. Prove to us your idea is big enough to be the next big thing and get the chance to have an audience for your idea during the C2-MTL conference.

The opportunity to be here and meet other people with interesting ideas, a driven passion, and creativity is great. I really want to learn how people have harnessed their creativity to earn money, and how they evaluated what risks to take to grow further without sacrificing core values.

With the knowledge gained from this week, I hope to put it into action with some of the future robots & projects we are making :) I’m sure there will be a few moments where someone will say something and it can put things into a different perspective, to look at them differently, and perhaps realize there is something really cool that can happen!

Winning the grand prize would put us one step closer to achieving our goal of making DIY robots as the toys for the future. We would be able to put some money towards more inventory for the RoboBrrd and Buddy 4000 electronics; a highly interactive display for Maker Faire NY; development pieces for other robots; more machines for our rapid prototyping ‘bot farm’; and more development.

Either way, we’ll still be making robots of course! (Stay tuned for a blog post later this week about our Buddy 4000 + BLE iPad App work in progress)

One of the fun things to think about is that DIY robots are really one of several stepping stones to our ultimate goal: making robots become creatures themselves, where they have their own robo-culture, stories that they pass down from generation to generation, and personalities… a real robot society!

A big thank you to everyone who shared and liked our link. It helped our video reach higher up on the page, and we were accepted!

It goes without saying that RoboBrrd wouldn’t be where it is now without the help from others in the Maker community. Read more about RoboBrrd’s history here.

If you are at C2MTL, please come say hi to us (RoboBrrd, Buddy4000, and RobotGrrl)! We’ll be wearing an aqua-blue wearable electronic necklace that lights up white to reveal a lightning bolt design. See ya there!

Introducing Buddy 4000!

Thursday, May 9th, 2013



Buddy 4000 is a classy robot chassis designed to express robot emotions with an artistic flair. ;)

See it in action in this video!



Buddy 4000 is available NOW in the RoboBrrd Store! Special introductory sale, $5 off!

It is everything you are looking for in a robot chassis that looks like a classic robot. Perfect as a chassis for a small project, or just a robotic statue.

Documentation

There is documentation available for building the robot, example electronics, and programming. Check out the main page for Buddy 4000 to see them all.

Open Source Hardware

Yes, Buddy 4000 is OSHW! You can view the .stl’s in our 3D viewer mode, and download an archive of all the files. Hopefully this will let everyone be able to make their own Buddy 4000 (or even a derivative of it). Send pics if you do! Go check it out.

Name Your Price

There is a special ‘name your price’ feature on the Buddy 4000 store page. The extra money is going towards our robotics fund / Maker Faire NY travel fund! We really appreciate your help, and hope to see you at Maker Faire NY!

Inspiration

Buddy 4000 was created to look like a modern version of the old ‘tin toy’ robots. We put much effort into the design of the ‘bot, so hopefully it meets this goal. It took a while to finish this off, especially with all the documentation. Enjoy it! If it makes someone smile, it has been worth it.

Thanks to all the twitter people for following this project over the course of developing it. It’s been fun, and the replies were always interesting to read!

Now go get your Buddy 4000 here, or make your own here!