deleted file mode 100755

@@ -1,151 +0,0 @@

-#!/usr/bin/python -u

-# The -u option turns off block buffering of python output. This assures

-# that output streams to stdout when output happens.

-#

-# Description:  This program passes commands from a command line prompt

-#               directly through to the FT991.  Also a few utility macro

-#               commands have been defined that can be typed on the 

-#               command line.

-#

-# This script has been tested with the following

-#

-#     Python 2.7.15rc1 (default, Nov 12 2018, 14:31:15) 

-#     [GCC 7.3.0] on linux2

-#2345678901234567890123456789012345678901234567890123456789012345678901234567890

-

-import sys, serial, time

-

-# Determine OS type and set device port accordingly.

-OS_type = sys.platform

-if 'WIN' in OS_type.upper():

-    _SERIAL_PORT = 'COM5'

-else:

-    _SERIAL_PORT = '/dev/ttyUSB0'

-

-# General constant defines

-_BAUD_RATE = 9600

-_INTERFACE_TIMEOUT = 0.1 # seconds

-_SERIAL_READ_TIMEOUT = 0.1 # seconds

-_SERIAL_READ_BUFFER_LENGTH = 1024 # characters

-

-# Define functions encapsulating serial communications to and from

-# a generic serial device object.

-

-def getAnswer(device, termchar):

-    """

-    Description: Reads output one character at a time from the device

-                 until a terminating character is received.  Returns a     

-                 string containing the characters read from the serial

-                 port.

-    Parameters:  device - a serial object connected to the device port

-                 termchar - character terminating the answer string

-    Returns:     string

-    """

-    answer = '' # initialize answer string to empty string

-    charCount = 0  # reset read character count to zero

-

-    while True:

-        startTime = time.time() # Start read character timer

-        c =''

-        while True:

-            # Check for a character available in the serial read buffer.

-            if device.in_waiting:

-                c = device.read()

-                break

-            # Timeout if a character does not become available.

-            if time.time() - startTime > _SERIAL_READ_TIMEOUT:

-                break # Read character timer has timed out.

-        # Return empty string if a character has not become available.

-        if c == '':

-            break;

-        answer += c # Form a string from the read characters.

-        charCount += 1 # Increment character count.

-        # If a semicolon has arrived then the FT991 has completed

-        # sending output to the serial port so stop reading characters.

-        # Also stop if max characters received. 

-        if c == termchar:

-            break

-        if charCount > _SERIAL_READ_BUFFER_LENGTH:

-            raise Exception('serial read buffer overflow')

-    device.flushInput() # Flush serial buffer to prevent overflows.

-    return answer           

-## end def

-

-def sendCommand(device, command):

-    """

-    Description: writes a string to the device.

-    Parameters:  device - a serial object connected to the device port

-                 command - string containing the FT991 command

-    Returns:     nothing

-    """

-    device.write(command) # Send command string to FT991

-    device.flushOutput() # Flush serial buffer to prevent overflows

-

-# Iterate through all menu items, getting each setting

-def readMenuSettings(device):

-    """

-    Description: prints out all menu settings.

-    Parameters:  device - a serial object connected to the FT991

-    Returns:     nothing

-    """

-    for inx in range(1,125):

-        sCommand = 'EX%0.3d;' % inx

-        sendCommand(device, sCommand)

-        sAnswer = getAnswer(device, ';')

-        print "%0.3d: %s" % (inx, sAnswer[5:])

-

-# Iterate through all memory channels, getting settings

-def readMemoryChannels(device):

-    """

-    Description: prints out all memory channels.

-    Parameters:  device - a serial object connected to the FT991

-    Returns:     nothing

-    """

-    for inx in range(1,118):

-        sCommand = 'MT%0.3d;' % inx

-        sendCommand(device, sCommand)

-        sAnswer = getAnswer(device, ';')

-        print "%0.3d: %s" % (inx, sAnswer)

-

-def main():

-    """

-    Description: main routine starts command line interpreter.

-    Parameters:  none

-    Returns:     nothing

-    """

