Вы находитесь на странице: 1из 18

Arduino Tarheels Adapter for the FT-100

Well, basically, I messed up and lost the original ATAS-100 off my car. Ive always been skeptical about
the efficiency of the ATAS antennas, though they do work. Consequently, rather than buying another (at
about $400) I decided to purchase the Little Tarheels HP antenna, and Ive been very pleased with the
performance and glad I made the change.

I did however decide that I would miss the automatic tuning feature of the ATAS antenna with the FT-
100, so I built the following interface that reads the DC voltage from the coax to the antenna and
translates that signal into the Up and Down movement for the Tarheels antenna.

By the way, this circuit should work for any radio that is compatible with the ATAS antenna systems,
including the FT897, FT-857, FT-991, etc. Also, with some other minor mods (changing the current sense
resistor) it should work for nearly any screwdriver antenna.

My wife and I recently took a trip to Utah to see some of the national parks in our Honda S2000. I had a
great time talking to friends back in South Dakota and Minnesota using the FT-100 with the Arduino
auto tune control. We drove through the parks with the top down of course.

I would like to know if you build this circuit or need some help. You can contact me at: W0IH@arrl.net

Mike W0IH
The circuit diagram that I designed is as follows

I ordered the Arduino Nano, relay board and the case from Ebay. You will also need a 7807 (I would not
suggest the 7806) voltage regulator, something to drop the automobile 14.5 volts to a lower value for
the Arduino so that it doesnt overheat the internal regulator. I had tried a small switching voltage
regulator on an earlier model but found that it was generating hash on the 40 meter band, so I changed
to the linear regulator. Note in the subsequent pictures that the tab is nestled against the aluminum
case for some added heat sinking.

The Little Tarheels HP (40 to 6 meter, 500 watt) has a higher Q and therefore requires a coil from the
antenna to ground for matching. The 80 thru 6 meter version of the Tarheels antenna doesnt require
the external coil, but it also isnt as efficient. Because of this shunt coil to ground, a capacitor is
required in series between the circuit and the antenna to keep from shorting the DC voltage signal from
the FT-100 to ground.
I mounted this capacitor in a separate box:

If you do mount the capacitor externally, you can also mount the inductor in the case with the capacitor
(200 volt is sufficient), and feed just the DC voltage into the box with the Arduino. The inductor and
capacitors comprise a bias tee (google this for some more details on different designs if you like). I
used several capacitors in parallel (the large blue one and the two other round ones above it) to keep
the loss through the capacitors to a minimum. The inductor is a 100 microhenry (Radio Shack) and a .1
microfarad cap to ground at the output of the phono connector that I used.

The 100 uh inductor and .1 uf cap filters the DC off the coaxial line from the FT-100 to the Arduino
analog input to grab the 8.5 volt (down signal) and the 11.0 volt (up signal) that is normally decoded by
the ATAS antenna. There is also a voltage divider and a 1K potentiometer built into the circuit to get the
voltage levels below the 5 volt analog input limit of the Arduino. The pot is adjusted to 2.2 volts to the
Arduino Pin A0 (wiper of the pot) with 8 volts applied at the input applied.

Parts List:
1. Arduino Nano (though you can use many other flavors of the Arduino if you like)
2. 7807 Voltage Regulator
3. SPDT Center Off, Momentary contact switch. (Or two momentary normally off push buttons)
4. 1 ea. 2 Relay module suitable for 5 volt input and 5 volt relay coils.
5. 1000 ohm pot, watt
6. 1000 ohm resistor, watt
7. 4.7 ohm watt resistor (may need a different value for higher current screwdriver antennas)
8. 3 ea. 0.01 uf capacitors
9. 10 uf, 20 volt capacitor
10. Appropriate connector to connect to your antenna power cable (pigtail, see text).
11. Connector compatible with the FT-100 pigtail cable for the 12V DC connection. Search ebay for:
2 Pcs DIN Plug Connector 8 Pin Mini w/ Plastic Handle
12. Blank perforated PC board for mounting components.
13. 1 or possibly 2 coax connectors. I like using BNC, but you can use SO239 instead. I used a BNC
Tee connector to tap into the coax line to the antenna, or you can mount 2 connectors on the
box . Another option is to mount the coaxial connectors in the Bias Tee box (reference text).
14. Case of your choice
The circuit that I build is pictured below:
From the circuit that I built, I would suggest 2 changes:

