The robot is able to self charge using the charger station, as shown in the previous figure. The following figure illustrates the position of the various sensors:

Useful information

the top light diffuser and robot are designed to lock together, but the diffuser isn't fixed and can thus be removed as desired; the top light diffuser, as the name suggests, helps the light coming from the RGB led to be smoothly spread out, moreover the strip attached around the diffuser let the robot be better detected from others robots. Once the top light diffuser is removed, pay attention not to look at the RGB led directly. In order to remove the top light diffuser simply pull up it, then to place it back on top of the robot remember to align the 3 holes in the diffuser with the 3 IRs emitters and push down carefully untill the diffuser is stable; pay attention to not apply too much force on the IRs emitters otherwise they can bend and stop working.

when the top light diffuser is fit on top of the robot, then in order to change the selector position you can use the tweezers; the selector is located near the front-left IR emitter, as shown in the following figure:

if you encounter problems with the radio communication (e.g. lot of packet loss) then you can try moving the antenna that is a wire near the robot label. Place the antenna as high as possible, near the plastic top light diffuser; try placing it in the borders in order to avoid seeing a black line on the top light diffuser when the RGB led is turned on.

Robot charging

The Elisa-3 can be piloted in the charger station in order to be automatically self charged; there is no need to unplug the battery for charing. The following figures shows the robot approaching the charger station; a led indicates that the robot is in charge:

The microcontroller is informed when the robot is in charge and this information is also transferred to the PC in the flags byte; this let the user be able to pilote the robot to the charger station and be informed when it is actually in charge. More information about the radio protocol can be found in the section Communication.

Moreover the robot is also charged when the micro USB cable is connected to a computer; pay attention that if the USB cable is connected to a hub, this one need to be power supplied.

The following video shows the Elisa-3 piloted through the radio to the charging station using the monitor application:

Top light diffuser

From February 2013 onwards the Elisa-3 is equipped with a new top light diffuser designed to fit perfectly in the 3 IRs emitters of the robot. The diffuser is made of plastic (3d printed), it is more robust and it simplifies the removal and insertion. Here is an image:

Hardware

The following figures show the main components offered by the Elisa-3 robot and where they are physically placed:

Power autonomy

The robot is equipped with two batteries for a duration of about 3 hours at normal usage (motors run continuously, IRs and RGB leds turned on).

8 infra-red sensors measuring ambient light and proximity of objects up to 6 cm; each sensor is 45° away from each other 4 ground sensors detecting the end of the viable surface (placed on the front-side of the robot)

IR emitters

3 IR emitters (2 on front-side, 1 on back-side of the robot)

Accelerometer

3D accelerometer along the X, Y and Z axis

LEDs

1 RGB LED in the center of the robot; 8 green LEDs around the robot

Switch / selector

16 position rotating switch

Communication

Standard Serial Port (up to 38kbps) Wireless: RF 2.4 GHz; the throughput depends on number of robot: eg. 250Hz for 4 robots, 10Hz for 100 robots; up to 10 m

Communication

Wireless

The radio base-station is connected to the PC through USB and transfers data to and from the robot wirelessly. In the same way the radio chip (nRF24L01+) mounted on the robot communicates through SPI with the microcontroller and transfers data to and from the PC wirelessly.
The robot is identified by an address that is stored in the last two bytes of the microcontroller internal EEPROM; the robot firmware setup the radio module reading the address from the EEPROM. This address corresponds to the robot id written on the label placed under the robot and should not be changed.

Packet format - PC to radio to robot

The 13 bytes payload packet format is shown below (the number in the parenthesis expresses the bytes):

Small green leds: each bit define whether the corresponding led is turned on (1) or off (0); e.g. if bit0=1 then led0=on

Flags2:

bit0 is used for odometry calibration

remaining bits unused

Remaining bytes free to be used

Optimized protocol

The communication between the pc and the base-station is controlled by the master (computer) that continuously polls the slave (base-station); the polling is done once every millisecond and this is a restriction on the maximum communication throughput. To overcome this limitation we implemented an optimized protocol in which the packet sent to the base-station contains commands for four robots simultaneously; the base-station then separate the data and send them to the correct robot address. The same is applied in reception, that is the base-station is responsible of receiving the ack payloads of 4 robots (64 bytes in total) and send them to the computer. This procedure let us have a throughput 4 times faster.