-    

-    # Present an introductory splash when the program first starts up.

-    splash = \

-"""

-Enter an FT991 command, e.g, "IF;";

-or enter one of the following commands

-    exit - terminates this program

-    rmem - prints out memory channels

-    rmenu - prints out all menu settings

-"""

-    print splash

-

-    # Create a FT991 object for serial communication

-    ft991 = serial.Serial(_SERIAL_PORT, _BAUD_RATE, timeout=_INTERFACE_TIMEOUT)

-    time.sleep(.1) # give the connection a moment to settle

-

-    while(True):

-        sCommand = raw_input('>')

-        # Process command string

-        if sCommand == '': # no command - do nothing

-            continue

-        elif sCommand.upper() == 'EXIT': # end program

-            break

-        elif sCommand.upper() == 'RMEM': # display channel memory

-            readMemoryChannels(ft991)

-        elif sCommand.upper() == 'RMENU': # display menu settings

-            readMenuSettings(ft991)

-        else: # run a user command

-            sendCommand(ft991, sCommand)

-            sAnswer = getAnswer(ft991, ';');

-            if sAnswer != '':

-                print sAnswer

-## end main

-

-if __name__ == '__main__':

-    main()

deleted file mode 100644

@@ -1,43 +0,0 @@

-Memory Ch,Rx Frequency,Tx Frequency,Offset,Repeater Shift,Mode,Tag,Encoding,Tone,DCS

-1,145.19,144.59,0.6,-RPT,FM,WA7ABU,TONE ENC,100.0 Hz,23

-2,145.29,144.69,0.6,-RPT,FM,WA7ABU,OFF,118.8 Hz,23

-3,444.95,449.95,5,+RPT,FM,W7ABU,TONE ENC,100.0 Hz,23

-4,145.49,144.89,0.6,-RPT,FM,W7PRA Sa,TONE ENC,136.5 Hz,23

-5,444.825,449.825,5,+RPT,FM,W7PRA Ha,DCS,100.0 Hz,23

-6,146.61,146.01,0.6,-RPT,FM,KA7ENW,TONE ENC,167.9 Hz,23

-7,442.85,447.85,5,+RPT,FM,KA7ENW,TONE ENC,167.9 Hz,23

-8,147.06,147.66,0.6,+RPT,FM,W1ARK,TONE ENC,100.0 Hz,23

-9,145.33,144.73,0.6,-RPT,FM,W7SRA,TONE ENC,186.2 Hz,23

-10,146.72,146.12,0.6,-RPT,FM,W7PXL,TONE ENC,100.0 Hz,23

-11,146.68,146.08,0.6,-RPT,FM,W7EUG,TONE ENC,100.0 Hz,23

-12,146.78,146.18,0.6,-RPT,FM,K7CVO,TONE ENC,156.7 Hz,23

-13,146.82,146.22,0.6,-RPT,FM,WA7TUV,TONE ENC,100.0 Hz,23

-14,434.91,439.91,5,+RPT,FM,KF7LDG,TONE ENC,100.0 Hz,23

-15,440.425,445.425,5,+RPT,FM,K7LNK,DCS,100.0 Hz,125

-16,440.8,445.8,5,+RPT,FM,AB7BS,TONE ENC,100.0 Hz,23

-17,441.975,446.975,5,+RPT,FM,W7CQZ,TONE ENC,100.0 Hz,23

-18,442.3,447.3,5,+RPT,FM,N8GFO,TONE ENC,162.2 Hz,23

-20,146.43,146.43,0,OFF,FM,Prep Net,OFF,100.0 Hz,23

-21,146.42,146.42,0,OFF,FM,VHF Prep,OFF,100.0 Hz,23

-22,146.55,146.55,0,OFF,FM,VHF Surv,OFF,100.0 Hz,23

-23,446.03,446.03,0,OFF,FM,UHF Prep,OFF,100.0 Hz,23

-24,146.43,146.43,0.6,OFF,FM,V Sim 1,OFF,100.0 Hz,23

