SparkFun Inventor’s Kit for RedBot.

I get many questions from people about how I think kids and adults should get started in robotics, how they should progress, and what they should buy, to learn about robotics. This is a quick guide to help you get going.

I’ve described three levels below — Level 1 is for people older than 12; Level 2 is for people older than 15, and Level 3 is for people over 18. An adult can probably start at Level 2 if desired, however starting at Level 1 will give you important basic skills and knowledge that you can build on.

Don’t worry about the details. You do not need to learn how SPI or wifi work, for example, but you will slowly pick up the details as you use them.

Level 1 – Getting Started with Micros

1. Set a clear and realistic goal – Robots are hard, so match your expectations to your skills. Your first robot should be really simple.
2. Recommended Book – Make: Arduino Bots and Gadgets: Six Embedded Projects with Open Source Hardware and Software and Arduino Robot Bonanza
3. Get your hands dirty – Learn how to mechanically and electrically build a robot.
   • For this task, design and build a robot that uses an Arduino Uno, 2-4 motors, 2-4 simple sensors, a switch, a LED and a battery.
   • The Sparkfun Inventors Kit for Redbot is a great choice for this step.
   • Design on paper what the robot should look like and the parts that you need (if you buy a kit, use it, but then modify it).
   • Build the robot using basic hand and power tools.
4. Learn how to program – Use the Arduino to program the robot.
   • Start by simply making the light on the Arduino blink. If you have never done this before, it will take longer than you think it!
   • Spin a single motor.
   • Read from your sensors and play with them – use Microsoft Excel to generate a calibration curve.
   • Combine the sensors and motor code to do what you desire.
5. Join a robotics club – There are many options! For example:
   • School robotics club
   • First Robotics
   • Society of Robots

Level 2 – Getting Started with Embedded Computing

1. Set a clear and realistic goal – Build upon what you learned in Level 1 to set goals for level 2.
2. Recommended Book – Make a Raspberry Pi-Controlled Robot: Building a Rover with Python, Linux, Motors, and Sensors
3. Get your hands dirty – Learn how to mechanically and electrically build a robot.
   • For this task, design and build a robot that uses a Raspberry Pi computer, 2-4 motors, 2-4 sensors, and a battery
   • Design your parts with a CAD tool (such as Google Sketchup or Solidworks)
   • Think about how you will interface your sensors to the computer?
   • Use new materials and construction techniques. Try to use a 3D printer or laser cutter if possible.
4. Learn how to program – Use the Linux computer to program the robot.
   • Learn basic C++ or Python, try talking to serial ports.
   • Make your robot act as desired.

Level 3 – Advanced Computing

1. Set clear and realistic goals – You should increase the difficulty of your goals as you advance. At this point, try setting a goal that you’d like to attempt, even if you are not sure you can achieve it.
2. Learn basic trig and statistics – Learn the basic math that you need for robotics.
3. Get someone else’s hands dirty – Design a part and shop it out to be machined.
4. Learn how to use more advanced sensors – Such as a Camera and/or LIDAR.
5. Software – Learn the Robot Operating System (ROS).
6. Algorithms – Continue making software more advanced. Autonomy, mapping, device drivers, etc…

Each level will take time to develop and learn, but following this path will ensure that you have the knowledge you’ll need to progress to the next level.

Additional Resources

I tend to like Sparkfun for buying hobby parts. Other places you should look are Adafruit, and Pololu. They all have blogs and tutorials for using the hardware they sell, including basic robotics, Arduino, and Raspberry Pi.

The Arduino family of micro controllers has quickly become a go-to board for hobbyists due to its ease of use. Often times roboticists must create communication protocols to allow their embedded hardware to communicate with a computer. One of the most powerful aspects of ROS is that it can communicate with a large variety of hardware. That’s where rosserial comes in! Rosserial is a general protocol for sending ROS messages over a serial interface, such as the UART on Arduino. This allows you to easily interface any sensors attached to Arduino into your ROS environment. Read on to learn more!

This tutorial will get you started  by setting up the Arduino IDE and installing the rosserial libraries. Then, we’ll test it out by driving the Husky simulation using a neat trick with the Arduino board. It should goes without saying you’ll need an Arduino to complete this tutorial. We’ll also be using a Husky simulator, so make sure to run through our “Drive a Husky” tutorial if you haven’t done so yet.

Setup

The first step is to set up your Arduino environment, begin by installing the Arduino IDE and rosserial using:

sudo apt-get install arduino arduino-core ros-hydro-rosserial ros-hydro-rosserial-arduino

Once you open up the Arduino IDE for the first time, a directory named “sketchbook” will be created in your home directory. Now we need to import the rosserial library into your arduino IDE. If your sketchbook directory is empty, you may need to create a directory named “libraries” inside of it.

