Todd Sampson

While trying to get in on the @aragonproject ICO today, I noticed the first transaction I submitted was taking longer than usual so I did a quick screen capture. A few minutes later the transaction stated “Unable to locate transaction entry” so I grabbed a screenshot of that as well. (see below) Since I only put enough Ether in my MetaMask wallet to cover the transaction plus a few extra Ether as a buffer for fees, etc. I figured I would just resubmit the transaction. I had the same thing happen two more times. On the fourth try the transaction actually went through. From what I have seen on Twitter so far, it seems like some other people weren’t as lucky.

Can anyone explain why this happened?

Is this just a limit of the Ethereum network ahead of the planned scaling upgrades?

Would love to get more info. In any case, huge congrats to the Aragon team on the second biggest ICO in history!

If you are running through any of my previous tutorials on ROS and Docker using the experimental networking feature, you should know that networking is no longer experimental.  It has been released in the 1.9.0 production tag.

Sadly, it appears that the current 1.10.0 experimental branch of Docker is completely hosed based on notes from a few people that reached out to me.  As such, I recommend uninstalling experimental Docker as described here: http://docs.docker.com/engine/installation/ubuntulinux/#uninstallation

Then install Docker 1.9.0 using:

wget -qO- https://get.docker.com/ | sh

It my last post we setup a usb camera to work as a ROS sensor inside a Docker container.  Now let’s get the image stream from that webcam displaying in ROS’s image_view via the image_pipeline package.

First run this on the host computer to authorize containers to access the X server from the docker container:

xhost +

Next we create our Dockerfile, which will be a bit more complex than the usbcam example since we need to setup user and group permissions that match the host computer.  Be sure to update the uid and gid to match your user on the host machine.

FROM ros:indigo-ros-core

RUN apt-get -y update

RUN apt-get -y install ros-indigo-image-pipeline

ENV uid 1000 # IMPORTANT: Update to the `id -u` value on your computer ENV gid 1000 # IMPORTANT: Update to the `id -g` value on your computer

RUN export uid=${uid} gid=${gid} && \   mkdir -p /home/ros && \   echo "ros:x:${uid}:${gid}:ros,,,:/home/ros:/bin/bash" >> /etc/passwd && \   echo "ros:x:${uid}:" >> /etc/group && \   echo "ros ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/ros && \   chmod 0440 /etc/sudoers.d/ros && \   chown ${uid}:${gid} -R /home/ros

USER ros ENV HOME /home/ros

Now we can add a launch config to the docker-compose.yml we created in the last post.  Note the shared X11-unix volume and environment DISPLAY.  These are needed to allow launching X window visualizations.

image_view:   build: .   # image: toddsampson/ros-indigo-image_pipeline   container_name: image_view   hostname: image_view   name: image_view   volumes_from:         - "rosmaster"   # net: rosdocker   volumes:         - "/tmp/.X11-unix:/tmp/.X11-unix"   environment:         - "DISPLAY=$DISPLAY"         - "ROS_HOSTNAME=image_view"         - "ROS_MASTER_URI=http://rosmaster:11311"   command: rosrun image_view image_view image:=/image_raw

The rosrun command calls the image_view ROS package to show the image stream from the usbcam setup in the last post.  The basic image_raw source and default baud rate settings worked for me.  You may need to update them for your system.

Once the above is added to your docker-compose file, and the rosmaster & usbcam containers are running, you can launch image_view with the following command:

docker-compose —x-networking up image_view

To make things easier I have posted a full example on Github.  I also have shared pre-built Docker Images on Docker Hub.

In my last post I showed how to get ROS working under Docker using a simple talker & listener example.  Using this method will work for most ROS packages that provide publisher & subscriber functionality.  In order to use ROS packages that require access to external sensors in Docker requires a bit of additional configuration.

As an example, let’s publish in an image stream from a webcam to ROS.

Since many of Apple’s newer iSight cameras aren’t compatible with the main camera packages in ROS, I temporarily disconnected the RobotGeek Webcam from my 21st Century Robot HR-OS1 and plugged it into a USB slot on my computer.

With the USB camera connected, we can get it working in ROS under Docker. First we create a wrapper around the libuvc-ros meta-package in a Dockerfile:

FROM ros:indigo-ros-core