-25,146.475,146.475,0.6,OFF,FM,V Sim 2,OFF,100.0 Hz,23

-26,146.58,146.58,0.6,OFF,FM,V Sim 3,OFF,100.0 Hz,23

-27,147.465,147.465,0.6,OFF,FM,V Sim 4,OFF,100.0 Hz,23

-28,445.9625,445.9625,5,OFF,FM,U Sim1,OFF,100.0 Hz,23

-29,445.975,445.975,5,OFF,FM,U Sim 2,OFF,100.0 Hz,23

-30,446.0375,446.0375,5,OFF,FM,U Sim 3,OFF,100.0 Hz,23

-31,446.075,446.075,5,OFF,FM,U Sim 4,OFF,100.0 Hz,23

-40,162.475,162.475,0,OFF,FM,WX3PA4,OFF,100.0 Hz,23

-41,162.5,162.5,0,OFF,FM,WX6PA5,OFF,100.0 Hz,23

-42,122.725,122.725,0,OFF,AM,ALB CTAF,OFF,100.0 Hz,23

-43,123.075,123.075,0,OFF,AM,CVO CTAF,OFF,100.0 Hz,23

-44,156.08,156.08,0.6,OFF,FM,PD,OFF,100.0 Hz,23

-45,156.815,156.815,0,OFF,FM,ALB PD,OFF,100.0 Hz,23

-46,155.01,155.01,0,OFF,FM,PD Sec,OFF,100.0 Hz,23

-47,151.13,151.13,0,OFF,FM,LCSO Knx,OFF,100.0 Hz,23

-48,154.71,154.71,0,OFF,FM,LCSO Sct,OFF,100.0 Hz,23

-49,156.7,156.7,0,OFF,FM,LCSO ST,OFF,100.0 Hz,23

-50,155.805,155.805,0,OFF,FM,LCSO SAR,OFF,100.0 Hz,23

-51,155.34,155.34,0,OFF,FM,ALB GEN,OFF,100.0 Hz,23

deleted file mode 100755

@@ -1,247 +0,0 @@

-#!/usr/bin/python -u

-# The -u option turns off block buffering of python output. This assures

-# that output streams to stdout when output happens.

-#

-# Description:  This module contains tables for tranlating common transceiver

-#               settings to FT991 CAT parameters.  Low level serial

-#               communication functions are handled by this module.  In

-#               particular this module handles:

-#                   1. Setting a serial connection object

-#                   2. Sending character strings to the serial port

-#                   3. Reading characters from the serial port

-#                   4. Formatting of FT991 commands

-#

-# This script has been tested with the following

-#

-#     Python 2.7.15rc1 (default, Nov 12 2018, 14:31:15) 

-#     [GCC 7.3.0] on linux2

-#2345678901234567890123456789012345678901234567890123456789012345678901234567890

-

-import sys, serial, time

-

-# Determine OS type and set device port accordingly.

-OS_type = sys.platform

-if 'WIN' in OS_type.upper():

-    _SERIAL_PORT = 'COM5'

-else:

-    _SERIAL_PORT = '/dev/ttyUSB0'

-

-# General constant defines

-_BAUD_RATE = 9600

-_INTERFACE_TIMEOUT = 0.1 # seconds

-_SERIAL_READ_TIMEOUT = 0.1 # seconds

-_SERIAL_READ_BUFFER_LENGTH = 1024 # characters

-

-verbose = False

-debug = False

-

-# Define lookup tables for common transceiver settings.  Common settings

-# such as modulation mode, repeater offset direction, DCS/CTCSS mode,

-# CTCSS tone, and DCS code are translated to the repective FT991 parameter

-# value.

-

-dMode = {'LSB':'1', 'USB':'2', 'CW':'3', 'FM':'4', 'AM':'5', 'RTTY-LSB':'6',

-         'CW-R':'7', 'DATA-LSB':'8', 'RTTY-USB':'9', 'DATA-FM':'A',

-         'FM-N':'B', 'DATA-USB':'C', 'AM-N':'D', 'C4FM':'E'}

