cw_keyer.py

############################################################################################
#
# cw_keyer.py - Rev 1.0
# Copyright (C) 2021-5 by Joseph B. Attili, joe DOT aa2il AT gmail DOT com
#
# Routines for translating keyboard strokes into CW chars.  The rig can be keyed
# via the DTR line or, more reliably, via a nanoIO ardunino-based interface.
#
############################################################################################
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
############################################################################################

import time
import socket
import threading
import sys
import serial

############################################################################################

TEST_MODE = True
TEST_MODE = False

MIN_WPM=5
MAX_WPM=50

############################################################################################

# Table of Morse code elements
#morse=["" for i in range(128)]
morse=128*[""]
morse[32]=" ";

# Numbers
morse[48]="-----"; # 0
morse[49]=".----";
morse[50]="..---";
morse[51]="...--";
morse[52]="....-";
morse[53]=".....";
morse[54]="-....";
morse[55]="--...";
morse[56]="---..";
morse[57]="----."; # 9

# Punc
morse[33]="-.-.--";   # !
morse[34]="";         # "     0b01010010
morse[35]="";         # #     0b00000001
morse[36]="...-..-";  # $     0b11001000
morse[39]=".----.";   # '     0b01011110
morse[40]="-.--.";    # (     0b00101101
morse[41]="-.--.-";   # )     0b01101101
morse[44]="--..--";   # ,
morse[46]=".-.-.-";   # .
morse[47]="-..-.";    # /
morse[58]="---...";   # :
morse[59]="-.-.-.";   # :
morse[63]="..--..";   # ?
morse[64]=".--.-.";   # @
morse[92]=".-..-.";   # \

# Letters
morse[65]=".-";     # A
morse[66]="-...";
morse[67]="-.-.";
morse[68]="-..";
morse[69]=".";
morse[70]="..-.";   # F
morse[71]="--.";
morse[72]="....";
morse[73]="..";
morse[74]=".---";
morse[75]="-.-";     # K
morse[76]=".-..";
morse[77]="--";      # M
morse[78]="-.";
morse[79]="---";
morse[80]=".--.";
morse[81]="--.-";
morse[82]=".-.";
morse[83]="...";
morse[84]="-";
morse[85]="..-";
morse[86]="...-";
morse[87]=".--";
morse[88]="-..-";
morse[89]="-.--";    # Y
morse[90]="--..";

# Prosigns - This matches what is the nano IO uses
morse[37]="...-.-";    # % = <SK>	0b01101000
morse[38]=".-...";     # & = <AS>	0b00011010
morse[42]="";          # * 	        0b00000001
morse[43]="-.--.";     # + = <KN>	0b00101101
morse[45]="-....-";    # - = <BT>	0b00110001
morse[60]=".-...";     # < = <AS>	0b00100010
morse[61]="-...-";     # = = <BT>	0b00110001
morse[62]=".-.-.";     # > = <AR>	0b00101010

############################################################################################