RUN apt-get -y update RUN apt-get -y install ros-indigo-libuvc-ros

Next we make a Docker Compose entry for the webcam:

usbcam:  image: toddsampson/ros-indigo-usbcam  name: usbcam  container_name: usbcam  net: rosdocker  devices:      - "/dev/bus/usb:/dev/bus/usb"  hostname: usbcam  environment:      - "ROS_HOSTNAME=usbcam"      - "ROS_MASTER_URI=http://rosmaster:11311"  command: rosrun libuvc_camera camera_node _height:=480 _width:=640 _vendor:=2084 _video_mode:=uncompressed _frame_rate:=30

A few things to note about the above:

The lines with `devices:  - “/dev/bus/usb:/dev/bus/usb”` allow the container to access the USB devices connected to the computer running Docker.  More importantly, it does so in a way that doesn’t require you to run the container in privileged mode as required in Docker’s earlier days.

You may need to tweak the settings for your specific camera.  

If you want to use the Dockerfile listed above instead of the one I have on Docker Hub, replace `image: toddsampson/ros-indigo-usbcam` with `build .`

Finally, for a full example, including a rosmaster container running roscore and the launch command, check out the source code on Github: https://github.com/toddsampson/ros-docker-usbcam/tree/indigo.

When I first saw Docker, it was love at first sight.  Adding network-effects, both human and tech, to Linux containers made so much sense.  Packaged, distributed processing units can finally join distributed networking and storage on the internet.

We (Cloudspace) immediately jumped in to use Docker for a number of internal projects as well as projects for a few brave clients. (Thanks guys!)  These projects ranged from traditional DevOps and a database backup system to a distributed job runner that allowed us to run jobs with the extra compute cycles on our office laptops -- all with great results.

Then we tried using Docker with the Robot Operating System (ROS)...

Due to conflicts between the networking models of Docker, which required you to open ports for communication between containers on launch, and ROS, which uses a “graph”  of dynamic communication systems under-the-hood, the two systems didn’t play nicely together.  This was especially true if you try to keep with Docker’s "one process per container” best practice.  So we shelved the idea

Fast-forward two and a half years. (I can’t believe it has been that long!) It probably goes without saying, but both Docker and ROS have come a long way.  ROS has even put out their own official containers for base system and perception modules on Docker Hub.  As the documentation on this page calls out, to properly use ROS with Docker containers you need to use Docker’s experimental networking.

Being experimental, Docker’s new networking is changing fast.  So much so that the instructions on the ROS Docker Hub page no longer work.  Several features and flags have been replaced.  Further, the docs don’t touch on how to use ROS with Docker Compose to design a large scale system, such as a ROS-based robot.  As Docker’s experimental networking nears launch -- Docker Compose just put out a release candidate with Docker’s new networking -- I figured it was time to try ROS with Docker again.

Long-story short, outside time spent digging into source code trying to discover how undocumented parts of Docker networking works, it is a complete success.  The remainder of this post is a quick summary of how to setup a Linux machine to use the new network with ROS.

Getting Docker Experimental Networking

Run the following to install Docker with the experimental features (be sure to enter your password when prompted):

curl -sSL https://experimental.docker.com/ | sh

November 9, 2015 Update: Docker Networking is no longer experimental.  As such, you should install the latest Docker production release.  See http://toddsampson.com/post/132906116887/docker-networking-no-longer-experimental for more information.

Once Docker is installed, you need to make the ROS Tutorial Docker image as described in the ROS instructions on Docker Hub.  Create a new directory, cd into it, and run the following:

printf "FROM ros:indigo-ros-base\nRUN apt-get update && apt-get install -y ros-indigo-ros-tutorials ros-indigo-common-tutorials && rm -rf /var/lib/apt/lists/ \n" > Dockerfile

docker build --tag ros:ros-tutorials .

If all went well, you will have a ros:ros-tutorial Docker image.  Now we can create a new Docker network:

docker network create foo

To use the network, open three terminal windows or tabs.  We will run one of the following commands in each terminal.  These will spin up roscore (master), a talker and a listener using the rostutorial image.  Be sure to launch master first. (Note: These are based on the ROS Docker Hub page, but updated for changes to Docker networking.)

docker run -it --rm --net=foo --name master ros:ros-tutorials  roscore