Packet format - robot to radio to PC

The robot send back to the base-station information about all its sensors every time it receive a command; this is accomplished by using the "ack payload" feature of the radio module. Each "ack payload" is 16 bytes length and is marked with an ID that is used to know which information the robot is currently transferring. The sequence is the following (the number in the parenthesis expresses the bytes):

ID=3 (1)

Prox0 (2)

Prox1 (2)

Prox2 (2)

Prox3 (2)

Prox5 (2)

Prox6 (2)

Prox7 (2)

Flags (1)

ID=4 (1)

Prox4 (2)

Ground0 (2)

Ground1 (2)

Ground2 (2)

Ground3 (2)

AccX (2)

AccY (2)

TV remote (1)

ID=5 (1)

ProxAmbient0 (2)

ProxAmbient1 (2)

ProxAmbient2 (2)

ProxAmbient3 (2)

ProxAmbient5 (2)

ProxAmbient6 (2)

ProxAmbient7 (2)

Selector (1)

ID=6 (1)

ProxAmbient4 (2)

GroundAmbient0 (2)

GroundAmbient1 (2)

GroundAmbient2 (2)

GroundAmbient3 (2)

AccZ (2)

Battery (2)

Free (1)

ID=7 (1)

LeftSteps (4)

RightSteps (4)

theta (2)

xpos (2)

ypos (2)

Free (1)

Pay attention that the base-station could return "error" codes in the first byte if the communication has problems:

0 => transmission succeed (no ack received though)

1 => ack received (should not be returned because if the ack is received, then the payload is read)

2 => transfer failed

Packet ID 3:

Prox* contain values from 0 to 1023, the greater the values the nearer the objects to the sensor

The Flags byte contains these information:

bit0: 0 = robot not in charge; 1 = robot in charge

bit1: 0 = button pressed; 1 = button not pressed

bit2: 0 = robot not charged completely; 1 = robot charged completely

the remainig bits are not used at the moment

Packet ID 4:

Prox4 contains values from 0 to 1023, the greater the values the nearer the objects to the sensor

Ground* contain values from 512 to 1023, the smaller the value the darker the surface

AccX and AccY contain raw values of the accelerometer; the range is between -64 to 64

TV remote contains the last interpreted command received through IR

Packet ID 5:

ProxAmbient* contain values from 0 to 1023, the smaller the values the brighter the ambient light

Selector contains the value of the current selector position

Packet ID 6:

ProxAmbient4 contains values from 0 to 1023, the smaller the values the brighter the ambient light

GroundAmbient* contain values from 0 to 1023, the smaller the values the brighter the ambient light

AccZ contains raw values of the accelerometer; the range is between 0 and -128 (upside down)

Battery contains the sampled value of the battery, the values range is between 780 (battery discharged) and 930 (battery charged)

Packet ID 7:

LeftSteps and RightSteps contain the sum of the sampled speed for left and right motors respectively (only available when the speed controller isn't used; refer to xpos, ypos and theta when the speed controller is used)

theta contains the orientation of the robot expressed in 1/10 of degree (3600 degrees for a full turn); available only when the speed controller is enabled

xpos and ypos contain the position of the robot expressed in millimeters; available only when the speed controller is enabled

Software

Robot

Requirements

In order to communicate with the robot through the micro USB the FTDI driver need to be installed. If a serial port is automatically created when connecting the robot to the computer you're done otherwise you need to download the drivers for your system and architecture:

AVR Studio 4 project

Basic demo

This project is thought to be a starting point for Elisa-3 newbie users and basically contains a small and clean main with some basic demos selected through the hardware selector that show how to interact with robot sensors and actuators.
The project source can be downloaded from Elisa-3 basic firmware source; the hex file can be directly downloaded from Elisa-3 basic firmware hex. To program the robot refer to section Programming.
Selector position and related demo:

13: local communication: listen and transmit continuously; when data received change RGB color

14: local communication: RGB color propagation

15: clock calibration (communicate with the PC through the USB cable to change the OSCCAL register); this position could also be used to remote contol the robot through the radio (only speed control is enabled)

Arduino IDE project

The project is built with the Arduino IDE 1.0 freely available from the official Arduino website. In order to build the Elisa-3 firmware with the Arduino IDE 1.0 the following steps has to be performed:

1. download the Arduino IDE 1.0 (later versions should be also fine, last tried is 1.8.5, refer to Arduino Software) and extract it, let say in a folder named arduino-1.0

2. download the Elisa-3 library and extract it within the libraries folder of the Arduino IDE, in this case arduino-1.0\libraries; you should end up with a Elisa3 folder within the libraries. If you start the Arduino IDE now you can see that the Elisa-3 library is available in the menu Sketch=>Import Library... (or Sketch=>Include Lirary in later IDE versions)

3. the file boards.txt in the Arduino IDE folder arduino-1.0\hardware\arduino (or arduino-1.x\hardware\arduino\avr in later IDE versions) need to be changed to contain the definitions for the Elisa-3 robot, add the following definitions at the end of the file:

4. this step need to be performed only with later IDE versions, when you receive a warning like this Bootloader file specified but missing... during compilation. In this case place the bootloader hex file you can find in the Bootloader section in the directory arduino-1.x\Arduino\hardware\arduino\avr\bootloaders\ and name it stk500v2-elisa3.hex

5. download the Elisa-3 project file and open it with the Arduino IDE (you should open the file "elisa3.ino")

6. select Elisa-3 robot from the Tools=>Board menu; click on the Verify button to build the project

7. to upload the resulting hex file, attach the micro usb and set the port from the Tools=>Serial Port menu consequently; turn on the robot and click on the Upload button

You can download the Arduino IDE 1.0.5 for Linux (32 bits) containing an updated avr toolchain (4.5.3) and the Elisa3 library from the following link arduino-1.0.5-linux32.zip.
If the Tools->Serial Port menu is grayed out then you need to start the Arduino IDE in a terminal typing sudo path/to/arduino.

If you want to have access to the compiler options you can download the following project Elisa3-arduino-makefile.zip that contains an Arduino IDE project with a Makefile, follow the instructions in the "readme.txt" file in order to build and upload to the robot.

Aseba

Matlab

The ePic2 Matlab interface was adapted to work with the Elisa-3 robot. The communication is handled with the radio module. Both Matlab 32 bits and 64 bits are supported (tested on Matlab R2010a) Follow these steps to start playing with the interface:

open (double click) the file main.m; once Matlab is ready type main+ENTER and the GUI should start

click on the + sign (top left) and insert the robot address (e.g 3307), then click on Connect

Webots simulator

The following features have been included in the Elisa-3 model for the Webots simulator:

proximity sensors

ground sensors

accelerometer

motors

green leds around the robot

RGB led

radio communication

You can donwload the Webots project containig the Elisa-3 model (proto) and a demonstration world in the following link Elisa-3-webots.zip.

You can download a Webots project containing a demonstration world illustrating the usage of the radio communication between 10 Elisa-3 robots and a supervisor in the following link Elisa-3-webots-radio.zip. Here is a video of this demo:

Onboard behaviors

The released firmware contains two basic onboard behaviors: obstacle and cliff avoidance. Both can be enabled and disabled from the computer through the radio (seventh bit of flags byte for obstacle avoidance, eight bit of flags byte for cliff avoidance).

The following videos show three robots that have their obstacle avoidance enabled:

Programming

The robot is pre-programmed with a serial bootloader. In order to upload a new program to the robot a micro USB cable is required. The connection with the robot is shown below:

If you are working with the Arduino IDE you don't need to follow this procedure, refer instead to section Arduino IDE project.

If you encounter some problem during programming (e.g. timeout problems) you can try following this sequence: turn on the robot, unplug the robot from the computer, plug the robot into the computer, it will make some blinks; when the blinks terminate execute the programming command again.Beware that every time you need to re-program the robot you need to unplug and plug again the cable to the computer.

Windows 7

Download the Windows 7 package and extract it. The package contains also the FTDI driver.

Execute the script config.bat and follow the installation; beware that this need to be done only once. The script will ask you to modify the registry, this is fine (used to save application preferences).

Connect the robot to the computer; the COM port will be created.

Run the application AVR Burn-O-Mat.exe; you need to configure the port to communicate with the robot:

click on Settings => AVRDUDE

in the AVRDUDE Options, on Port enter the name of the port just created when the robot was connected to the computer (e.g. COM10); then click Ok

In the Flash section search the hex file you want to upload on the robot.

Turn on the robot, wait the blinks terminate and then click on Write in the Flash section.

During the programming the robot will blink; at the end you'll receive a message saying Flash succesfully written.

Mac OS X

The following procedure is tested in Max OS X 10.10, but should work from Mac OS X 10.9 onwards; in these versions there is built-in support for the FTDI devices.

Execute the script config.sh in the terminal, it will ask you to install the Java Runtime Environment; in case there is a problem executing the script try with chmod +x config.sh and try again. Beware that this need to be done only once.

Connect the robot to the computer; the serial device will be created (something like /dev/tty.usbserial-AJ03296J).

Run the application AVR Burn-O-Mat; you need to configure the port to communicate with the robot:

click on Settings => AVRDUDE

in the AVRDUDE Options, on Port enter the name of the port just created when the robot was connected to the computer; then click Ok

In the Flash section search the hex file you want to upload on the robot.

Turn on the robot, wait the blinks terminate and then click on Write in the Flash section.

During the programming the robot will blink; at the end you'll receive a message saying Flash succesfully written.

1. connect the robot to the computer, the serial device will be created (something like /dev/USB0)

2. to use the USB port the permissions need to be set to read and write issueing the command sudo chmod a+rw /dev/ttyUSB0

3. start the application and click on Settings => AVRDUDE

4. set the location of avrdude and the related configuration file (refer to the previous section when avrdude was installed to know the exact location); the configuration file is in /etc/avrdude.conf

3. click OK, close the application and open it again (this is needed to load the configuration file information); click on Settings => AVRDUDE

4. select stk500v2 as the Programmer

5. set the serial port connected to the robot (/dev/ttyUSB0)

6. in additional options insert -b 57600, you will end up with a window like the following one:

7. click OK; select ATmega2560 in the AVR type

8. in the Flash section search the hex file you want to upload on the robot; select Intel Hex on the right

9. connect the robot to the computer, turn on the robot, wait the blinks terminate and then click on Write in the Flash section

10. during the programming the robot will blink; at the end you'll receive a message saying Flash succesfully written.

Command line

The avrdude utility is used to do the upload, you can download it directly from the following links depending on your system:

Windows; avrdude will be installed in the path C:\WinAVR-20100110\bin\avrdude; avrdude version 5.10

Mac OS X; avrdude will be installed in the path /usr/local/CrossPack-AVR/bin/avrdude; to check the path issue the commmand which avrdude in the terminal; avrdude version 6.0.1

Ubuntu (12.04 32-bit): issue the command sudo apt-get install avrdude in the terminal; avrdude will be installed in the path /usr/bin/avrdude; to check the path issue the commmand which avrdude in the terminal; avrdude version 5.11.1

Open a terminal and issue the command avrdude -p m2560 -P COM10 -b 57600 -c stk500v2 -D -Uflash:w:Elisa3-avr-studio.hex:i -v
where COM10 must be replaced with your com port and Elisa3-avr-studio.hex must be replaced with your application name; in Mac OS X the port will be something like /dev/tty.usbserial-..., in Ubuntu will be /dev/ttyUSB0.
The Basic demo and Advanced demo have this command contained in the file program.bat in the default directory within the project, this can be useful for Windows users.

Internal EEPROM

The internal 4 KB EEPROM that resides in the microcontroller is pre-programmed with the robot ID in the last two bytes (e.g. if ID=3200 (0x0C80), then address 4094=0x80 and address 4095=0x0C). The ID represents also the RF address that the robot uses to communicate with the computer and is automatically read at startup (have a look a the firmware for more details).
Moreover the address 4093 is used to save the clock calibration value that is found during production/testing of the robots; this value hasn't to be modified otherwise some functionalities such as tv remote control could not work anymore. For more information on clock calibration refers to the applicaiton note AVR053: Calibration of the internal RC oscillator.
The Elisa-3 robot supports an autonomous calibration process and the result of this calibration is saved in EEPROM starting at address 3946 to 4092.The size of usable EEPROM is thus 3946 bytes (0-3945) and the remaining memory must not be modified/erased.

In order to program the eeprom an AVR programmer is required, we utilize the Pocket AVR Programmer from Sparkfun (recognized as USBtiny device); then with the avrdude utility the following command has to be issued:

where Elisa3-eeprom.hex is the EEPROM memory saved as Intel Hex format (eeprom example); a possible tool to read and write Intel Hex format is Galep32 from Conitec Datensysteme.
Alternatively a program designed to writing to these EEPROM locations can be uploaded to the robot, in case an AVR programmer isn't available. The project source can be downloaded from Elisa3-eeprom-write.zip; it is simply needed to modify the address, rebuild and upload to the robot.

Bootloader

In case the bootloader of the Elisa-3 is erased by mistake, then you can restore it by using an AVR programmer. You can download the bootloader from here stk500v2.hex; the source code is available here bootloader-stk500v2.zip.Avrdude can be used to actually write the bootloader to the robot with a command similar to the following one:avrdude -p m2560 -c stk500v2 -P COM348 -v -U lfuse:w:0xE2:m -U hfuse:w:0xD8:m -U efuse:w:0xFF:m -V -U flash:w:stk500v2.hex:i -v -B 2
Here we used a programmer recognized as a serial device (port COM348) that utilizes the stk500v2 protocol.

Base-station

This chapter explains informations that aren't needed for most of the users since the radio module is ready to be used and don't need to be reprogrammed. Only if you are interested in the firmware running in the radio module and on how to reprogram it then refer to section http://www.gctronic.com/doc/index.php/Elisa#Base-station (chapter 4.2) of the Elisa robot wiki.

PC side

This section gives informations related to the radio module connected to the computer; if you don't have a radio module you can skip this section.

Elisa-3 library

This library simplify the implementation of applications on the pc side (where the RF module is connected) that will take control of the robots and receive data from them. Some basic examples will be provided in the following sections to show how to use this library.
The project is built with Code::Blocks (mingw) and requires libusb-1.0 since it is used to communicate with the radio base-station. The source code of the library can be downloaded from pc-side-elisa3-library, it includes libusb-1.0.21.

Compilation on Windows:

within the libusb-1.0 package you'll find the header "libusb.h" (under /include/libusb-1.0/) and the library "libusb-1.0.a" (in this case under /MinGW32/static/ since we use MinGW) that should be copied or referenced in the compiler headers/libraries

add the linker flag "-lusb-1.0" in the project in order to build successfully

the Code::Blocks project provided has already these configurations set

build: under the "/linux" folder within the project directory there is a makefile, simply type make clean && make on a terminal to build the library

Multiplatform monitor

The demo is a command line monitor that shows all the sensors information (e.g. proximity, ground, acceleromter, battery, ...) and let the user move the robot and change its colors and behavior with the keyboard. The data are sent using the protocol described in the previous section.
The following figures show the monitor on the left and the available commands on the right.

Windows

Execution:

install the driver contained in the nRFgo Studio tool if not already done; this let the base-station be recognized as a WinUSB device (bootloader), independently of whether the libusb library is installed or not

once the driver is installed, the pre-compiled "exe" (under \bin\Release dir) should run without problems; the program will prompt you the address of the robot you want to control

Compilation:
the Code::Blocks project should already be setup to reference the Elisa-3 library headers and lib files, anyway you need to put this project within the same directory of the Elisa-3 library, e.g. you should have a tree similar to the following one:

Elisa-3 demo (parent dir)

pc-side-elisa3-library (Elisa-3 library project)

pc-side-elisa3-library-1-robot (current project)

Linux / Mac OS X

The project was tested to work also in Ubuntu and Mac OS X (no driver required).
Compilation:

you need to put this project within the same directory of the Elisa-3 library

build command: go under "linux" dir and type make clean && make

Execution:

sudo ./main

Communicate with 4 robots simultaneously

This example shows how to interact with 4 robots simlutaneously, basically it shows the sensors information (proximity and ground) coming from 4 robots and let control one robot at a time through the keyboard (you can change the robot you want to control). The project requires the Elisa-3 library; the source can be downloaded from pc-side 4 robots. For building refer to the section Multiplatform monitor.

Obstacle avoidance

This demo implements the obstacle avoidance behavior controlling the robot from the pc through the radio; this means that the robot reacts only to the commands received using the basic communication protocol and has no intelligence onboard. The demo uses the information gathered from the 3 front proximity sensors and set the motors speed accordingly; moreover the rgb leds are updated with a random color at fixed intervals.
The project requires the Elisa-3 library; the source can be downloaded from pc-side-obstacle-avoidance. For building refer to the section Multiplatform monitor.
The following video shows the result:

Cliff avoidance

This demo implements the cliff avoidance behavior controlling the robot from the pc through the radio; as with the obstacle avoidance demo, the robot reacts only to the commands received from the radio. The demo uses the information gathered from the 4 ground sensors to stop the robot when a cliff is detected (threshold tuned to run in a white surface); moreover the rgb leds are updated with a random color at fixed intervals.
The project requires the Elisa-3 library; the source can be downloaded from pc-side-cliff-avoidance. For building refer to the section Multiplatform monitor.
The following video shows the result:

Set robots state from file

This project show how to send data to robots for which we will know the address only at runtime, in particular the content of the packets to be transmitted is parsed from a csv file and the interpreted commands are sent to the robots one time. The project requires the Elisa-3 library; the source can be downloaded from pc-side from file. For building refer to the section Multiplatform monitor.

Odometry

The odometry of Elisa-3 is quite good even if the speed is only measured by back-emf. On vertical surfaces the absolute angle is given by the accelerometer measuring g... quite a fix reference without drifting ;-)
A fine calibration of the right and left wheel speed parameters might give better results.
However the current odometry is a good estimate of the absolute position from a starting point.
The experiments are performed on a square labyrinth and the robot advances doing obstacle avoidance. The on-board calculated (x,y,theta) position is sent to a PC via radio and logged for further display.
Details about the code can be found in the advanced-demo project, in particular the motors.c source file. The PC application used for logging data is the monitor.

