similarity index 100%

rename from ft991/passthrough/passThrough.py

rename to ft991/passthrough/passthrough.py

new file mode 100644

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

+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

new file mode 100755

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

+#!/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()

new file mode 100644

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

new file mode 100644

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

+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.

new file mode 100755

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

+#!/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()