1. I used an RJ-45 network type cable for my connection between the case and the antenna. I
would suggest that instead, you use a compatible connector with about a 12 inch pigtail
connector coming out of the case to connect to your antenna relay cable.
2. I used a 12 volt coaxial connector for the DC input. Instead, I would suggest that you connect a
cable directly to the FT-100 pigtail connector. This works especially well considering that when
you turn off the radio, the power to the Arduino is turned off.

These two changes eliminate some of the complicated holes in the case. You may want to use some
rubber grommets to make sure that there is no chafing of the wires. I would also suggest a 1 amp fuse
in line with the 12 volt DC line.

NOTE that the 12 volt line on the pigtail coming out of FT-100 will supply enough current for the Little
Tarheels antenna. I dont know what the current limit is so you may want to check this if you are using
an antenna with more current requirements and possibly consider a different source for the 12 volts to
the circuit driving the antenna motor.

You will notice in the circuit diagram that it shows a pizo electric buzzer. I had originally designed this in
but I kept having problems with the code where it would not turn off the antenna motor fast enough
which would always detune the antenna. I have since removed the code support for the buzzer. The
buzzer was to indicate the antenna end points reached and a few other minor functions.

I used some bare perf-board to mount the other components on, cut to 2 inches wide so that the boards
would fit in the grooves in the case that I used. Note that the relay board also fits nicely into this case.
The case was easy to work on in that all the boards could be slid out to work on the bottom side if
necessary, or just open the top for access to some of the wiring and components.

I chose a fairly small case as I personally like to keep things as small as possible. If you choose an
Arduino Uno or some other larger board, you will want a larger case. This would also be less of a
challenge to assemble, especially if you use SO239 connectors.

Speaking of the SO239 connectors, as I mentioned earlier, you might find it much easier to put the full
bias tee into a separate aluminum case, along with the 100 uh inductor and the series capacitor, and
then just feed the signal voltage through a separate cable (similar to what I show in the picture above)
and NOT put the inductor and .01 uf capacitor into the Arduino case.

Notes on the Arduino Code:

If you are familiar with the ATAS antenna system, you will have noticed that when the FT-100 is changed
to enable the ATAS antenna, it first runs the antenna all the way down to the bottom as a reference.
Not knowing exactly where the antenna is, the FT-100 just keeps the Down signal going for 60 seconds
(time required to go all the way from the top to the bottom). The motor keeps spinning as the internal
clutch just slips. The Tarheels antennas (and others) do not have the clutch mechanism so they would
just keep trying to turn, and possibly burn out the motor. There is a 5 ohm resistor in series with the
antenna motor power used to measure the current through the motor. Once the motor current goes up
(the voltage across the resistor suddenly increases) when the motor has reached either end. The motor
direction is reverse for about second to take the strain off the motor and wait (with both relays off)
for the signal from the FT-100 to change direction or turn off. This logic is used for both the automatic
mode and the push button changes.

Part of the trick to getting this circuit to work is to decode when the voltage from the FT-100 is
indicating up or down. This is handled by tapping off the coaxial line with a 100 uh coil (very low current
is required, less than 10 ma, so a very small coil can be used) and filtered with a 0.1 uf capacitor to
ground. This then gives us a DC voltage to measure. The Arduino analog inputs wont tolerate voltages
above 5 volts so we drop the voltage across a 1K resistor and into a 1K ohm pot. The voltage at the
wiper of the pot is adjusted to 2.2 volts when there is an 8 volt signal applied to the input. Basically,
when 8.5 volts is sent from the FT-100, the antenna should go down, and when 11 volts is generated,
the antenna should go up. I learned that there is also an anomaly where when the 8.5 signal is turned
off, the voltage goes up to about 10 volts briefly before turning off. I had to compensate for that by
turning off the down signal above 9.5 volts, and not turning on the up relay until we hit at least 10.5

I also added provisions for the Up and Down switch. This allows the user to manually tune the antenna
if you like. You can use the manual tune via the FT-100 by pressing the mic button and holding the Up or
Down keys on the radio, but this will mess with the next direction that the antenna tries to tune. This is
normal operation for the FT-100.
Code for the Arduino Nano:

