"1":"spot_server",

"2":"wsjtx_udp",

"3":"pydecoder_udp",

"""

receive udp packet from my ft8-deocder

each message format is : 150430 -6 1.1 2724 ~ CQ BD4QA OM91

Identify each station is send a line before any message : Start Decode

"""

try:

mSocket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

mSocket.bind(("",5556))

except Exception as e:

logging.error("bind 5556 error {}".format(e))

else :

logging.debug("Listening for Plante UDP ({}) log on port {}. CTRL-C to break.".format(my_thread, "5556"))

try:

while True:

if my_thread not in SERVER_RUN :

logging.info("Restart pydecoder_udp thread by %s" % SERVER_RUN)

return

fileContent, (remoteHost, remotePort) = mSocket.recvfrom(10240)

DecoderStation = ("{}:{}:UDP".format(remoteHost, remotePort))

for i in fileContent.decode("utf-8").split("\n") :

if len(i) > 0:

decode_2(i, DecoderStation)

except Exception as e :

if Station not in DecoderArray :

DecoderArray.update({Station : ""} )

logging.debug("New Station %s" % Station)

try:

if msg[:11] == "<parameters" :

msg = adif_spot(msg)

elif msg[:12] == "Start Decode" :

msg = msg.upper()

if DecoderArray[Station].split("@")[0] != msg.replace("START DECODE ", "") :

DecoderArray[Station] = msg.replace("START DECODE ", "") + "@" + datetime.datetime.now().strftime('%Y/%m/%d-%H:%M:%S')

for station in list(DecoderArray.keys()) :

if DecoderArray[station].split("@")[0] == msg.replace("START DECODE ", "") :

if station != Station :

del DecoderArray[station]

elif msg[:16] == "Redpitaya Decode" :

msg = msg.upper()

if DecoderArray[Station].split("@")[0] != msg.replace("REDPITAYA DECODE ", "") :

DecoderArray[Station] = msg.replace("REDPITAYA DECODE ", "") + "@" + datetime.datetime.now().strftime('%Y/%m/%d-%H:%M:%S')

for i in list(DecoderArray.keys()) :

if DecoderArray[i].split("@")[0] == msg.replace("REDPITAYA DECODE ", "") :

if i != Station :

del DecoderArray[i]

elif msg[:10] == "End Decode" :

return

else :

if DecoderArray[Station].split("@")[0][0:2] == "0-" :

rp_freq = msg[30:38]

msg = (msg.replace(rp_freq + " ", "") + " ")[0:51]

broadcast(msg + DecoderArray[Station].split("@")[0].replace("0-", rp_freq + "-") + '\n')

else :

broadcast(msg[:51] + DecoderArray[Station].split("@")[0] + '\n')

except :

logging.error("UDP packet error (%s) : %s" % (DecoderArray[Station],msg))

adif_data = {}

resutl = ""

"""

#https://github.com/ctjacobs/pyqso/blob/master/pyqso/adif.py

#https://n1mmwp.hamdocs.com/appendices/external-udp-broadcasts/

p1 = re.compile("(\<parameters\:[0-9]*\>)")

adif_text = re.sub(p1, "", adif_text)

p2 = re.compile("<(.*?):(\d*).*?>([^<]+)")

for item in p2.findall(adif_text) :

adif_data[item[0]]=item[2][:int(item[1])]

try:

Spot = adif_data['STATION_CALLSIGN'].upper() + ":" + " "

Freq = " " + str(float(adif_data['Freq'])*1000) + " "

Call = adif_data['Call'].upper() + " "

Note = adif_data['NOTES'] + " "

Time = adif_data['TIME_ON'][:4] + "Z "

Mode = adif_data['Mode'].upper() + " "

result = 'DX de ' + Spot[:10] + Freq[:-9] + Call[:10] + Note[:31] + Time[:6] + Mode[:5]

except :

result = ""

print("adif data error %s" % adif_data)

"""

"""

receive message from JTDX or WSJTX program UDP packet

"""

try:

mSocket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

mSocket.bind(("",5555))

except Exception as e:

logging.error("bind 5555 error {}".format(e))