mkdir ~/sketchbook/libraries
cd ~/sketchbook/libraries
rosrun rosserial_arduino make_libraries.py .

Restart your Arduino IDE and you should see the ros_lib part of your libraries!

You’ll want to ensure that your Ubuntu user is part of the “Dailout” group, which grants you access to serial ports. You can check by using

groups "username”

If you don’t see “dailout”, you can easily add yourself using

sudo gpasswd --add "username" dialout

One last step to make our lives easier will be to create udev rules so your Arduino is  recognized when plugged in and the correct permissions are set. For more information on udev rules check out our udev article . Begin by plugging in your Arduino.

NOTE:If you are using a virtual machine, you will have to connect Arduino to the virtual machine after plugging it in.

You can confirm your system is actually connected to Arduino by running

ls -l /dev

Depending on your specific Arduino board, you should either see a line with ttyAMC# or ttyUSB#, where # is a number. This will also tell you the current permissions for your Arduino. Chances are you wouldn’t be able to upload code to your Arduino at the moment because you don’t sufficient permissions, but we will soon solve that by creating a new udev rule!

The udev rule will require the product and vendor ID to be able to identify when our arduino is connected which you can easily find using

lsusb

You should see a line similar to

Bus 002 Device 005: ID 2341:0043

To confirm this is indeed your Arduino, disconnect it and run the command again, taking note which entry has disappeared. Remember the ID numbers, in this case, 2341 is the vendor ID and 0043 is the product ID. Now venture over to your udev rules at:

cd /etc/udev/rules.d/

and create our new rules file, the naming conventions for rules files follows “##-name.rules”. Chose a number that isn’t in use!

sudo gedit 97-arduino.rules

Copy the following into your new rules file, replacing #### with your product ID and vendor ID. For more information about what these tags mean, check out our article on udev rules.

SUBSYSTEMS=="usb", ATTRS{idProduct}=="###", ATTRS{idVendor}=="####", SYMLINK+="arduino",MODE="0777",

All that is left is to update your udev rules and reboot your system

udevadm trigger
sudo reboot

You should now see “arduino” as an entry in ls -l /dev with full permissions! (rwxrwxrwx)

Code

We’re now set to upload our code to Arduino! The code is fairly straight forward, however if you have any difficulties following along, check out our “Creating a publisher” tutorial. Copy the following code into the Arduino IDE and click upload. If your udev rules were set correctly you should be able to upload without any errors.

If you encounter any errors, verify your arduino is coming up as “arduino” in a ls -l /dev and proper permissions are set. You may also have to point the Arduino IDE towards the correct USB port in tools -> serial port.

#include <ArduinoHardware.h>
#include <ros.h>
#include <geometry_msgs/Twist.h>

ros::NodeHandle nh;

geometry_msgs::Twist msg;

ros::Publisher pub("husky/cmd_vel", &msg);

void setup()
{
 nh.initNode();
 nh.advertise(pub);
} void loop()
{
 if(digitalRead(8)==1)
 msg.linear.x=-0.25;
 
 else if (digitalRead(4)==1)
 msg.linear.x=0.25;
 
 else if (digitalRead(8)==0 && digitalRead(4)==0)
 msg.linear.x=0;
 
 pub.publish(&msg);
 nh.spinOnce();
 }

Driving Husky

Now that Arduino is loaded with our code and publishing velocity commands, we can pass these messages along into our ROS environment. We’ll start by launching a Husky simulation:

roslaunch husky_gazebo husky_empty_world.launch

All that’s left is to attach the Arduino into our ROS environment using:

rosrun rosserial_python serial_node.py _port:=/dev/arduino

We’re ready to try it out! Go ahead and touch the digital pin 8 and you should see Husky drive forward! Similarly if you touch digital pin 4 Husky will drive backwards.

This trick is made possible by a phenomenon known as parasitic capacitance, which is usually an unwanted effect in electronics design, but serves nicely for the purpose of our example. That being said, this isn’t the most reliable method, and is intended to provide a simple example with minimal equipment.  If you are having difficulties moving your simulated Husky, try using rostopic echo /husky/cmd_vel to verify some commands are in fact being sent to Husky when you touch the pins.

Be sure to go through the rest of our ROS tutorials on our knowledge base. If you want to learn more about rosserial, be sure to visit the rosserial page of the ROS wiki.

Looking for other Clearpath tutorials? You might like these ones! Or visit www.support.clearpathrobotics.com.

Watch video on YouTube

Learn more here

This video consists of the earliest participants in the Arduino project talking about how it got started.

Checking Vimeo, there are over 4,000 videos there tagged “arduino”. [2012Oct14: now over 9,000]

Similarly, a search of YouTube with “arduino” as the search term results in over 5,000 hits. [2012Oct14: now over 100,000]

Found on Engadget.

Reposted from Cultibotics.