Autonomous calibration

Since the motors can be slightly different a calibration can improve the behavior of the robot in terms of maneuverability and odometry accuracy.
An autonomous calibration process is implemented onboard: basically a calibration is performed for both the right and left wheels in two modes that are forward and backward with speed control enabled. In order to let the robot calibrate istelf a white sheet in which a black line is drawed is needed; the robot will measure the time between detection of the line at various speeds. The calibration sheet can be downloaded from the following link calibration-sheet.pdf.
In order to accomplish the calibration the robot need to be programmed with the advanced firmare and a specific command has to be sent to the robot through the radio module or the TV remote; if you are using the radio module you can use the monitor application in which the letter l (el) is reserved to launch the calibration, otherwise if you have a TV remote control you can press the button 5.
The sequence is the following:
1. put the selector in position 8
2. place the robot near the black line as shown below; the left motor is the first to be calibrated. Pay attention to place the right wheel as precise as possible with the black line
3. once the robot is placed you can type the l (el) command (or press the button 5); wait a couple of minutes during which the robot will do various turns at various speed in the forward direction and then in the backward direction
4. when the robot terminated (robot is stopped after going backward at high speed) you need to place it in the opposite direction in order to calibrate the right motor, as shown below.
5. once the robot is placed you can type again the l (el) command (or press the button 5)
6. when the robot finish, the calibration process is also terminated.