-

-dShift = {'OFF':'0', '+RPT':'1', '-RPT':'2'}

-

-dPower = { 'LOW':'005', 'MID':'020', 'HIGH':'050' }

-

-dEncode = {'OFF':'0', 'ENC/DEC':'1', 'TONE ENC':'2', 'DCS ENC/DEC':'4',

-          'DCS':'3'}

-

-dTones = {'67.0 Hz':'000', '69.3 Hz':'001', '71.9 Hz':'002', '74.4 Hz':'003', 

-       '77.0 Hz':'004', '79.7 Hz':'005', '82.5 Hz':'006', '85.4 Hz':'007',

-       '88.5 Hz':'008', '91.5 Hz':'009', '94.8 Hz':'010', '97.4 Hz':'011',

-       '100.0 Hz':'012', '103.5 Hz':'013', '107.2 Hz':'014', '110.9 Hz':'015',

-       '114.8 Hz':'016', '118.8 Hz':'017', '123.0 Hz':'018', '127.3 Hz':'019',

-       '131.8 Hz':'020', '136.5 Hz':'021', '141.3 Hz':'022', '146.2 Hz':'023',

-       '151.4 Hz':'024', '156.7 Hz':'025', '159.8 Hz':'026', '162.2 Hz':'027',

-       '165.5 Hz':'028', '167.9 Hz':'029', '171.3 Hz':'030', '173.8 Hz':'031',

-       '177.3 Hz':'032', '179.9 Hz':'033', '183.5 Hz':'034', '186.2 Hz':'035',

-       '189.9 Hz':'036', '192.8 Hz':'037', '196.6 Hz':'038', '199.5 Hz':'039',

-       '203.5 Hz':'040', '206.5 Hz':'041', '210.7 Hz':'042', '218.1 Hz':'043',

-       '225.7 Hz':'044', '229.1 Hz':'045', '233.6 Hz':'046', '241.8 Hz':'047',

-       '250.3 Hz':'048', '254.1 Hz':'049'} 

-

-dDcs = {'23':'000', '25':'001', '26':'002', '31':'003', '32':'004',

-        '36':'005', '43':'006', '47':'007', '51':'008', '53':'009',

-        '54':'010', '65':'011', '71':'012', '72':'013', '73':'014',

-        '74':'015', '114':'016', '115':'017', '116':'018', '122':'019',

-        '125':'020', '131':'021', '132':'022', '134':'023', '143':'024',

-        '145':'025', '152':'026', '155':'027', '156':'028', '162':'029',

-        '165':'030', '172':'031', '174':'032', '205':'033', '212':'034',

-        '223':'035', '225':'036', '226':'037', '243':'038', '244':'039',

-        '245':'040', '246':'041', '251':'042', '252':'043', '255':'044',

-        '261':'045', '263':'046', '265':'047', '266':'048', '271':'049',

-        '274':'050', '306':'051', '311':'052', '315':'053', '325':'054',

-        '331':'055', '332':'056', '343':'057', '346':'058', '351':'059',

-        '356':'060', '364':'061', '365':'062', '371':'063', '411':'064',

-        '412':'065', '413':'066', '423':'067', '431':'068', '432':'069',

-        '445':'070', '446':'071', '452':'072', '454':'073', '455':'074',

-        '462':'075', '464':'076', '465':'077', '466':'078', '503':'079',

-        '506':'080', '516':'081', '523':'082', '526':'083', '532':'084',

-        '546':'085', '565':'086', '606':'087', '612':'088', '624':'089',

-        '627':'090', '631':'091', '632':'092', '654':'093', '662':'094',

-        '664':'095', '703':'096', '712':'097', '723':'098', '731':'099',

-        '732':'100', '734':'101', '743':'102', '754':'103'}

-

-# Define functions for implementing the various FT991 CAT commands

-

-def getMTcommand(dChan):

