Mappino v0.1

Mappino is an open source (code GPL, hardware CC BY-SA 2.5) robot that can be used for learning about the basics in mobile robotics as odometry, path planning, obstacle avoidance, mapping, occupancy grid building, localization, etc... An effort has been made to make Mappino as simple as possible while enabling to do similar things as one can do with its big and expensive brothers. This of course comes with the price tag of needing a flat, hard floor and Sharp IR sensor friendly obstacles. If one already got a robot body, Mappino's sensing head can be put on other robots without needing the rest of Mappino.

On the following images you can see Mappino v0.1 assembled, disassembled and the range sensing head which is a stand alone unit:

On the following videos you can see Mappino doing a scan matching and homing demo and Mappino being tested for endurance:

Mappino's acrylic laser cut body fits without the wheels into a cube with cca 15cm sides. The wheels add about 2.5cm to one of the dimensions. Stepper motors powered by 6 AAA batteries move the robot and the sensing head. The stepper motors are easy to control and provide accurate motions without the use of incremental encoders, thus making odometry simple and accurate. Mappino's Sharp distance sensors rotate by +- 180 degrees while getting a cross section of the environment with range readings to about 2.5meters. The range readings can be used for scan matching, map building and localization. Mappino's two processor boards - the sensor and dual motor control board can be conveniently programmed by the Arduino IDE.

To read more about Mappino, a paper presented at the International Conference in Robotics Education (RiE 2011) can be accessed here (1MB), together with the corresponding presentation slides (360kB). During the talk at RiE 2011, a live demo was given, where Mappino was repeatedly put into random positions in a rectangular area where Mappino took a scan, performed scan matching and went to the center of the area.

For those who want a Mappino but don't want to build one, the company ABC Robotics, s.r.o. is working on ready made kits.

Putting Mappino v0.1 to the Test

To find out the reliability the mechanics and electronics, Mappino was put to a test involving many cycles of scanning, matching and moving. Mappino was tested in a rectangular testing area (cca 125x120cm) with high enough walls to be seen by the distance sensors. When starting the experiment, Mappino was put in the middle of the test area. After turned on, Mappino took a reference scan and stored it in its EEPROM. Then it moved 30cm forwards, followed by a 50cm backward motion. Next it would take a scan and match it with the reference scan. The result would tell Mappino where it had to move to get back to the initial position. Upon arrival at the initial position, a new scan was taken and matched. Based on the result, Mappino adjusted its orientation to match the initial one. Then the next cycle continued by going forward 30cm...

During the 23+ hours of testing, Mappino did 1500 cycles boiling down to 1500m travel, 4500 starts, 4500 stops, 6000 scanner rotations and 3000 scan matches. Mappino was always stopped when it diverged from the path which almost exclusively happened when Mappino run out of energy. Mappino ran for at least 3 hours and 40 minutes on a freshly charged set of 2450mAh NiMh batteries. Mappino was so reliable, that I often left the house for hours during testing, knowing that Mappino will be doing its laps when I come back.

There were 3 misbehaviors during the experiment. In all 3 cases the PSD cables get caught. They happened just after restarting the experiment following battery replacements. This cable catching is not a design fault, but an assembly fault as at the last re-assembly I have forgot to keep the PSD scanner cables short. The caught cable would stop the scanner from doing full rotations and the matching result with skewed scans would make Mappino to go off an angle. To protect the floor from wearing out, Mappino was moving on a thick, just large enough sheet. Once got off the sheet, Mappino could not climb back, thus there would not be recovery from once-off (:-)) errors. Instead of shortening the cables to fix the problem, I took the lazy solution of propping up the cables with a bit of blue-tac.

Wear and tear:

• After the first battery change I have tightened Mappino's screws as I have forgot to do so prior testing and it is important to start off with from a known state. After the test, the screws did not loosen.
• After one of the first battery changes, I had to cut and strip one of the battery pack wires as the thin wire going into a screw terminal was about to break.
• After the 1500m of travel the only visible sign of wear and tear was a barely visible wear on the skid pads. The wear on the pads might had been worse if Mappino wasn't moving on smooth surface.

Building a Mappino

As Mappino is a work in progress (including its documentation), it is recommended to wait until version 0.2 is released.

Build and use Mappino at your own risk. If you do build one, do not leave it out of sight while it is turned on. To build the electronics, you need good SMD soldering skills.

If you got any questions or ideas for improvement, write me an email. Your questions may going to be added to a FAQ. Please do put the word Mappino in the subject line.

The Mappino project is distributed under the Creative Commons license Attribution-ShareAlike 2.5, except for the software which is distributed under GPL.

Some of the known issues with Mappino v0.1 (most of them will be addressed at v0.2):