The previous figures show a robot without the top diffuser, anyway you don't need to remove it!

Tracking

Assembly documentation

You can download the documentation from here tracking-doc.pdf.
Have a look also at the video:

SwisTrack

Some experiments are done with the SwisTrack software in order to be able to track the Elisa-3 robots through the back IR emitter, here is a resulting image with 2 robots:
The pre-compiled SwisTrack software (Windows) can be downloaded from the following link SwisTrack-compiled.

The following video shows the tracking of 5 robots:

The SwisTrack software lets you easily log also the resulting data that you can then elaborate, here is an example taken from the experiment using 5 robots:

The following video shows the test done with 20, 30 and 38 Elisa-3 robots, the tracking is still good; it's important to notice that we stopped to 38 Elisa-3 robots because are the ones we have in our lab.

Position control

We developed a simple position control example that interacts with Swistrack through a TCP connection and control 4 robots simultaneously; the orientation of the robots is estimated only with the Swistrack information (delta position), future improvements will integrate odometry information. The following video shows the control of 4 robots that are driven in a 8-shape.

One of the characteristics of the Elisa-3 robot is that it can move in vertical thanks to its magnetic wheels, thus we developed also a vertical position control that use accelerometer data coming from the robot to get the orientation of the robot (more precise) instead of estimating it with the Swistrack information, you can download the source code from the following link:

We developed also an example of position control that control a single robot (code adapted from previous example) that can be useful during the initial environment installation/testing; you can download the source code from the following link:

Another good example to start playing with the tracking is an application that lets you specify interactively the target point that the robot should reach; you can download the source code of this application from the following link:

Utilities

In order to adjust the IR camera position it is useful to have an application that turn on the back IR of the robots. The following application back-IR-on-4-robots-rev182-30.06.14.zip is an example that turn on the back IR of 4 robots, their addresses are asked to the user at the execution.

Local communication

The advanced firmware is needed in order to use the local communication. You can find some examples on how to use this module in the main, refers to demos in selector position from 11 to 14.
Here are some details about the current implementation of the communication module:

use the infrared sensors to exchange data, thus during reception/transmission the proximity sensors cannot be used to avoid obstacles; in the worst case (continuous receive and transmit) the sensor update frequency is about 3 Hz

bidirectional communication

id and angle of the proximity sensor that received the data are available

the throughput is about 1 bytes/sec

maximum communication distance is about 5 cm

no reception/transmission queue (only one byte at a time)

the data are sent using all the sensors, cannot select a single sensor from which to send the data. The data isn't sent contemporaneously from all the sensors, but the sensors used are divided in two groups of 4 alternating sensors (to reduce consumption)

