kopia lustrzana https://github.com/bmo/py-wsjtx
initial packet decoding / generation and simple server
rodzic
f3eebef5b4
commit
7ca130d841
|
@ -0,0 +1,12 @@
|
||||||
|
Copyright 2018 Brian Moran
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
|
||||||
|
to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||||
|
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||||
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||||
|
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||||
|
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
@ -0,0 +1,3 @@
|
||||||
|
from pywsjtx.wsjtx_packets import *
|
||||||
|
|
||||||
|
|
|
@ -0,0 +1,80 @@
|
||||||
|
# -*- coding: utf-8 -*-
|
||||||
|
|
||||||
|
class GPSException(Exception):
|
||||||
|
def __init__(self,*args):
|
||||||
|
Exception.__init__(*args)
|
||||||
|
|
||||||
|
# From K6WRU via stackexchange : see https://ham.stackexchange.com/questions/221/how-can-one-convert-from-lat-long-to-grid-square/244#244
|
||||||
|
# Convert latitude and longitude to Maidenhead grid locators.
|
||||||
|
#
|
||||||
|
# Arguments are in signed decimal latitude and longitude. For example,
|
||||||
|
# the location of my QTH Palo Alto, CA is: 37.429167, -122.138056 or
|
||||||
|
# in degrees, minutes, and seconds: 37° 24' 49" N 122° 6' 26" W
|
||||||
|
class LatLongToGridSquare(object):
|
||||||
|
upper = 'ABCDEFGHIJKLMNOPQRSTUVWX'
|
||||||
|
lower = 'abcdefghijklmnopqrstuvwx'
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def to_grid(cls,dec_lat, dec_lon):
|
||||||
|
|
||||||
|
if not (-180<=dec_lon<180):
|
||||||
|
raise GPSException('longitude must be -180<=lon<180, given %f\n'%dec_lon)
|
||||||
|
if not (-90<=dec_lat<90):
|
||||||
|
raise GPSException('latitude must be -90<=lat<90, given %f\n'%dec_lat)
|
||||||
|
|
||||||
|
adj_lat = dec_lat + 90.0
|
||||||
|
adj_lon = dec_lon + 180.0
|
||||||
|
|
||||||
|
grid_lat_sq = LatLongToGridSquare.upper[int(adj_lat/10)]
|
||||||
|
grid_lon_sq = LatLongToGridSquare.upper[int(adj_lon/20)]
|
||||||
|
|
||||||
|
grid_lat_field = str(int(adj_lat%10))
|
||||||
|
grid_lon_field = str(int((adj_lon/2)%10))
|
||||||
|
|
||||||
|
adj_lat_remainder = (adj_lat - int(adj_lat)) * 60
|
||||||
|
adj_lon_remainder = ((adj_lon) - int(adj_lon/2)*2) * 60
|
||||||
|
|
||||||
|
grid_lat_subsq = LatLongToGridSquare.lower[int(adj_lat_remainder/2.5)]
|
||||||
|
grid_lon_subsq = LatLongToGridSquare.lower[int(adj_lon_remainder/5)]
|
||||||
|
|
||||||
|
return grid_lon_sq + grid_lat_sq + grid_lon_field + grid_lat_field + grid_lon_subsq + grid_lat_subsq
|
||||||
|
|
||||||
|
# GPS sentences are encoded
|
||||||
|
@classmethod
|
||||||
|
def convert_to_degrees(cls, gps_value, direction):
|
||||||
|
if direction not in ['N','S','E','W']:
|
||||||
|
raise GPSException("Invalid direction specifier for lat/long: {}".format(direction))
|
||||||
|
|
||||||
|
dir_mult = 1
|
||||||
|
if direction in ['S','W']:
|
||||||
|
dir_mult = -1
|
||||||
|
|
||||||
|
if len(gps_value) < 3:
|
||||||
|
raise GPSException("Invalid Value for lat/long: {}".format(gps_value))
|
||||||
|
|
||||||
|
dot_posn = gps_value.index('.')
|
||||||
|
|
||||||
|
if dot_posn < 0:
|
||||||
|
raise GPSException("Invalid Format for lat/long: {}".format(gps_value))
|
||||||
|
|
||||||
|
degrees = gps_value[0:dot_posn-2]
|
||||||
|
mins = gps_value[dot_posn-2:]
|
||||||
|
|
||||||
|
f_degrees = dir_mult * (float(degrees) + (float(mins) / 60.0))
|
||||||
|
return f_degrees
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def GPGLL_to_grid(cls, GPSLLText):
|
||||||
|
# example: $GPGLL,4740.99254,N,12212.31179,W,223311.00,A,A*70\r\n
|
||||||
|
try:
|
||||||
|
components = GPSLLText.split(",")
|
||||||
|
if components[0]=='$GPGLL':
|
||||||
|
del components[0]
|
||||||
|
if components[5] != 'A':
|
||||||
|
raise GPSException("Not a valid GPS fix")
|
||||||
|
lat = LatLongToGridSquare.convert_to_degrees(components[0], components[1])
|
||||||
|
long = LatLongToGridSquare.convert_to_degrees(components[2], components [3])
|
||||||
|
grid = LatLongToGridSquare.to_grid(lat, long)
|
||||||
|
except GPSException:
|
||||||
|
grid = ""
|
||||||
|
return grid
|
|
@ -0,0 +1,51 @@
|
||||||
|
#
|
||||||
|
# In WSJTX parlance, the 'network server' is a program external to the wsjtx.exe program that handles packets emitted by wsjtx
|
||||||
|
#
|
||||||
|
# TODO: handle multicast groups.
|
||||||
|
#
|
||||||
|
# see dump_wsjtx_packets.py example for some simple usage
|
||||||
|
#
|
||||||
|
import socket
|
||||||
|
import struct
|
||||||
|
import pywsjtx
|
||||||
|
import logging
|
||||||
|
|
||||||
|
class SimpleServer(object):
|
||||||
|
logger = logging.getLogger()
|
||||||
|
MAX_BUFFER_SIZE = pywsjtx.GenericWSJTXPacket.MAXIMUM_NETWORK_MESSAGE_SIZE
|
||||||
|
DEFAULT_UDP_PORT = 2237
|
||||||
|
#
|
||||||
|
# note that '' and '127.0.0.1' behave differently. On Windows, try '' instead of 127.0.0.1 if you're not receiving any packets.
|
||||||
|
#
|
||||||
|
def __init__(self, ip_address='', udp_port=DEFAULT_UDP_PORT, **kwargs):
|
||||||
|
self.timeout = None
|
||||||
|
|
||||||
|
if kwargs.get("timeout") is not None:
|
||||||
|
self.timeout = kwargs.get("timeout")
|
||||||
|
|
||||||
|
self.sock = socket.socket(socket.AF_INET, # Internet
|
||||||
|
socket.SOCK_DGRAM) # UDP
|
||||||
|
|
||||||
|
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||||
|
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
|
||||||
|
|
||||||
|
if self.timeout is not None:
|
||||||
|
self.sock.settimeout(self.timeout)
|
||||||
|
|
||||||
|
self.sock.bind((ip_address, int(udp_port)))
|
||||||
|
|
||||||
|
# can through a sock.timeout exception if it's configured that way.
|
||||||
|
def rx_packet(self):
|
||||||
|
pkt, addr_port = self.sock.recvfrom(self.MAX_BUFFER_SIZE) # buffer size is 1024 bytes
|
||||||
|
return(pkt, addr_port)
|
||||||
|
|
||||||
|
def send_packet(self, addr_port, pkt):
|
||||||
|
bytes_sent = self.sock.sendto(pkt,addr_port)
|
||||||
|
self.logger.debug("send_packet: Bytes sent ",bytes_sent)
|
||||||
|
|
||||||
|
def demo_run(self):
|
||||||
|
while True:
|
||||||
|
(pkt, addr_port) = self.rx_packet()
|
||||||
|
if (pkt != None):
|
||||||
|
the_packet = pywsjtx.WSJTXPacketClassFactory.from_udp_packet(addr_port, pkt)
|
||||||
|
print(the_packet)
|
|
@ -0,0 +1,361 @@
|
||||||
|
|
||||||
|
import struct
|
||||||
|
import datetime
|
||||||
|
|
||||||
|
class PacketUtil:
|
||||||
|
@classmethod
|
||||||
|
# this hexdump brought to you by Stack Overflow
|
||||||
|
def hexdump(cls, src, length=16):
|
||||||
|
FILTER = ''.join([(len(repr(chr(x))) == 3) and chr(x) or '.' for x in range(256)])
|
||||||
|
lines = []
|
||||||
|
for c in range(0, len(src), length):
|
||||||
|
chars = src[c:c + length]
|
||||||
|
hex = ' '.join(["%02x" % x for x in chars])
|
||||||
|
printable = ''.join(["%s" % ((x <= 127 and FILTER[x]) or '.') for x in chars])
|
||||||
|
lines.append("%04x %-*s %s\n" % (c, length * 3, hex, printable))
|
||||||
|
return ''.join(lines)
|
||||||
|
|
||||||
|
# timezone tomfoolery
|
||||||
|
@classmethod
|
||||||
|
def midnight_utc(cls):
|
||||||
|
utcnow = datetime.datetime.utcnow()
|
||||||
|
utcmidnight = datetime.datetime(utcnow.year, utcnow.month, utcnow.day, 0, 0)
|
||||||
|
return utcmidnight
|
||||||
|
|
||||||
|
class PacketWriter(object):
|
||||||
|
def __init__(self ):
|
||||||
|
self.ptr_pos = 0
|
||||||
|
self.packet = bytearray()
|
||||||
|
# self.max_ptr_pos
|
||||||
|
self.write_header()
|
||||||
|
|
||||||
|
def write_header(self):
|
||||||
|
self.write_QUInt32(GenericWSJTXPacket.MAGIC_NUMBER)
|
||||||
|
self.write_QInt32(GenericWSJTXPacket.SCHEMA_VERSION)
|
||||||
|
|
||||||
|
def write_QInt8(self, val):
|
||||||
|
self.packet.extend(struct.pack('>b', val))
|
||||||
|
|
||||||
|
def write_QInt32(self, val):
|
||||||
|
self.packet.extend(struct.pack('>l',val))
|
||||||
|
|
||||||
|
def write_QUInt32(self, val):
|
||||||
|
self.packet.extend(struct.pack('>L', val))
|
||||||
|
|
||||||
|
def write_QInt64(self, val):
|
||||||
|
self.packet.extend(struct.pack('>q',val))
|
||||||
|
|
||||||
|
def write_QFloat(self, val):
|
||||||
|
self.packet.extent(struct.pack('>d', val))
|
||||||
|
|
||||||
|
def write_QString(self, str_val):
|
||||||
|
length = len(str_val)
|
||||||
|
self.write_QInt32(length)
|
||||||
|
b_values = str_val
|
||||||
|
if type(str_val) != bytes:
|
||||||
|
b_values = str_val.encode()
|
||||||
|
self.packet.extend(b_values)
|
||||||
|
|
||||||
|
class PacketReader(object):
|
||||||
|
def __init__(self, packet):
|
||||||
|
self.ptr_pos = 0
|
||||||
|
self.packet = packet
|
||||||
|
self.max_ptr_pos = len(packet)-1
|
||||||
|
self.skip_header()
|
||||||
|
|
||||||
|
def at_eof(self):
|
||||||
|
return self.ptr_pos > self.max_ptr_pos
|
||||||
|
|
||||||
|
def skip_header(self):
|
||||||
|
if self.max_ptr_pos < 8:
|
||||||
|
raise Exception('Not enough data to skip header')
|
||||||
|
self.ptr_pos = 8
|
||||||
|
|
||||||
|
def check_ptr_bound(self,field_type, length):
|
||||||
|
if self.ptr_pos + length > self.max_ptr_pos+1:
|
||||||
|
raise Exception('Not enough data to extract {}'.format(field_type))
|
||||||
|
|
||||||
|
## grab data from the packet, incrementing the ptr_pos on the basis of the data we've gleaned
|
||||||
|
def QInt32(self):
|
||||||
|
self.check_ptr_bound('QInt32', 4) # sure we could inspect that, but that is slow.
|
||||||
|
(the_int32,) = struct.unpack('>l',self.packet[self.ptr_pos:self.ptr_pos+4])
|
||||||
|
self.ptr_pos += 4
|
||||||
|
return the_int32
|
||||||
|
|
||||||
|
def QInt8(self):
|
||||||
|
self.check_ptr_bound('QInt8', 1)
|
||||||
|
(the_int8,) = struct.unpack('>b', self.packet[self.ptr_pos:self.ptr_pos+1])
|
||||||
|
self.ptr_pos += 1
|
||||||
|
return the_int8
|
||||||
|
|
||||||
|
def QInt64(self):
|
||||||
|
self.check_ptr_bound('QInt64', 8)
|
||||||
|
(the_int64,) = struct.unpack('>q', self.packet[self.ptr_pos:self.ptr_pos+8])
|
||||||
|
self.ptr_pos += 8
|
||||||
|
return the_int64
|
||||||
|
|
||||||
|
def QFloat(self):
|
||||||
|
self.check_ptr_bound('QFloat', 8)
|
||||||
|
(the_double,) = struct.unpack('>d', self.packet[self.ptr_pos:self.ptr_pos+8])
|
||||||
|
self.ptr_pos += 8
|
||||||
|
return the_double
|
||||||
|
|
||||||
|
def QString(self):
|
||||||
|
str_len = self.QInt32()
|
||||||
|
if str_len == -1:
|
||||||
|
return None
|
||||||
|
self.check_ptr_bound('QString[{}]'.format(str_len),str_len)
|
||||||
|
(str,) = struct.unpack('{}s'.format(str_len), self.packet[self.ptr_pos:self.ptr_pos + str_len])
|
||||||
|
self.ptr_pos += str_len
|
||||||
|
return str.decode('utf-8')
|
||||||
|
|
||||||
|
class GenericWSJTXPacket(object):
|
||||||
|
SCHEMA_VERSION = 2
|
||||||
|
MINIMUM_SCHEMA_SUPPORTED = 2
|
||||||
|
MAXIMUM_SCHEMA_SUPPORTED = 2
|
||||||
|
MINIMUM_NETWORK_MESSAGE_SIZE = 8
|
||||||
|
MAXIMUM_NETWORK_MESSAGE_SIZE = 2048
|
||||||
|
MAGIC_NUMBER = 0xadbccbda
|
||||||
|
SCHEMA_VERSION = 2
|
||||||
|
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
self.addr_port = addr_port
|
||||||
|
self.magic = magic
|
||||||
|
self.schema = schema
|
||||||
|
self.pkt_type = pkt_type
|
||||||
|
self.id = id
|
||||||
|
self.pkt = pkt
|
||||||
|
|
||||||
|
class InvalidPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = -1
|
||||||
|
def __init__(self, addr_port, packet, message):
|
||||||
|
self.packet = packet
|
||||||
|
self.message = message
|
||||||
|
self.addr_port = addr_port
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return 'Invalid Packet: %s from %s:%s\n%s' % (self.message, self.addr_port[0], self.addr_port[1], PacketUtil.hexdump(self.packet))
|
||||||
|
|
||||||
|
class HeartBeatPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 0
|
||||||
|
|
||||||
|
def __init__(self, addr_port: object, magic: object, schema: object, pkt_type: object, id: object, pkt: object) -> object:
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
ps = PacketReader(pkt)
|
||||||
|
the_type = ps.QInt32()
|
||||||
|
self.wsjtx_id = ps.QString()
|
||||||
|
self.max_schema = ps.QInt32()
|
||||||
|
self.version = ps.QInt8()
|
||||||
|
self.revision = ps.QInt8()
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return 'HeartBeatPacket: from {}:{}\n\twsjtx id:{}\tmax_schema:{}\tversion:{}\trevision:{}' .format(self.addr_port[0], self.addr_port[1],
|
||||||
|
self.wsjtx_id, self.max_schema, self.version, self.revision)
|
||||||
|
@classmethod
|
||||||
|
# make a heartbeat packet (a byte array) we can send to a 'client'. This should be it's own class.
|
||||||
|
def Builder(cls,wsjtx_id='pywsjtx', max_schema=2, version=1, revision=1):
|
||||||
|
# build the packet to send
|
||||||
|
pkt = PacketWriter()
|
||||||
|
pkt.write_QInt32(HeartBeatPacket.TYPE_VALUE)
|
||||||
|
pkt.write_QString(wsjtx_id)
|
||||||
|
pkt.write_QInt32(max_schema)
|
||||||
|
pkt.write_QInt32(version)
|
||||||
|
pkt.write_QInt32(revision)
|
||||||
|
return pkt.packet
|
||||||
|
|
||||||
|
class StatusPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 1
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
ps = PacketReader(pkt)
|
||||||
|
the_type = ps.QInt32()
|
||||||
|
self.wsjtx_id = ps.QString()
|
||||||
|
self.dial_frequency = ps.QInt64()
|
||||||
|
|
||||||
|
self.mode = ps.QString()
|
||||||
|
self.dx_call = ps.QString()
|
||||||
|
|
||||||
|
self.report = ps.QString()
|
||||||
|
self.tx_mode = ps.QString()
|
||||||
|
|
||||||
|
self.tx_enabled = ps.QInt8()
|
||||||
|
self.transmitting = ps.QInt8()
|
||||||
|
self.decoding = ps.QInt8()
|
||||||
|
self.rx_df = ps.QInt32()
|
||||||
|
self.tx_df = ps.QInt32()
|
||||||
|
|
||||||
|
|
||||||
|
self.de_call = ps.QString()
|
||||||
|
|
||||||
|
self.de_grid = ps.QString()
|
||||||
|
self.dx_grid = ps.QString()
|
||||||
|
|
||||||
|
self.tx_watchdog = ps.QInt8()
|
||||||
|
self.sub_mode = ps.QString()
|
||||||
|
self.fast_mode = ps.QInt8()
|
||||||
|
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
str = 'StatusPacket: from {}:{}\n\twsjtx id:{}\tde_call:{}\tde_grid:{}\n'.format(self.addr_port[0], self.addr_port[1],self.wsjtx_id,
|
||||||
|
self.de_call, self.de_grid)
|
||||||
|
str += "\tfrequency:{}\trx_df:{}\ttx_df:{}\tdx_call:{}\tdx_grid:{}\treport:{}\n".format(self.dial_frequency, self.rx_df, self.tx_df, self.dx_call, self.dx_grid, self.report)
|
||||||
|
str += "\ttransmitting:{}\t decoding:{}\ttx_enabled:{}\ttx_watchdog:{}\tsub_mode:{}\tfast_mode:{}".format(self.transmitting, self.decoding, self.tx_enabled, self.tx_watchdog,
|
||||||
|
self.sub_mode, self.fast_mode)
|
||||||
|
return str
|
||||||
|
|
||||||
|
|
||||||
|
class DecodePacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 2
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
ps = PacketReader(pkt)
|
||||||
|
the_type = ps.QInt32()
|
||||||
|
self.wsjtx_id = ps.QString()
|
||||||
|
self.new_decode = ps.QInt8()
|
||||||
|
self.millis_since_midnight = ps.QInt32()
|
||||||
|
self.time = PacketUtil.midnight_utc() + datetime.timedelta(milliseconds=self.millis_since_midnight)
|
||||||
|
self.snr = ps.QInt32()
|
||||||
|
self.delta_t = ps.QFloat()
|
||||||
|
self.delta_f = ps.QInt32()
|
||||||
|
self.mode = ps.QString()
|
||||||
|
self.message = ps.QString()
|
||||||
|
self.low_confidence = ps.QInt8()
|
||||||
|
self.off_air = ps.QInt8()
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
str = 'DecodePacket: from {}:{}\n\twsjtx id:{}\tmessage:{}\n'.format(self.addr_port[0],
|
||||||
|
self.addr_port[1],
|
||||||
|
self.wsjtx_id,
|
||||||
|
self.message)
|
||||||
|
str += "\tdelta_f:{}\tnew:{}\ttime:{}\tsnr:{}\tdelta_f:{}\tmode:{}".format(self.delta_f,
|
||||||
|
self.new_decode,
|
||||||
|
self.time,
|
||||||
|
self.snr,
|
||||||
|
self.delta_f,
|
||||||
|
self.mode)
|
||||||
|
return str
|
||||||
|
|
||||||
|
class ClearPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 3
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
class ReplyPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 4
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
class QSOLoggedPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 5
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
class ClosePacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 6
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
class ReplayPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 7
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
class HaltTxPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 8
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
class FreeTextPacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 9
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def Builder(cls,to_wsjtx_id='WSJT-X', text="", send=False):
|
||||||
|
# build the packet to send
|
||||||
|
pkt = PacketWriter()
|
||||||
|
print('To_wsjtx_id ',to_wsjtx_id,' text ',text, 'send ',send)
|
||||||
|
pkt.write_QInt32(FreeTextPacket.TYPE_VALUE)
|
||||||
|
pkt.write_QString(to_wsjtx_id)
|
||||||
|
pkt.write_QString(text)
|
||||||
|
pkt.write_QInt8(send)
|
||||||
|
return pkt.packet
|
||||||
|
|
||||||
|
class WSPRDecodePacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 10
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
class LocationChangePacket(GenericWSJTXPacket):
|
||||||
|
TYPE_VALUE = 11
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
GenericWSJTXPacket.__init__(self, addr_port, magic, schema, pkt_type, id, pkt)
|
||||||
|
# handle packet-specific stuff.
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def Builder(cls, to_wsjtx_id='WSJT-X', new_grid=""):
|
||||||
|
# build the packet to send
|
||||||
|
pkt = PacketWriter()
|
||||||
|
pkt.write_QInt32(LocationChangePacket.TYPE_VALUE)
|
||||||
|
pkt.write_QString(to_wsjtx_id)
|
||||||
|
pkt.write_QString(new_grid)
|
||||||
|
return pkt.packet
|
||||||
|
|
||||||
|
class WSJTXPacketClassFactory(GenericWSJTXPacket):
|
||||||
|
|
||||||
|
PACKET_TYPE_TO_OBJ_MAP = {
|
||||||
|
HeartBeatPacket.TYPE_VALUE: HeartBeatPacket,
|
||||||
|
StatusPacket.TYPE_VALUE: StatusPacket,
|
||||||
|
DecodePacket.TYPE_VALUE: DecodePacket,
|
||||||
|
ClearPacket.TYPE_VALUE: ClearPacket,
|
||||||
|
ReplyPacket.TYPE_VALUE: ReplyPacket,
|
||||||
|
QSOLoggedPacket.TYPE_VALUE: QSOLoggedPacket,
|
||||||
|
ClosePacket.TYPE_VALUE: ClosePacket,
|
||||||
|
ReplayPacket.TYPE_VALUE: ReplayPacket,
|
||||||
|
HaltTxPacket.TYPE_VALUE: HaltTxPacket,
|
||||||
|
FreeTextPacket.TYPE_VALUE: FreeTextPacket,
|
||||||
|
WSPRDecodePacket.TYPE_VALUE: WSPRDecodePacket
|
||||||
|
}
|
||||||
|
def __init__(self, addr_port, magic, schema, pkt_type, id, pkt):
|
||||||
|
self.addr_port = addr_port
|
||||||
|
self.magic = magic
|
||||||
|
self.schema = schema
|
||||||
|
self.pkt_type = pkt_type
|
||||||
|
self.pkt_id = id
|
||||||
|
self.pkt = pkt
|
||||||
|
|
||||||
|
def __repr__(self):
|
||||||
|
return 'WSJTXPacketFactory: from {}:{}\n{}' .format(self.addr_port[0], self.addr_port[1], PacketUtil.hexdump(self.pkt))
|
||||||
|
|
||||||
|
# Factory-like method
|
||||||
|
@classmethod
|
||||||
|
def from_udp_packet(cls, addr_port, udp_packet):
|
||||||
|
if len(udp_packet) < GenericWSJTXPacket.MINIMUM_NETWORK_MESSAGE_SIZE:
|
||||||
|
return InvalidPacket( addr_port, udp_packet, "Packet too small")
|
||||||
|
|
||||||
|
if len(udp_packet) > GenericWSJTXPacket.MAXIMUM_NETWORK_MESSAGE_SIZE:
|
||||||
|
return InvalidPacket( addr_port, udp_packet, "Packet too large")
|
||||||
|
|
||||||
|
(magic, schema, pkt_type, id_len) = struct.unpack('>LLLL', udp_packet[0:16])
|
||||||
|
|
||||||
|
if magic != GenericWSJTXPacket.MAGIC_NUMBER:
|
||||||
|
return InvalidPacket( addr_port, udp_packet, "Invalid Magic Value")
|
||||||
|
|
||||||
|
if schema < GenericWSJTXPacket.MINIMUM_SCHEMA_SUPPORTED or schema > GenericWSJTXPacket.MAXIMUM_SCHEMA_SUPPORTED:
|
||||||
|
return InvalidPacket( addr_port, udp_packet, "Unsupported schema value {}".format(schema))
|
||||||
|
klass = WSJTXPacketClassFactory.PACKET_TYPE_TO_OBJ_MAP.get(pkt_type)
|
||||||
|
|
||||||
|
if klass is None:
|
||||||
|
return InvalidPacket( addr_port, udp_packet, "Unknown packet type {}".format(pkt_type))
|
||||||
|
|
||||||
|
return klass(addr_port, magic, schema, pkt_type, id, udp_packet)
|
||||||
|
|
|
@ -0,0 +1,15 @@
|
||||||
|
|
||||||
|
#sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
|
||||||
|
import pywsjtx.extra.simple_server
|
||||||
|
|
||||||
|
s = pywsjtx.SimpleServer()
|
||||||
|
|
||||||
|
while True:
|
||||||
|
(pkt, addr_port) = s.rx_packet()
|
||||||
|
if (pkt != None):
|
||||||
|
the_packet = pywsjtx.WSJTXPacketClassFactory.from_udp_packet(addr_port, pkt)
|
||||||
|
if type(the_packet) == pywsjtx.StatusPacket:
|
||||||
|
pass
|
||||||
|
print(the_packet)
|
||||||
|
|
||||||
|
|
|
@ -0,0 +1,146 @@
|
||||||
|
# using standard NMEA sentences
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import threading
|
||||||
|
from datetime import datetime
|
||||||
|
|
||||||
|
import serial
|
||||||
|
|
||||||
|
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
|
||||||
|
import pywsjtx
|
||||||
|
import pywsjtx.extra.simple_server
|
||||||
|
import pywsjtx.extra.latlong_to_grid_square
|
||||||
|
|
||||||
|
class NMEALocation(object):
|
||||||
|
# parse the NMEA message for location into a grid square
|
||||||
|
def __init__(self, grid_changed_callback = None):
|
||||||
|
self.valid = False
|
||||||
|
self.grid = ""
|
||||||
|
self.last_fix_at = None
|
||||||
|
self.grid_changed_callback = grid_changed_callback
|
||||||
|
|
||||||
|
def handle_serial(self,text):
|
||||||
|
# should be a single line.
|
||||||
|
if text.startswith('$GPGLL'):
|
||||||
|
print('nmea sentence: ', text)
|
||||||
|
grid = pywsjtx.extra.latlong_to_grid_square.LatLongToGridSquare.GPGLL_to_grid(text)
|
||||||
|
|
||||||
|
if grid != "":
|
||||||
|
self.valid = True
|
||||||
|
self.last_fix_at = datetime.utcnow()
|
||||||
|
else:
|
||||||
|
self.valid = False
|
||||||
|
|
||||||
|
if self.grid != grid:
|
||||||
|
print("NMEA = grid mismatch old: {} new: {}".format(self.grid,grid))
|
||||||
|
self.grid = grid
|
||||||
|
if (self.grid_changed_callback):
|
||||||
|
c_thr = threading.Thread(target=self.grid_changed_callback, args=(grid,), kwargs={})
|
||||||
|
c_thr.start()
|
||||||
|
|
||||||
|
class SerialGPS(object):
|
||||||
|
|
||||||
|
def __init__(self):
|
||||||
|
# TODO arbitrate access to line_handlers[]
|
||||||
|
self.line_handlers = []
|
||||||
|
self.comm_thread = None
|
||||||
|
self.comm_device = None
|
||||||
|
self.stop_signalled = False
|
||||||
|
pass
|
||||||
|
|
||||||
|
def add_handler(self, line_handler):
|
||||||
|
if (not (line_handler is None)) and (not (line_handler in self.line_handlers)):
|
||||||
|
self.line_handlers.append(line_handler)
|
||||||
|
|
||||||
|
def open(self, comport, baud, line_handler, **serial_kwargs):
|
||||||
|
if self.comm_device is not None:
|
||||||
|
self.close()
|
||||||
|
self.stop_signalled = False
|
||||||
|
self.comm_device = serial.Serial(comport, baud, **serial_kwargs)
|
||||||
|
if self.comm_device is not None:
|
||||||
|
self.add_handler(line_handler)
|
||||||
|
self.comm_thread = threading.Thread(target=self.serial_worker, args=())
|
||||||
|
self.comm_thread.start()
|
||||||
|
|
||||||
|
def close(self):
|
||||||
|
self.stop_signalled = True
|
||||||
|
self.comm_thread.join()
|
||||||
|
|
||||||
|
self.comm_device.close()
|
||||||
|
self.line_handlers = []
|
||||||
|
self.comm_device = None
|
||||||
|
self.stop_signalled = False
|
||||||
|
|
||||||
|
def remove_handler(self, line_handler):
|
||||||
|
self.line_handlers.remove(line_handler)
|
||||||
|
|
||||||
|
def serial_worker(self):
|
||||||
|
while (True):
|
||||||
|
if self.stop_signalled:
|
||||||
|
return # terminate
|
||||||
|
line = self.comm_device.readline()
|
||||||
|
# dispatch the line
|
||||||
|
if line.startswith(b'$'):
|
||||||
|
str_line = line.decode("utf-8")
|
||||||
|
for p in self.line_handlers:
|
||||||
|
p(str_line)
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def example_line_handler(cls, text):
|
||||||
|
print('serial: ',text)
|
||||||
|
|
||||||
|
# set up the serial_gps to run
|
||||||
|
# get location data from the GPS, update the grid
|
||||||
|
# get the grid out of the status message from the WSJT-X instance
|
||||||
|
|
||||||
|
# if we have a grid, and it's not the same as GPS, then make it the same by sending the message.
|
||||||
|
# But only do that if triggered by a status message.
|
||||||
|
|
||||||
|
# rinse and repeat -- wait for a status message. Once we have a status message, see if
|
||||||
|
|
||||||
|
wsjtx_id = None
|
||||||
|
nmea_p = None
|
||||||
|
gps_grid = ""
|
||||||
|
|
||||||
|
def example_callback(new_grid):
|
||||||
|
global gps_grid
|
||||||
|
print("New Grid! {}".format(new_grid))
|
||||||
|
# this sets the
|
||||||
|
gps_grid = new_grid
|
||||||
|
|
||||||
|
sgps = SerialGPS()
|
||||||
|
|
||||||
|
s = pywsjtx.extra.simple_server.SimpleServer()
|
||||||
|
|
||||||
|
print("Starting wsjt-x message server")
|
||||||
|
|
||||||
|
while True:
|
||||||
|
|
||||||
|
(pkt, addr_port) = s.rx_packet()
|
||||||
|
if (pkt != None):
|
||||||
|
the_packet = pywsjtx.WSJTXPacketClassFactory.from_udp_packet(addr_port, pkt)
|
||||||
|
if wsjtx_id is None and (type(the_packet) == pywsjtx.HeartBeatPacket):
|
||||||
|
# we have an instance of WSJTX
|
||||||
|
print("wsjtx detected, id is {}".format(the_packet.wsjtx_id))
|
||||||
|
print("starting gps monitoring")
|
||||||
|
wsjtx_id = the_packet.wsjtx_id
|
||||||
|
# start up the GPS reader
|
||||||
|
nmea_p = NMEALocation(example_callback)
|
||||||
|
sgps.open('COM8', 9600, nmea_p.handle_serial, timeout=1.0)
|
||||||
|
|
||||||
|
if type(the_packet) == pywsjtx.StatusPacket:
|
||||||
|
if gps_grid != "" and the_packet.de_grid != gps_grid:
|
||||||
|
print("Sending Grid Change to wsjtx-x, old grid:{} new grid: {}".format(the_packet.de_grid, gps_grid))
|
||||||
|
grid_change_packet = pywsjtx.LocationChangePacket.Builder(wsjtx_id, "GRID:"+gps_grid)
|
||||||
|
print(pywsjtx.PacketUtil.hexdump(grid_change_packet))
|
||||||
|
s.send_packet(the_packet.addr_port, grid_change_packet)
|
||||||
|
# for fun, change the TX5 message to our grid square, so we don't have to call CQ again
|
||||||
|
# this only works if the length of the free text message is less than 13 characters.
|
||||||
|
# if len(the_packet.de_call <= 5):
|
||||||
|
# free_text_packet = pywsjtx.FreeTextPacket.Builder(wsjtx_id,"73 {} {}".format(the_packet.de_call, the_packet[0:4]),False)
|
||||||
|
# s.send_packet(addr_port, free_text_packet)
|
||||||
|
|
||||||
|
print(the_packet)
|
||||||
|
|
||||||
|
|
||||||
|
|
Ładowanie…
Reference in New Issue