docker run -it --rm --net=foo --env ROS_HOSTNAME=talker --env ROS_MASTER_URI=http://master:11311 --name talker ros:ros-tutorials  rosrun roscpp_tutorials talker

docker run -it --rm --net=foo --env ROS_HOSTNAME=listener --env ROS_MASTER_URI=http://master:11311 --name listener ros:ros-tutorials  rosrun roscpp_tutorials listener

Again, if all went well, you should see messages published by the talker being displayed by the listener subscriber.

ROS Networking with Docker Compose 1.5.0 RC1

Now that we have Docker’s new networking working from the command line, let’s setup Docker Compose to automate spinning-up our container network.

First we need to install the release candidate for 1.5.0 by running the following in terminal:

sudo su

curl -L https://github.com/docker/compose/releases/download/1.5.0rc1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

exit

Next create a Docker Compose YAML file to launch our ROS container network:

printf 'master:\n  image: ros:ros-tutorials\n  container_name: master\n  command: roscore \ntalker:\n  image: ros:ros-tutorials\n  container_name: talker\n  environment:\n      - "ROS_HOSTNAME=talker"\n      - "ROS_MASTER_URI=http://master:11311"\n  command: rosrun roscpp_tutorials talker\nlistener:\n  image: ros:ros-tutorials\n  container_name: listener\n  environment:\n      - "ROS_HOSTNAME=listener"\n      - "ROS_MASTER_URI=http://master:11311"\n  command: rosrun roscpp_tutorials listener\n' > docker-compose.yml

Now start the network:

docker-compose --x-networking up -d

To verify that the containers all started correctly run:

docker ps

And to verify that the listener is receiving messages correctly:

docker logs listener

One final note, Docker Compose will automatically create a new network based on the name of the directory containing the config YAML file.  You can see this network with:

docker network ls

In order to test out the motion/force/flex sensing glove I have been working on integrating with ROS, I need a few robotic grippers.  (Think hands for robots.)  As always, I’m starting with checking out what is out there in open source land.

The first gripper we tried to build was Mad Mare Studio’s Medium-Duty Robot Gripper.  While I dig the overall design, I realized there is no way one of our RepRap Prusa printers was going to successfully print the two largest parts due to several inch long bridges -- which frankly don’t appear to be needed.  (I discovered this two hours in to the second to last print... Le sigh.)  I may try modify the parts an reprint them soon.

I just finished building JJShortcut’s Standard Servo Gripper.  I picked this gripper since it could be printed on a standard 3d printer, cut on a laser cutter or machined on a CNC machine.  I went for MDF on the CNC machine since it was just for testing.

The original build of JJ’s SSG didn’t work too well.  I’m sure it was something I did in the machining, but I’m not sure if I machined the holes too tight or did something else.  I ended up modifying one of the gears using a drill press so I could attach a round, metal servo horn.

This modification worked like a charm, as you can see in the following video showing the gripper doing a simple sweep motion controlled by an Arduino:

Man, what a great week.

Some cool weather has finally made it to Florida!

I managed to get up at 3am yesterday and today to watch all of the ROSCON 2015 talks.  Fantastic info.  Feels like robotics are at an exciting tipping point, lead by ROS (the Robotic Operating System) on the software side.  So many ideas...

Our seven-year-old daughter blew everyone’s mind at Parkour this week when she made it up the eight-foot warp-wall for the first time.  So proud of her.  She set a goal and worked her butt off to make it happen.

Several great business and personal projects in the work, including an amazing project my wife Lis is building for our son’s Halloween costume.  He is going as Scout from Team Fortress 2 (TF2 is his favorite game) and she is building a custom Scattergun for the costume.

As part of that project, she asked me to design and machine a handle for the Scattergun.  I hit VCarve Pro and built this prototype out of MDF on the Shopbot.  The final version will be made from real wood and aluminum; and have a working trigger.

While we worked on the build, our kids and a bunch of the kids from the neighborhood held a battle bots competition in the garage.  Sphero’s new BB-8 held its own surprisingly well against a Nerf Haxapod, MiP and custom Android-controlled Lego NXT spiderbot my son built & programmed.  Good times.

Then we wrapped the day with this sunset.

Making sure I stop to reflect on how amazing life is right now.  I’m seriously grateful.