logging.debug("Listening for WSTJ-X UDP ({}) log on port {}. CTRL-C to break.".format(my_thread, "5555"))

while True:

if my_thread not in SERVER_RUN:

logging.info("Restart wsjtx_udp thread by %s" % SERVER_RUN)

return

fileContent, (remoteHost, remotePort) = mSocket.recvfrom(1024)

DecoderStation = ("{}:{}:JTDX".format(remoteHost, remotePort))

try:

# logging.info("{} send UDP '{}'".format(remoteHost, fileContent))

NewPacket = WSJTXClass.WSJTX_Packet(fileContent, 0)

NewPacket.Decode()

if NewPacket.PacketType == 0:

HeartbeatPacket = WSJTXClass.WSJTX_Heartbeat(fileContent, NewPacket.index)

HeartbeatPacket.Decode()

dataDecode = ("{} {} {}".format(HeartbeatPacket.MaximumSchema, HeartbeatPacket.Version ,HeartbeatPacket.Revision))

try:

logging.debug("Heartbeat : {} @ {}".format(dataDecode, DecoderArray[DecoderStation]))

except :

logging.debug("Heartbeat : {} @ ".format(dataDecode))

elif NewPacket.PacketType == 1:

StatusPacket = WSJTXClass.WSJTX_Status(fileContent, NewPacket.index)

StatusPacket.Decode()

dataDecode = ("{:08}-{}-{}".format(StatusPacket.Frequency, StatusPacket.Mode, StatusPacket.DECall))

#StatusPacket.Decoding

if DecoderStation not in DecoderArray :

DecoderArray.update({DecoderStation : ""} )

logging.debug("New Station %s" % DecoderStation)

if StatusPacket.Decoding and DecoderArray[DecoderStation].split("@")[0] != dataDecode:

DecoderArray[DecoderStation] = dataDecode + "@" + datetime.datetime.now().strftime('%Y/%m/%d-%H:%M:%S')

for station in list(DecoderArray.keys()) :

if DecoderArray[station].split("@")[0] == dataDecode :

if station != DecoderStation :

del DecoderArray[station]

logging.debug("Status : {} {} @ {}".format(dataDecode, StatusPacket.Decoding, DecoderArray[DecoderStation]))

# broadcast("Status : {} {} @ {}\n".format(dataDecode, StatusPacket.Decoding, DecoderArray[DecoderStation]))

elif NewPacket.PacketType == 2:

DecodePacket = WSJTXClass.WSJTX_Decode(fileContent, NewPacket.index)

DecodePacket.Decode()

# can use PyQt4.QtCore.QTime for this as well!

s = int( (DecodePacket.Time/1000) % 60 )

m = int( ((DecodePacket.Time/(1000*60) ) %60 ) )

h = int( ((DecodePacket.Time/(1000*60*60)) %24))

pkmsg = (DecodePacket.Message + ' ')[:26]

dataDecode = ("{:02}:{:02}:{:02} {:>3} {:4.1f} {:>4} {} {}".format(h,m,s,DecodePacket.snr,DecodePacket.DeltaTime,DecodePacket.DeltaFrequency,DecodePacket.Mode,pkmsg))

try :

logging.debug("Decode : {} @ {}".format(dataDecode, DecoderArray[DecoderStation]))

except :

logging.info("Decode : {} @".format(dataDecode))

# self.DecodeCount += 1

# now we need to send it to the UI

try:

msg = dataDecode + DecoderArray[DecoderStation].split("@")[0] + '\n'

except :

msg = dataDecode + ' @ ' + DecoderStation + '\n'

broadcast(msg)

elif NewPacket.PacketType == 3:

logging.debug("PacketType = 3")

elif NewPacket.PacketType == 5:

LoggedPacket = WSJTXClass.WSJTX_Logged(fileContent, NewPacket.index)

LoggedPacket.Decode()

logging.debug("LoggedPacket : {}".format(LoggedPacket))

except :

"""

Create a telnet server with a port, address, a function to call with new connections

and one to call with lost connections.

"""

telnet_server = TelnetServer(

port=7300,

address='',

on_connect=on_connect,

on_disconnect=on_disconnect,

timeout = .05

)