What follows is the code for the Arduino Nano. As I mentioned earlier, you can use almost any type of
Arduino besides the Nano if you like, but you must choose the correct board type before downloading
the code to the board.

You will need to download the software for the Arduino from:


Check the Arduino totorials to get started. Basically you set your board type to the correct type (under
Tools > Board) and the correct Comm Port (under Tools > Port) and press the > arrow just below the
Edit menu to download the code to the device with the USB port connected to the Arduino.

Everything that follows should be copied and pasted into the Arduino editor and loaded into you


* This version works for the FT-100.

* Includes Up and Down buttons for manual tuning.

* This is the version for the Arduino Nano.


// Define the Pins for the Up and Down Relays

int DownRelay = 7; //Blue Wire

int UpRelay = 8; //Orange Wire

//Relay Name Constants:

const int OFF = 1;

const int ON = 0;

//Declare the buttons

const int UpButton = 3; //Green Wire

const int DownButton = 2; //Blue Wire

// Define the Pin for the Input Voltage, from FT100, used to measure the 8 or 11 Volt signal

int InputVoltage = A0;

//How long does it take for the motor to stop turning when reversing the direction (Overcurrent on the

const int MotorStopTime = 400;

//Value greater than this is Stall Current: (May have to increase this if you get false detection of Stall,
like in cold weather!)

const int StallCurrentValue = 200;

//State machine...

byte State = 0;

const byte Stable = 0;

const byte UpEnd = 1;

const byte DownEnd = 2;

const byte MovingUp = 3;

const byte MovingDown = 4;

const byte ButtonUp = 5;

const byte ButtonDown = 6;

const byte bU = 1;

