Alena
differential-driven platform with steppers and Palm computer onboard, 2001
Alena was our first try in the robot business. It is a differential-driven platform powered by steppers with a gripper onboard. It can be controlled by regular PC over serial line or by palm-sized computer carried onboard. The robot has successfully qualified to the Eurobot 2001 competition in France and ended up at the 12th place.
| Dimension | Value | Note |
|---|---|---|
| Length | 37/29 cm | with/without flag holder |
| Width | 29/42 cm | hand in base/side position |
| Height | 24/40 cm | hand in base/topmost position |
| Weight | approx. 3 kg | |
| Operational area | approx. 50 cm | min. diameter of area to turn in |
| Wheel diameter | 8 cm | |
| Wheels pitch | 19.5 cm | |
| Max Speed | 25 cm/s |
Mechanical construction
The chasis of the robot is made of steel sheet metal with all the main
components attached to it. It also provides additional heatsink for the stepper
motors and high-current electronics. The two powered wheels are mounted
directly on the axle of the stepper (without gearbox). Additional castor
provides the required stability.
The front side covers simple bumper made of two microswithes. The back side
is occupied by the flag bracket made of aluminum sheet metal. In front of the
bracket you may find plexiglass cover for the Palm computer.
On the second picture you can see that the sun was much higher than the rest
of the planets so we used a special trick to place the flag on top of it. The
first flag to place was always the sun. The flag was placed directly into the
gripper but upside down than the others. That allowed the gripper to place the
flag overhead instead of to the side.
 AVR board |
The third picture shows the main board containing AVR microcontroller. This
microcontroller acted as an interface between the hardware (sensors, gripper, motors)
and the Palm computer which was responsible for the “strategic” decisions.
Power Supply
The power for the robot is provided by a set of AA-sized accumulators. We
used eight NiCd cells (1.2V/700mAh per cell). The set is able to supply enough
current to power the steppers. The more tender equipment (such as the
microcontrollers) are powered through one 7805 stabiliser. Another
one powers the servos.
Charging the batery pack takes about an hour with a special charger. The
robot is then able to drive around for about 20 to 40 minutes depending on how
often it uses the gripper.
 Gripper detail |
Sensors
The robot does not use many sensors. It can detect obstacles with its front
bumper. It can also follow line using two infrared transcievers mounted on the
bottom of the robot. The AVR microcontroller that drives the steppers also
counts the steps so a bit unreliable odometry data is also available.
Gripper
The gripper is powered by three servos. One sets the orientation of the
whole mechanism, the other elevation and the last one controls the fingers
(open/closed). The gripper servos are controled by separate Atmel
microcontroller that takes command from the AVR through I2C-like (synchronous)
open-collector bus. The communication speed is approximately 1kbps.
 Main screen |
Software
The software system consists from three basic parts:
- host computer code
- AVR code
- Atmel code
Each component has it's specific task described below.
The communication between the host computer and the AVR microcontroller
is asynchronous (UART serial line), the communication between the AVR and the Atmel
microcontroller is synchronous (I2C-like bus). The protocols are described below.
Host computer code
 Manual gripper control screen |
The host computer code is the base of the control system. The original
“full” system (PC version) has been written in C++ (mostly platform
independent), the “light” version for the Palm device is written in C
using GCC with PRC-Tools chain and PalmOS SDK. This part provides the
behavior of the robot. In the light version is this component based on
finite-state automata (designed especially for the Eurobot contest). In the
full version is this component is much more complex. Different parts of this
component (world map, path planner…) communicate with each other through
sophisticated message system and their interaction creates the final behavior.
A common part to both versions is the serial line communication and packet
generating/parsing.
AVR (AT90S8535) code
The AVR code handles the communication with the host computer and with the Atmel
microcontroller driving the gripper, the sensors and the steering. AVR-GCC (GCC
patched for AVR microcontrollers) has been used to program this part of the system.
 Manual drive control screen |
The AVR code implements following functions:
- Serial communication to host
- Synchronous communication to Atmel controlling the hand
- Message generating and parsing
- Stepper motors control
- Sensor data processing
- Sensor data reporting
- Line following
- Emergency stop funcions
- Visualisation on LCD
Atmel (AT89C51) code
The Atmel code controls the servos driving the gripper. This code is written in
assembler. The microcontroller receives the commands through the sychronous (I2C-like)
bus and sets the servos to appropriate positions by generating appropriate PWM signas.
Asynchronous communitation host ↔ AVR
The asynchronous communication between host computer and AVR microcontroller is
packet-based. Each packet contains the sender, the target (broadcast messages
are available), the ID of the message, the command code and (optionally) the data
payload. This content is closed in start/stop block pair (2 byte each).
The consistency is ensured by 2-complement checksums.
Synchronous protocol AVR ↔ gripper
The synchronous protocol between AVR microcontroller and Atmel microcontroller
is block based. The block has fixed length (4 bytes). Each block contains the
header byte (21h) and three bytes with the new hand position (rotation, angle,
fingers). There is no checksum and no block acknowledgement.
Each byte is “acknowledged” with start bit/stop bit.
People
| Martin Dlouhý | team leader, general ideas, system core |
| Zbyněk Winkler | message system, software developement, coordination |
| Kamil Řezáč | hardware, AVR, PalmOS |
| Jaroslav Sládek | host system, PalmOS, world map |
| Vítězslav Hola | hardware, gripper Atmel |
| Bogdan Pilch | software, Linux port |
If you have found this project interesting or you have some comments
about it, please feel free to use our
feedback form