TYPE_CHECKING,
Union,
)
+from types import SimpleNamespace
__all__ = (
"Stream",
"class_by_prefix",
+ "enframe",
"inline_response",
+ "proto_handled",
"parse_message",
"probe_buffer",
- "proto_by_name",
"proto_name",
"DecodeError",
"Respond",
self.imei: Optional[str] = None
self.datalen: int = 0
- @staticmethod
- def enframe(buffer: bytes, imei: Optional[str] = None) -> bytes:
- assert imei is not None and len(imei) == 10
- return f"[LT*{imei:10s}*{len(buffer):04X}*".encode() + buffer + b"]"
-
def recv(self, segment: bytes) -> List[Union[bytes, str]]:
"""
Process next segment of the stream. Return successfully deframed
)
self.buffer = self.buffer[toskip:]
# From this point, buffer starts with a packet header
- if self.imei is not None and self.imei != imei:
+ if self.imei is None:
+ self.imei = imei
+ if self.imei != imei:
msgs.append(
f"Packet's imei {imei} mismatches"
- f" previous value {self.imei}"
+ f" previous value {self.imei}, old value kept"
)
- self.imei = imei
self.datalen = datalen
if len(self.buffer) < self.datalen + 21: # Incomplete packet
break
return ret
+def enframe(buffer: bytes, imei: Optional[str] = None) -> bytes:
+ assert imei is not None and len(imei) == 10
+ off, vid, _, dlen = _framestart(buffer)
+ assert off == 0
+ return f"[{vid:2s}*{imei:10s}*{dlen:04X}*".encode() + buffer[20:]
+
+
### Parser/Constructor ###
@property
def packed(self) -> bytes:
- return self.encode().encode() # first is object's, second str's
+ buffer = self.encode().encode()
+ return f"[LT*0000000000*{len(buffer):04X}*".encode() + buffer + b"]"
class UNKNOWN(BeeSurePkt):
class CONFIG(BeeSurePkt):
PROTO = "CONFIG"
- RESPOND = Respond.INL
-class UD(BeeSurePkt):
- PROTO = "UD"
+class ICCID(BeeSurePkt):
+ PROTO = "ICCID"
+
+class _LOC_DATA(BeeSurePkt):
def in_decode(self, *args: str) -> None:
- (
- _,
- self.date,
- self.time,
- self.gps_valid,
- self.lat,
- self.nors,
- self.lon,
- self.eorw,
- self.speed,
- self.direction,
- self.altitude,
- self.num_of_sats,
- self.gsm_strength_percentage,
- self.battery_percentage,
- self.pedometer,
- self.tubmling_times,
- self.device_status,
- ) = args[:17]
- rest_args = args[17:]
- self.base_stations_number = int(rest_args[0])
- self.base_stations = rest_args[1 : 4 + 3 * self.base_stations_number]
- rest_args = rest_args[3 + 3 * self.base_stations_number + 1 :]
- self.wifi_ap_number = int(rest_args[0])
- self.wifi_ap = rest_args[1 : self.wifi_ap_number]
- # rest_args = rest_args[self_wifi_ap_number+1:]
- self.positioning_accuracy = rest_args[-1]
-
-
-class UD2(BeeSurePkt):
+ p = SimpleNamespace()
+ _id = lambda x: x
+ for (obj, attr, func), val in zip(
+ (
+ (p, "verb", _id),
+ (p, "date", _id),
+ (p, "time", _id),
+ (self, "gps_valid", lambda x: x == "A"),
+ (p, "lat", float),
+ (p, "nors", lambda x: 1 if x == "N" else -1),
+ (p, "lon", float),
+ (p, "eorw", lambda x: 1 if x == "E" else -1),
+ (self, "speed", float),
+ (self, "direction", float),
+ (self, "altitude", float),
+ (self, "num_of_sats", int),
+ (self, "gsm_strength_percentage", int),
+ (self, "battery_percentage", int),
+ (self, "pedometer", int),
+ (self, "tubmling_times", int),
+ (self, "device_status", lambda x: int(x, 16)),
+ (self, "base_stations_number", int),
+ (self, "connect_base_station_number", int),
+ (self, "mcc", int),
+ (self, "mnc", int),
+ ),
+ args[:21],
+ ):
+ setattr(obj, attr, func(val)) # type: ignore
+ rest_args = args[21:]
+ # (area_id, cell_id, strength)*
+ self.base_stations = [
+ tuple(int(el) for el in rest_args[i * 3 : 3 + i * 3])
+ for i in range(self.base_stations_number)
+ ]
+ rest_args = rest_args[3 * self.base_stations_number :]
+ self.wifi_aps_number = int(rest_args[0])
+ # (SSID, MAC, strength)*
+ self.wifi_aps = [
+ (
+ rest_args[1 + i * 3],
+ rest_args[2 + i * 3],
+ int(rest_args[3 + i * 3]),
+ )
+ for i in range(self.wifi_aps_number)
+ ]
+ rest_args = rest_args[1 + 3 * self.wifi_aps_number :]
+ self.positioning_accuracy = float(rest_args[0])
+ self.devtime = (
+ datetime.strptime(
+ p.date + p.time,
+ "%d%m%y%H%M%S",
+ )
+ .replace(tzinfo=timezone.utc)
+ .astimezone(tz=timezone.utc)
+ )
+ self.latitude = p.lat * p.nors
+ self.longitude = p.lon * p.eorw
+
+
+class UD(_LOC_DATA):
+ PROTO = "UD"
+
+
+class UD2(_LOC_DATA):
PROTO = "UD2"
RESPOND = Respond.INL
-class AL(BeeSurePkt):
+class AL(_LOC_DATA):
PROTO = "AL"
RESPOND = Respond.INL
return CLASSES[proto]
+def proto_handled(proto: str) -> bool:
+ return proto.startswith(PROTO_PREFIX)
+
+
def proto_name(obj: Union[MetaPkt, BeeSurePkt]) -> str:
return PROTO_PREFIX + (
obj.__class__.__name__ if isinstance(obj, BeeSurePkt) else obj.__name__
)
-def proto_by_name(name: str) -> str:
- return PROTO_PREFIX + PROTOS.get(name, "UNKNOWN")
-
-
def proto_of_message(packet: bytes) -> str:
- return PROTO_PREFIX + packet.split(b",")[0].decode()
+ return PROTO_PREFIX + packet[20:-1].split(b",")[0].decode()
def imei_from_packet(packet: bytes) -> Optional[str]:
projects / loctrkd.git / blobdiff