logging.debug("Listening for SPOT ({}) connections on port {}. CTRL-C to break.".format(my_thread, telnet_server.port))

while 1:

if my_thread not in SERVER_RUN :

logging.info("Restart spot_server thread by %s" % SERVER_RUN)

return

telnet_server.poll()

kick_idle()

"""

Sample on_connect function.

Handles new connections.

"""

logging.info("Opened connection to {}".format(client.addrport()))

#broadcast("{} joins the conversation.\n".format(client.addrport()))

CLIENT_LIST.append(client)

"""

Sample on_disconnect function.

Handles lost connections.

"""

logging.info("Lost connection to {}".format(client.addrport()))

CLIENT_LIST.remove(client)

#broadcast("{} leaves the conversation.\n".format(client.addrport()))

"""

Check each client, if client.cmd_ready == True then there is a line of

input available via client.get_command().

"""

for client in CLIENT_LIST:

if client.active :

# If the client sends input echo it to the chat room

if client.callsign == "" :

client.send("Please input your Callsign :\n")

client.callsign = "-"

elif client.filter == "" and client.callsign != "-" :

client.send("Please select band(Mhz) to monitor , example : fe=14\n")

client.filter = "-"

if client.cmd_ready :

"""

Echo whatever client types to everyone.

"""

msg = client.get_command()

if msg is not None :

msg = msg.upper().replace(" ", "")

logging.info("{} says '{}'".format(client.addrport(), msg))

if len(msg.split())>0 :

command = msg.split("=")

if command[0] == "HELP" or command[0] == "?":

send_msg = "sa=ba7ib : filter only msg from station ba7ib\n"

send_msg += "fe=14 : filter only band is 14MHz\n"

send_msg += "ca=y : filter only callsign begin with y\n"

send_msg += "mo=ft8 : filter only mode is ft8\n"

send_msg += "cq : only cq call will display\n"

send_msg += "ck : check your filter\n"

send_msg += "nf : clear all filter\n"

send_msg += "nc : toggle color True/False\n"

send_msg += "stations : list all register report station\n"

send_msg += "clients : list all listen clients\n"

send_msg += "bye : disconnect\n"

client.send(colorize("^w" + send_msg))

elif command[0] in ['SA', 'FE', 'CA', "MO", "CQ", "DI"] :

if client.filter == "-" :

client.filter = msg.replace(" ", "")

else :

client.filter = client.filter + ", " + msg.replace(" ", "")

client.send(colorize("^w your filter is : {}\n".format( client.filter )))

elif command[0] == "NF" :

client.filter = ""

client.send(colorize("^wNo filters\n"))

elif command[0] == "NC" :

client.color = not client.color

client.send(colorize("^wSet Colorful %s\n" % client.color))

elif command[0] == "CK" :

client.send(colorize("^w{} filter is : {}\n".format( client.callsign, client.filter )))

elif command[0] == 'BYE': # bye = disconnect

client.active = False

elif command[0] == "THREADS" : # check threading status

send_msg = "Telnet Server Thread List :\n"

for i in threads :

send_msg += service[threads[i]] + "(" + threads[i] + ") is : " + str(i.isAlive()) + '\n'

client.send(colorize("^w" + send_msg))

elif command[0] == 'SHUTDONW': # shutdown == stop the server

if command[1] == ADMIN_PWD.upper() :

SERVER_RUN.append("STOP")

else :

client.send(colorize("^wAdmin Password Error\n".format(SERVER_RUN)))

elif command[0] == 'RESTART' : # restart == restart thread

if command[1] == ADMIN_PWD.upper() :

for i in command[2].split(",") :

if i in SERVER_RUN:

SERVER_RUN.remove(i)

client.send(colorize("^wwait 60s for {}\n".format(SERVER_RUN)))

else :

client.send(colorize("^wAdmin Password Error\n".format(SERVER_RUN)))

elif command[0] == 'CLIENTS' : # clients == list all clients

i = 0

send_msg = ""

for guest in CLIENT_LIST :