# The key object - this is where all the hard work is really done
class Keyer():

    def __init__(self,P,DEFAULT_WPM=25,KEY_DOWN=False):

        self.P = P
        if DEFAULT_WPM<5:
            self.DEFAULT_WPM=25
        else:
            self.DEFAULT_WPM=DEFAULT_WPM
        self.KEY_DOWN = KEY_DOWN

        # Set defaults
        self.WPM      = self.DEFAULT_WPM
        self.dotlen   = 1.2/self.WPM 
        self.time=time.time();
        self.enable = True
        self.stop   = False
        self.Udp=False
        self.Cmd=[]

        # We need locks to coordinate time-critical sections of the keying & practice threads
        self.evt  =  threading.Event()
        self.evt.clear()
        self.evt2 =  threading.Event()
        self.evt2.clear()

        # Compute weight (in dots) of each char
        self.weight=128*[0]
        for i in range(128):
            for el in morse[i]:
                if el in [' ','-']:
                    self.weight[i]+=3
                else:
                    self.weight[i]+=1
                self.weight[i]+=1


    def busy(self):
        status = self.P.keyer_device.get_status()
        return (status[0] & 4) > 0


    def abort(self):
        P=self.P
        print('CW_KEYER - ABORT! \t evt cleared')
        self.evt.clear()
        self.evt2.clear()
        self.stop=True
        if P.DIGI:
            P.sock_xml.put_tx_buff( '',HALT=True )  
            time.sleep(.1)
            P.sock_xml.ptt(0)                       
        elif P.USE_KEYER:
            #self.P.keyer_device.nano_write('\\')
            P.keyer_device.abort()
            return

    # Routine to send a message in cw by toggling DTR line
    #    1. The length of a dot is 1 time unit.
    #    2. A dash is 3 time units.
    #    3. The space between symbols (dots and dashes) of the same letter is 1 time unit.
    #    4. The space between letters is 3 time units.
    #    5. The space between words is 7 time units.
    def send_cw(self,msg):
        P   = self.P
        print('CW_KEYER->SEND CW: msg=',msg,
              '\tUSE_KEYER=',P.USE_KEYER,
              '\tVIA DTR=',P.SEND_VIA_DTR,
              'VIA CMD=',P.SEND_VIA_CMD)

        if P.DIGI:
            return

        # Init
        if P.SEND_VIA_DTR:        
            ser = P.direct
        else:
            ser = P.ser
        WPM = self.WPM
        dotlen = self.dotlen

        if P.SEND_VIA_CMD:
            # When using hamlib command, send the char & let the rig do the rest
            P.sock.send_morse(msg,VERBOSITY=1)
            return
            
        elif P.SEND_VIA_DTR:
            pass
            
        elif P.USE_KEYER:
            # When using nano IO interface, send the char & let the nano do the rest
            wght=0
            for char in msg.upper():
                wght+=self.weight[ord(char)]

            dt=dotlen*wght
            #print('\tsend_cw: msg=',msg,'\t@ wpm=',self.WPM,'\twght=',wght,'\tdt=',dt)
            P.keyer_device.nano_write(msg)
            #print('\t\tsent dt=',dt)
            
            time.sleep(dt)
            #print('\t\t\tdone dt=',dt,flush=True)
            return

        # If in practice mode, use pc audio instead
        elif P.PRACTICE_MODE:
            print('CW_KEYER->SEND_CW: msg=',msg,len(msg))
            self.sidetone.send_cw(msg,self.WPM,0,True)
            return

        elif TEST_MODE:
            # Disable for testing purposes
            print("send_cw:",msg)    # ,WPM,dotlen
            return

        # If we get here, we're toggling the DTR and have to do all the heavy lifiting.
        # Loop over all chars in message to form symbols and timing
        for char in msg.upper():
            #print('\tchar=',char)

            i=ord(char)
            cw=morse[i]
            dt=time.time() - self.time;
            print('SEND_CW: sending ',char,'\tdotlen=',dotlen)
            
            # Loop over all elements in this char
            startup = 0.02                            # Additional time needed to overcome OS limitations?
            if i>=32: #    or dt<3*dotlen ):
                for el in cw:
                    if( el==' ' ):
                        # After each char, 3 short spaces have already been added (see code below).
                        # Hence, we only need 4 more short spaces to get letter spacing correct (7 short).
                        # This seems too long so we cheat and only 3 short spaces (6 short)
                        #print('Key Up')
                        ser.setDTR(False)
                        time.sleep(3*dotlen + startup)
                    elif( el=='.' ):
                        # Enable DTR for dot period
                        #print('Key Down')
                        ser.setDTR(self.enable)
                        time.sleep(dotlen + startup)
                    elif( el=='-' ):
                        # Enable DTR for 3 dot periods
                        #print('Key Down')
                        ser.setDTR(self.enable)
                        time.sleep(3*dotlen + startup)

                    # After each element, we insert a short space to effect element spacing
                    #print('Key Up')
                    ser.setDTR(False)
                    time.sleep(dotlen - startup)
                    
                # Effect spacing between letters - we've already added one short space
                # so we only need 2 more to effect char spacing
                ser.setDTR(False)
                time.sleep(2*dotlen)
                self.time=time.time();

    # Set speed
    def set_wpm(self,wpm,farnsworth=None,buffered=False):

        P   = self.P
        ser = P.ser
        
        if wpm>0:
            print("CW_KEYER->SET_WPM: Setting speed to ",wpm)
            self.WPM = wpm
            self.dotlen=1.2/self.WPM

            if P.USE_KEYER:
                print("SET_WPM: Setting NANO speed to ",wpm)
                if P.LOCK_SPEED:  
                    P.keyer_device.set_wpm(wpm,idev=3,farnsworth=farnsworth,buffered=buffered)
                    if P.gui:
                        if hasattr(P.gui,'PaddlingWin'):
                            P.gui.PaddlingWin.WPM_TXT.set(str(wpm))
                    else:
                        P.PaddlingWin.WPM_TXT.set(str(wpm))
                else:
                    P.keyer_device.set_wpm(wpm,farnsworth=farnsworth,buffered=buffered)
                    
            if P.gui:
                # Can't fiddle with gui here since it would cause a memoery leak
                # Tell watchdog to do it instead
                P.WPM2=wpm

    def txt2morse(self,msg):
        print('\nTXT2MORSE: msg=',msg,len(msg))
        tdown=0
        times=[]
        dotlen_ms = int(1000*self.dotlen)

        for char in msg.upper():
            i=ord(char)
            if i>32 and i<128:
                cw=morse[i]
                for el in cw:
                    times.append(tdown)
                    if( el=='.' ):
                        tdown+=2*dotlen_ms            # Element plus space between elements
                    elif( el=='-' ):
                        tdown+=4*dotlen_ms

                tdown+=2*dotlen_ms                    # Space between letters = 3 dits

            else:
                tdown+=4*dotlen_ms                    # Space between letters = 7 dits

        #print('IDEAL TIMING:',times,'\n')
              
                    
    # Get speed
    def get_wpm(self):
        return self.WPM

    # Enable & disable TX keying
    def enable(self):
        self.enable = True

    def disable(self):
        self.enable = False

    # This was the guts of cw_server - need to make more efficent but works for now
    # Former UDP Commands for client/sever model:
    #        [RESET]   Reset to defaults
    #        [EXIT]    Exit server
    #        [WPM##]   Set WPM to ##
    #        [+#]      Increase WPM by # 
    #        [-#]      Decrease WPM by # 
    #        [TUNE##]  Key TX for ## sec.
    #        []
    def send_msg(self,msg):

        P   = self.P
        ser = P.ser
        print('CW_KEYER->SEND_MSG: ',msg,' at ',self.WPM,' wpm - evt=',
              self.evt.isSet(),'\tVIA DTR=',P.SEND_VIA_DTR,
              '\tUSE KEYER=',P.USE_KEYER)

        # Select manner we're going to key the rig
        HAS_CMD = ('[' in msg) or ('[' in msg) 
        if not HAS_CMD:

            # Send the entire message at once - there are no cmds buried in the msg
            if P.SEND_VIA_CMD:
                # Send via a hamlib command - most rigs dont support this!
                print('\tSEND_MSG: Via hamlib command - msg=',msg,'\t@ wpm=',self.WPM)
                P.sock.send_morse(msg,VERBOSITY=1)
                return

            elif P.SEND_VIA_DTR:
                # Send by toggling DTR - need to do more work
                pass
            
            elif P.USE_KEYER:
                # Send via external keyer & let it do all the hard work - most common pathway
                print('\tSEND_MSG: Via keyer - msg=',msg,'\t@ wpm=',self.WPM,'\tevt set')
                P.keyer_device.nano_write(msg)
                self.evt.set()           # Signal to other processes that we've sent the message
                return

        # If we get here, the mesage has a keyer command and/or we are keying the rig by toggling DTR
        # Either way, we have to do the heavy lifting ...
        self.stop   = False
        txt2=''
        for ch in msg:
            #print('\tch=',ch,flush=True)

            self.stop = self.stop or P.Stopper.isSet()
            if self.stop:
                self.stop   = False
                print('SEND_MSG: Aborting msg ...')
                break
            
            # Check for any UDP commands - they are encapsolated by []
            if ch=='[':
                # Start of a Udp command
                self.Udp=True
                self.Cmd=[]

            elif ch==']':
                
                # End of a Udp command
                self.Udp=False
                cmd2=''.join(self.Cmd)
                cmd2=cmd2.upper()
                print("cmd2=",cmd2)   # ,'\t',cmd2[:4])

                # Execute the command
                if cmd2[0]=='~':
                    # Direct command for the nano io
                    cmd2=''.join(self.Cmd)
                    print('Nano Cmd:',cmd2)
                    self.send_cw(''.join(self.Cmd))

                    # Allow the response to be echoed in process_chars
                    P.NANO_ECHO=True

                elif cmd2=="RESET":
                    # Reset defaults & reopen comm port
                    print("Reseting WPM to ",self.DEFAULT_WPM," wpm ...")
                    self.set_wpm(self.DEFAULT_WPM)

                    print("Reseting serial port ...")
                    P.ser = serial.Serial(ser.PORT,ser.BAUD,timeout=0.1)
                    P.ser.setDTR(False)

                #elif cmd2=="EXIT":
                    # Exit server
                    #print "Exiting server ..."
                    #sys.exit(0)

                elif cmd2[:3]=="WPM":
                    # Set speed
                    self.set_wpm( int(cmd2[3:]) )

                elif cmd2[:3]=="QSY":
                    # Change freq
                    df = float( cmd2[3:] )
                    frq = .001*P.sock.freq + df
                    print('SEND_MSG - QSY - DF=',df,P.sock.freq,frq)
                    P.sock.freq = P.sock.set_freq(frq)

                elif cmd2[:3]=="LOG":
                    # log the qso
                    print('SEND_MSG: Logging - evt2 set ...',flush=True)
                    self.evt2.set()
                    P.gui.log_qso()
                    print('SEND_MSG: ... Done Logging',flush=True)

                elif cmd2=="SERIAL":
                    # Substitute SERIAL NUMBER OUT
                    MY_CNTR=cut_numbers(P.MY_CNTR)
                    self.send_cw(MY_CNTR)
                    txt2+=MY_CNTR

                elif cmd2=="MYNAME":
                    # Substitute my name
                    self.send_cw(MY_NAME)
                    txt2+=MY_NAME

                elif cmd2=="MYSKCC":
                    # Substitute my skcc no.
                    self.send_cw(MY_SKCC)
                    txt2+=MY_SKCC

                elif cmd2=="MYQTH":
                    # Substitute my name
                    self.send_cw(MY_QTH)
                    txt2+=MY_QTH

                elif cmd2=="MYSEC":
                    # Substitute my name
                    self.send_cw(MY_SEC)
                    txt2+=MY_SEC

                elif cmd2=="MYCALL":
                    # Substitute my call
                    self.send_cw(MY_CALL)
                    txt2+=MY_CALL

                elif cmd2=="MYSTATE":
                    # Substitute my state
                    self.send_cw(MY_STATE)
                    txt2+=MY_STATE

                elif cmd2=="MYCOUNTY":
                    # Substitute my county
                    self.send_cw(MY_COUNTY)
                    txt2+=MY_COUNTY

                elif cmd2=="MYGRID":
                    # Substitute my state
                    self.send_cw(MY_GRID[0:4])
                    txt2+=MY_GRID[0:4]

                elif cmd2=="MYPREC":
                    # Substitute my precicence
                    self.send_cw(MY_PREC)
                    txt2+=MY_PREC

                elif cmd2=="MYCHECK":
                    # Substitute my check
                    self.send_cw(MY_CHECK)
                    txt2+=MY_CHECK

                elif cmd2=="MYCQZ":
                    # Substitute my check
                    self.send_cw(MYCQZ)
                    txt2+=MYCQZ

                elif cmd2=="CALL":
                    # Substitute his call
                    #print '@@@@@@@@@@@@@@@@@@@@@ CALL @@@@@@@@@@@@@@@@@@@@'
                    txt=P.gui.get_call()
                    #print txt
                    self.send_cw(txt)
                    txt2+=txt

                elif cmd2=="NAME":
                    # Substitute his name
                    #print '@@@@@@@@@@@@@@@@@@@@@ NAME @@@@@@@@@@@@@@@@@@@@'
                    txt=P.gui.get_name()
                    #print txt
                    self.send_cw(txt)
                    txt2+=txt

                elif cmd2=="RST":
                    # Substitute outgoing rst
                    #print '@@@@@@@@@@@@@@@@@@@@@ RST @@@@@@@@@@@@@@@@@@@@'
                    txt=P.gui.get_rst()
                    #print txt
                    self.send_cw(txt)
                    txt2+=txt

                elif cmd2[:4]=="TUNE":
                    # Key TX
                    #                print "Len=",len(cmd)
                    if len(cmd2)>4:
                        SEC=int(cmd2[4:])
                        print("Keying TX for ",SEC)
                        #pwr=read_tx_pwr(self)
                        P.sock.set_power(5)
                        if P.USE_KEYER:
                            P.keyer_device.tune(True)
                            time.sleep(SEC)
                            P.keyer_device.tune(False)
                        else:
                            ser.setDTR(True)
                            time.sleep(SEC)
                            ser.setDTR(False)
                        P.sock.set_power(99)
                    elif self.KEY_DOWN:
                        if P.USE_KEYER:
                            P.keyer_device.tune(False)
                        else:
                            ser.setDTR(False)
                        self.KEY_DOWN=False
                        print('TUNE - key up')
                        P.sock.set_power(99)
                    else:
                        #pwr=read_tx_pwr(self)
                        P.sock.set_power(5)
                        if P.USE_KEYER:
                            P.keyer_device.tune(True)
                        else:
                            ser.setDTR(True)
                        self.KEY_DOWN=True
                        print('TUNE - key down')

                elif cmd2[0]=="+":
                    # Increase speed
                    dWPM = int(cmd2[1:])
                    self.set_wpm( self.WPM + dWPM ,buffered=True)
                    print("Increaing speed by",dWPM," to",self.WPM)

                elif cmd2[0]=="-":
                    # Decrease speed
                    dWPM = int(cmd2[1:])
                    self.set_wpm( self.WPM - dWPM ,buffered=True)
                    print("Decreaing speed by",dWPM," to",self.WPM)

                else:
                    print("\n*** SEND_MSG: WARNING - Unknown command -",cmd2,'\n')
                    #sys.exit(1)

            else:
                if self.Udp:
                    # Collecting a command
                    self.Cmd.append(ch)

                else:
                    # Nothing special - key tranmitter
                    print("\tSending ",ch)
                    self.send_cw(""+ch)
                    txt2+=ch

        # Signal to other processes that we've went the message
        print('SEND_MSG: Setting evt...',flush=True)
        self.evt.set()
        if P.DIGI and len(txt2.strip())>0:
            print('SEND_MSG: sending txt2=',txt2,'to fldigi ... len=',len(txt2.strip()))
            P.sock_xml.put_tx_buff( chr(10)+txt2+chr(10)+"^r" )        # Pad with LineFeeds and go back into rx mode after we send it
            P.sock_xml.ptt(1)                                     # Start TX
        
        return txt2


