Figure 1 : Goliath

Table of Contents

Serial Transmitter
Serial Reciever
Motor Control


As part of the Digital and Analogue Circuit Design (DACS) module i decided to set an open assessment based on a wire guided robot. Researching into the origins of these simple robots i was surprised to see that some of the earliest examples were used by the military as shown in figure 1. Goliath (Link) (Local) is a German tracked mine used in World War 2, there are also even early examples: Land Torpedo(Link) (Local). America, France and England all had variation on this idea, but Goliath is perhaps the best know owing to its news reel coverage :(Link) (Link). Reading the Wiki and watching these videos the engineer in me has taken over, so i'm going to ignore the ethical issues, more importantly:


Which i find most annoying. Both the video and the Wiki page say that the robot was powered by the cable. This must be incorrect. These are big heavy robots (5 - 10mm armour plate), the current needed to power these electric motors would be in the tens of amps (surge 100s of amps), the cable shown is simply too thin, it would melt, not to mention the voltage drop down 650m of thin cable. Therefore, these cables must of been used to send command signals to the robot. One of the videos also states that Goliath used radio control, this type of technology had been used in radio controlled missiles (bomb) of the time (Link), but the module shown in the video looks a little small for a valve based unit, also if you have a wired control link you don't need a radio link, so i'm guessing this is not correct. The Wiki states:

"The control box was attached to the Goliath by a triple-strand cable connected to the rear of the vehicle, for transmitting power to the electric driven version. Two of the strands were used to move and steer the Goliath, while the third was used for detonation."

All electrical circuits need a GND line i.e. a voltage is always measured relative to something. I can see how a simple three wire system could work:

Using such a system you can control the robot by stopping a motor (track) to turn the robot, just as you would for a tank i.e. a low voltage (current) signal from the handset can be used to switch larger currents (on-board batteries) on the robot. However, how do you detonate the charge? All three wires have been used to steer the robot. The detonate command is one control signal you don't want to accidentally sent, there must of been one or more layers of protection to prevent "accidents" (torpedoes of the time had both mechanical and electrical firewalls to prevent such events). Looking at a picture of the handset show in figure 2 you can clearly see a thumb operated joystick and a series of buttons. So the problem remains, how do you send these different commands down a limited set of wires?

Figure 2 : Goliath hand set

