class Period(object): """Period. Statistics on the period of observations received from the base station. As complete observation sets are received, their time of reception is compared with the prior set''s time of reception. This measurement provides a proxy for link quality as incomplete or missing sets will increase the period. Long periods can cause momentary RTK solution outages. Parameters ---------- avg : int Average period pmin : int Minimum period pmax : int Maximum period current : int Smoothed estimate of the current period """ _parser = construct.Embedded( construct.Struct( 'avg' / construct.Int32sl, 'pmin' / construct.Int32sl, 'pmax' / construct.Int32sl, 'current' / construct.Int32sl, )) __slots__ = [ 'avg', 'pmin', 'pmax', 'current', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.avg = kwargs.pop('avg') self.pmin = kwargs.pop('pmin') self.pmax = kwargs.pop('pmax') self.current = kwargs.pop('current') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = Period._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return Period.build(d)
class Latency(object): """Latency. Statistics on the latency of observations received from the base station. As observation packets are received their GPS time is compared to the current GPS time calculated locally by the receiver to give a precise measurement of the end-to-end communication latency in the system. Parameters ---------- avg : int Average latency lmin : int Minimum latency lmax : int Maximum latency current : int Smoothed estimate of the current latency """ _parser = construct.Embedded( construct.Struct( 'avg' / construct.Int32sl, 'lmin' / construct.Int32sl, 'lmax' / construct.Int32sl, 'current' / construct.Int32sl, )) __slots__ = [ 'avg', 'lmin', 'lmax', 'current', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.avg = kwargs.pop('avg') self.lmin = kwargs.pop('lmin') self.lmax = kwargs.pop('lmax') self.current = kwargs.pop('current') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = Latency._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return Latency.build(d)
class GPSTime(object): """GPSTime. A wire-appropriate receiver clock time, defined as the time since the beginning of the week on the Saturday/Sunday transition. In most cases, observations are epoch aligned so ns field will be 0. Parameters ---------- tow : int Milliseconds since start of GPS week ns_residual : int Nanosecond residual of millisecond-rounded TOW (ranges from -500000 to 500000) wn : int GPS week number """ _parser = construct.Embedded( construct.Struct( 'tow' / construct.Int32ul, 'ns_residual' / construct.Int32sl, 'wn' / construct.Int16ul, )) __slots__ = [ 'tow', 'ns_residual', 'wn', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.tow = kwargs.pop('tow') self.ns_residual = kwargs.pop('ns_residual') self.wn = kwargs.pop('wn') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = GPSTime._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return GPSTime.build(d)
class GnssSignalDep(object): """GnssSignalDep. Deprecated. Parameters ---------- sat : int Constellation-specific satellite identifier. Note: unlike GnssSignal, GPS satellites are encoded as (PRN - 1). Other constellations do not have this offset. code : int Signal constellation, band and code reserved : int Reserved """ _parser = construct.Embedded( construct.Struct( 'sat' / construct.Int16ul, 'code' / construct.Int8ul, 'reserved' / construct.Int8ul, )) __slots__ = [ 'sat', 'code', 'reserved', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.sat = kwargs.pop('sat') self.code = kwargs.pop('code') self.reserved = kwargs.pop('reserved') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = GnssSignalDep._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return GnssSignalDep.build(d)
class GridElement(object): """GridElement. Contains one tropo delay (mean and stddev), plus STEC residuals (mean and stddev) for each satellite at the grid point. Parameters ---------- index : int Index of the grid point tropo_delay_correction : TroposphericDelayCorrection Wet and hydrostatic vertical delays (mean, stddev) stec_residuals : array STEC residuals for each satellite (mean, stddev) """ _parser = construct.Embedded( construct.Struct( 'index' / construct.Int16ul, 'tropo_delay_correction' / construct.Struct(TroposphericDelayCorrection._parser), construct.GreedyRange('stec_residuals' / construct.Struct(STECResidual._parser)), )) __slots__ = [ 'index', 'tropo_delay_correction', 'stec_residuals', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.index = kwargs.pop('index') self.tropo_delay_correction = kwargs.pop('tropo_delay_correction') self.stec_residuals = kwargs.pop('stec_residuals') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = GridElement._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return GridElement.build(d)
class STECSatElement(object): """STECSatElement. STEC polynomial for the given satellite. Parameters ---------- sv_id : SvId Unique space vehicle identifier stec_quality_indicator : int Quality of the STEC data. Encoded following RTCM DF389 specifcation but in units of TECU instead of m. stec_coeff : array Coefficents of the STEC polynomial in the order of C00, C01, C10, C11 """ _parser = construct.Embedded( construct.Struct( 'sv_id' / construct.Struct(SvId._parser), 'stec_quality_indicator' / construct.Int8ul, 'stec_coeff' / construct.Array(4, construct.Int16sl), )) __slots__ = [ 'sv_id', 'stec_quality_indicator', 'stec_coeff', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.sv_id = kwargs.pop('sv_id') self.stec_quality_indicator = kwargs.pop('stec_quality_indicator') self.stec_coeff = kwargs.pop('stec_coeff') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = STECSatElement._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return STECSatElement.build(d)
class TrackingChannelState(object): """TrackingChannelState. Tracking channel state for a specific satellite signal and measured signal power. Parameters ---------- sid : GnssSignal GNSS signal being tracked fcn : int Frequency channel number (GLONASS only) cn0 : int Carrier-to-Noise density. Zero implies invalid cn0. """ _parser = construct.Embedded( construct.Struct( 'sid' / construct.Struct(GnssSignal._parser), 'fcn' / construct.Int8ul, 'cn0' / construct.Int8ul, )) __slots__ = [ 'sid', 'fcn', 'cn0', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.sid = kwargs.pop('sid') self.fcn = kwargs.pop('fcn') self.cn0 = kwargs.pop('cn0') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = TrackingChannelState._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return TrackingChannelState.build(d)
class TroposphericDelayCorrection(object): """TroposphericDelayCorrection. Troposphere vertical delays (mean and standard deviation) at the grid point. Parameters ---------- hydro : int Hydrostatic vertical delay wet : int Wet vertical delay stddev : int stddev """ _parser = construct.Embedded( construct.Struct( 'hydro' / construct.Int16sl, 'wet' / construct.Int8sl, 'stddev' / construct.Int8ul, )) __slots__ = [ 'hydro', 'wet', 'stddev', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.hydro = kwargs.pop('hydro') self.wet = kwargs.pop('wet') self.stddev = kwargs.pop('stddev') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = TroposphericDelayCorrection._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return TroposphericDelayCorrection.build(d)
class STECResidual(object): """STECResidual. STEC residual (mean and standard deviation) for the given satellite at the grid point, Parameters ---------- sv_id : SvId space vehicle identifier residual : int STEC residual stddev : int stddev """ _parser = construct.Embedded( construct.Struct( 'sv_id' / construct.Struct(SvId._parser), 'residual' / construct.Int16sl, 'stddev' / construct.Int8ul, )) __slots__ = [ 'sv_id', 'residual', 'stddev', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.sv_id = kwargs.pop('sv_id') self.residual = kwargs.pop('residual') self.stddev = kwargs.pop('stddev') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = STECResidual._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return STECResidual.build(d)
class SubSystemReport(object): """SubSystemReport. Report the general and specific state of a sub-system. If the generic state is reported as initializing, the specific state should be ignored. Parameters ---------- component : int Identity of reporting subsystem generic : int Generic form status report specific : int Subsystem specific status code """ _parser = construct.Embedded( construct.Struct( 'component' / construct.Int16ul, 'generic' / construct.Int8ul, 'specific' / construct.Int8ul, )) __slots__ = [ 'component', 'generic', 'specific', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.component = kwargs.pop('component') self.generic = kwargs.pop('generic') self.specific = kwargs.pop('specific') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = SubSystemReport._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return SubSystemReport.build(d)
class SolutionInputType(object): """SolutionInputType. Metadata describing which sensors were involved in the solution. The structure is fixed no matter what the actual sensor type is. The sensor_type field tells you which sensor we are talking about. It also tells you whether the sensor data was actually used or not. The flags field, always a u8, contains the sensor-specific data. The content of flags, for each sensor type, is described in the relevant structures in this section. Parameters ---------- sensor_type : int The type of sensor flags : int Refer to each InputType description """ _parser = construct.Embedded( construct.Struct( 'sensor_type' / construct.Int8ul, 'flags' / construct.Int8ul, )) __slots__ = [ 'sensor_type', 'flags', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.sensor_type = kwargs.pop('sensor_type') self.flags = kwargs.pop('flags') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = SolutionInputType._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return SolutionInputType.build(d)
class TrackingChannelStateDepB(object): """TrackingChannelStateDepB. Deprecated. Parameters ---------- state : int Status of tracking channel sid : GnssSignalDep GNSS signal being tracked cn0 : float Carrier-to-noise density """ _parser = construct.Embedded( construct.Struct( 'state' / construct.Int8ul, 'sid' / construct.Struct(GnssSignalDep._parser), 'cn0' / construct.Float32l, )) __slots__ = [ 'state', 'sid', 'cn0', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.state = kwargs.pop('state') self.sid = kwargs.pop('sid') self.cn0 = kwargs.pop('cn0') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = TrackingChannelStateDepB._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return TrackingChannelStateDepB.build(d)
class MeasurementState(object): """MeasurementState. Measurement Engine tracking channel state for a specific satellite signal and measured signal power. The mesid field for Glonass can either carry the FCN as 100 + FCN where FCN is in [-7, +6] or the Slot ID (from 1 to 28) Parameters ---------- mesid : GnssSignal Measurement Engine GNSS signal being tracked (carries either Glonass FCN or SLOT) cn0 : int Carrier-to-Noise density. Zero implies invalid cn0. """ _parser = construct.Embedded( construct.Struct( 'mesid' / construct.Struct(GnssSignal._parser), 'cn0' / construct.Int8ul, )) __slots__ = [ 'mesid', 'cn0', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.mesid = kwargs.pop('mesid') self.cn0 = kwargs.pop('cn0') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = MeasurementState._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return MeasurementState.build(d)
class GnssSignal(object): """GnssSignal. Signal identifier containing constellation, band, and satellite identifier Parameters ---------- sat : int Constellation-specific satellite identifier. This field for Glonass can either be (100+FCN) where FCN is in [-7,+6] or the Slot ID in [1,28] code : int Signal constellation, band and code """ _parser = construct.Embedded( construct.Struct( 'sat' / construct.Int8ul, 'code' / construct.Int8ul, )) __slots__ = [ 'sat', 'code', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.sat = kwargs.pop('sat') self.code = kwargs.pop('code') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = GnssSignal._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return GnssSignal.build(d)
class CarrierPhase(object): """CarrierPhase. Carrier phase measurement in cycles represented as a 40-bit fixed point number with Q32.8 layout, i.e. 32-bits of whole cycles and 8-bits of fractional cycles. This phase has the same sign as the pseudorange. Parameters ---------- i : int Carrier phase whole cycles f : int Carrier phase fractional part """ _parser = construct.Embedded( construct.Struct( 'i' / construct.Int32sl, 'f' / construct.Int8ul, )) __slots__ = [ 'i', 'f', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.i = kwargs.pop('i') self.f = kwargs.pop('f') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = CarrierPhase._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return CarrierPhase.build(d)
class GPSTimeSec(object): """GPSTimeSec. A GPS time, defined as the number of seconds since beginning of the week on the Saturday/Sunday transition. Parameters ---------- tow : int Seconds since start of GPS week wn : int GPS week number """ _parser = construct.Embedded( construct.Struct( 'tow' / construct.Int32ul, 'wn' / construct.Int16ul, )) __slots__ = [ 'tow', 'wn', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.tow = kwargs.pop('tow') self.wn = kwargs.pop('wn') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = GPSTimeSec._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return GPSTimeSec.build(d)
class CodeBiasesContent(object): """CodeBiasesContent. Code biases are to be added to pseudorange. The corrections conform with typical RTCMv3 MT1059 and 1065. Parameters ---------- code : int Signal constellation, band and code value : int Code bias value """ _parser = construct.Embedded( construct.Struct( 'code' / construct.Int8ul, 'value' / construct.Int16sl, )) __slots__ = [ 'code', 'value', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.code = kwargs.pop('code') self.value = kwargs.pop('value') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = CodeBiasesContent._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return CodeBiasesContent.build(d)
class SvId(object): """SvId. A (Constellation ID, satellite ID) tuple that uniquely identifies a space vehicle Parameters ---------- satId : int ID of the space vehicle within its constellation constellation : int Constellation ID to which the SV belongs """ _parser = construct.Embedded( construct.Struct( 'satId' / construct.Int8ul, 'constellation' / construct.Int8ul, )) __slots__ = [ 'satId', 'constellation', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.satId = kwargs.pop('satId') self.constellation = kwargs.pop('constellation') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = SvId._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return SvId.build(d)
class TrackingChannelCorrelation(object): """TrackingChannelCorrelation. Structure containing in-phase and quadrature correlation components. Parameters ---------- I : int In-phase correlation Q : int Quadrature correlation """ _parser = construct.Embedded( construct.Struct( 'I' / construct.Int32sl, 'Q' / construct.Int32sl, )) __slots__ = [ 'I', 'Q', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.I = kwargs.pop('I') self.Q = kwargs.pop('Q') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = TrackingChannelCorrelation._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return TrackingChannelCorrelation.build(d)
class OdoInputType(object): """OdoInputType. Metadata around the Odometry sensors involved in the fuzed solution. Accessible through sol_in[N].flags in a MSG_SOLN_META. Parameters ---------- flags : int Instrument ODO rate, grade, and quality. """ _parser = construct.Embedded(construct.Struct('flags' / construct.Int8ul, )) __slots__ = [ 'flags', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.flags = kwargs.pop('flags') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = OdoInputType._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return OdoInputType.build(d)
class GNSSInputType(object): """GNSSInputType. Metadata around the GNSS sensors involved in the fuzed solution. Accessible through sol_in[N].flags in a MSG_SOLN_META. Parameters ---------- flags : int flags that store all relevant info specific to this sensor type. """ _parser = construct.Embedded(construct.Struct('flags' / construct.Int8ul, )) __slots__ = [ 'flags', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.flags = kwargs.pop('flags') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = GNSSInputType._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return GNSSInputType.build(d)
"cam_multiplier_limit" / construct.Int16ub, construct.Padding(2) ) header_cmd2 = construct.Struct( 'JDN_base' / construct.Int16ul, construct.Padding(2), 'seconds' / construct.Int32ul ) header = construct.Struct( 'packet_type' / construct.Int16ul, 'cmd_id' / construct.Int16ul, 'payload_size' / construct.Int16ul, 'seq_id' / construct.Int16ul, construct.Embedded( construct.Switch(lambda ctx: ctx.cmd_id, { 0: construct.If( lambda ctx: ctx.payload_size >= header_cmd0.sizeof(), header_cmd0), 1: construct.If( lambda ctx: ctx.payload_size == header_cmd1.sizeof(), header_cmd1), 2: construct.If( lambda ctx: ctx.payload_size == header_cmd2.sizeof(), header_cmd2) }, default=construct.Pass ) ) )
class PhaseBiasesContent(object): """PhaseBiasesContent. Phase biases are to be added to carrier phase measurements. The corrections conform with typical RTCMv3 MT1059 and 1065. Parameters ---------- code : int Signal constellation, band and code integer_indicator : int Indicator for integer property widelane_integer_indicator : int Indicator for two groups of Wide-Lane(s) integer property discontinuity_counter : int Signal phase discontinuity counter. Increased for every discontinuity in phase. bias : int Phase bias for specified signal """ _parser = construct.Embedded( construct.Struct( 'code' / construct.Int8ul, 'integer_indicator' / construct.Int8ul, 'widelane_integer_indicator' / construct.Int8ul, 'discontinuity_counter' / construct.Int8ul, 'bias' / construct.Int32sl, )) __slots__ = [ 'code', 'integer_indicator', 'widelane_integer_indicator', 'discontinuity_counter', 'bias', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.code = kwargs.pop('code') self.integer_indicator = kwargs.pop('integer_indicator') self.widelane_integer_indicator = kwargs.pop( 'widelane_integer_indicator') self.discontinuity_counter = kwargs.pop('discontinuity_counter') self.bias = kwargs.pop('bias') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = PhaseBiasesContent._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return PhaseBiasesContent.build(d)
class GridDefinitionHeader(object): """GridDefinitionHeader. Defines the grid for MSG_SSR_GRIDDED_CORRECTION messages. Also includes an RLE encoded validity list. Parameters ---------- region_size_inverse : int region_size (deg) = 10 / region_size_inverse 0 is an invalid value. area_width : int grid height (deg) = grid idth (deg) = area_width / region_size 0 is an invalid value. lat_nw_corner_enc : int North-West corner latitdue (deg) = region_size * lat_nw_corner_enc - 90 lon_nw_corner_enc : int North-West corner longtitude (deg) = region_size * lon_nw_corner_enc - 180 num_msgs : int Number of messages in the dataset seq_num : int Postion of this message in the dataset """ _parser = construct.Embedded( construct.Struct( 'region_size_inverse' / construct.Int8ul, 'area_width' / construct.Int16ul, 'lat_nw_corner_enc' / construct.Int16ul, 'lon_nw_corner_enc' / construct.Int16ul, 'num_msgs' / construct.Int8ul, 'seq_num' / construct.Int8ul, )) __slots__ = [ 'region_size_inverse', 'area_width', 'lat_nw_corner_enc', 'lon_nw_corner_enc', 'num_msgs', 'seq_num', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.region_size_inverse = kwargs.pop('region_size_inverse') self.area_width = kwargs.pop('area_width') self.lat_nw_corner_enc = kwargs.pop('lat_nw_corner_enc') self.lon_nw_corner_enc = kwargs.pop('lon_nw_corner_enc') self.num_msgs = kwargs.pop('num_msgs') self.seq_num = kwargs.pop('seq_num') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = GridDefinitionHeader._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return GridDefinitionHeader.build(d)
Tauth = construct.Struct( "size" / SizeField, "type" / construct.Const(MessageType.Tauth.value, TypeField), "tag" / TagField, "afid" / FidField, "uname" / StringField, "aname" / StringField ) # size[4] Rauth tag[2] aqid[13] Rauth = construct.Struct( "size" / SizeField, "type" / construct.Const(MessageType.Rauth.value, TypeField), "tag" / TagField, "aqid" / construct.Embedded( QidField ) ) # size[4] Rerror tag[2] ename[s] Rerror = construct.Struct( "size" / SizeField, "type" / construct.Const(MessageType.Rerror.value, TypeField), "tag" / TagField, "ename" / StringField * "error name" ) * "error response" # size[4] Tflush tag[2] oldtag[2] Tflush = construct.Struct( "size" / SizeField, "type" / construct.Const(MessageType.Tflush.value, TypeField),
class AcqSvProfile(object): """AcqSvProfile. Profile for a specific SV for debugging purposes The message describes SV profile during acquisition time. The message is used to debug and measure the performance. Parameters ---------- job_type : int SV search job type (deep, fallback, etc) status : int Acquisition status 1 is Success, 0 is Failure cn0 : int CN0 value. Only valid if status is '1' int_time : int Acquisition integration time sid : GnssSignal GNSS signal for which acquisition was attempted bin_width : int Acq frequency bin width timestamp : int Timestamp of the job complete event time_spent : int Time spent to search for sid.code cf_min : int Doppler range lowest frequency cf_max : int Doppler range highest frequency cf : int Doppler value of detected peak. Only valid if status is '1' cp : int Codephase of detected peak. Only valid if status is '1' """ _parser = construct.Embedded( construct.Struct( 'job_type' / construct.Int8ul, 'status' / construct.Int8ul, 'cn0' / construct.Int16ul, 'int_time' / construct.Int8ul, 'sid' / construct.Struct(GnssSignal._parser), 'bin_width' / construct.Int16ul, 'timestamp' / construct.Int32ul, 'time_spent' / construct.Int32ul, 'cf_min' / construct.Int32sl, 'cf_max' / construct.Int32sl, 'cf' / construct.Int32sl, 'cp' / construct.Int32ul, )) __slots__ = [ 'job_type', 'status', 'cn0', 'int_time', 'sid', 'bin_width', 'timestamp', 'time_spent', 'cf_min', 'cf_max', 'cf', 'cp', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.job_type = kwargs.pop('job_type') self.status = kwargs.pop('status') self.cn0 = kwargs.pop('cn0') self.int_time = kwargs.pop('int_time') self.sid = kwargs.pop('sid') self.bin_width = kwargs.pop('bin_width') self.timestamp = kwargs.pop('timestamp') self.time_spent = kwargs.pop('time_spent') self.cf_min = kwargs.pop('cf_min') self.cf_max = kwargs.pop('cf_max') self.cf = kwargs.pop('cf') self.cp = kwargs.pop('cp') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = AcqSvProfile._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return AcqSvProfile.build(d)
class GriddedCorrectionHeader(object): """GriddedCorrectionHeader. The 3GPP message contains nested variable length arrays which are not suppported in SBP, so each grid point will be identified by the index. Parameters ---------- time : GPSTimeSec GNSS reference time of the correction num_msgs : int Number of messages in the dataset seq_num : int Position of this message in the dataset update_interval : int Update interval between consecutive corrections. Encoded following RTCM DF391 specification. iod_atmo : int IOD of the SSR atmospheric correction tropo_quality_indicator : int Quality of the troposphere data. Encoded following RTCM DF389 specifcation in units of m. """ _parser = construct.Embedded( construct.Struct( 'time' / construct.Struct(GPSTimeSec._parser), 'num_msgs' / construct.Int16ul, 'seq_num' / construct.Int16ul, 'update_interval' / construct.Int8ul, 'iod_atmo' / construct.Int8ul, 'tropo_quality_indicator' / construct.Int8ul, )) __slots__ = [ 'time', 'num_msgs', 'seq_num', 'update_interval', 'iod_atmo', 'tropo_quality_indicator', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.time = kwargs.pop('time') self.num_msgs = kwargs.pop('num_msgs') self.seq_num = kwargs.pop('seq_num') self.update_interval = kwargs.pop('update_interval') self.iod_atmo = kwargs.pop('iod_atmo') self.tropo_quality_indicator = kwargs.pop( 'tropo_quality_indicator') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = GriddedCorrectionHeader._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return GriddedCorrectionHeader.build(d)
class STECHeader(object): """STECHeader. A full set of STEC information will likely span multiple SBP messages, since SBP message a limited to 255 bytes. The header is used to tie multiple SBP messages into a sequence. Parameters ---------- time : GPSTimeSec GNSS reference time of the correction num_msgs : int Number of messages in the dataset seq_num : int Position of this message in the dataset update_interval : int Update interval between consecutive corrections. Encoded following RTCM DF391 specification. iod_atmo : int IOD of the SSR atmospheric correction """ _parser = construct.Embedded( construct.Struct( 'time' / construct.Struct(GPSTimeSec._parser), 'num_msgs' / construct.Int8ul, 'seq_num' / construct.Int8ul, 'update_interval' / construct.Int8ul, 'iod_atmo' / construct.Int8ul, )) __slots__ = [ 'time', 'num_msgs', 'seq_num', 'update_interval', 'iod_atmo', ] def __init__(self, payload=None, **kwargs): if payload: self.from_binary(payload) else: self.time = kwargs.pop('time') self.num_msgs = kwargs.pop('num_msgs') self.seq_num = kwargs.pop('seq_num') self.update_interval = kwargs.pop('update_interval') self.iod_atmo = kwargs.pop('iod_atmo') def __repr__(self): return fmt_repr(self) def from_binary(self, d): p = STECHeader._parser.parse(d) for n in self.__class__.__slots__: setattr(self, n, getattr(p, n)) def to_binary(self): d = dict([(k, getattr(obj, k)) for k in self.__slots__]) return STECHeader.build(d)
class Game: command_id = namedtuple("packet_type", ("register", "error", "update", "start", "state"))( register=0, error=1, update=2, start=3, state=4) players_struct = construct.Struct("x" / construct.Int16ul, "y" / construct.Int16ul, "score" / construct.Int8ul, "active" / construct.Int8ul) command_state = construct.Struct( "puck_x" / construct.Int16ul, "puck_y" / construct.Int16ul, "players" / construct.Array(4, players_struct)) command_update = construct.Struct("x" / construct.Int16ul, "y" / construct.Int16ul) command_register = construct.Struct("id" / construct.String(36)) command = construct.Struct( "type" / construct.Int8ul, construct.Embedded( construct.Switch(lambda ctx: ctx.type, { command_id.update: command_update, command_id.register: command_register, command_id.state: command_state, }, default=construct.Pass))) def __init__(self): self.sockets = [] self.redis = rredis.from_url(os.environ.get("REDIS_URL")) def add_state_socket(self, ws): sock = ClientSocket(ws) data = sock.receive() if data: data = self.command.parse(data) if data and data.type == self.command_id.register: sock.set_id(data.id) self.sockets.append(sock) else: sock.close() def update(self): while True: games = ast.literal_eval(self.redis.get("games")) self.update_games(games) # Send states for ws in list(self.sockets): # Clear inactive sockets if ws.is_closed(): for game in list(games): for player in range(0, len(game["players"])): if game["players"][player]["id"] == ws.get_id(): game["players"][player]["id"] = None game["players"][player]["active"] = 0 if self.active_players(game["players"]) == 0: games.remove(game) self.sockets.remove(ws) continue # Send state for game in games: for player in game["players"]: if player["id"] == ws.get_id(): ws.send(self.build_state_packet(game), True) self.redis.set("games", games) gevent.sleep(0.05) @staticmethod def update_games(games): if len(games): games[0]["puck"]["x"] += 1 def start(self): self.redis.set("games", []) gevent.spawn(self.update) def add_request_socket(self, ws): sock = ClientSocket(ws) while not sock.is_closed(): data = sock.receive() if not data: sock.close() return data = self.command.parse(data) # Register if data and data.type == self.command_id.register and sock.get_id( ) is None: client_id = self.get_new_client_id() sock.set_id(client_id) if client_id: sock.send( self.command.build( dict(type=self.command_id.register, id=client_id)), True) else: sock.send( self.command.build(dict(type=self.command_id.error)), True) # Position Update elif data.type == self.command_id.update: self.update_player_position(sock.client_id, data.x, data.y) def get_new_client_id(self): games = ast.literal_eval(self.redis.get("games")) new_player_id = str(uuid.uuid4()) # Make sure the id is unique for game in games: for player in game["players"]: if player["id"] == new_player_id: return self.get_new_client_id() # Find an open game found_game = False for game in games: if self.active_players(game["players"]) < 4: found_game = True # Add player to game for player in range(0, len(game["players"])): if game["players"][player]["active"] == 0: game["players"][player]["id"] = new_player_id game["players"][player]["active"] = 1 break # Check if game can start if self.active_players(game["players"]) == 4: for player in game["players"]: for sock in self.sockets: if sock.get_id() == player["id"]: sock.send( self.command.build( dict(type=self.command_id.start)), True) # Create game if an open one was not found if not found_game: game = {"players": [], "puck": {"x": 0, "y": 0}} for player_num in range(0, 4): game["players"].append({ "id": None, "x": 0, "y": 0, "score": 0, "active": 0 }) game["players"][0]["id"] = new_player_id game["players"][0]["active"] = 1 games.append(game) self.redis.set("games", games) return new_player_id def build_state_packet(self, game): state = dict(type=self.command_id.state, puck_x=game["puck"]["x"], puck_y=game["puck"]["y"], players=game["players"]) return self.command.build(state) def update_player_position(self, client_id, x, y): games = ast.literal_eval(self.redis.get("games")) for game in games: for player in game["players"]: if player["id"] == client_id: player["x"] = x player["y"] = y self.redis.set("games", games) @staticmethod def active_players(players): count = 0 for player in players: if player["active"] == 1: count += 1 return count
construct.Embedded( construct.Switch( 'block', lambda ctx: ctx.block_start, { 0x3B: construct.Struct( # workaround for Pass not working 'terminator', construct.Value('terminator', lambda ctx: 'terminator'), ), 0x2C: _image_block, 0x21: construct.Struct( 'ext', construct.ULInt8('ext_label'), construct.Embedded( construct.Switch( 'extension', lambda ctx: ctx.ext_label, { 0xFF: _application_extension, 0xFE: _comment_extension, 0xF9: _gce_extension, }, default=_unknown_extension, ), ), ), }, ), ),