I have built so far just one Mappino. I have been using it for quite a while without experiencing any major problems (except that the RAM is just enough for doing scan matching demos with 256 point scans), or without having to do any repairs. Before building a Mappino, you should definitely read about the following issues:

• The robot has not been systematically tested yet. It is unknown which parts will fail and how. Testing where the robot moves and does scan matching over and over again has commenced, but no results yet. Mappino v0.1 reliably ran for over 23 hours, travelled 1500m, did 6000 full scanner turns, matched 3000 scans.
• Currently the documentation is poor. There is no guide of how to put Mappino together, nor which part numbers one needs to order from where. Thus you will need to search for the parts based on their name. A list of part numbers is expected to be released with the next build of the robot (Mappino v0.1).
• The code has not been cleaned up yet. It is more of a hardware test code while providing a scan matching and homing demo. Most of the code was written during a surfing trip in Australia between two surfing sessions in a car, and the code looks like it...:-)
• There are a few mechanical issues:
  1. The short range PSD's supporting plate's mounting slots don't have little "bumps" called nodes to hold the plate firmly in place. This was not a mistake but an experiment to see what are the effects of not having nodes. Solution: one side of the plate needs to be super-glued, or just add the node into the CAD file yourself.
  2. Rubber bands have to be glued on the wheels to reduce slipping. O-rings would be nicer.
  3. After a few mountings/unmountings of the wheels, they will become loose on the motor axis. I have used a grub screw to fix the problem, but if you decide to glue the on the shaft make sure you drill a hole in the plate for accessing the motor mounting screws. The same problem exists for the sensor head, where I had to put a thin layer of Cellar tape on the shaft to stop the head from slipping.
  4. There is no hole for cables in the cross plate separating motors and the batteries - you have to drill one, or run the cables in the narrow gap between the cross plate and the side plate's of the robot.
  5. For proper working of the sensor head cable guides, cable length must be well chosen between the control board connector and the point of entry inside the cable. If this cable section is too long, the cable will get caught. The cable has to be just long enough.
  6. The screws under the long range PDS needs to be counter sunk.
  7. Thread locking fluid could keep some of the screws from getting loose.
  8. The distance between holes in the acrylic and the edge needs to be larger. Managed to get two tiny cracks in the acrylic so far. One by forcing something which wouldn't fit, and the second time be over-tightening the screw holding the long range PSD.
• Electrical issues:
  1. The wiring harness has not been documented yet. You have to figure it out yourself.
  2. The PSD scanner board's (sensor head's board) microcontroller's pin 19 (ADC6) has to be shorted to a neighboring pin with a bit of solder. I did not notice that ADC6 unlike the other ADC channels is just an input, thus it can't drive the nSleep signal which wakes the motor up.:-).
  3. All PCBs made so far were manufactured without solder masks. Thus the solder mask designs haven't been tested yet. To be sure make the boards without solder mask.
  4. The chip used for controlling the robot in the moment got just 2KB of RAM. Thus if you do scan matching, you'll likely won't have enough memory to keep an occupancy grid in the RAM in the same time. Due to the lack of RAM, currently scan are saved into the EEPROM.

Design files

Mechanical drawings were made using QCad (version 2.0.5.0 Community Edition). Electronics schematics were drawn using GEDA/gSchem (version 1.4.3.20081231). PCBs were designed using GEDA/PCB (version 20081128). Arduino IDE was used for developing/compiling of the code. If you want to use Ponoko to cut out the parts, you can use Inkscape to convert the CAD files into a single .svg file.

Ooffice spreadsheet used for estimating the cost bill of material cost in the RiE 2011 paper: mappino_bom.ods.

CAD files for the 3mm laser cut acrylic parts: acrylic_parts.zip. The number after the x in the file names inside the zip file is the number of copies you need for the particular part.

Power board files: power_board.pdf, power_board.bom, power_board.pcb, power_board.sch.

Sensor head / robot controller board files: psd_board.pdf psd_board.bom psd_board.pcb psd_board.sch psd_scanner.pde.

Bipolar stepper control board files: stepper_board.pdf stepper_board.bom stepper_board.pcb stepper_board.sch stepper.pde.

The sensor head / robot controller board code comes set up to perform scanning, scan matching and homing to a reference scan's pose. It works in my 120x130cm test area. At first, I place the robot in the middle of the area. Then connect to it using a USB to serial converter. Push 'x' when Mappino boots to tell it to take a reference scan on next power on. Then disconnect the cable, turn it on again, wait until it takes a scan, turn it off and move it anywhere within a 50cm circle while keeping a +-30degree orientation to the reference position. After turning it on the robot usually goes back to the reference position with seemingly less than 10cm error. It it quite fun to watch. I'll post a video once I got some time.

Copyright Albert Diosi, 2011

Last changed: 14/12/2011