-    """

-    Description: returns a formatted MT command to the calling function.

-    Parameters: dChan - a dictionary objected with the following keys defined

-                    chnum - the memory location to be written

-                    rxfreq - the receive frequency of VFO-A in MHz

-                    mode - the modulation mode

-                    encode - the tone or DCS encoding mode

-                    shift - the direction of the repeater shift

-                    tag - a label for the memory location

-    Returns: a string containing the formatted command

-    """

-    sCmd = 'MT'

-    sCmd += '%0.3d' % int(dChan['chnum'])

-    sCmd += '%d' % int(float(dChan['rxfreq']) * 1E6)

-    sCmd += '+000000'

-    sCmd += dMode[dChan['mode']]

-    sCmd += '0'

-    sCmd += dEncode[dChan['encode']]

-    sCmd += '00'

-    sCmd += dShift[dChan['shift']]

-    sCmd += '0'

-    sCmd += '%-12s' % dChan['tag']

-    sCmd += ';'

-    if verbose:

-        print sCmd,

-    return sCmd

- 

-def getCTCSScommand(dChan):

-    """

-    Description:  returns a formatted CN command that sets the desired

-                  CTCSS tone.

-    Parameters:  dChan - a dictionary object with the following key defined

-                     tone - the CTCSS tone in Hz, e.g.,

-                            dChan = {'tone':'100 Hz'}

-    Returns: a string containing the formatted command

-    """

-    sCmd = 'CN0'

-    sCmd += '0%s;' % dTones[dChan['tone']]

-    if verbose:

-        print sCmd,

-    return sCmd

-

-def getDCScommand(dChan):

-    """

-    Description:  returns a formatted CN command that sets the desired

-                  DCS code.

-    Parameters:  dChan - a dictionary object with the following key defined

-                     dcs - the DCS code, e.g., dChan = {'dcs':'23'}

-    Returns: a string containing the formatted command

-    """

-    sCmd = 'CN0'

-    sCmd += '1%s;' % dDcs[dChan['dcs']]

-    if verbose:

-        print sCmd,

-    return sCmd

-

-def getPCcommand(dChan):

-    """

-    Description:  returns a formatted PC command that sets the desired

-                  RF transmit power level.

-    Parameters:  dChan - a dictionary object with the following key defined

-                     power - the power level in Watts

-                            e.g., dChan = {'power':'020'}

-    Returns: a string containing the formatted command

-    """

-    sCmd = 'PC'

-    sCmd += '%s;' % dPower[dChan['power']] 

-    if verbose:

-        print sCmd,

-    return sCmd

-

-def receiveSerial(device, termchar=';'):

-    """

-    Description: reads output one character at a time from the device

-                 until a terminating character is received.  Returns a     

-                 string containing the characters read from the serial

-                 port.

-    Parameters:  device - a serial object connected to the device port

-                 termchar - character terminating the answer string

-    Returns:     string

-    """

-    answer = '' # initialize answer string to empty string

-    charCount = 0  # reset read character count to zero

-

-    while True:

-        startTime = time.time() # Start read character timer

-        c =''

-        while True:

-            # Check for a character available in the serial read buffer.

-            if device.in_waiting:

-                c = device.read()

-                break

-            # Timeout if a character does not become available.

-            if time.time() - startTime > _SERIAL_READ_TIMEOUT:

-                break # Character waiting timer has timed out.

-        # Return empty string if a character has not become available.

-        if c == '':

-            break;

-        answer += c # Form a string from the received characters.

-        charCount += 1 # Increment character count.

-        # If a semicolon has arrived then the FT991 has completed

-        # sending output to the serial port so stop reading characters.

-        # Also stop if max characters received. 

-        if c == termchar:

-            break

-        if charCount > _SERIAL_READ_BUFFER_LENGTH:

-            raise Exception('serial read buffer overflow')

-    device.flushInput() # Flush serial buffer to prevent overflows.

-    return answer           

-## end def

-

-def sendSerial(device, command):

-    """

-    Description: writes a string to the device.

-    Parameters:  device - a serial object connected to the device port

-                 command - string containing the FT991 command

-    Returns:     nothing

-    """

