czech english


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
Length37/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
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
Gripper detail


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.


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
Main screen


The software system consists from three basic parts:
  1. host computer code
  2. AVR code
  3. 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
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
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.


Martin Dlouhýteam leader, general ideas, system core
Zbyněk Winklermessage system, software developement, coordination
Kamil Řezáčhardware, AVR, PalmOS
Jaroslav Sládekhost system, PalmOS, world map
Vítězslav Holahardware, gripper Atmel
Bogdan Pilchsoftware, Linux port
If you have found this project interesting or you have some comments about it, please feel free to use our feedback form