const byte bD = 2;
boolean CheckMotorCurrent() {

int MotorCurrent = 1; //Motor Input Pin Number

int CurrentValue = 0; //Initialize the Motor Current Value.

CurrentValue = analogRead(MotorCurrent);

//Serial.print(F("Motor Current = ")); Serial.println(CurrentValue);

if (CurrentValue > StallCurrentValue) {


//We hit the Stall Current (at one end or the other):

if ((State == MovingUp) || (State == ButtonUp)) {

//STALL: Turn off the UP Relay action and move the antenna just off the stop to take the pressure off.






State = UpEnd;

//Return the ButtonStall flag to keep from moving Up again if the button was pushed (if not pushed,
doesn't matter!)

return true;

else if ((State == MovingDown) || (State == ButtonDown)) {

//STALL: Turn off the DOWN Relay action and move the antenna just off the stop to take the
pressure off.






State = DownEnd;

//Return the ButtonStall flag to keep from moving Down again. if the button was pushed (if not
pushed, doesn't matter!)

return true;

return false;

// the setup routine runs once when you press reset:

void setup() {

// open the serial port at 115200 bps: (Used for Serial Monitor for Debugging.


// initialize the digital pin as an outputs for the Up and Down relays.

pinMode(DownRelay, OUTPUT);

pinMode(UpRelay, OUTPUT);

//Make sure that the Relays are OFF before begining.


//Setup the Up and Down buttons (switch) with the internal pullup. No resistor required.

pinMode(UpButton, INPUT_PULLUP);

pinMode(DownButton, INPUT_PULLUP);

void DirectionUp() {

digitalWrite(DownRelay, OFF); //Make sure the Down Relay is OFF

digitalWrite(UpRelay, ON); //Turn on the Up Relay

void DirectionDown() {

digitalWrite(UpRelay, OFF); //Make sure the Up Relay is OFF

digitalWrite(DownRelay, ON); //Turn on the Down Relay

void DirectionOff() {

digitalWrite(UpRelay, OFF); //Make sure the Up Relay is OFF

digitalWrite(DownRelay, OFF); //Make sure the Down Relay is OFF

// the loop routine runs over and over again forever:

void loop() {
//FT-100 puts out ~8v for DOWN direction,

// and ~11 v for UP direction.

//Value where is Voltage DOWN value starts:

const int LowBreakValue = 400; //About 6 volts

//Value part way between Down (~8V) and Up (~11V),

// This is required because when the Yaesu changed from DOWN to OFF, it goes to HIGH first, and can
detune the antenna.

const int UpDownBreakValue = 550; //About 9 Volts

boolean ValueUp = OFF;

boolean ValueDown = OFF;

boolean ButtonStall = false;

int InputValue = 0;

int InputValue2 = 0;

int InputValue3 = 0;

//Read the InputVoltage from the Antenna Cable.

InputValue = analogRead(InputVoltage);

//If value starts up, then take 20 milliseconds more readings are stable,

// Take readings 10ms apart and take the average of the last 2.

if (InputValue > 100) {

//Voltage is starting or is already up.

delay(10); //Allow the value to settle...

InputValue2 = analogRead(InputVoltage);

delay(10); //Allow the value to settle...

InputValue3 = analogRead(InputVoltage);

InputValue = (InputValue2 + InputValue3) / 2;

//This value should read about 450 counts (InputValue) on the DOWN signal from the Yaesu Radio
(8V) and read 2.20 Volts to Pin A0.

//This value should read about 625 counts on the UP signal from the Yaesu Radio (11V) and read 3.0
Volts to Pin A0.

//Serial.print(F("InputValue = ")); Serial.println(InputValue);

else {


if ((State >= MovingUp) && (State <= ButtonDown) && (ButtonStall == false)) {

//We are Moving (up or down), check the Current

ButtonStall = CheckMotorCurrent();

//Read the two buttons:

ValueUp = digitalRead(UpButton);

ValueDown = digitalRead(DownButton);

// Serial.print(F(" Up = ")); Serial.print(ValueUp);

// Serial.print(F(" Down = ")); Serial.print(ValueDown);

// Serial.print(F(" Stall = ")); Serial.print(ButtonStall);

// Serial.print(F(" State = ")); Serial.println(State);

switch (State) {

case Stable:

if (InputValue > UpDownBreakValue) {

//Turn On Up Relay


delay(100); //Wait past to motor startup peak current

State = MovingUp;

else if ((InputValue > LowBreakValue) && (InputValue < 500)) { //Added "&& (InputValue < 500), see
if that helps

//Turn on Down Relay


delay(100); //Wait past to motor startup peak current

State = MovingDown;

else if ((ValueUp == ON) && (ButtonStall == false)) {

//Up Button Pressed, Turn On Up Relay


delay(100); //Wait past to motor startup peak current

State = ButtonUp;

else if ((ValueDown == ON) && (ButtonStall == false)) {

//Down Button Pressed, Turn On Down Relay


delay(100); //Wait past to motor startup peak current

State = ButtonDown;


case MovingUp:

//Moving Up...

if (InputValue < UpDownBreakValue) {

//When EVER the voltage drops out of UP range,

// Turned Off the Up Relay, wait 1/2 seconds (allow for Decay of voltage)

// and let the InputVoltage test recheck for direction change.


State = Stable;

delay(1000); //Wait for the voltage to decay an then retest Inputvoltage.


case ButtonUp:

//Pressed Button Moving Up...

if (ValueUp == OFF) { //Detected Up Button OFF

//Turn Off the Up Relay:


//Change back to the Stable State:

State = Stable;


case MovingDown:

//Moving Down...

if ((InputValue < LowBreakValue) || (InputValue > 500)) {

//Change from Down to OFF (If the voltage goes to UP value, let the InputVoltage reading take


State = Stable;

delay(1000); //Wait for the voltage to decay an then retest Inputvoltage.


case ButtonDown:

//Down Pressed Button Moving Down...

if (ValueDown == OFF) { //Detected Down Button OFF

//Turn off the Down Relay:


//Change back to the Stable State:

State = Stable;


case UpEnd:

if ((ValueUp == OFF) && (InputValue < LowBreakValue)) {

//We have turned off the Up relay in CheckMotorCurrent(), wait for the voltage to change.

//Wait for the button to be released to clear the state.

State = Stable;

else if ((InputValue < UpDownBreakValue) && (ValueUp == OFF)) {


delay(100); //Wait past to motor startup peak current

State = MovingDown;


case DownEnd:

if ((ValueDown == OFF) && (InputValue < LowBreakValue)) {

//Relay Turned Off in CheckMotorCurrent().

//Wait for the button to be released to clear the state.

State = Stable;

//Serial.println("Hit 1");

//We have turned off the DOWN relay, wait for the voltage to change.
else if (InputValue > UpDownBreakValue) {


delay(100); //Wait past to motor startup peak current

State = MovingUp;

//Serial.println("Hit 2");


} //End of Switch

} //End of Loop