 The cab. |
 The rear trailer. |
The TBMin project is an exercise in using a neural network to learn to solve a control problem. A Kohonen self-organizing feature map is used to match input values to the appropriate output behavior. The first work in this kind of neural network control was done with PBMin, the Pole-Balancing Mini-robot. The inputs into the robot consist of the various hitch angles as well as the angle of the rear trailer to the target. The output is what direction to turn the steering mechanism. This project has quite an extensive history, spanning multiple generations of robots and software versions.
This is the first generation trailer backer built by John Fischer. This robot used an RC car for its chassis and made use of a set of 6811-powered boards that John designed and built. This robot had 16K of code space in EPROM and 32K of RAM for use by the neural network. Because so much of the address space of the 6811 was used for code storage and execution, auxiliary functions, such as motor driving, were run from additional boards. This robot has been retired from active use.
The second generation trailer backer was contructed out of LEGOs due to their ease of use and modularity. However, nearly all of its design was based on the structure of the original robot. This robot used the Handy Board as its primary computational resource, keeping the tradition of the Motorola 6811. This robot was slightly functionally different from the first in that it had a longer trailer and a front bumper to detect collisions when resetting itself for another run. Otherwise, the cab dimensions were as close as possible to the original robot.
Once the 2nd generation robot was being used for multiple experiments, a new problem reared its ugly head. Because the robot was used to collect on the order of 100 runs per trial, it became extremely tedious for the operator to have to pick the robot up each time and place it in the new starting position. This approach also introduced errors into the learning algorithm because it wasn't getting a uniform distribution of initial starting values. Essentially, for the learning algorithm to generalize the problem properly, it had to be shown a sequence of uniformly random situations. To solve this problem, we built a robot that could pick itself up and place itself in the required starting position (fed to it from the unix workstation used to record the results.)
|
The cab. |
The rear trailer. |
This robot's physical characteristics (footprint and sensor placement) was identical to the 2nd genaration robot. However, the addition of additional servos and motors for the self-positioning aspects of the machine required the use of an additional microcontroller board. The 6811-based Miniboard was added to the robot for this purpose. Communications between the Handyboard and Miniboard was accomplished by using the SPI port in a master-slave configuration. In fact, the SPI code was based on the master-slave code that was used with the Loon family of robots.
Once the robot had demonstrated that it could learn the task as well as the simulation predicted, we decided to extend the system to two trailers since it is such a much more difficult problem. There were a few problems with doing this since the size of the neural network increased by a factor of 8 since there are now three inputs into the system (creating a 3-dimensional neural network). The primary problem was a lack of RAM on the Handyboard since Interactive-C takes up 8K of RAM for overhead, leaving 16K for code space and 8K for data. Several functions for doing the self-positioning and neural network updating were moved off-line to the unix station monitoring the system to allow everything to fit. Work is still being done to collect data from the runs. However, the simulation results are promising.
Cab top view. |
Middle top view. |
Rear top view. |
One trailer top view. |
Two trailers top view. |
Cab side view. |
Middle side view. |
Rear side view. |
One trailer side view. |
Two trailers side view. |
Other Mini Robots.