ROS

This chapter explains how to use ROS with the elisa-3 robots; the radio module is needed here. Basically all the sensors are exposed to ROS and you can also send commands back to the robot through ROS. The ROS node is implemented in cpp. Here is a general schema:Click to enlarge

First of all you need to install and configure ROS, refer to http://wiki.ros.org/Distributions for more informations. Alternatively you can download directly a virtual machine pre-installed with everything you need, refer to section virtual machine; this is the preferred way.

6. Open a terminal and go to the catkin workspace directory (~/catkin_ws) and issue the command catkin_make, there shouldn't be errors

7. The USB radio module by default requires root priviliges to be accessed; to let the current user have access to the radio we use udev rules:

plug in the radio and issue the command lsusb, you'll get the list of USB devices attached to the computer, included the radio:

Bus 002 Device 003: ID 1915:0101 Nordic Semiconductor ASA

issue the command udevadm info -a -p $(udevadm info -q path -n /dev/bus/usb/002/003), beware to change the bus according to the result of the previous command. You'll receive a long output showing all the informations regarding the USB device, the one we're interested is the product attribute:

ATTR{product}=="nRF24LU1P-F32 BOOT LDR"

in the udev rules file you can find in /etc/udev/rules.d/name.rules add the following string changing the GROUP field with the current user group:

build the driver by opening a terminal and issueing the command catkin_make from within the catkin workspace directory (e.g. ~/catkin_ws).

Now you can start the ROS node, for this purposes there is a launch script (based on roslaunch), as explained in the following section. Before starting the ROS node you need to start roscore, open another terminal tab and issue the command roscore.

Single robot

Open a terminal and issue the following command: roslaunch elisa3_node_cpp elisa3_single.launch elisa3_address:='1234' where 1234 is the robot id (number on the bottom).

If all is going well rviz will be opened showing the informations gathered from the topics published by the elisa ROS node as shown in the following figure: Click to enlarge

The launch script is configured also to run the gmapping (SLAM) node that let the robot construct a map of the environment; the map is visualized in real-time directly in the rviz window. Here is a video:

Virtual machine

To avoid the tedious work of installing and configuring all the system we provide a virtual machine which includes all the system requirements you need to start playing with ROS and elisa. You can download the image as open virtualization format from the following link ROS-Hydro-12.04.ova (based on the VM from http://nootrix.com/2014/04/virtualized-ros-hydro/); you can then use VirtualBox to import the file and automatically create the virtual machine. Some details about the system:

Videos

Autonomous charge

The following videos show 3 Elisa-3 robots moving around in the environment avoiding obstacles thanks to their proximity sensors and then going to the charging station autonomously; some black tape is placed in the charging positions to help the robots place themselves thanks to their ground sensors. The movement and charging is indipendent of the gravity. It works also vertically and up-side-down.

Remote control

The following video shows 38 Elisa-3 robots moving around with onboard obstacle avoidance enabled; 15 of them are running autonmously, the remaining 23 are controlled from one computer with the radio module.