-    # In debug we only want to see the output of the command formatter,

-    # not actually send commands to the FT991.  Debug mode should be

-    # used in conjunction with verbose mode.

-    if not debug: 

-        device.write(command) # Send command string to FT991

-        device.flushOutput() # Flush serial buffer to prevent overflows

-

-def begin():

-    """

-    Description: initiates a serial connection the the FT991. Should always

-                 be called before sending commands to or receiving data

-                 from the FT991.  Only needs to be called once.

-    Parameters: none

-    Returns: a pointer to the FT991 serial connection

-    """    # Create a FT991 object for serial communication

-    pDevice = serial.Serial(_SERIAL_PORT, _BAUD_RATE,      

-                            timeout=_INTERFACE_TIMEOUT)

-    time.sleep(.1) # give the connection a moment to settle

-    return pDevice

-

-

-def main():

-    """

-    Description: functions and function calls that test the functions

-                 in this module should be placed here.

-    Parameters: none

-    Returns: nothing

-    """    # Test this module.

-    verbose = True

-    ft991 = begin()

-    sendSerial(ft991,'if;')

-    answer= receiveSerial(ft991)

-    print answer

-## end def

-

-if __name__ == '__main__':

-    main()

deleted file mode 100644

Binary files a/ft991/writememory/ft991_memory_settings.ots and /dev/null differ

deleted file mode 100644

@@ -1,19 +0,0 @@

-1.  Create a folder for the writemmory files.

-2.  Copy the files writememory.py and ft991.py to the folder.

-3.  Use the following commands to make the file executable

-        chmod +x writememory.py

-4.  An example of a comma delimited spreadsheet has been provided.

-    To use the example without actually programming your FT991 run

-    the following command

-        ./writememory.py -d -v -f example.csv

-5.  Using the -d debug option prevents commands from actually being

-    written to the FT991.  Using the -v verbose option allows you to

-    see the commands that are sent to the FT991.  The -f file option

-    allows you to use a custom file name for the settings file.

-6.  A LibreOffice spreadsheet template "ft991_memory_settings.ots" has

-    been provided to help you create comma delimited settings files.

-    Various cells have dropdown list boxes for modes, tones, dcs codes, etc.

-    You should use these list boxes for setting those items.  Save the

-    spreadsheet in comma delimited format (.csv).

-7.  Incorrectly entered modes, codes, tones, etc, will cause to program

-    to crash, most likely with a dictionary object, key error.

deleted file mode 100755

@@ -1,159 +0,0 @@

-#!/usr/bin/python -u

-# The -u option turns off block buffering of python output. This assures

-# that output streams to stdout when output happens.

-#

-# Description:  This program reads a comma delimited spreadsheet file

-#               containing common transceiver settings.  The settings

-#               are stored in the transceivers memory.

-#

-# This script has been tested with the following

-#

-#     Python 2.7.15rc1 (default, Nov 12 2018, 14:31:15) 

-#     [GCC 7.3.0] on linux2

-#2345678901234567890123456789012345678901234567890123456789012345678901234567890

-

-# Import python library modules. The serial module should be included in

-# recent linux distributions.  If not, it may need to be installed.

-import sys, serial, time

-# Import FT991 serial communication functions and command library.  This

-# is a custom module that should be in the same folder as this script.

-import ft991

-

-# Define default memory settings file

-_SETTINGS_FILE = './ft991mem.csv'

-

-# Define global variables

-settingsFile = _SETTINGS_FILE

-

-def readSettingsFile(fileName):

-    """

-    Description: reads the comma delimited memory settings file and parses

-                 each line of that file into a dictionary object which stores

-                 the settings for that memory location.  Each dictionary

-                 object in turn gets stored in a single list object.

-    Parameters: name of memory settings file

-    Returns: a list object

-    """

-    lChan = []

-    fchs = open(fileName, 'r') # open the file for reading

-    # read a line from the file

-    for line in fchs:

-        # remove non-printable characters

-        rline = line.strip()

-        # parse the comma delimited line and store in a dictionary object

