python-mbee
serialstar.py
1 # Библиотека MBee-Python для работы с модулями MBee производства фирмы "Системы, модули и компоненты".
2 # "Системы модули и компоненты" ("СМК"). 2018. Москва.
3 # Распространяется свободно. Надеемся, что программные продукты, созданные
4 # с помощью данной библиотеки будут полезными, однако никакие гарантии, явные или
5 # подразумеваемые не предоставляются.
6 # The MIT License(MIT)
7 # MBee-Python Library.
8 # Copyright © 2017 Systems, modules and components. Moscow. Russia.
9 # Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
10 # documentation files(the "Software"), to deal in the Software without restriction, including without limitation
11 # the rights to use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the Software,
12 # and to permit persons to whom the Software is furnished to do so, subject to the following conditions :
13 # The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
14 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
15 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR
16 # COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
17 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
18 
19 import time
20 import binascii
21 import functools
22 from serial import Serial
23 
24 
27 class SerialStar:
28  START_BYTE = "7E"
29  ESCAPED_CHARACTER = ["7E","7D","11","13"]
30  RX_TIMEOUT = 0.5 #Таймаут чтения в секундах из последовательного порта.
31  WR_TIMEOUT = 0 #Таймаут на запись данный в последовательный порт. Если этот таймаут не определить, то начинает иногда происходить соответствующее исключение.
32  API_FRAME_TX_TIMEOUT = 0.1 #Минимальный интервал времени в секундах между двумя фреймами, посылаемыми в последовательный порт.
33  LOCAL_TX_STATUS_RETRY_COUNT = 1 #Число попыток получения API-фрейма со статусом отправки пакета в эфир.
34  LOCAL_RESPONSE_RETRY_COUNT = 1 #Число попыток получения API-фрейма с ответом на локальную команду.
35  REMOTE_RX_STATUS_RETRY_COUNT = 1 #Число попыток получения API-фрейма с подтверждением получения пакета с данными удаленным узлом.
36  GET_FRAME_RETRY_COUNT = 1 #Число попыток получения любого фрейма перед возвратом из метода run() в основной скрипт.
37  IO_SAMPLE_RX_RETRY_COUNT = 1 #Число попыток получения API-фрейма с данными о состоянии линий ввода/вывода от удаленного модуля.
38 
39  TX_STATUS_DECODE = {
40  "00": "TX_OK",
41  "01": "UNSUFFICIENT_MEMORY_FOR_PACKET",
42  "02": "INVALID_COMMAND_CODE",
43  "03": "INVALID_COMMAND_PARAMETER",
44  "04": "TX_CCA_FAILURE",
45  }
46 
47  TX_STATUS_ENCODE = {
48  "TX_OK": "00",
49  "UNSUFFICIENT_MEMORY_FOR_PACKET": "01",
50  "INVALID_COMMAND_CODE": "02",
51  "INVALID_COMMAND_PARAMETER": "03",
52  "TX_CCA_FAILURE": "04",
53  }
54 
55  PIN_ID_DECODE = {
56  "02": "L0",
57  "03": "L1",
58  "04": "L2",
59  "06": "L3",
60  "07": "L4",
61  "09": "L5",
62  "0B": "L6",
63  "0C": "L7",
64  "0D": "L8",
65  "0E": "B0",
66  "0F": "B1",
67  "10": "B2",
68  "11": "B3",
69  "12": "B4",
70  "13": "B5",
71  "18": "R9",
72  "1B": "R8",
73  "1C": "R7",
74  "1D": "R6",
75  "1E": "R5",
76  "1F": "R4",
77  "20": "R3",
78  "21": "R2",
79  "22": "R1",
80  "23": "R0"
81  }
82 
83  PIN_MODE_DECODE = {
84  "02": "ANALOG_INPUT",
85  "03": "DIGITAL_INPUT",
86  "04": "DIGITAL_OUTPUT_LOW",
87  "05": "DIGITAL_OUTPUT_HIGH",
88  "0D": "COUNTER_INPUT_1",
89  "0E": "COUNTER_INPUT_2",
90  "0F": "WAKEUP_INPUT_FALLING",
91  "10": "WAKEUP_INPUT_RISING"
92  }
93 
94  GET_SAMPLE_LENGTH = {
95  "02": 4,
96  "03": 0,
97  "04": 0,
98  "05": 0,
99  "0D": 8,
100  "0E": 8,
101  "0F": 0,
102  "10": 0
103  }
104 
105 
109  def __init__(self, port, baud):
110  self.baud = baud
111  self.port = port
112  self.ser = Serial(self.port, self.baud, timeout = self.RX_TIMEOUT, write_timeout = self.WR_TIMEOUT)
113  self.ser.reset_input_buffer()
114  self.ser.reset_output_buffer()
115  self.on_rx_81_8F_frame_callback = None
116  self.on_rx_83_frame_callback = None
117  self.on_rx_87_88_89_frame_callback = None
118  self.on_rx_8A_frame_callback = None
119  self.on_rx_8B_frame_callback = None
120  self.on_rx_8C_frame_callback = None
121  self.on_rx_97_frame_callback = None
122 
123  def add_hex2(self, hex1, hex2):
124  return hex(int(hex1, 16) + int(hex2, 16))
125 
126  def sub_hex2(self,hex1, hex2):
127  return hex(int(hex1, 16) - int(hex2, 16))
128 
129  def xor_hex(self, a, b):
130  return '%x' % (int(a, 16) ^ int(b, 16))
131 
132  def toHex(self, s):
133  lst = []
134  for ch in s:
135  hv = hex(ch).replace('0x', '')
136  if len(hv) == 1:
137  hv = '0' + hv
138  lst.append(hv)
139  return functools.reduce(lambda x, y: x + y, lst)
140 
141  def add_bytes(self,byte):
142  self.bytes.append(byte)
143 
144  def get_bytes(self):
145  return self.bytes
146 
147  def read_frame_infos(self):
148  wait = True
149  self.bytes = []
150  length = 0
151  type_hex = "00"
152  while True:
153  start_byte = self.ser.read()
154  if(start_byte == b""):
155  return {"length" : 0, "frame_type" : "00"}
156  if self.toHex(start_byte).upper() == self.START_BYTE:
157  self.bytes.append(start_byte)
158  i = 1
159  detect = False
160  while i < 3:
161  cc = self.ser.read()
162  if(cc == b""):
163  return {"length" : 0, "frame_type" : "00"}
164  self.bytes.append(cc)
165  length_hex = ""
166  if self.toHex(cc).upper() in self.ESCAPED_CHARACTER:
167  detect = True
168  continue
169  else:
170  if detect:
171  length_hex += self.xor_hex(self.toHex(cc),"20")
172  detect = False
173  else:
174  length_hex += self.toHex(cc)
175  i += 1
176  length = int(length_hex, 16)
177  type_byte = self.ser.read()
178  if(type_byte == b""):
179  return {"length" : 0, "frame_type" : "00"}
180  self.bytes.append(type_byte)
181  type_hex = self.toHex(type_byte).upper()
182  return {"length" : length , "frame_type" : type_hex}
183 
184  def read_rx_api(self, type = []):
185  while True:
186  infos = self.read_frame_infos()
187  length = infos["length"]
188  if (infos["frame_type"] == type or type == []) and length != 0:
189  while length > 0:
190  byte = self.ser.read()
191  if(byte == b""):
192  return "ERROR : received less than length bytes"
193  self.bytes.append(byte)
194  if not (self.toHex(byte).upper() in self.ESCAPED_CHARACTER):
195  length -= 1
196  return self.bytes
197  else:
198  return "ERROR : received a Wrong frame !!! "
199 
200  def filter_frame(self):
201  if self.toHex(self.bytes[0]).upper() != self.START_BYTE:
202  return "ERROR invalid Frame"
203  self.fields = [self.START_BYTE]
204  detect = False
205  for j in range(1, len(self.bytes)):
206  byte = self.toHex(self.bytes[j]).upper()
207  if byte in self.ESCAPED_CHARACTER:
208  detect = True
209  else:
210  if detect :
211  self.fields.append(self.sub_hex2(byte,"20")[2:4])
212  detect=False
213  else:
214  self.fields.append(byte)
215  return self.fields
216 
217 
222  def callback_registring(self, frame_type, function_name):
223  if frame_type == "81":
224  self.on_rx_81_frame_callback = function_name
225  elif frame_type == "83":
226  self.on_rx_83_frame_callback = function_name
227  elif frame_type == "87":
228  self.on_rx_87_frame_callback = function_name
229  elif frame_type == "88":
230  self.on_rx_88_frame_callback = function_name
231  elif frame_type == "89":
232  self.on_rx_89_frame_callback = function_name
233  elif frame_type == "8A":
234  self.on_rx_8A_frame_callback = function_name
235  elif frame_type == "8B":
236  self.on_rx_8B_frame_callback = function_name
237  elif frame_type == "8C":
238  self.on_rx_8C_frame_callback = function_name
239  elif frame_type == "8F":
240  self.on_rx_8F_frame_callback = function_name
241  elif frame_type == "97":
242  self.on_rx_97_frame_callback = function_name
243 
244  def send_local_at(self, frame_type, frame_id, at_command, at_parameter = ""):
245  if len(at_command) != 2:
246  return "Error : verify the Command AT !!!!"
247  else:
248  frame_local_at = []
249  ll = 4 + len(at_parameter) // 2
250  length = str(format(ll,"04x"))
251  frame_local_at.append(length[0:2])
252  frame_local_at.append(length[2:4])
253  frame_local_at.append(frame_type)
254  frame_local_at.append(frame_id)
255  frame_local_at.append(self.toHex(bytes(at_command.upper(), encoding = "ascii"))[0:2])
256  frame_local_at.append(self.toHex(bytes(at_command.upper(), encoding = "ascii"))[2:4])
257  if len(at_parameter) > 0:
258  for i in range(0, len(at_parameter), 2):
259  pp = at_parameter.upper()[i:i + 2]
260  frame_local_at.append(pp)
261  checksum = "00"
262  for i in range(2, len(frame_local_at)): #При подсчете контрольной суммы байты с длиной фрейма не учитываются.
263  checksum = self.add_hex2(frame_local_at[i], checksum)
264  checksum = (self.sub_hex2("FF", checksum[len(checksum) - 2 : len(checksum)])[2:4]).zfill(2)
265  frame_local_at.append(checksum)
266  frame_local_at.insert(0, self.START_BYTE) #SerialStar не поддерживает режимы с escape-символами в направлении хост->модуль, поэтому анализ на их наличие не призводится.
267  #print(frame_local_at)
268  tx_packet = binascii.unhexlify("".join(map(str, frame_local_at)))
269  self.ser.write(tx_packet)
270  time.sleep(self.API_FRAME_TX_TIMEOUT)
271 
272 
277  def send_immidiate_apply_local_at(self, frame_id, at_command, at_parameter = ""):
278  return self.send_local_at("07", frame_id, at_command, at_parameter)
279 
280 
285  def send_immidiate_apply_and_save_local_at(self, frame_id, at_command, at_parameter = ""):
286  return self.send_local_at("08", frame_id, at_command, at_parameter)
287 
288 
293  def send_queue_local_at(self, frame_id, at_command, at_parameter = ""):
294  return self.send_local_at("09", frame_id, at_command, at_parameter)
295 
296 
312  def send_tx_request(self, frame_id, destination_id, data, options = ""):
313  frame_tx_request = []
314  if options == "":
315  ll = 4 + len(data) // 2
316  else:
317  ll = 5 + len(data) // 2
318  length = str(format(ll,"04x"))
319  frame_tx_request.append(length[0:2])
320  frame_tx_request.append(length[2:4])
321  if options == "":
322  frame_tx_request.append("0F")
323  else:
324  frame_tx_request.append("10")
325  frame_tx_request.append(frame_id)
326  frame_tx_request.append(destination_id[0:2])
327  frame_tx_request.append(destination_id[2:4])
328  if options != "":
329  frame_tx_request.append(options)
330  for i in range(0, len(data), 2):
331  pp = data.upper()[i:i + 2]
332  frame_tx_request.append(pp)
333  checksum = "00"
334  for i in range(2, len(frame_tx_request)): #При подсчете контрольной суммы байты с длиной фрейма не учитываются.
335  checksum = self.add_hex2(frame_tx_request[i], checksum)
336  checksum = (self.sub_hex2("FF", checksum[len(checksum) - 2 : len(checksum)])[2:4]).zfill(2)
337  frame_tx_request.append(checksum)
338  frame_tx_request.insert(0, self.START_BYTE) #SerialStar не поддерживает режимы с escape-символами в направлении хост->модуль, поэтому анализ на их наличие не призводится.
339  tx_packet = binascii.unhexlify("".join(map(str, frame_tx_request)))
340  self.ser.write(tx_packet)
341  time.sleep(self.API_FRAME_TX_TIMEOUT)
342 
343 
359  def send_remote_at(self, frame_id, destination_id, options, at_command, at_parameter = ""):
360  if len(at_command) != 2:
361  return "Error : verify the Command AT !!!!"
362  else:
363  frame_at = []
364  ll = 7 + len(at_parameter) // 2
365  length = str(format(ll,"04x"))
366  frame_at.append(length[0:2])
367  frame_at.append(length[2:4])
368  frame_at.append("17")
369  frame_at.append(frame_id)
370  frame_at.append(destination_id[0:2])
371  frame_at.append(destination_id[2:4])
372  frame_at.append(options)
373  frame_at.append(self.toHex(bytes(at_command.upper(), encoding = "ascii"))[0:2])
374  frame_at.append(self.toHex(bytes(at_command.upper(), encoding = "ascii"))[2:4])
375  if len(at_parameter) > 0:
376  for i in range(0, len(at_parameter), 2):
377  pp = at_parameter.upper()[i:i + 2]
378  frame_at.append(pp)
379  checksum = "00"
380  for i in range(2, len(frame_at)):
381  checksum = self.add_hex2(frame_at[i], checksum)
382  checksum = (self.sub_hex2("FF", checksum[len(checksum) - 2 : len(checksum)])[2:4]).zfill(2)
383  frame_at.append(checksum)
384  frame_at.insert(0, self.START_BYTE)
385  tx_packet = binascii.unhexlify("".join(map(str, frame_at)))
386  self.ser.write(tx_packet)
387  time.sleep(self.API_FRAME_TX_TIMEOUT)
388 
389  def get_frame_common_fields(self):
390  ss = "".join(map(str, self.fields))
391  self.frame["DELIMITER"] = ss[0:2]
392  self.frame["LENGTH"] = int(ss[2:6], 16)
393  self.frame["FRAME_TYPE"] = ss[6:8]
394  return ss
395 
396 
419  def get_tx_request(self):
420  self.frame = {}
421  for i in range(0, self.LOCAL_RESPONSE_RETRY_COUNT):
422  response = self.read_rx_api("81")
423  if not "ERROR" in response:
424  self.filter_frame()
426  break
427  return self.frame
428 
429 
453  self.frame = {}
454  for i in range(0, self.LOCAL_RESPONSE_RETRY_COUNT):
455  response = self.read_rx_api("8F")
456  if not "ERROR" in response:
457  self.filter_frame()
459  break
460  return self.frame
461 
462  def export_81_8F_frame(self, ss):
463  self.frame["SOURCE_ADDRESS_DEC"] = str(int(ss[8:12], 16)).zfill(5)
464  self.frame["SOURCE_ADDRESS_HEX"] = ss[8:12]
465  self.frame["RSSI"] = int(ss[12:14], 16) - 256
466  self.frame['OPTIONS'] = ss[14:16]
467  self.frame['DATA'] = ss[16:len(ss) - 2]
468  self.frame["CHECKSUM"] = ss[len(ss) - 2 : len(ss)]
469  return self.frame
470 
471 
486  self.frame = {}
487  for i in range(0, self.LOCAL_RESPONSE_RETRY_COUNT):
488  response = self.read_rx_api("87")
489  if not "ERROR" in response:
490  self.filter_frame()
492  break
493  return self.frame
494 
495 
510  self.frame = {}
511  for i in range(0, self.LOCAL_RESPONSE_RETRY_COUNT):
512  response = self.read_rx_api("88")
513  if not "ERROR" in response:
514  self.filter_frame()
516  break
517  return self.frame
518 
519 
534  self.frame = {}
535  for i in range(0, self.LOCAL_RESPONSE_RETRY_COUNT):
536  response = self.read_rx_api("89")
537  if not "ERROR" in response:
538  self.filter_frame()
540  break
541  return self.frame
542 
543  def export_87_88_89_frame(self, ss):
544  self.frame["FRAME_ID"] = ss[8:10]
545  self.frame["AT_COMMAND"] = binascii.unhexlify(ss[10:14]).decode("ascii")
546  self.frame["STATUS"] = ss[14:16]
547  if len(ss) - 2 == 0:
548  self.frame["AT_PARAMETER_HEX"] = []
549  self.frame["AT_PARAMETER"] = []
550  else:
551  self.frame["AT_PARAMETER_HEX"] = ss[16:len(ss) - 2]
552  self.frame["AT_PARAMETER"] = binascii.unhexlify(ss[16:len(ss) - 2])
553  self.frame["CHECKSUM"] = ss[len(ss) - 2 : len(ss)]
554  return self.frame
555 
556 
567  def get_modem_status(self):
568  self.frame = {}
569  for i in range(0, self.LOCAL_RESPONSE_RETRY_COUNT):
570  response = self.read_rx_api("8A")
571  if not "ERROR" in response:
572  self.filter_frame()
574  break
575  return self.frame
576 
577  def export_8A_frame(self, ss):
578  self.frame["STATUS"] = ss[8:10]
579  self.frame["CHECKSUM"] = ss[10:12] #Этот пакет имеет фиксированную длину, поэтому контрольная сумма всегда на одном и том же месте.
580  return self.frame
581 
582 
600  self.frame = {}
601  for i in range(0, self.LOCAL_TX_STATUS_RETRY_COUNT):
602  response = self.read_rx_api("8B")
603  if not "ERROR" in response:
604  self.filter_frame()
606  break
607  return self.frame
608 
609  def export_8B_frame(self, ss):
610  self.frame["FRAME_ID"] = ss[8:10]
611  self.frame["DESTINATION_ADDRESS_DEC"] = str(int(ss[10:14], 16)).zfill(5)
612  self.frame["DESTINATION_ADDRESS_HEX"] = ss[10:14]
613  self.frame["TX_RETRY_COUNT"] = int(ss[14:16], 16)
614  self.frame["STATUS"] = ss[16:18]
615  self.frame["RESERVE"] = ss[18:20]
616  self.frame["CHECKSUM"] = ss[20:22] #Этот пакет имеет фиксированную длину, поэтому контрольная сумма всегда на одном и том же месте.
617  return self.frame
618 
619 
635  self.frame = {}
636  for i in range(0, self.REMOTE_RX_STATUS_RETRY_COUNT):
637  response = self.read_rx_api("8C")
638  if not "ERROR" in response:
639  self.filter_frame()
641  break
642  return self.frame
643 
644  def export_8C_frame(self, ss):
645  self.frame["SOURCE_ADDRESS_DEC"] = str(int(ss[8:12], 16)).zfill(5)
646  self.frame["SOURCE_ADDRESS_HEX"] = ss[8:12]
647  self.frame["RSSI"] = int(ss[12:14], 16) - 256
648  self.frame["OPTIONS"] = ss[14:16]
649  self.frame['FRAME_ID'] = ss[16:18]
650  self.frame["CHECKSUM"] = ss[18:20] #Этот пакет имеет фиксированную длину, поэтому контрольная сумма всегда на одном и том же месте.
651  return self.frame
652 
653 
670  def get_remote_at_command_response(self): #Getting remote AT-command delivery status API-frame(Frame type 0x97).
671  self.frame = {}
672  for i in range(0, self.REMOTE_RX_STATUS_RETRY_COUNT):
673  response = self.read_rx_api("97")
674  if not "ERROR" in response:
675  self.filter_frame()
677  break
678  return self.frame
679 
680  def export_97_frame(self, ss):
681  self.frame["SOURCE_ADDRESS_DEC"] = str(int(ss[8:12], 16)).zfill(5)
682  self.frame["SOURCE_ADDRESS_HEX"] = ss[8:12]
683  self.frame["RSSI"] = int(ss[12:14], 16) - 256
684  self.frame["OPTIONS"] = ss[14:16]
685  self.frame["AT_COMMAND"] = binascii.unhexlify(ss[16:20]).decode("ascii")
686  self.frame["STATUS"] = ss[20:22]
687  if len(ss) - 2 == 0:
688  self.frame["AT_PARAMETER_HEX"] = []
689  self.frame["AT_PARAMETER"] = []
690  else:
691  self.frame["AT_PARAMETER_HEX"] = ss[22:len(ss) - 2]
692  self.frame["AT_PARAMETER"] = binascii.unhexlify(ss[22:len(ss) - 2])
693  self.frame["CHECKSUM"] = ss[len(ss) - 2 : len(ss)]
694  return self.frame
695 
696 
731  def get_io_sample_rx(self):
732  self.frame = {}
733  for i in range(0, self.IO_SAMPLE_RX_RETRY_COUNT):
734  response = self.read_rx_api("83")
735  if not "ERROR" in response:
736  self.filter_frame()
738  break
739  return self.frame
740 
741  def export_83_frame(self, ss):
742  self.frame["SOURCE_ADDRESS_DEC"] = str(int(ss[8:12], 16)).zfill(5)
743  self.frame["SOURCE_ADDRESS_HEX"] = ss[8:12]
744  self.frame["RSSI"] = int(ss[12:14], 16) - 256
745  self.frame["OPTIONS"] = ss[14:16]
746  self.frame["TEMPERATURE"] = int(ss[16:18], 16)
747  self.frame["VCC"] = round(int(ss[18:20], 16) / 51, 2)
748  self.frame["DATA_HEX"] = ss[20:len(ss) - 2]
749  self.frame["DATA_PARSED"] = {}
750  self.frame["DATA_PARSED_DECODED"] = {}
751  i = 20
752  while i < len(ss) - 2:
753  pin_number = ss[i:i + 2]
754  pin_id = pin_number
755  i += 2
756  pin_mode = ss[i:i + 2]
757  pin_mode_decoded = format((int(pin_mode, 16) & 0x7F), 'X').zfill(2)
758  sample_length = self.GET_SAMPLE_LENGTH[pin_mode_decoded]
759  i += 2
760  if sample_length == 0:
761  if int(pin_mode, 16) & 0x80:
762  value = "HIGH"
763  else:
764  value = "LOW"
765  else:
766  value = ss[i:i + sample_length]
767  i += sample_length
768  self.frame["DATA_PARSED"][pin_id] = {pin_mode_decoded: value}
769  self.frame["DATA_PARSED_DECODED"][self.PIN_ID_DECODE[pin_id]] = {self.PIN_MODE_DECODE[pin_mode_decoded]: value}
770  self.frame["DATA_RAW"] = binascii.unhexlify(ss[20:len(ss) - 2])
771  self.frame["CHECKSUM"] = ss[len(ss) - 2 : len(ss)]
772  return self.frame
773 
774 
778  def run(self): #Getting API-frame from UART.
779  self.frame = {}
780  for i in range(0, self.GET_FRAME_RETRY_COUNT):
781  response = self.read_rx_api()
782  if not "ERROR" in response:
783  self.filter_frame()
784  ss = self.get_frame_common_fields()
785  if self.frame["FRAME_TYPE"] == "81" and self.on_rx_81_frame_callback:
787  elif self.frame["FRAME_TYPE"] == "83" and self.on_rx_83_frame_callback:
789  elif self.frame["FRAME_TYPE"] == "87" and self.on_rx_87_frame_callback:
791  elif self.frame["FRAME_TYPE"] == "88" and self.on_rx_88_frame_callback:
793  elif self.frame["FRAME_TYPE"] == "89" and self.on_rx_89_frame_callback:
795  elif self.frame["FRAME_TYPE"] == "8A" and self.on_rx_8A_frame_callback:
797  elif self.frame["FRAME_TYPE"] == "8B" and self.on_rx_8B_frame_callback:
799  elif self.frame["FRAME_TYPE"] == "8C" and self.on_rx_8C_frame_callback:
801  elif self.frame["FRAME_TYPE"] == "8F" and self.on_rx_8F_frame_callback:
803  elif self.frame["FRAME_TYPE"] == "97" and self.on_rx_97_frame_callback:
805  else:
806  #print(self.frame)
807  pass
808  break
809  return self.frame
810 
Класс для проектов, основанных на программном обеспечении SerialStar.
Definition: serialstar.py:27
def sub_hex2(self, hex1, hex2)
Definition: serialstar.py:126
def send_queue_local_at(self, frame_id, at_command, at_parameter="")
Отправка фрейма с локальной AT-командой с помещением параметра в очередь: API-фрейм 0x09...
Definition: serialstar.py:293
def send_local_at(self, frame_type, frame_id, at_command, at_parameter="")
Definition: serialstar.py:244
def send_remote_at(self, frame_id, destination_id, options, at_command, at_parameter="")
Отправка фрейма с AT-командой удаленному модулю: API-фрейм 0x17.
Definition: serialstar.py:359
dictionary GET_SAMPLE_LENGTH
Definition: serialstar.py:94
def run(self)
Метод, осуществляющий постоянный опрос буфера последовательного порта с целью обнаружения в нем всех ...
Definition: serialstar.py:778
def get_tx_request_without_option(self)
Получение фрейма с данными от удаленного модуля, переданными без байта опций: API-фрейм 0x8F...
Definition: serialstar.py:452
def xor_hex(self, a, b)
Definition: serialstar.py:129
def export_81_8F_frame(self, ss)
Definition: serialstar.py:462
def add_hex2(self, hex1, hex2)
Definition: serialstar.py:123
def get_frame_common_fields(self)
Definition: serialstar.py:389
def get_tx_request(self)
Получение фрейма с данными от удаленного модуля, переданными с байтом опций: API-фрейм 0x81...
Definition: serialstar.py:419
def get_immidiate_apply_local_at_response(self)
Получение фрейма, подтверждающего прием пакета с локальной AT-командой с немедленным применением изме...
Definition: serialstar.py:485
def export_8B_frame(self, ss)
Definition: serialstar.py:609
def export_8A_frame(self, ss)
Definition: serialstar.py:577
def get_queue_local_at_response(self)
Получение фрейма, подтверждающего прием пакета с локальной AT-командой и помещением параметра в очере...
Definition: serialstar.py:533
def send_tx_request(self, frame_id, destination_id, data, options="")
Отправка фрейма с данными удаленному модулю, которые должны быть переданы им в UART: API-фреймы 0x10...
Definition: serialstar.py:312
def get_io_sample_rx(self)
Получение фрейма с данными о состоянии линий ввода вывода удаленного модуля: API-фрейм 0x83...
Definition: serialstar.py:731
def callback_registring(self, frame_type, function_name)
Метод для регистрации callback-функции.
Definition: serialstar.py:222
def get_local_tx_status(self)
Получение фрейма со статусом отправки пакета, предназначенного для передачи в эфир: API-фрейм 0x8B...
Definition: serialstar.py:599
def export_97_frame(self, ss)
Definition: serialstar.py:680
def __init__(self, port, baud)
Definition: serialstar.py:109
def read_rx_api(self, type=[])
Definition: serialstar.py:184
def send_immidiate_apply_and_save_local_at(self, frame_id, at_command, at_parameter="")
Отправка фрейма с локальной AT-командой с немедленным применением и сохранением изменений в энергонез...
Definition: serialstar.py:285
def get_immidiate_apply_and_save_local_at_response(self)
Получение фрейма, подтверждающего прием пакета с локальной AT-командой с немедленным применением и со...
Definition: serialstar.py:509
def get_remote_at_command_response(self)
Получение фрейма с ответом от удаленного модуля на отправленную ему AT-команду: API-фрейм 0x97...
Definition: serialstar.py:670
def export_83_frame(self, ss)
Definition: serialstar.py:741
def export_87_88_89_frame(self, ss)
Definition: serialstar.py:543
def send_immidiate_apply_local_at(self, frame_id, at_command, at_parameter="")
Отправка фрейма с локальной AT-командой с немедленным применением изменений: API-фрейм 0x07...
Definition: serialstar.py:277
def export_8C_frame(self, ss)
Definition: serialstar.py:644
def get_remote_tx_status(self)
Получение фрейма с подтверждением доставки пакета с данными удаленному модулю: API-фрейм 0x8C...
Definition: serialstar.py:634
def get_modem_status(self)
Получение фрейма со статусом модуля, отправляемого им при рестарте: API-фрейм 0x8A.
Definition: serialstar.py:567