############################################################################################

# CW UDP server - runs in another thread
def cw_server(P,HOST='',PORT=7388):
    print('Starting cw server - ',HOST,PORT,'\n')
    keyer=P.keyer
    
    # Open udp socket
    try :
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.settimeout(1)           # Need a timeout so we can interrupt/terminate it
        print('Socket created')
    except socket.error as msg :
        print('Failed to create socket. Error Code : ' + str(msg[0]) + ' Message ' + msg[1])
        sys.exit(1)
 
    # Bind socket to local host and port
    try:
        s.bind((HOST, PORT))
        print('Socket bound',HOST,PORT)
    except socket.error as msg:
        print('CW_SERVER: Bind failed with Error Code ',msg[0],'-',msg[1])
        print(HOST,PORT)        
        sys.exit(1)

    # Keep talking with the client
    #while True:
    while not P.Stopper.isSet():

        # Receive data from client (data, addr)
        try:
            #print 'CW_SERVER ...'
            d = s.recvfrom(1024)
            data = d[0]
            addr = d[1]
     
            if data: 
                print('Message[' + addr[0] + ':' + str(addr[1]) + '] - ' + data)
                keyer.send_msg(data)
            else:
                print('CW_SERVER: blah - never should have got here!')
                sys.exit(1)

        except socket.error as msg:
            # print "msg=",msg
            pass

    print('CW_SERVER Done.')
    

    