-        dChanData = parseData(rline)

-        # store the parsed line in a list object

-        if dChanData != None:

-            lChan.append(dChanData)

-    fchs.close()

-    return lChan

-

-def parseData(sline):

-    """

-    Description:  stores each item in the comma delimited line in a single

-                  dictionary object using a key appropriate for that item.

-    Parameters: a string containing the comma delimited items to be parsed.

-    Returns: a dictionary object containing the parsed line.

-    """

-    dChan = {} # define an empty dictionary object

-    lchan = sline.split(',') # split the line at the commas

-    # If the first line is a header line, ignore it.

-    if not lchan[0].isdigit():

-        return None

-    # Store the parsed items with the appropriate key in the dictionary object.

-    dChan['chnum'] = lchan[0]

-    dChan['rxfreq'] = lchan[1]

-    dChan['txfreq'] = lchan[2]

-    dChan['offset'] = lchan[3]

-    dChan['shift'] = lchan[4]

-    dChan['mode'] = lchan[5]

-    dChan['tag'] = lchan[6]

-    dChan['encode'] = lchan[7]

-    dChan['tone'] = lchan[8]

-    dChan['dcs'] = str(int(lchan[9]))

-    return dChan # return the dictionary object

-

-

-def sendCommand(device, sCmd):

-    """

-    Description:  sends a formatted FT911 command to the communication port

-                  connected to the FT991.  Prints to stdout the answer from

-                  the FT991 (if any).

-    Parameters: device - a pointer to the FT991 comm port

-                sCmd - a string containing the formatted command

-    Returns: nothing

-    """

-    ft991.sendSerial(device, sCmd)

-    sAnswer = ft991.receiveSerial(device);

-    if sAnswer != '':

-        print sAnswer

-

-def getCLarguments():

-    """Get command line arguments.  There are four possible arguments

-          -v turns on verbose mode

-          -d turns on debug mode

-          -f name of comman delimited memory settings file

-       Returns: nothing

-    """

-    #global ft991.verbose, ft991.debug, settingsFile

-    global settingsFile

-

-    index = 1

-    while index < len(sys.argv):

-        if sys.argv[index] == '-f':

-            if len(sys.argv) < index + 2:

-                print "-f option requires file name"

-                exit(1);

-            settingsFile = sys.argv[index + 1]

-            index += 1

-        elif sys.argv[index] == '-v':

-            ft991.verbose = True

-        elif sys.argv[index] == '-d':

-            ft991.debug = True

-        else:

-            cmd_name = sys.argv[0].split('/')

-            print "Usage: %s [-v] [-f file]\n" \

-                  "  -f: settings file\n" \

-                  "  -v: verbose mode\n" \

-                  "  -d: debug mode" % cmd_name[-1]

-            exit(-1)

-        index += 1

-##end def

-

-def main():

-    """

-    Description:  Reads the settings file, creating a list object which

-                  contains dictionary objects as its elements.  The dictionary

-                  objects contain the settings for each memory location to be

-                  programmed.

-    Parameters: none

-    Returns: nothing

-    """

-

-    # Get command line arguments, if any.  Otherwise use defaults.

-    getCLarguments()

-

-    # Create a FT991 object for serial communication.

-    pft991 = ft991.begin()

-    time.sleep(.1) # give the connection a moment to settle

-

-    # Read and parse the settings file.

-    dChan = readSettingsFile(settingsFile)

-    # Get and send the commands to the FT991 for writing the memory locations.

-    for item in dChan:

-        if ft991.verbose:

-            print '%s: ' % item['chnum'],

-

-        # Format and send memory channel vfo and mode data.

-        sendCommand(pft991, ft991.getMTcommand(item))

-        # Format and send CTCSS tone for memory channel.

-        sendCommand(pft991, ft991.getCTCSScommand(item))

-        # Format and send DCS code for memory channel. 

-        sendCommand(pft991, ft991.getDCScommand(item))

-

-        if ft991.verbose:

-            print

-## end def

-

-if __name__ == '__main__':

-    main()