Solution: email museums with surviving examples (below), i did stop and think about sending these emails i.e. emailing people for details of the inner workings of a bomb, hmmm, cue knock on door and men in black suits :), but in the end thought they must get stranger questions. To date no new info :(

Update (6/9/15): success, the very nice people at The Tank Museum (Link) had some MOD intelligence documents from 1944 that gave some insight into how Goliath was controlled. However, not all of the circuit diagrams were available, so i only have a basic understanding of the control system Update.


The aim of the DACS open assessment was to design a robot to take part in a Robot Sumo competition: using the mobile robotic platform shown in figures 3 - 6, you are required to design digital electronic circuits to implement a Sumo robot. The platform is equipped with two DC motors mounted at the rear and a front skid, allowing the robot to be manoeuvred using differential steering i.e. varying the speed and direction of the drive motors. Each motor is controlled by an on-board H-bridge using three control lines. Two inputs control a motors direction: 00 - free wheel, 01 - clockwise, 10 - anticlockwise and 11 - regenerative braking. The third control line is a Pulse Width Modulator (PWM) input, controlling the speed of the motor. To interact with its environment the robot has both front and rear bumper sensors, allowing it to differentiate the location of an obstacle as:

These sensors are very simple. The front and rear bumper plates are connect to 0V, black wire shown in figure 5. There is one central bolt holding this plate in position. Around this pivot are three 'contact' bolts, yellow, blue and green wires, connected to pull-up resistors (4K7). In operation when the bumper plate hits an obstacle the plate is pushed onto one or more 'contact' bolts, producing an active low signal i.e. a logic 1 = no obstacle, a logic 0 = obstacle detected. Sensor processing and actuator control is to be implemented in a Complex Programmable Logic Device (CPLD) i.e. a Xilinx 9572XL CPLD module. This hardware module is combined with the Button IO module, providing eight input switches, eight output LEDS and a 4MHz clock oscillator. Each robot is controlled using a two cables:

Up to four control signals must define the following functionality:

  1. Move forwards
  2. Move backwards
  3. Turn left (left wheel stop, right wheel forwards)
  4. Turn right (left wheel forwards, right wheel stop)
  5. Rotate left (left wheel backwards, right wheel forwards)
  6. Rotate right (left wheel forwards, right wheel backwards)
  7. Brake (regenerative braking)
  8. Freewheel (wheels free to rotate)

Each function is assigned to a single user specified push button. Using both the Button board and the CPLD board, design the digital circuits required to implement this specification.

Figure 3 : Goliath junior

Figure 4 : Robot Controller, Button / CPLD boards (left), H-bridge (right)

Figure 5 : Bumper

Figure 6 : Handset

Serial Transmitter

Controlling the robot using a limited number of wires is easy if you have modern electronics i.e. a Universal Asynchronous Receiver Transmitter unit (UART). This converts the push button command signal into a serial packet that can be transmitted down a single wire, you still need a GND, so actually need two wires. There are lots of different ways to design and construct this circuit, but i wanted so show how this functionality could be implemented using only simple shift registers. The solution discussed below uses asynchronous, duplex (bidirectional) serial communications: the robot's movement is controlled via one control signal and bumper status data is communicated back to the handset and displayed on LEDs via another control signal i.e. a three wire solution. A serial data packet is divided into equal time slices, each bit is allocated one time slice, as shown in figure 7. Each packet starts with a start bit, a logic 1, to allow the receiver to detect the start of the packet. Each packet ends with a stop bit, a logic 0, to allow the receiver time to process previously received data and to detect the end of the packet i.e. to prevent multiple packets accidentally being merged together. When idle the serial line is a logic 0.

Figure 7 : Serial Data Packet

The UART transmitter circuit is shown in figure 8. This circuit is made up of five main sections:

  1. Reset: top right, SISO four stage shift register. Async clear sets all flip-flops to zero, output is inverted setting the RESET signal high. When async clear set low, shift register clocks in logic '1', therefore, producing a sync reset of four clock pulses.
  2. Clock Divider: top left, eight stage shift register configured as a ring counter i.e. first stage pre-set to a logic '1', final output feedback to first stage input. This produces a pulse for one clock cycle on BAUD_EN every eight clock cycles i.e. the time slice for each bit is eight clock cycles long.
  3. Key Pressed Detector: bottom left, all push buttons (D0 - D7, active low) are connected to the eight input NAND gate. When no button is pressed the NAND gate produces a logic 0. This is clock through the two stage shift register (00). When any button is press the NAND gate produces a logic 1. On the next clock pulse this is clock into the first stage of the shift register (10). This logic 1 and the inverted output of the second stage are ANDed together setting KEY_PRESSED to a logic 1 for one clock cycle (assuming SHIFT_EN is 0).
  4. State Register: middle right, a parallel load twelve stage shift register storing a one-hot encoded value representing the TX state. When a key is pressed the KEY_PRESSED signal causes the value 100000000000 to be loaded into the shift register, capturing the push button state via the SHIFT_LOAD signal. Every eighth clock cycle this shift register is clocked once, moving the one-hot token down the shift register and clocking in a logic 0 i.e. the TX idle state is represented by an all zero value. This is detected by the 12 input NAND gate controlling the SHIFT_EN signal. This gate is actually an OR gate i.e. a NAND gate with inverted inputs, such that whilst any of the state bits are a logic 1 the SHIFT_EN will remain high.
  5. Data shift register: middle left, a parallel load ten bit shift register, the SHIFT_LOAD signal loads the shift register, MSB is hardwired to a logic 1 i.e. start bit, LSB is hardwired to a logic 0 i.e. stop bit, bits 1 - 8 are key data. On the next clock cycle the shift register shifts out the data packet, one bit every eight clock cycles, logic 0s are clocked in automatically clearing the data

Figure 8 : TX Circuit Diagram

Figure 9 : TX State Diagram

Figure 10 : TX Testbench

Serial Reciever

The UART receiver circuit is shown in figure 11. This circuit is made up of seven main sections:

  1. Reset: top right, as previous
  2. Clock Divider: top left, as previous
  3. State Register: middle right, a parallel load ten stage shift register storing a one-hot encoded value representing the RX state. Initially this is reset to zero. The eight input NAND gate (again with inverted inputs, making it an OR gate) drives the RX_EN signal, indicating that the RX unit is not receiving data. When the start pulse is detected by the Start Pulse Detector the RX_START signal is set high, loading in a one-hot value. This token is then clocked through the shift register every eight clock cycles.
  4. Start Pulse Detector: middle left, parallel load five stage shift register. To ensure that the hardware samples the incoming data in the middle of its time slice an initial delay of 4 clock cycles is needed. When the RX unit is not receiving data RX_EN, RX_START and RX_INT will all be zero, enabling RX_TEST, causing this shift register to constantly reload its one-hot input value, resetting the clock divider. When the start bit of the incoming data packet is received the shift register is enabled setting RX_START to a logic 1 after 4 clock cycles. This then enables the State Register (should of ANDed RX_START with the RX_INT to double check that the start bit is still high) and clock divider so that the RX unit is 'synchronised' with the transmitter i.e. both the robot and handset use a 4MHz clock, but these will not be synchronised, the rising edges of the clock will not happen at the same time. Holding the clock divider in reset until the start pulse is received means that the RX unit will sample the data in the middle of the bit slice.
  5. Data shift register: bottom left, serial in, parallel out, eight bit shift register. Whilst RX_EN is high the received data packet is shifted into the shift register.
  6. Data register: bottom middle, eight bit register. When all bits have been received the RX_LOAD is set high. If the current input i.e. the stop bit, is a logic 0, the received data is stored in the data register.
  7. Decoder: bottom right, logic. The eight bit value stored in the data register represents the state of the push buttons on the handset. This is then decoded using a simple logic circuit to produce the correct control signals for the two H-bridge motor controllers.

Figure 11 : RX Circuit Diagram

Figure 12 : RX State Diagram

Figure 13 : RX Testbench

Figure 14 : Serial data

Motor Control

The robot uses two DC motors (figure 3), each controlled by a H-bridge circuit shown in figure 15. The motor is connected to header JP1. The voltage across the motor is determined by the MOSFET transistors Q1, Q2, Q3 and Q4 (figure 4, right), electronic switches, each controlled by their Gate (G) pin, switching the contacts Source (S) and Drain (D). Q1 and Q2 are PMOS transistors (irf9z24n), G=0 turn on, G=1 turn off. Q3 and Q4 are NMOS transistors (irl520n), G=1 turn on, G=0 turn off (opposite to PMOS). Controlling each transistor's Gate is a logic circuit, this ensures that the two transistors in a column can not turn on at the same time e.g. Q1 and Q3 or Q2 and Q4, as this will cause a short circuit. Each motor is controlled by three digital signals: E (enable), B (backwards) and A (forwards). All input combinations and resultant motor actions are shown in figure 16. Note, IC U3 is an open collector driver, de-coupling the logic control circuit from the voltage switched by the drive MOSFETS.

Figure 15 : H-bridge circuit diagram

Figure 16 : H-bridge logic truth table


The Goliath handset is shown in figure 17. The control cable has three wires, Red (signal), Blue (signal) and Black (GND). The user controls the robot using two, three position switches, commanding the robot to move: Left (L), Right (R), Forwards (V) and Reverse (R). Note, to prevent the robot accidentally moving back over (damaging) the control cable, reverse movements need to be enabled by moving a bar. Each switch has three positions allowing it to 'drive' one of three voltages onto each signal cable: 0V, +13.5V, or -13.5V. These two signals control polarised relays 1 and 2, shown in figure 18, enabling the four smaller relays that control the voltage across each drive motor i.e. a +24V battery supply in the robot. Possible command signals are shown in figure 19. Note, these are a best guess as the full wiring diagrams for handset and the robot were not available (from the news reel video, steering seems to be done by stopping a track, rather than reversing). The key switch on the handset is used to detonate the robot (key on attached chain). This sends a +40V signal down either signal cable (Red or Blue), energizing the firing relay. This relay turns off the power to the drive motors, stopping the robot and switches a +4.5V voltage onto the electronic detonator, igniting the main charge. Note, the firing relay is connected to the same wires used to control the polarised relays 1 and 2, however, these 13.5V control signals are not sufficient to switch (turn on) the firing relay i.e. the smaller signal voltages do not generate a large enough magnetic field within the firing relay to overcome it's contact spring and close the relay's contacts. Therefore, to encode the different movement commands Goliath used a ternary representation (0,+13.5V,-13.5V) and to control the detonation circuits a binary representation (0,+40V).

Figure 17 : Control Handset

Figure 18 : Goliath control circuit

Figure 19 : Control signals

Creative Commons Licence

This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.

Contact details: email - mike.freeman@york.ac.uk, telephone - 01904 32(5473)