# CW UDP server - old, depricated
class CW_Server_OLD(threading.Thread):
    
    def __init__(self,keyer,HOST='',PORT=7388):
        self.keyer=keyer
    
        print('Starting CW server - ',HOST,PORT)
    
        # Open udp socket
        try :
            self.s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            self.s.settimeout(1)           # Need a timeout so we can interrupt/terminate it
            print('Socket created')
        except socket.error as msg :
            print('Failed to create socket. Error Code : ' + str(msg[0]) + ' Message ' + msg[1])
            sys.exit(1)
 
        # Bind socket to local host and port
        try:
            self.s.bind((HOST, PORT))
            print('Socket bound')
        except socket.error as msg:
            print('Bind failed. Error Code : ' + str(msg[0]) + ' Message ' + msg[1])
            sys.exit(1)

        # Start the server
        threading.Thread.__init__(self)
        self.start()                           # This apparently calls self.run ?!

    # The server listener runs in another thread
    def run(self):
        #print "Heydo!"
     
        # Keep talking with the client
        self.Done = False
        while not(self.Done):

            # Receive data from client (data, addr)
            try:
                d = self.s.recvfrom(1024)
                data = d[0]
                addr = d[1]
     
                if data: 
                    print('Message[' + addr[0] + ':' + str(addr[1]) + '] - ' + data)
                    self.keyer.send_msg(data)
                else:
                    print('CW_Server: blah - never should have got here!')
                    sys.exit(1)

            except socket.error as msg:
                # print "msg=",msg
                pass

        # That's all folks - terminate
        print("Server done.")
        #sys.exit(1)