send_msg += "{} from {} filter {} ({}s)\n".format(guest.callsign, guest.addrport(), guest.filter, int(guest.duration()))

i += 1

send_msg += "Total clints : {}\n".format(i)

client.send(colorize("^w" + send_msg))

elif command[0] == 'KILL' : # kill == kick out client

if command[1] == ADMIN_PWD.upper() :

try:

for guest in CLIENT_LIST :

if guest.addrport() == command[2] :

guest.active = False

client.send("\n")

break

except :

logging.error("kickout command error %s" % msg)

else :

client.send(colorize("^wAdmin Password Error\n".format(SERVER_RUN)))

elif command[0] == 'STATIONS' : # stations == list all report stations

for station in list(DecoderArray.keys()) :

client.send(colorize("^w{} : {}\n".format(station, DecoderArray[station])))

if DecoderArray[station].strip() == "" :

del DecoderArray[station]

elif client.callsign == "" or client.callsign == "-" :

CallSign_reg = r'([A-Z]{1,2}|[0-9][A-Z])([0-9])([A-Z]{1,3})'

try:

if re.match(CallSign_reg, command[0] , re.I).span()[0] == 0 :

logging.info("{} logon the server".format(command[0]))

client.callsign = command[0]

client.send(colorize("^wWellcome {} logon @ {}\n".format(command[0], client.addrport())))

except :

client.send(colorize("^wCallsign Error. Please input again\n"))

else :

client.send(colorize("^wunknow command, try 'help' for all command\n"))

"""

for guest in CLIENT_LIST:

if guest != client:

#guest.send("{} says '{}'\n".format(client.addrport(), msg))

client.active = True

else:

guest.send("You say '{}'\n".format(msg))

"""

Looks for idle clients and disconnects them by setting active to False.

"""

# Who hasn't been typing?

for client in CLIENT_LIST:

if client.idle() > IDLE_TIMEOUT and client.callsign == "-" :

logging.info("Kicking idle lobby client from {}".format(client.addrport()))

"""

Send msg to every client.

"""

colorful = ("^r", "^g", "^y", "^b", "^m", "^c", "^w")

detail_msg = msg.split()

msg_color=""

grid = detail_msg[-2]

DIS = 0

if re.match(r'^[a-z]{2}[0-9]{2}$', grid , re.I) and grid != "RR73" :

DIS = calu_dis(grid)

if detail_msg[5] == "CQ" :

msg_color = "^G"

if DIS > 7 :

msg_color = "^R"

elif DIS > 3 and DIS <= 7 :

msg_color = "^Y"

else :

char_sum = 0

for i in "-".join(detail_msg[-1].split("-")[2:]) :

char_sum += ord(i)

msg_color = colorful[int(char_sum % 7)]

for client in CLIENT_LIST:

if client.callsign != "" and client.callsign != "-" and client.filter != "" and client.filter != "-" :

sended = True

if len(client.filter) > 0 :

if client.filter.find("=*") == -1 :

for detail in client.filter.split(", ") :

filter = detail.split("=")

if filter[0] == "SA" :

if "-".join(detail_msg[-1].split("-")[2:]) != filter[1] :

sended = False

elif filter[0] == "FE" :

if detail_msg[-1].split("-")[0][0:2] != ("0" + filter[1])[-2:] :

sended = False

elif filter[0] == "CQ" :

if detail_msg[5] != "CQ" :

sended = False

elif filter[0] == "CA" :

if " ".join(detail_msg[5:-1]).find(filter[1]) == -1 :

sended = False

elif filter[0] == "MO" :

if detail_msg[-1].split("-")[1] != filter[1] :

sended = False

elif filter[0] == "DI" :

if DIS < int(filter[1]) :

sended = False

if not sended :

break

if sended :

if len(detail_msg[0]) == 6 :

if client.last_send != detail_msg[1] :

client.send(" .-.-. .-.-. .-.-.\n")

client.last_send = detail_msg[1]

else :

if client.last_send != detail_msg[0] :

client.send(" .-.-. .-.-. .-.-.\n")

client.last_send = detail_msg[0]

if client.color :

client.send(colorize(msg_color + msg))

else :