class RFID:
def __init__(self,
rx=15,
tx=2,
freq=1,
new_tag_cmd=None,
tag_removed_cmd=None):
self.uart = UART(1, tx=tx, rx=rx, baudrate=115200)
self.uart.init()
self.uart.write(b'\xAB\xBA\x00\x10\x00\x10')
#self.uart.read()#clear buffer
self.uart.flush()
self.uart.any()
self.new_tag_cmd = new_tag_cmd
self.tag_removed_cmd = tag_removed_cmd
self.current_id = b''
self.waittime = max(.2, 1 / freq)
self.uart.callback(UART.CBTYPE_PATTERN,
self.uart_cb,
pattern=b'\xcd\xdc')
loop = asyncio.get_event_loop()
loop.create_task(self.mainloop())
def uart_cb(self, response):
#print('[RFID] {}'.format(' '.join('{:02x}'.format(x) for x in bytearray(response[2]))))
response = bytearray(response[2])
if response[:2] == b'\x00\x81':
id = response[2:-1]
if id != self.current_id:
log.info('new card "{}"'.format(' '.join('{:02x}'.format(x)
for x in id)))
self.current_id = id
if self.new_tag_cmd is not None:
self.new_tag_cmd(id)
elif self.current_id:
log.info('card "{}" removed'.format(' '.join(
'{:02x}'.format(x) for x in self.current_id)))
if self.tag_removed_cmd is not None:
self.tag_removed_cmd(self.current_id)
self.current_id = b''
async def mainloop(self):
while True:
self.uart.write(b'\xAB\xBA\x00\x10\x00\x10')
await asyncio.sleep(self.waittime - .1)
class wavecom:
def __init__(self):
print("init WaveCom Device")
self._responce = ''
self._f_read_data_from_server = False # Флаг чтения данных с сервера
self._f_resp_ok = False # Флаг успешного запросса
self._f_device_ok = False # Флаг успешного подключения к модему
self._f_err_no_connect_gprs = False
self._f_err_no_connect_module = False
self.cb_exec_server_data = None
self.cmd_AT = {
'cmd': "AT\r\n",
'cmd_resp': 'OK',
'time_out': 1000,
'delay': 0,
'skip': 0
}
self.cmd_CONNECT = {
'cmd': "AT\r\n",
'cmd_resp': 'OK',
'time_out': 1,
'delay': 0,
'skip': 0
}
self.cmd_START_IP_STACK = {
'cmd': "AT+WIPCFG=1\r\n",
'cmd_resp': 'OK',
'time_out': 3000,
'delay': 0,
'skip': 0
}
self.cmd_STOP_IP_STACK = {
'cmd': "AT+WIPCFG=0\r\n",
'cmd_resp': 'OK',
'time_out': 3000,
'delay': 0,
'skip': 0
}
self.cmd_OPEN_GPRS_BR = {
'cmd': "AT+WIPBR=1,6\r\n",
'cmd_resp': 'OK',
'time_out': 3000,
'delay': 0,
'skip': 0
}
self.cmd_APN_GPRS_BR = {
'cmd': 'AT+WIPBR=2,6,11,"internet"\r\n',
'cmd_resp': 'OK',
'time_out': 3000,
'delay': 0,
'skip': 0
}
self.cmd_START_GPRS_BR = {
'cmd': 'AT+WIPBR=4,6,0\r\n',
'cmd_resp': 'OK',
'time_out': 6000,
'delay': 0,
'skip': 0
}
self.cmd_STOP_GPRS_BR = {
'cmd': 'AT+WIPBR=5,6\r\n',
'cmd_resp': 'OKK',
'time_out': 6000,
'delay': 0,
'skip': 0
}
self.cmd_CLOSE_GPRS_BR = {
'cmd': 'AT+WIPBR=0,6\r\n',
'cmd_resp': 'OKK',
'time_out': 6000,
'delay': 0,
'skip': 0
}
self.cmd_CREATE_TCP_CLIENT = {
'cmd': 'AT+WIPCREATE=2,1,"185.41.186.74",2021\r\n',
'cmd_resp': 'OK',
'time_out': 6000,
'delay': 0,
'skip': 0
}
self.cmd_READ_DATA = {
'cmd': 'AT+WIPDATA=2,1,1\r\n',
'cmd_resp': 'CONNECT',
'time_out': 6000,
'delay': 0,
'skip': 0
}
self.cmd_STOP_READ_DATA = {
'cmd': '+++',
'cmd_resp': 'CONNECT',
'time_out': 6000,
'delay': 0,
'skip': 0
}
self.cmd_READSMS = {
'cmd': "AT\r\n",
'cmd_resp': 'OK',
'time_out': 1000,
'delay': 0,
'skip': 0
}
self.uGSM = UART(1, baudrate=115200, rx=22, tx=23, timeout=3000)
# Подключаем канал GPRS, возвращает True и переходит в режим чтения данных
def connect_to_gprs(self):
"""
Настройка соеденения
AT+WIPCFG=1
AT+WIPBR=1,6
AT+WIPBR=2,6,11,"internet"
AT+WIPBR=4,6,0
:return:
"""
#
#self.uGSM.callback(self.uGSM.CBTYPE_PATTERN, self.uart_cb_func, pattern=b'\r\n')
print("connect to device...")
res = self.send_at_req(self.cmd_AT)
if (res == True):
self._f_device_ok = True
print("connect to device ok")
res = self.send_at_req(self.cmd_START_IP_STACK)
if (res == False):
return False
res = self.send_at_req(self.cmd_OPEN_GPRS_BR)
if (res == False):
return False
res = self.send_at_req(self.cmd_APN_GPRS_BR)
if (res == False):
return False
res = self.send_at_req(self.cmd_START_GPRS_BR)
if (res == False):
res = self.send_at_req(self.cmd_STOP_GPRS_BR)
#return False
res = self.send_at_req(self.cmd_CREATE_TCP_CLIENT)
if (res == False):
return False
res = self.send_at_req(self.cmd_READ_DATA)
if (res == False):
return False
self._f_read_data_from_server = True
return True
else:
#
print("device not work")
# Отключаем режим GPRS, режим AT команд
def disconnect_gprs(self):
time.sleep(2)
self.send_at_req(self.cmd_STOP_READ_DATA)
time.sleep(2)
self.send_at_req(self.cmd_AT)
self.send_at_req(self.cmd_STOP_GPRS_BR)
self.send_at_req(self.cmd_CLOSE_GPRS_BR)
self.uGSM.flush()
return self.send_at_req(self.cmd_STOP_IP_STACK)
def send_data_to_server(self, data):
self.uGSM.flush()
data = ujson.dumps(data)
print("send_data_to_server data = ", data)
if (type(data) == str):
data = data + "\n"
self.uGSM.write(data.encode())
else:
self.uGSM.write(data)
def uart_cb_func(self, res):
# Ф-ция обратного вызова при приеме данных через UART
# сдесь нужно разделять в каком режиме работает модем,
# если это прием через gprs, обрабатываем данные
print("uart_cb_func: ", res)
if (res[0] == 3):
# Ошибка
pass
else:
# Обрабатываем данные
if (self._f_read_data_from_server == True):
# Пришли данные с сервера
pass
else:
# Пришли данные, обрабатываем запросс к модему
if (res[2] == self._responce):
self._f_resp_ok = True
#else:
pass
pass
def _get_str_from_line(self, ln):
# удаляем из строки перенос
if (ln != None):
stroka = ln.split('\r\n')
try:
while (True):
stroka.remove('')
except ValueError:
#print("except ValueError in _get_str_from_line is ok")
pass
if (len(stroka) > 0):
print("_get_str_from_line(self,ln) len(stroka) > 0 = ",
len(stroka))
#j=0
#for i in stroka:
# print("j = ", j)
# print("stroka[j] = ", i)
# j = j+1
print("stroka[0]", stroka[0])
return stroka[0]
else:
print("_get_str_from_line(self,ln) len(stroka) = 0")
return None
return None
def cb_exec_at_data(self, data):
# проверяем какая команда пришла
print(data)
pass
# процесс обработки данных в режиме AT
def proc_at_data(self):
stroka = self._get_str_from_line(self.uGSM.readln(1000))
if (stroka != None):
# проверяем данные
# может быть вызов
# а также проверка смс
if (self.cb_exec_server_data != None):
self.cb_exec_at_data(stroka)
else:
self.uGSM.flush()
# здесь проверяем наличие новых смс
self.uGSM.write('AT+CMGL="REC UNREAD"\r\n')
stroka = self._get_str_from_line(self.uGSM.readln(1000))
ans = list()
while (stroka != None):
# Для начала ищем в строрке +CMGL
# если да - это шапка и первая строка
# удаляем '+CMGL: ', раскладываем через разделители ','
# 1- номер сообщения, 2 - флаг состояния(прочитано или нет)
# 3 - номер телефона, 4 название в симкарте
# 5 Service Center Time Stamp
# дальше перевод строки, и текст сообщения
ans.append(stroka[0])
ans.append(stroka[1])
ans.append(stroka[2])
ans.append("")
ans.append("")
ans.append("")
# если не найдена строка '+CMGL: ', скорее всего это текст сообщения
stroka = self._get_str_from_line(self.uGSM.readln(1000))
pass
def proc_server_data(self):
# чтение данных, задержка на чтение в течении 2 сек
stroka = self._get_str_from_line(self.uGSM.readln(2000))
if (stroka != None):
# передаем строку на обработку
# print("proc_server_data - ",stroka)
if (self.cb_exec_server_data != None):
self.cb_exec_server_data(stroka)
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! Not work errore
def send_at_req(self, at_cmd):
"""
Send AT request and read answer
:param at_cmd:
:return:
"""
# Отправляем ат команду
self._responce = at_cmd['cmd_resp']
self._f_resp_ok = False
self.uGSM.write(at_cmd['cmd'])
read_str = self.uGSM.readln(at_cmd['time_out'])
while (read_str != None):
read_str = read_str.split()
#print(read_str)
if (len(read_str) > 0):
if (read_str[0] == at_cmd['cmd_resp']):
self._f_resp_ok = True
#self.uGSM.flush()
break
read_str = self.uGSM.readln(at_cmd['time_out'])
return self._f_resp_ok
pass
#
def GetSMS(self, num):
"""
:param num:
:return: None, if not read sms
"""
cmd_READSMS = {
'cmd': "AT+CMGR=%d\r\n" % num,
'cmd_resp': "AT+CMGR=%d" % num,
'time_out': 1000,
'delay': 0,
'skip': 0
}
#print(cmd_READSMS)
res = self.send_at_req(cmd_READSMS)
ret = {}
ret["ERROR"] = "ERROR"
if (res):
time.sleep(1)
# req ok, wait OK or ERROR
while True:
s = self.uGSM.readln(100)
print("s = ", s)
if (s != None):
if (s.startswith('+CMGR') == True):
ret["state"] = s.split(',')[0]
ret["phone"] = s.split(',')[1]
ret["text"] = self.uGSM.readln(100).split()
ret["ERROR"] = "OK"
return ret
if (s.startswith('OK') == True):
ret["ERROR"] = "OK"
return ret
if (s.startswith('ERROR') == True):
ret["ERROR"] = "ERROR"
return ret
else:
return ret
def DelSMS(self, num):
"""
:param num: number for delete SMS
:return: True or False
"""
cmd_DELSMS = {
'cmd': "AT+CMGD=%d\r\n" % num,
'cmd_resp': "AT+CMGD=%d" % num,
'time_out': 1000,
'delay': 0,
'skip': 0
}
return self.send_at_req(cmd_DELSMS)
def ExecSMSText(self, sms_struct):
"""
Exec command from SMS
:param sms_struct: dict for SMS struct
:return: True if ok exec
"""
def ProcSMS(self):
"""
Exec cmd from sms
:return:
"""
endproc = False
while (endproc != True):
sms = self.GetSMS()
pass
class sqnsupgrade:
global sysname
def __init__(self):
self.__sysname = sysname
self.__pins = None
self.__connected = False
self.__sdpath = None
def special_print(self, msg, flush=None, end='\n'):
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
print(msg, end=end)
else:
print(msg, flush=flush, end=end)
def read_rsp(self, size=None, timeout=-1):
if timeout < 0:
timeout = 20000
elif timeout is None:
timeout = 0
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
while not self.__serial.any() and timeout > 0:
time.sleep_ms(1)
timeout -= 1
else:
while self.__serial.in_waiting <= 0 and timeout > 0:
time.sleep(0.001)
timeout -= 1
if size is not None:
rsp = self.__serial.read(size)
else:
rsp = self.__serial.read()
if rsp is not None:
return rsp
else:
return b''
def print_pretty_response(self, rsp, flush=False):
lines = rsp.decode('ascii').split('\r\n')
for line in lines:
if 'OK' not in line:
self.special_print(line, flush=flush)
def return_pretty_response(self, rsp):
ret_str = ''
lines = rsp.decode('ascii').split('\r\n')
for line in lines:
if 'OK' not in line:
ret_str += line
return ret_str
def return_code(self, rsp):
ret_str = b''
lines = rsp.decode('ascii').split('\r\n')
for line in lines:
if 'OK' not in line:
ret_str += line
try:
return int(ret_str)
except:
return -1
def wait_for_modem(self, send=True, expected=b'OK'):
rsp = b''
while True:
if send:
self.__serial.write(b"AT\r\n")
r = self.read_rsp(size=(len(expected) + 4), timeout=50)
if r:
rsp += r
if expected in rsp:
print()
break
else:
self.special_print('.', end='', flush=True)
time.sleep(0.5)
def __check_file(self, file_path, debug=False):
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
if file_path[
0] == '/' and not 'flash' in file_path and not file_path.split(
'/')[1] in os.listdir('/'):
if self.__sdpath is None:
self.__sdpath = file_path.split('/')[1]
sd = SD()
time.sleep(0.5)
os.mount(sd, '/{}'.format(self.__sdpath))
else:
print('SD card already mounted on {}!'.format(
self.__sdpath))
return False
try:
size = os.stat(file_path)[6]
if debug: print('File {} has size {}'.format(file_path, size))
return True
except Exception as ex:
print('Exception when checking file... wrong file name?')
print('{}'.format(ex))
return False
return False
def check_files(self, ffile, mfile=None, debug=False):
if mfile is not None:
if self.__check_file(mfile, debug):
return self.__check_file(ffile, debug)
else:
return False
else:
return self.__check_file(ffile, debug)
def detect_modem_state(self, retry=10, initial_delay=5):
if 'FiPy' or 'GPy' in self.__sysname:
if 'GPy' in self.__sysname:
pins = ('P5', 'P98', 'P7', 'P99')
else:
pins = ('P20', 'P18', 'P19', 'P17')
count = 0
while count < retry:
count += 1
delay = initial_delay * count
s = UART(1, baudrate=921600, pins=pins, timeout_chars=10)
s.read()
s.write(b"AT\r\n")
time.sleep_ms(delay)
resp = s.read()
s.write(b"AT\r\n")
time.sleep_ms(delay)
resp = s.read()
if resp is not None and b'OK' in resp:
s.write(b"AT+SMOD?\r\n")
time.sleep_ms(delay)
resp = s.read()
try:
return self.return_code(resp)
except:
continue
else:
s = UART(1, baudrate=115200, pins=pins, timeout_chars=10)
s.write(b"AT\r\n")
time.sleep_ms(delay)
resp = s.read()
s.write(b"AT\r\n")
time.sleep_ms(delay)
resp = s.read()
if resp is not None and b'OK' in resp:
s.write(b"AT+SMOD?\r\n")
time.sleep_ms(delay)
resp = s.read()
try:
return self.return_code(resp)
except:
continue
def __run(self,
file_path=None,
baudrate=921600,
port=None,
resume=False,
load_ffh=False,
mirror=False,
switch_ffh=False,
bootrom=False,
rgbled=0x050505,
debug=False,
pkgdebug=False,
atneg=True,
max_try=10,
direct=True,
atneg_only=False,
version_only=False):
mirror = True if atneg_only else mirror
recover = True if atneg_only else load_ffh
resume = True if mirror or recover or atneg_only or version_only else resume
if debug:
print(
'mirror? {} recover? {} resume? {} direct? {} atneg_only? {} bootrom? {} '
.format(mirror, recover, resume, direct, atneg_only, bootrom))
abort = True
external = False
self.__serial = None
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
if 'GPy' in self.__sysname:
self.__pins = ('P5', 'P98', 'P7', 'P99')
else:
self.__pins = ('P20', 'P18', 'P19', 'P17')
self.__serial = UART(1,
baudrate=115200 if recover else baudrate,
pins=self.__pins,
timeout_chars=100)
self.__serial.read()
else:
if port is None:
raise ValueError('serial port not specified')
if debug: print('Setting port {}'.format(port))
external = True
br = 115200 if recover and not direct else baudrate
if debug: print('Setting baudrate to {}'.format(br))
self.__serial = serial.Serial(port,
br,
bytesize=serial.EIGHTBITS,
timeout=1 if version_only else 0.1)
self.__serial.reset_input_buffer()
self.__serial.reset_output_buffer()
if debug: print('Initial prepartion complete...')
if version_only:
self.__serial.read()
self.__serial.write(b"AT!=\"showver\"\r\n")
time.sleep(.5)
shver = self.read_rsp(2000)
if shver is not None:
self.print_pretty_response(shver)
return True
if not mirror:
if bootrom:
if debug: print('Loading built-in recovery bootrom')
from sqnsbr import bootrom
blob = bootrom()
blobsize = blob.get_size()
else:
if debug: print('Loading {}'.format(file_path))
blobsize = os.stat(file_path)[6]
blob = open(file_path, "rb")
if not load_ffh:
if not self.wakeup_modem(baudrate, port, 10, 1, debug):
return False
if not resume:
# disable echo
self.__serial.write(b"ATE0\r\n")
response = self.read_rsp(size=6)
self.__serial.read(100)
if debug: print('Entering recovery mode')
self.__serial.write(b"AT+SMOD?\r\n")
response = self.return_pretty_response(self.read_rsp(size=7))
self.__serial.read(100)
if debug: print("AT+SMOD? returned {}".format(response))
if not bootrom:
self.__serial.write(b"AT+SMSWBOOT=3,1\r\n")
time.sleep(2)
self.wait_for_modem()
self.__serial.write(b"AT\r\n")
self.__serial.write(b"AT\r\n")
else:
self.__serial.read(100)
if debug: print('Entering recovery mode')
self.__serial.write(b"AT+SMOD?\r\n")
response = self.return_pretty_response(self.read_rsp(size=7))
self.__serial.read(100)
if debug: print("AT+SMOD? returned {}".format(response))
time.sleep(1)
self.__serial.read()
if (not recover) and (not direct):
if mirror:
time.sleep(.5)
self.__serial.read(100)
print(
'Going into MIRROR mode... please close this terminal to resume the upgrade via UART'
)
self.uart_mirror(rgbled)
elif bootrom:
print('Starting STP (DO NOT DISCONNECT POWER!!!)')
else:
print('Starting STP ON_THE_FLY')
self.__serial.read(100)
self.__serial.write(b'AT+SMSTPU=\"ON_THE_FLY\"\r\n')
response = self.read_rsp(size=4)
if response != b'OK\r\n' and response != b'\r\nOK' and response != b'\nOK':
raise OSError("Invalid answer '%s' from the device" % response)
blob.close()
self.__serial.read()
elif recover and (not direct):
if atneg:
result = self.at_negotiation(baudrate, port, max_try, mirror,
atneg_only, debug)
if result:
if atneg_only:
return True
if mirror:
time.sleep(.5)
self.__serial.read(100)
print(
'Going into MIRROR mode... please close this terminal to resume the upgrade via UART'
)
self.uart_mirror(rgbled)
else:
self.__serial.write(b"AT+STP\n")
response = self.read_rsp(size=6)
if not b'OK' in response:
print('Failed to start STP mode!')
sys.exit(1)
else:
print('AT auto-negotiation failed! Exiting.')
return False
else:
if debug: print('Starting STP mode...')
self.__serial.write(b"AT+STP\n")
response = self.read_rsp(size=6)
if not b'OK' in response:
print('Failed to start STP mode!')
sys.exit(1)
try:
if debug:
print('Starting STP code upload')
if stp.start(blob,
blobsize,
self.__serial,
baudrate,
AT=False,
debug=debug,
pkgdebug=pkgdebug):
blob.close()
if switch_ffh:
print(
'Bootrom updated successfully, switching to upgrade mode'
)
abort = False
elif load_ffh:
if not self.wakeup_modem(baudrate, port, 100, 1, debug):
return False
print(
'Upgrader loaded successfully, modem is in upgrade mode'
)
return True
else:
print('Code download done, returning to user mode')
abort = recover
else:
blob.close()
print('Code download failed, aborting!')
return False
except:
blob.close()
print('Code download failed, aborting!')
abort = True
time.sleep(1.5)
if not abort:
self.__serial.read()
if switch_ffh:
self.__serial.write(b"AT+SMSWBOOT=0,1\r\n")
return True
else:
self.special_print('Resetting (DO NOT DISCONNECT POWER!!!).',
end='',
flush=True)
self.__serial.write(b"AT+SMSWBOOT=1,1\r\n")
self.wait_for_modem(send=False, expected=b'+SYSSTART')
self.__serial.write(b"AT\r\n")
self.__serial.write(b"AT\r\n")
time.sleep(0.5)
self.__serial.read()
print('Upgrade completed!')
print("Here's the current firmware version:")
time.sleep(0.5)
self.__serial.read()
self.__serial.write(b"AT!=\"showver\"\r\n")
time.sleep(.5)
shver = self.read_rsp(2000)
if shver is not None:
self.print_pretty_response(shver)
return True
return False
def wakeup_modem(self, baudrate, port, max_try, delay, debug):
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
self.__serial = UART(1,
baudrate=baudrate,
pins=self.__pins,
timeout_chars=1)
MAX_TRY = max_try
count = 0
print('Attempting AT wakeup...')
self.__serial.read()
self.__serial.write(b"AT\r\n")
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
while (not b'OK' in response) and (count < MAX_TRY):
count = count + 1
if debug: print('count={}'.format(count))
time.sleep(delay)
self.__serial.read()
self.__serial.write(b"AT\r\n")
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
if 'FiPy' in sysname or 'GPy' in sysname:
self.__serial = UART(1,
baudrate=baudrate,
pins=self.__pins,
timeout_chars=100)
return count < MAX_TRY
def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only,
debug):
MAX_TRY = max_try
count = 0
print('Attempting AT auto-negotiation...')
self.__serial.write(b"AT\r\n")
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
while (not b'OK' in response) and (count < MAX_TRY):
count = count + 1
if debug: print('count={}'.format(count))
time.sleep(1)
self.__serial.read()
self.__serial.write(b"AT\r\n")
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
if b'OK' in response:
self.__serial.read()
cmd = "AT+IPR=%d\n" % baudrate
if debug: print('Setting baudrate to {}'.format(baudrate))
self.__serial.write(cmd.encode())
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
if b'OK' in response:
if atneg_only:
return True
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
self.__serial = UART(1,
baudrate=baudrate,
pins=self.__pins,
timeout_chars=100)
else:
self.__serial = None
self.__serial = serial.Serial(port,
baudrate,
bytesize=serial.EIGHTBITS,
timeout=0.1)
self.__serial.reset_input_buffer()
self.__serial.reset_output_buffer()
self.__serial.flush()
self.__serial.read()
if debug: print('Checking SMOD')
self.__serial.write(b"AT+SMOD?\r\n")
response = self.read_rsp(size=1)
if b'0' in response:
if debug: print("AT+SMOD? returned {}".format(response))
self.__serial.read()
return True
else:
print('ERROR in AT+SMOD returned {}'.format(response))
return False
else:
print('ERROR in AT+IPR={} returned {}'.format(
baudrate, response))
return False
else:
print(
'ERROR sending AT command... no response? {}'.format(response))
return False
time.sleep(1)
return True
def uart_mirror(self, color):
import pycom
pycom.heartbeat(False)
time.sleep(.5)
pycom.rgbled(color)
from network import LTE
LTE.modem_upgrade_mode()
def upgrade_sd(self,
ffile,
mfile=None,
baudrate=921600,
retry=False,
resume=False,
debug=False,
pkgdebug=False):
print('<<< Welcome to the SQN3330 firmware updater >>>')
success = True
if not retry and mfile is not None:
success = False
success = self.__run(bootrom=True,
resume=resume,
switch_ffh=True,
direct=False,
debug=debug,
pkgdebug=pkgdebug)
time.sleep(1)
if debug: print('Success1? {}'.format(success))
if success:
if mfile is not None:
success = False
success = self.__run(file_path=mfile,
load_ffh=True,
direct=False,
baudrate=baudrate,
debug=debug,
pkgdebug=pkgdebug)
time.sleep(1)
else:
success = True
else:
print('Unable to upgrade bootrom.')
if debug: print('Success2? {}'.format(success))
if success:
self.__run(file_path=ffile,
resume=True if mfile is not None else resume,
baudrate=baudrate,
direct=False,
debug=debug,
pkgdebug=pkgdebug)
else:
print('Unable to load updater from {}'.format(mfile))
def upgrade_uart(self,
ffh_mode=False,
mfile=None,
retry=False,
resume=False,
color=0x050505,
debug=False,
pkgdebug=False):
success = True
print('Preparing modem for upgrade...')
if not retry and ffh_mode:
success = False
success = self.__run(bootrom=True,
resume=resume,
switch_ffh=True,
direct=False,
debug=debug,
pkgdebug=pkgdebug)
time.sleep(1)
if success:
if mfile is not None:
success = False
success = self.__run(file_path=mfile,
load_ffh=True,
direct=False,
debug=debug,
pkgdebug=pkgdebug)
if debug: print('Success2? {}'.format(success))
if success:
self.__run(mirror=True,
load_ffh=False,
direct=False,
rgbled=color,
debug=debug)
else:
print('Unable to load updater from {}'.format(mfile))
else:
self.__run(mirror=True,
load_ffh=ffh_mode,
direct=False,
rgbled=color,
debug=debug)
else:
print('Unable to upgrade bootrom.')
def show_version(self, port=None, debug=False):
self.__run(port=port, debug=debug, version_only=True)
def upgrade_ext(self,
port,
ffile,
mfile,
resume=False,
debug=False,
pkgdebug=False):
success = True
print('<<< Welcome to the SQN3330 firmware updater >>>')
if mfile is not None:
success = False
success = self.__run(file_path=mfile,
load_ffh=True,
port=port,
debug=debug,
pkgdebug=pkgdebug)
if success:
self.__run(file_path=ffile,
resume=True if mfile is not None else resume,
direct=False,
port=port,
debug=debug,
pkgdebug=pkgdebug)
else:
print('Unable to load updater from {}'.format(mfile))
class Device:
def __init__(self):
print("init uDevice")
self.ID = "1"
# Номера ус-в
self.dict_devices = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31)
#self.registrPhoneNumbers = "+380665168235"
self.ConfigModule = {}
# default config
self.registrPhoneNumbers = ["+380688810836", "+380665168235"]
self.gsmAPN = 'internet'
self.gsmsocket_ip = '185.41.186.74'
self.gsmsocket_port = 2021
self.isDataFromServer = False
self.isDataToServer = False
self.datafromserver = bytearray()
self.datatoserver = bytearray(100)
self.serversock = socket.socket()
self.err_thr_read = ERR_NONE
#Событие из внешнего процесса на подключение к GSM
self.evConnectGsm = False
self.uDevice = UART(2, baudrate=9600, rx=16, tx=17, timeout=1000)
#self.uGSMModule =
self.count_pol_sec = 0
self.count_tuggle_pol_sec = 0
self.en485pin = GPIO(5, GPIO.OUT)
self.indStateWorkPin = GPIO(12, GPIO.OUT) # Постоянно моргаем
self.indStateGPRSPin = GPIO(14, GPIO.OUT) # Горит когда в режиме GPRS
self.indStateErrorPin = GPIO(26, GPIO.OUT) # Моргает когда есть ошибки
self.indStateModemPin = GPIO(
27, GPIO.OUT) # Горит когда есть связь с модемом
self.indStateRezervPin = GPIO(25, GPIO.OUT) # Резервный
self.indStateWorkPin.value(0)
self.indStateGPRSPin.value(0)
self.indStateErrorPin.value(0)
self.indStateModemPin.value(0)
self.indStateRezervPin.value(0)
# Для Wavecom
self.gsm = wavecom()
self.gsm.cb_exec_server_data = self._analis_server_socket_buff_
self._send_data_to_server_ = self.gsm.send_data_to_server
print("Init configuration")
#f = open('config.json', 'w')
self.gsm.cmd_CREATE_TCP_CLIENT = {
'cmd':
'AT+WIPCREATE=2,1,"%s",%d\r\n' %
(self.gsmsocket_ip, self.gsmsocket_port),
'cmd_resp':
'OK',
'time_out':
6000,
'delay':
0,
'skip':
0
}
self.StartThrTimePolSec()
self.modbus = ModBus()
# Для SIM800
# gsm.debug(True)
# gsm.start(tx=23, rx=22, apn=self.gsmAPN)
# gsm.sms_cb(self.smscb, 5)
#gsm.connect()
#self.serversock.settimeout(0.5)
#self.serversock.connect(('185.41.186.74', 2020))
def LoadConfig(self, fname):
pass
def SaveConfig(self, fname):
pass
def ConnectToGSM(self):
"""
Connect via GSM to server socket
:return: none
"""
#self.gsm.connect()
#self.serversock.settimeout(0.5)
#self.serversock.connect(('185.41.186.74', 2020))
#self.serversock.connect(('google.ru', 80))
def DisconnectGSM(self):
"""
Disconnect from server
:return: None
"""
pass
"""
callback - ф-ция приема сообщений
int(indexes[0]) номер сообщения
msg[2] номер телефона
msg[6] текст сообщеия
"""
def smscb(self, indexes):
print("indexes = ", indexes)
if (indexes):
msg = gsm.readSMS(int(indexes[0]), True)
if (self._is_register_phone_(msg[2])):
#if(msg[2].find(self.registrPhoneNumbers)>=0):
print("Phone Ok")
ret = self._sms_cmd_exec_(msg[6])
gsm.sendSMS(msg[2], ret)
else:
print("Not register phone number - ", msg[2])
#На всякий случай удаляем все смс
gsm.atcmd('AT+CMGDA="DEL ALL"', printable=True)
return
print("Errore indexes in smscb")
pass
def _is_register_phone_(self, phone):
for el in self.registrPhoneNumbers:
if el == phone:
return True
return False
# Обработка текста сообщения
def _sms_cmd_exec_(self, msg):
print(msg)
dmsg = msg.split(" ")
#print(dmsg.count())
if (len(dmsg) > 0):
try:
if (dmsg[0] == "APN"):
self.gsmAPN = dmsg[1]
return "APN OK"
elif (dmsg[0] == "IP"):
self.gsmsocket_ip = dmsg[1]
self.gsmsocket_port = int(dmsg[2])
return "IP OK"
elif (dmsg[0] == "START"):
self.evConnectGsm = True
print("STARTGSM OK")
return "STARTGSM OK"
return "ERR CMD"
except IndexError:
return "PARAM NUMBER ERRORE"
except ValueError:
return "PARAM VALUE ERRORE"
pass
def MainThread(self):
# основной цикл
if self.isDataFromServer:
# есть данные от сервера
self._analis_server_socket_buff_(self.datafromserver)
self.isDataFromServer = False
if (self.idThrReciveSocket != None):
_thread.notify(self.idThrReciveSocket, SEND_DATA_TO_SERVER)
if (self.err_thr_read != ERR_NONE):
self.err_thr_read == ERR_NONE
_thread.notify(self.idThrReciveSocket, READ_DATA_FROM_SERVER)
if self.evConnectGsm == True:
# Пробуем подключиться
self.evConnectGsm = False
if (self.isConnect() == False):
print("Probuem podkluchitsya")
self.ConnectToGSM()
#else:
# Пробуем отключиться
# if (self.isConnect == True):
# self.DisconnectGSM()
"""
Основная ф-ция для объекта
"""
def MainWavecom(self):
try:
while (True):
# основной цикл для wavecom
err = self.gsm.connect_to_gprs()
if (err == True):
# соеденились с gprs
self.indStateGPRSPin.value(1)
self.indStateModemPin.value(1)
data_server = {}
data_server["ID"] = self.ID
data_server["cmd"] = "READY"
self._send_data_to_server_(data_server)
gprs_t_count = 0
while (gprs_t_count < 60):
gprs_t_count = gprs_t_count + 1
self.gsm.proc_server_data()
else:
# Необходимо сообщить об ошибке
# Возможно модем в режиме чтения данных, проверим это
self.gsm.disconnect_gprs()
err = self.gsm.send_at_req(self.gsm.cmd_AT)
if (err != True):
# Ошибка связи с модемом
self.indStateErrorPin.value(1)
self.indStateModemPin.value(0)
self.indStateGPRSPin.value(0)
else:
self.indStateErrorPin.value(0)
self.indStateGPRSPin.value(0)
self.indStateModemPin.value(1)
# Пробуем еще раз
"""
err = self.gsm.connect_to_gprs()
# соеденились с gprs
self.indStateGPRSPin.value(1)
self.indStateModemPin.value(1)
gprs_t_count = 0
while (gprs_t_count < 20):
gprs_t_count = gprs_t_count + 1
self.gsm.proc_server_data()
"""
err = self.gsm.disconnect_gprs()
self.indStateGPRSPin.value(0)
gprs_t_count = 0
while (gprs_t_count < 5):
gprs_t_count = gprs_t_count + 1
#self.gsm.proc_at_data()
except KeyboardInterrupt as e:
print("MainWavecom except KeyboardInterrupt")
self.StopThrTimePolSec()
except Exception as e:
print("MainWavecom except Exception")
print(e)
sys.print_exception(e)
self.StopThrTimePolSec()
def isConnect(self):
state_int, state_str = gsm.status()
if (state_int == 1):
return True
else:
return False
def writeCmd(self):
self.uDevice.write("Hello")
def __del__(self):
print("del uDevice")
self.uDevice.deinit()
"""
Получить все данные от усв-ва fixed
"""
def GetDevData(self, dev):
"""
Get all data from device
:param dev: id(num) device, type integer
:return: register value from device as type 'dict', or ['msg':'Error'] if not read data
"""
self.uDevice.flush()
finddev = False
for devid in self.dict_devices:
if (devid == dev):
finddev = True
if (finddev != True):
ret = {}
ret["msg"] = "ERROR DEV_ID NOT PRESENT"
return ret
data_out = bytearray()
data_out.extend(struct.pack('b', dev))
data_out.extend(b'\x03\x20\x00\x00\x0C')
self.modbus._add_crc_to_bytearray_(data_out)
count_repeat = 3
self._send_req_(data_out)
while (count_repeat != 0):
data = self._read_ans_()
if (len(data) > 25):
ret = self._alldata_modbus_to_strct_(data)
if (ret.get("msg").get("devID") == dev):
return ret
#print("Not eqal devID = ", ret.get("msg").get("devID"))
count_repeat = count_repeat - 1
else:
count_repeat = count_repeat - 1
print("repeat _send_req_, count = ", count_repeat)
self._send_req_(data_out)
#data = self._read_ans_()
#print("data = ", data)
#print("len(data) = ", len(data))
#if(len(data)>25):
# ret = self._alldata_modbus_to_strct_(data)
if (len(data) == 0):
ret = {}
ret["msg"] = "Error"
#data = data_out
return ret
def SetCtrlData(self, cmd_dict):
"""
:param cmd_dict: {"devID":1,"reg":"01"}
:return:
"""
print("cmd_dict = ", cmd_dict)
print("type cmd_dict = ", type(cmd_dict))
self.uDevice.flush()
data_out = bytearray()
data_out.extend(struct.pack('b', cmd_dict.get("devID")))
data_out.extend(b'\x06')
data_out.extend(b'\x20\x0b')
data_out.extend(struct.pack('>H', cmd_dict.get("reg")))
self.modbus._add_crc_to_bytearray_(data_out)
self._send_req_(data_out)
return cmd_dict
def SetDevData(self, cmd_dict):
"""
From server comes a command like {"Iust":[0.15],"Uust":[0.25],"reg":"01"}
:param cmd_dict: dict param
:return: register value from device as type 'dict', or
"""
print("cmd_dict = ", cmd_dict)
print("type cmd_dict = ", type(cmd_dict))
self.uDevice.flush()
#if(cmd_dict.get("cmd")==None):
# return "Error"
Iust = cmd_dict.get("Iust")
Uust = cmd_dict.get("Uust")
reg = cmd_dict.get("reg")
#float(str(data_dev_iust)[1:-1])
print("Iust SetDevData")
print(cmd_dict.get("Iust"))
print("Uust SetDevData")
print(cmd_dict.get("Uust"))
print("reg SetDevData")
print(cmd_dict.get("reg"))
if (Iust != None):
#print("Iust = ",Iust)
Iust = float(str(Iust)[1:-1])
Iust = Iust * 100
Iust = int(Iust)
#print("Iusti = ", Iust)
data_out = bytearray()
data_out.extend(struct.pack('b', cmd_dict.get("devID")))
data_out.extend(b'\x06')
data_out.extend(b'\x20\x0A')
data_out.extend(struct.pack('>H', Iust))
self.modbus._add_crc_to_bytearray_(data_out)
self._send_req_(data_out)
data = self._read_ans_()
print("data _read_ans_ = Iust ", data)
if (Uust != None):
Uust = float(str(Uust)[1:-1])
Uust = Uust * 100
Uust = int(Uust)
# print("Iusti = ", Iust)
data_out = bytearray()
data_out.extend(struct.pack('b', cmd_dict.get("devID")))
data_out.extend(b'\x06')
data_out.extend(b'\x20\x09')
data_out.extend(struct.pack('>H', Uust))
self.modbus._add_crc_to_bytearray_(data_out)
self._send_req_(data_out)
data = self._read_ans_()
print("data _read_ans_ Uust = ", data)
if (reg != None):
self.uDevice.flush()
data_out = bytearray()
data_out.extend(struct.pack('b', cmd_dict.get("devID")))
data_out.extend(b'\x06')
data_out.extend(b'\x20\x0b')
data_out.extend(struct.pack('>H', cmd_dict.get("reg")))
self.modbus._add_crc_to_bytearray_(data_out)
self._send_req_(data_out)
data = self._read_ans_()
print("data _read_ans_ reg = ", data)
def GetAllData(self):
for dev in self.dict_devices:
ans = self.GetDevData(dev)
self._send_data_to_server_(ans)
# self.serversock.send(ans)
def _alldata_modbus_to_strct_(self, buff):
"""
Analis buffer from device, on request get all registers
buff - not error
:param buff: input buffer
:return:
data from device in type 'dict'
"""
try:
# buff = bytearray([6, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5 ,5 ,5,6,7,7])
# print("_alldata_modbus_to_strct_ buff len", len(buff))
# print("_alldata_modbus_to_strct_ buff",buff[3],buff[4],buff[5],buff[6],buff[7],buff[8])
data_device = {}
data_device["devID"] = buff[0]
data_u_in = struct.unpack('>H', buff[3:5])[0]
data_u_in = data_u_in / 100
data_u_out = struct.unpack('>H', buff[5:7])[0]
data_u_out = data_u_out / 100
data_i_in = struct.unpack('>H', buff[7:9])[0]
data_i_in = data_i_in / 100
data_i_out = struct.unpack('>H', buff[9:11])[0]
data_i_out = data_i_out / 100
data_kpd = struct.unpack('>H', buff[11:13])[0]
data_kpd = data_kpd / 100
data_temper = struct.unpack('>H', buff[13:15])[0]
data_temper = data_temper / 100
data_reg_state = struct.unpack('>H', buff[15:17])[0]
data_u_ust_local = struct.unpack('>H', buff[17:19])[0]
data_u_ust_local = data_u_ust_local / 100
data_i_ust_local = struct.unpack('>H', buff[19:21])[0]
data_i_ust_local = data_i_ust_local / 100
data_u_ust_dist = struct.unpack('>H', buff[21:23])[0]
data_u_ust_dist = data_u_ust_dist / 100
data_i_ust_dist = struct.unpack('>H', buff[23:25])[0]
data_i_ust_dist = data_i_ust_dist / 100
data_reg_upr = struct.unpack('>H', buff[25:27])[0]
data_device["Uinput"] = data_u_in
data_device["Uoutput"] = data_u_out
data_device["Iinput"] = data_i_in
data_device["Ioutput"] = data_i_out
data_device["kpd"] = data_kpd
data_device["temp"] = data_temper
data_device["state"] = data_reg_state
data_device["Udist"] = data_u_ust_local
data_device["Idist"] = data_i_ust_local
data_device["Ulocal"] = data_u_ust_dist
data_device["Ilocal"] = data_i_ust_dist
data_device["regupr"] = data_reg_upr
data_to_server = {}
data_to_server["msg"] = data_device
data_to_server["timestamp"] = "10:10:10"
#print(data_to_server)
return data_to_server
except NameError as e:
print(e)
pass
def _read_ans_(self):
is_data_read = False
num_byte = 0
read_buff = bytearray()
time.sleep(0.3)
self.en485pin.value(1)
time.sleep(0.01)
self.en485pin.value(0)
time.sleep(0.01)
while (is_data_read != True):
bts = self.uDevice.read(1)
#print("bts = ",bts)
if (len(bts) != 0):
bt = bts[0]
#bt = ~bt
if (len(read_buff) == 0):
if (bt != 0):
#print("type(bt) = ",type(bt))
#print("bt = ", bt)
read_buff.append(bt)
num_byte += 1
else:
read_buff.append(bt)
num_byte += 1
else:
is_data_read = True
# Проверяем переполнение буффера
if (len(read_buff) > 100):
print("!!!!!!!!!!!!!!!! Error Overflow modbus in buffer")
print("read_buff = ", read_buff)
read_buff = bytearray()
self.uDevice.flush()
return read_buff
return read_buff
# fixed
def _send_req_(self, req):
# Включаем передатчик
self.en485pin.value(1)
self.uDevice.write(req)
#print(self.uDevice.write(req))
#print(self.uDevice.any())
time.sleep(0.01)
#self.uDevice.flush()
self.en485pin.value(0)
# Выключаем передатчик
# Ждем ответа, если ответ пришел отправляем данные на сервер,
# если ответа нет или повторяем или отправляем серверу ошибку
pass
# Анализ данных от сервера
# На всякий случай прорверяем в каком виде данные строка или буфер
def _analis_server_socket_buff_(self, buff):
try:
print("_analis_server_socket_buff_ start")
print("_analis_server_socket_buff_ buff = ", buff)
if (type(buff) != str):
stroka = ''
for b in buff:
stroka += chr(b)
else:
stroka = buff
print("stroka = ", stroka)
try:
in_data = ujson.loads(stroka)
except ValueError as e:
print(
"-------except ValueError in _analis_server_socket_buff_")
return
if (in_data.get("ID") != self.ID):
return
# in_data = str
print("in_data = ", in_data)
print("-----_analis_server_socket_buff_------")
#self._send_data_to_server_(in_data)
# Смотрим какая команда пришла
if (in_data.get("cmd") == "GETALLDATA"):
# пришла команда опроса всех ус-в
# Survey all devices from the list self.dict_devices
print("GETALLDATA")
for dev in self.dict_devices:
data = self.GetDevData(dev)
print("data = ", data)
print("type data = ", type(data))
timestamp = in_data.get("timestamp")
# data_dev_id = int(in_data.get("cmd")[len("GETDATA"):])
#data_dev_id = int(in_data.get("id"))
# print("data_dev_id = ", data_dev_id)
#data = self.GetDevData(data_dev_id)
data_device = {}
data_device["ID"] = self.ID
data_device["msg"] = data["msg"]
data_device["cmd"] = "DATA"
data_device["timestamp"] = timestamp
#print("self.GetDevData(data_dev_id) = ", data)
# print("type(data) = ", type(data))
self._send_data_to_server_(data_device)
if (in_data.get("cmd").find("GETDATA") == 0):
# пришла команда опроса одного ус-ва
# Survey device num "id" from the list self.dict_devices
print("cmd=GETDATA")
timestamp = in_data.get("timestamp")
#data_dev_id = int(in_data.get("cmd")[len("GETDATA"):])
data_dev_id = int(in_data.get("msg").get("devID"))
#print("data_dev_id = ", data_dev_id)
data = self.GetDevData(data_dev_id)
data_device = {}
data_device["ID"] = self.ID
data_device["msg"] = data["msg"]
data_device["cmd"] = "DATA"
data_device["timestamp"] = timestamp
print("self.GetDevData(data_dev_id) = ", data)
#print("type(data) = ", type(data))
self._send_data_to_server_(data_device)
# self.serversock.send(data)
if (in_data.get("cmd").find("SETCTRL") == 0):
#print("SETCTRL to dev")
data_dev_id = int(in_data.get("msg").get("devID"))
timestamp = in_data.get("timestamp")
print("SETCTRL to dev - ", data_dev_id)
data = self.SetCtrlData(in_data.get("msg"))
print("SETCTRL data - ", data)
data_device = {}
data_device["ID"] = self.ID
data_device["msg"] = data
data_device["cmd"] = "SETCTRL"
data_device["timestamp"] = timestamp
self._send_data_to_server_(data_device)
pass
if (in_data.get("cmd").find("SETDATA") == 0):
# пришла команда опроса установки параметров
print("SETDATA")
#data_dev_id = int(in_data.get("cmd")[len("SETDATA"):])
data_dev_id = int(in_data.get("msg").get("devID"))
timestamp = in_data.get("timestamp")
print("data_dev_id = ", data_dev_id)
data_dev_reg = in_data.get("msg").get("reg")
data_dev_iust = in_data.get("msg").get("Iust")
data_dev_uust = in_data.get("msg").get("Uust")
#print("data_dev_reg = ", data_dev_reg)
#print("Iust = ", data_dev_iust)
#print("Uust = ", data_dev_uust)
#print(type(data_dev_iust))
#print(type(data_dev_uust))
#print(str(data_dev_iust)[1:-1])
#print(str(data_dev_uust)[1:-1])
data = self.SetDevData(in_data.get("msg"))
data_device = {}
data_device["ID"] = self.ID
data_device["msg"] = in_data.get("msg")
data_device["cmd"] = "SETDATA"
data_device["timestamp"] = in_data.get("timestamp")
self._send_data_to_server_(in_data)
#data_dev_iust = float(str(data_dev_iust)[1:-1])
#data_dev_uust = float(str(data_dev_uust)[1:-1])
#data_out = bytearray()
#if(data_dev_id != None):
# data_out.extend(struct.pack('b', data_dev_id))
#if (data_dev_reg != None):
# data_out.extend(struct.pack('b', data_dev_reg))
#if (data_dev_iust != None):
# data_out.extend(struct.pack('f', data_dev_iust))
#if (data_dev_uust != None):
# data_out.extend(struct.pack('f', data_dev_uust))
#data_out.extend(b'\xaa')
#print(data_out)
# self._send_req_(data_out)
# сформировали выходной буффер, можем отправлять
#print("devID = ", data_dev_id)
#print("reg = ", data_dev_reg)
#print("Iust = ", data_dev_iust)
#print("Uust = ", data_dev_uust)
#print("data_out = ", data_out)
except OSError as e:
print(
"!!!!!!!!!!!!!!! except OSError in _analis_server_socket_buff_ !!!!!!!!"
)
print(e)
except Exception as e:
print(
"!!!!!!!!!!!!!!! except Exception in _analis_server_socket_buff_ !!!!!!!!"
)
data_device = {}
data_device["ID"] = self.ID
data_device["msg"] = in_data.get("msg")
data_device["cmd"] = "ERROR TYPE"
self._send_data_to_server_(data_device)
print(e)
finally:
#print("!!!!!!!!!!!!!!! except finally in _analis_server_socket_buff_ !!!!!!!!")
pass
# Анализируем входной буффер сервер соккета
pass
# OK
def _read_buff_to_json_(self, buff):
# преобразуем даные от ус-ва в json объект
try:
# buff = bytearray([6, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5 ,5 ,5,6,7,7])
data_device = {}
data_device["devID"] = buff[0]
data_u_in = struct.unpack('f', buff[1:5])
data_u_out = struct.unpack('f', buff[5:9])
data_i_in = struct.unpack('f', buff[9:13])
data_i_out = struct.unpack('f', buff[13:17])
data_t = struct.unpack('f', buff[17:21])
data_device["Uinput"] = data_u_in
data_device["Uoutput"] = data_u_out
data_device["Iinput"] = data_i_in
data_device["Ioutput"] = data_i_out
data_device["temp"] = data_t
data_device["temp"] = data_t
data_to_server = {}
data_to_server["msg"] = data_device
data_to_server["timestamp"] = "10:10:10"
return data_to_server
except NameError as e:
print(e)
# Процесс индикации работы ус-ва
def IndProc(self):
self.count_pol_sec += 1
if (self.count_tuggle_pol_sec == 0):
self.count_tuggle_pol_sec = 1
self.indStateWorkPin.value(1)
#self.indStateModemPin.value(1)
else:
self.count_tuggle_pol_sec = 0
self.indStateWorkPin.value(0)
#self.indStateModemPin.value(0)
pass
# Запуск потока таймера 0,5 сек
def StartThrTimePolSec(self):
self.idThrTimePolSec = _thread.start_new_thread(
"ThrTimePolSec", self.ThrTimePolSec, ())
# Остановка потока таймера 0,5 сек
def StopThrTimePolSec(self):
if (self.idThrTimePolSec != None):
_thread.stop(self.idThrTimePolSec)
def ThrTimePolSec(self):
# Поток для вызова ф-ций каждые пол секунды
i = 0
try:
while i < 100:
self.IndProc()
notification = _thread.wait(500)
if (notification == _thread.EXIT):
print("ThrTimePolSec.EXIT")
break
except KeyboardInterrupt:
print("ThrTimePolSec KeyboardInterrupt")
except Exception:
print("ThrTimePolSec Exception")
# ==================================================================================================================
# ==================================================================================================================
# Функции для модема SIM800
# ==================================================================================================================
# ==================================================================================================================
def set_call_state_gsm(self):
gsm.stop()
time.sleep(4)
#self.uDevice = UART(2, baudrate=9600, rx=16, tx=17, timeout=3000)
self.gsm_call = UART(1,
baudrate=115200,
rx=22,
tx=23,
timeout=3000,
buffer_size=100)
self.gsm_call.flush()
#self.gsm_call.callback(uart.CBTYPE_DATA, self.gsm_call_cb, data_len=12)
self.gsm_call.callback(gsm_call.CBTYPE_PATTERN,
gsm_call_cb,
pattern=b'\r\n')
def gsm_call_cb(self, res):
print("[UART CB]", res[2])
if (res[2] == 'RING'):
#запросс номера
print("Day nomer")
gsm_call.write('AT+CLCC\r\n')
pass
#gsm.start(tx=23, rx=22, apn=self.gsmAPN)
# Запуск потока чтения из соккета
def StartThrReciveSocket(self):
self.idThrReciveSocket = _thread.start_new_thread(
"ThrReciveSocket", self.ThrReciveSocket, ())
# Остановка потока чтения из соккета
def StopThrReciveSocket(self):
if (self.idThrReciveSocket != None):
_thread.stop(self.idThrReciveSocket)
def ThrReciveSocket(self):
print("thrReciveSocket is RUN")
#_thread.allowsuspend(True)
# while True:
i = 0
while i < 100:
i = i + 1
print("Hello from thread")
print(_thread.getSelfName())
# mainID = _thread.getReplID()
# print(mainID)
# print(_thread.getmsg())
if (self.isConnect()):
# если есть соеденение то читаем из соккета
isOk = False
cntByte = 0
self.datafromserver = bytearray()
while (isOk != True):
try:
bn = self.serversock.read(1)
self.datafromserver.extend(chr(bn[0]))
cntByte += 1
except OSError as e:
if e.args[0] == 110:
if cntByte > 0:
isOk = True
#print(e)
#print("cntByte = ", cntByte)
self.isDataFromServer = True
print("read data size = ", cntByte)
print("len data size = ", len(self.datafromserver))
print(self.datafromserver)
"""
try:
print("self.isConnect()")
bn = self.serversock.readinto(self.datafromserver)
if(bn >0):
self.isDataFromServer = True
else:
self.err_thr_read = ERR_READ_DATA_FROM_SERVER
print("read data size = ",bn)
print("len data size = ", len(self.datafromserver))
print(self.datafromserver)
except OSError as e:
print("!!!!!!!! except OSError in ThrReciveSocket")
# выставляем флаг того что была ошибка
"""
notification = _thread.wait()
print("notification = ", notification)
if (notification == _thread.EXIT):
print("_thread.EXIT")
break
#if (notification == 10):
#print("SEND_DATA_TO_SERBER == 1")
#if (self.isConnect()):
# try:
# self.serversock.send(self.datatoserver)
# except OSError as e:
# print("!!!!!!!! except OSError in ThrReciveSocket")
# выставляем флаг того что была ошибка
#continue
print("Stop thrReciveSocket")
class uModBusSerial:
def __init__(self, uart_id=1, slave_address=1, baudrate=38400, data_bits=8, stop_bits=2, parity=None, timeout=10, ctrl_pin=None, pins=[10,9]):
self.slave_address=slave_address
# Either 2 or 4 pins defined
pinsLen=len(pins)
if pins==None or pinsLen<2 or pinsLen>4 or pinsLen==3:
raise ValueError('Pins should contain pin names/numbers for: tx, rx, [rts, cts] => either 2 or 4 arguments.')
tx = pins[0]
rx = pins[1]
if pinsLen==4:
rts=pins[2]
cts=pins[3]
self._uart = UART(uart_id, baudrate=baudrate, bits=data_bits, parity=parity,
stop=stop_bits, timeout=timeout, tx=tx, rx=rx, rts=rts, cts=cts)
else:
self._uart = UART(uart_id, baudrate=baudrate, bits=data_bits, parity=parity,
stop=stop_bits, timeout=timeout, tx=tx, rx=rx)
if ctrl_pin is not None:
self._ctrlPin = Pin(ctrl_pin, mode=Pin.OUT)
else:
self._ctrlPin = None
self.char_time_ms = (1000 * (data_bits + stop_bits + 2)) // baudrate
#%% general functions
def _calculate_crc16(self, data):
crc = 0xFFFF
for char in data:
crc = (crc >> 8) ^ Const.CRC16_TABLE[((crc) ^ char) & 0xFF]
return struct.pack('<H',crc)
def _bytes_to_bool(self, byte_list):
bool_list = []
for index, byte in enumerate(byte_list):
bool_list.extend([bool(byte & (1 << n)) for n in range(8)])
return bool_list
def _to_short(self, byte_array, signed=True):
response_quantity = int(len(byte_array) / 2)
fmt = '>' + (('h' if signed else 'H') * response_quantity)
return struct.unpack(fmt, byte_array)
def _exit_read(self, response):
if response[1] >= Const.ERROR_BIAS:
if len(response) < Const.ERROR_RESP_LEN:
return False
elif (Const.READ_COILS <= response[1] <= Const.READ_INPUT_REGISTER):
expected_len = Const.RESPONSE_HDR_LENGTH + 1 + response[2] + Const.CRC_LENGTH
if len(response) < expected_len:
return False
elif len(response) < Const.FIXED_RESP_LEN:
return False
return True
def _uart_read(self):
response = bytearray()
for x in range(1, 40):
if self._uart.any():
print('Bytes to read: '+str(self._uart.any()))
response.extend(self._uart.read(self._uart.any()))
# response.extend(self._uart.read())
# response.extend(self._uart.readall())
# variable length function codes may require multiple reads
print('Response: '+str(response))
if self._exit_read(response):
break
utime.sleep(0.05)
return response
def _send_receive(self, modbus_pdu, count):
serial_pdu = bytearray()
serial_pdu.append(self.slave_address)
serial_pdu.extend(modbus_pdu)
crc = self._calculate_crc16(serial_pdu)
print('crc: '+str(crc))
serial_pdu.extend(crc)
print('serial_pdu: '+str(serial_pdu))
# flush the Rx FIFO
print("Flush RX")
self._uart.read()
self._uart.flush()
# if self._ctrlPin:
# self._ctrlPin(1)
self._uart.write(serial_pdu)
# if self._ctrlPin:
# while not self._uart.wait_tx_done(2):
# machine.idle()
# time.sleep_ms(1 + self.char_time_ms)
# self._ctrlPin(0)
# t = utime.time()
# timeout = t+5
# while float(t) < float(timeout):
# if self._uart.any():
# print('Reading response.')
# return self._validate_resp_hdr(self._uart_read(), slave_addr, modbus_pdu[0], count)
# t = utime.time()
## print(float(t))
## print(float(timeout))
## print(self._uart.any())
# print('Leaving response loop, timeout overstepped.')
## print(self._uart.read())
return self._validate_resp_hdr(self._uart_read(), modbus_pdu[0], count)
def _validate_resp_hdr(self, response, function_code, count):
if len(response) == 0:
raise OSError('no data received from slave')
resp_crc = response[-Const.CRC_LENGTH:]
expected_crc = self._calculate_crc16(response[0:len(response) - Const.CRC_LENGTH])
if (resp_crc[0] != expected_crc[0]) or (resp_crc[1] != expected_crc[1]):
raise OSError('invalid response CRC')
if (response[0] != self.slave_address):
raise ValueError('wrong slave address')
if (response[1] == (function_code + Const.ERROR_BIAS)):
raise ValueError('slave returned exception code: {:d}'.format(response[2]))
hdr_length = (Const.RESPONSE_HDR_LENGTH + 1) if count else Const.RESPONSE_HDR_LENGTH
return response[hdr_length : len(response) - Const.CRC_LENGTH]
#%% reading/writing functions for registers and coils
def read_coils(self, starting_addr, coil_qty):
modbus_pdu = functions.read_coils(starting_addr, coil_qty)
resp_data = self._send_receive(modbus_pdu, True)
status_pdu = self._bytes_to_bool(resp_data)
return status_pdu
def read_discrete_inputs(self, starting_addr, input_qty):
modbus_pdu = functions.read_discrete_inputs(starting_addr, input_qty)
resp_data = self._send_receive(modbus_pdu, True)
status_pdu = self._bytes_to_bool(resp_data)
return status_pdu
def read_holding_registers(self, starting_addr, register_qty, signed=True):
modbus_pdu = functions.read_holding_registers(starting_addr, register_qty)
resp_data = self._send_receive(modbus_pdu, True)
register_value = self._to_short(resp_data, signed)
return register_value
def read_input_registers(self, starting_address, register_quantity, signed=True):
modbus_pdu = functions.read_input_registers(starting_address, register_quantity)
resp_data = self._send_receive(modbus_pdu, True)
register_value = self._to_short(resp_data, signed)
return register_value
def write_single_coil(self, output_address, output_value):
modbus_pdu = functions.write_single_coil(output_address, output_value)
resp_data = self._send_receive(modbus_pdu, False)
operation_status = functions.validate_resp_data(resp_data, Const.WRITE_SINGLE_COIL,
output_address, value=output_value, signed=False)
return operation_status
def write_single_register(self, register_address, register_value, signed=True):
modbus_pdu = functions.write_single_register(register_address, register_value, signed)
resp_data = self._send_receive(modbus_pdu, False)
operation_status = functions.validate_resp_data(resp_data, Const.WRITE_SINGLE_REGISTER,
register_address, value=register_value, signed=signed)
return operation_status
def write_multiple_coils(self, starting_address, output_values):
modbus_pdu = functions.write_multiple_coils(starting_address, output_values)
resp_data = self._send_receive(modbus_pdu, False)
operation_status = functions.validate_resp_data(resp_data, Const.WRITE_MULTIPLE_COILS,
starting_address, quantity=len(output_values))
return operation_status
def write_multiple_registers(self, starting_address, register_values, signed=True):
modbus_pdu = functions.write_multiple_registers(starting_address, register_values, signed)
resp_data = self._send_receive(modbus_pdu, False)
operation_status = functions.validate_resp_data(resp_data, Const.WRITE_MULTIPLE_REGISTERS,
starting_address, quantity=len(register_values))
return operation_status
def close(self):
if self._uart == None:
return
try:
self._uart.deinit()
except Exception:
pass
class sqnsupgrade:
global sysname
def __init__(self):
self.__sysname = sysname
self.__pins = None
self.__connected = False
self.__sdpath = None
self.__resp_921600 = False
self.__serial = None
self.__kill_ppp_ok = False
if 'GPy' in self.__sysname:
self.__pins = ('P5', 'P98', 'P7', 'P99')
else:
self.__pins = ('P20', 'P18', 'P19', 'P17')
def special_print(self, msg, flush=None, end='\n'):
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
print(msg, end=end)
else:
print(msg, flush=flush, end=end)
def read_rsp(self, size=None, timeout=-1):
if timeout < 0:
timeout = 20000
elif timeout is None:
timeout = 0
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
while not self.__serial.any() and timeout > 0:
time.sleep_ms(1)
timeout -= 1
else:
while self.__serial.in_waiting <= 0 and timeout > 0:
time.sleep(0.001)
timeout -= 1
if size is not None:
rsp = self.__serial.read(size)
else:
rsp = self.__serial.read()
if rsp is not None:
return rsp
else:
return b''
def print_pretty_response(self, rsp, flush=False):
lines = rsp.decode('ascii').split('\r\n')
for line in lines:
if 'OK' not in line and line != '':
self.special_print(line, flush=flush)
def return_pretty_response(self, rsp):
ret_str = ''
lines = rsp.decode('ascii').split('\r\n')
for line in lines:
if 'OK' not in line:
ret_str += line
return ret_str
def return_upgrade_response(self, rsp):
pretty = self.return_pretty_response(rsp)
if "+SMUPGRADE:" in pretty:
try:
return pretty.split(':')[1].strip()
except:
pass
return None
def return_code(self, rsp, debug=False):
ret_str = b''
lines = rsp.decode('ascii').split('\r\n')
for line in lines:
if 'OK' not in line and len(line) > 0:
try:
if debug:
print('Converting response: {} to int...'.format(line))
return int(line)
except:
pass
raise OSError('Could not decode modem state')
def wait_for_modem(self, send=True, expected=b'OK', echo_char=None):
rsp = b''
start = time.time()
while True:
if send:
self.__serial.write(b"AT\r\n")
r = self.read_rsp(size=(len(expected) + 4), timeout=50)
if r:
rsp += r
if expected in rsp:
if echo_char is not None:
print()
break
else:
if echo_char is not None:
self.special_print(echo_char, end='', flush=True)
time.sleep(0.5)
if time.time() - start >= 300:
raise OSError('Timeout waiting for modem to respond!')
def __check_file(self, file_path, debug=False):
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
if file_path[
0] == '/' and not 'flash' in file_path and not file_path.split(
'/')[1] in os.listdir('/'):
if self.__sdpath is None:
self.__sdpath = file_path.split('/')[1]
try:
sd = SD()
time.sleep(0.5)
os.mount(sd, '/{}'.format(self.__sdpath))
except Exception as ex:
print('Unable to mount SD card!')
return False
else:
print('SD card already mounted on {}!'.format(
self.__sdpath))
return False
try:
size = os.stat(file_path)[6]
if debug: print('File {} has size {}'.format(file_path, size))
return True
except Exception as ex:
print('Exception when checking file {}... wrong file name?'.format(
file_path))
print('{}'.format(ex))
return False
return False
def check_files(self, ffile, mfile=None, debug=False):
if mfile is not None:
if self.__check_file(mfile, debug):
return self.__check_file(ffile, debug)
else:
return False
else:
return self.__check_file(ffile, debug)
def __check_resp(self, resp, kill_ppp=False):
if resp is not None:
self.__resp_921600 = b'OK' in resp or b'ERROR' in resp
self.__kill_ppp_ok = self.__kill_ppp_ok or (kill_ppp
and b'OK' in resp)
def __hangup_modem(self, delay, debug):
self.__serial.read()
if not self.__kill_ppp_ok:
self.__serial.write(b"+++")
time.sleep_ms(1150)
resp = self.__serial.read()
if debug: print('Response (+++ #1): {}'.format(resp))
self.__check_resp(resp, True)
self.__serial.write(b"AT\r\n")
time.sleep_ms(250)
resp = self.__serial.read()
if debug: print('Response (AT #1) {}'.format(resp))
self.__check_resp(resp)
if resp is not None:
if b'OK' not in resp and not self.__kill_ppp_ok:
self.__serial.write(b"AT\r\n")
time.sleep_ms(250)
resp = self.__serial.read()
if debug: print('Response (AT #2) {}'.format(resp))
self.__check_resp(resp)
if resp is not None and b'OK' in resp:
return True
self.__serial.write(b"+++")
time.sleep_ms(1150)
resp = self.__serial.read()
if debug: print('Response (+++ #2): {}'.format(resp))
self.__check_resp(resp, True)
if resp is not None and b'OK' in resp:
self.__serial.write(b"AT\r\n")
time.sleep_ms(250)
resp = self.__serial.read()
if debug: print('Response (AT #2) {}'.format(resp))
self.__check_resp(resp)
if resp is not None and b'OK' in resp:
return True
return False
def detect_modem_state(self, retry=3, initial_delay=1000, debug=False):
count = 0
self.__serial = UART(1,
baudrate=921600,
pins=self.__pins,
timeout_chars=1)
self.__serial.read()
while count < retry:
count += 1
delay = initial_delay * count
if debug: print("The current delay is {}".format(delay))
self.__serial = UART(1,
baudrate=921600,
pins=self.__pins,
timeout_chars=10)
#if True:
if self.__hangup_modem(initial_delay, debug):
self.__serial.write(b"AT+SMOD?\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
if debug: print('Response (AT+SMOD?) {}'.format(resp))
try:
return self.return_code(resp, debug)
except:
pass
else:
self.__serial = UART(1,
baudrate=921600,
pins=self.__pins,
timeout_chars=1)
self.__serial.read()
self.__serial.write(b"AT\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
self.__check_resp(resp)
if debug: print('Response (AT #3) {}'.format(resp))
if resp is not None and b'OK' in resp:
self.__serial.write(b"AT+SMOD?\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
try:
if debug: print('Response (AT+SMOD?) {}'.format(resp))
return self.return_code(resp, debug)
except:
pass
self.__serial.write(b"AT\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
self.__check_resp(resp)
if debug: print('Response (AT #4) {}'.format(resp))
if resp is not None and b'OK' in resp:
self.__serial.write(b"AT+SMOD?\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
try:
return self.return_code(resp, debug)
if debug: print('Response (AT+SMOD?) {}'.format(resp))
except:
pass
else:
if not self.__resp_921600:
self.__serial = UART(1,
baudrate=115200,
pins=self.__pins,
timeout_chars=10)
self.__serial.write(b"AT\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
if debug:
print('Response (AT #1 @ 115200) {}'.format(resp))
if resp is not None and b'OK' in resp:
self.__serial.write(b"AT+SMOD?\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
try:
if debug:
print(
'Response (AT+SMOD?) {}'.format(resp))
return self.return_code(resp, debug)
except:
pass
self.__serial.write(b"AT\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
if debug:
print('Response (AT #2 @ 115200) {}'.format(resp))
if resp is not None and b'OK' in resp:
self.__serial.write(b"AT+SMOD?\r\n")
time.sleep_ms(delay)
resp = self.__serial.read()
try:
if debug:
print(
'Response (AT+SMOD?) {}'.format(resp))
return self.return_code(resp, debug)
except:
pass
return None
def __get_power_warning(self):
return "<<<=== DO NOT DISCONNECT POWER ===>>>"
def __get_wait_msg(self, load_fff=True):
if not self.__wait_msg:
self.__wait_msg = True
if load_fff:
return "Waiting for modem to finish the update...\nThis might take several minutes!\n" + self.__get_power_warning(
)
else:
return "Waiting for modem to finish the update...\n" + self.__get_power_warning(
)
return None
def __run(self,
file_path=None,
baudrate=921600,
port=None,
resume=False,
load_ffh=False,
mirror=False,
switch_ffh=False,
bootrom=False,
rgbled=0x050505,
debug=False,
pkgdebug=False,
atneg=True,
max_try=10,
direct=True,
atneg_only=False,
version_only=False,
expected_smod=None,
verbose=False,
load_fff=False):
self.__wait_msg = False
mirror = True if atneg_only else mirror
recover = True if atneg_only else load_ffh
resume = True if mirror or recover or atneg_only or version_only else resume
verbose = True if debug else verbose
load_fff = False if bootrom and switch_ffh else load_fff
if debug:
print(
'mirror? {} recover? {} resume? {} direct? {} atneg_only? {} bootrom? {} load_fff? {}'
.format(mirror, recover, resume, direct, atneg_only, bootrom,
load_fff))
abort = True
external = False
self.__serial = None
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
self.__serial = UART(1,
baudrate=115200 if recover else baudrate,
pins=self.__pins,
timeout_chars=100)
self.__serial.read()
else:
if port is None:
raise ValueError('serial port not specified')
if debug: print('Setting port {}'.format(port))
external = True
br = 115200 if recover and not direct else baudrate
if debug: print('Setting baudrate to {}'.format(br))
self.__serial = serial.Serial(port,
br,
bytesize=serial.EIGHTBITS,
timeout=1 if version_only else 0.1)
self.__serial.reset_input_buffer()
self.__serial.reset_output_buffer()
if version_only:
self.__serial.read()
self.__serial.write(b'AT\r\n')
self.__serial.write(b'AT\r\n')
self.__serial.read()
if verbose:
self.__serial.write(b"AT!=\"showver\"\r\n")
else:
self.__serial.write(b"ATI1\r\n")
time.sleep(.5)
shver = self.read_rsp(2000)
if shver is not None:
self.print_pretty_response(shver)
return True
if debug: print('Initial prepartion complete...')
if not mirror:
if bootrom:
if debug: print('Loading built-in recovery bootrom...')
try:
# try compressed bootrom first
from sqnsbrz import bootrom
except:
# fallback to uncompressed
from sqnsbr import bootrom
blob = bootrom()
blobsize = blob.get_size()
else:
if debug: print('Loading {}'.format(file_path))
blobsize = os.stat(file_path)[6]
if blobsize < 128:
print('Firmware file is too small!')
reconnect_uart()
sys.exit(1)
if blobsize > 4194304:
if load_fff:
print(
"Firmware file is too big to load via FFF method. Using ON_THE_FLY"
)
load_fff = False
blob = open(file_path, "rb")
if not load_ffh:
if not self.wakeup_modem(baudrate, port, 10, 1, debug):
return False
if not resume:
# disable echo
self.__serial.write(b"ATE0\r\n")
response = self.read_rsp(size=6)
self.__serial.read(100)
if debug: print('Entering upgrade mode...')
self.__serial.write(b"AT+SMOD?\r\n")
response = self.return_pretty_response(self.read_rsp(size=7))
self.__serial.read(100)
if debug: print("AT+SMOD? returned {}".format(response))
self.__serial.write(b"AT+SQNSUPGRADENTF=\"started\"\r\n")
self.wait_for_modem()
if not load_fff:
self.__serial.write(b"AT+SMSWBOOT=3,1\r\n")
resp = self.read_rsp(100)
if debug: print('AT+SMSWBOOT=3,1 returned: {}'.format(resp))
if b'ERROR' in resp:
time.sleep(5)
self.__serial.write(b"AT+SMSWBOOT=3,0\r\n")
resp = self.read_rsp(100)
if debug:
print('AT+SMSWBOOT=3,0 returned: {}'.format(resp))
if b'OK' in resp:
self.__serial.write(b"AT^RESET\r\n")
resp = self.read_rsp(100)
if debug: print('AT^RESET returned: {}'.format(resp))
else:
print('Received ERROR from AT+SMSWBOOT=3,1! Aborting!')
reconnect_uart()
sys.exit(1)
time.sleep(3)
resp = self.__serial.read()
if debug: print("Response after reset: {}".format(resp))
self.wait_for_modem()
self.__serial.write(b"AT\r\n")
else:
self.__serial.read(100)
if debug: print('Entering recovery mode')
self.__serial.write(b"AT+SMOD?\r\n")
response = self.return_pretty_response(self.read_rsp(size=7))
self.__serial.read(100)
if debug: print("AT+SMOD? returned {}".format(response))
time.sleep(1)
self.__serial.read()
if (not recover) and (not direct):
if mirror:
time.sleep(.5)
self.__serial.read(100)
print(
'Going into MIRROR mode... please close this terminal to resume the upgrade via UART'
)
self.uart_mirror(rgbled)
elif bootrom:
if verbose: print('Starting STP')
else:
if verbose:
if load_fff:
print('Starting STP [FFF]')
else:
print('Starting STP ON_THE_FLY')
self.__serial.read(100)
if verbose: print("Sending AT+CFUN=4")
resonse = self.__serial.write(b'AT+CFUN=4\r\n')
if verbose: print("AT+CFUN=4 returned {}".format(response))
self.__serial.read(100)
if load_fff:
if debug: print("Sending AT+SMSTPU")
self.__serial.write(b'AT+SMSTPU\r\n')
else:
if debug: print("Sending AT+SMSTPU=\"ON_THE_FLY\"")
self.__serial.write(b'AT+SMSTPU=\"ON_THE_FLY\"\r\n')
response = self.read_rsp(size=4)
if response != b'OK\r\n' and response != b'\r\nOK' and response != b'\nOK':
raise OSError("Invalid answer '%s' from the device" % response)
blob.close()
self.__serial.read()
elif recover and (not direct):
if atneg:
result = self.at_negotiation(baudrate, port, max_try, mirror,
atneg_only, debug)
if result:
if atneg_only:
return True
if mirror:
time.sleep(.5)
self.__serial.read(100)
print(
'Going into MIRROR mode... please close this terminal to resume the upgrade via UART'
)
self.uart_mirror(rgbled)
else:
self.__serial.write(b"AT+STP\n")
response = self.read_rsp(size=6)
if not b'OK' in response:
print('Failed to start STP mode!')
reconnect_uart()
sys.exit(1)
else:
print('AT auto-negotiation failed! Exiting.')
return False
else:
if debug: print('Starting STP mode...')
self.__serial.write(b"AT+STP\n")
response = self.read_rsp(size=6)
if not b'OK' in response:
print('Failed to start STP mode!')
reconnect_uart()
sys.exit(1)
try:
if debug:
if verbose: print('Starting STP code upload')
if stp.start(blob,
blobsize,
self.__serial,
baudrate,
AT=False,
debug=debug,
pkgdebug=pkgdebug):
blob.close()
self.__serial.read()
if switch_ffh:
if verbose:
print(
'Bootrom updated successfully, switching to recovery mode'
)
abort = False
elif load_ffh:
if not self.wakeup_modem(baudrate, port, 100, 1, debug,
'Waiting for updater to load...'):
return False
if verbose:
print(
'Upgrader loaded successfully, modem is in update mode'
)
return True
else:
if verbose:
print('Code download done, returning to user mode')
abort = recover
else:
blob.close()
print('Code download failed, aborting!')
return False
except:
blob.close()
print('Code download failed, aborting!')
abort = True
time.sleep(1.5)
if not abort:
self.__serial.read()
if switch_ffh:
self.__serial.write(b"AT+SMSWBOOT=0,1\r\n")
resp = self.read_rsp(100)
if debug: print("AT+SMSWBOOT=0,1 returned {}".format(resp))
if b"ERROR" in resp:
time.sleep(5)
self.__serial.write(b"AT+SMSWBOOT=0,0\r\n")
resp = self.read_rsp(100)
if debug:
print('AT+SMSWBOOT=0,0 returned: {}'.format(resp))
if b'OK' in resp:
self.__serial.write(b"AT^RESET\r\n")
resp = self.read_rsp(100)
if debug: print('AT^RESET returned: {}'.format(resp))
return True
else:
print('Received ERROR from AT+SMSWBOOT=0,0! Aborting!')
return False
return True
else:
if load_fff:
self.__serial.write(b"AT+SMUPGRADE\r\n")
if not self.wakeup_modem(
baudrate, port, 100, 1, debug,
self.__get_wait_msg(load_fff=load_fff)):
print(
"Timeout while waiting for modem to finish updating!")
reconnect_uart()
sys.exit(1)
start = time.time()
while True:
self.__serial.read()
self.__serial.write(b"AT+SMUPGRADE?\r\n")
resp = self.read_rsp(1024)
if debug:
print("AT+SMUPGRADE? returned {} [timeout: {}]".format(
resp,
time.time() - start))
if resp == b'\x00' or resp == b'':
time.sleep(2)
if b'No report' in resp or b'on-going' in resp:
time.sleep(1)
if b'success' in resp or b'fail' in resp:
break
if time.time() - start >= 300:
raise OSError('Timeout waiting for modem to respond!')
self.__serial.write(b"AT+SMSWBOOT?\r\n")
resp = self.read_rsp(100)
if debug: print("AT+SMSWBOOT? returned {}".format(resp))
start = time.time()
while (b"RECOVERY"
not in resp) and (b"FFH" not in resp) and (b"FFF"
not in resp):
if debug: print("Timeout: {}".format(time.time() - start))
if time.time() - start >= 300:
reconnect_uart()
raise OSError('Timeout waiting for modem to respond!')
time.sleep(2)
if not self.wakeup_modem(
baudrate, port, 100, 1, debug,
self.__get_wait_msg(load_fff=load_fff)):
reconnect_uart()
raise OSError(
'Timeout while waiting for modem to finish updating!'
)
self.__serial.read()
self.__serial.write(b"AT+SMSWBOOT?\r\n")
resp = self.read_rsp(100)
if debug: print("AT+SMSWBOOT? returned {}".format(resp))
self.__serial.read()
self.__serial.write(b"AT+SMUPGRADE?\r\n")
resp = self.read_rsp(1024)
if debug: print("AT+SMUPGRADE? returned {}".format(resp))
sqnup_result = self.return_upgrade_response(resp)
if debug: print('This is my result: {}'.format(sqnup_result))
if 'success' in sqnup_result:
if not load_fff:
self.special_print('Resetting.', end='', flush=True)
self.__serial.write(b"AT+SMSWBOOT=1,1\r\n")
if debug:
print("AT+SMSWBOOT=1,1 returned {}".format(resp))
if b"ERROR" in resp:
time.sleep(5)
self.__serial.write(b"AT+SMSWBOOT=1,0\r\n")
resp = self.read_rsp(100)
if debug:
print('AT+SMSWBOOT=1,0 returned: {}'.format(
resp))
if b'OK' in resp:
self.__serial.write(b"AT^RESET\r\n")
resp = self.read_rsp(100)
if debug:
print('AT^RESET returned: {}'.format(resp))
return True
else:
print(
'Received ERROR from AT+SMSWBOOT=1,0! Aborting!'
)
return False
self.wait_for_modem(send=False,
echo_char='.',
expected=b'+SYSSTART')
elif sqnup_result is not None:
print(
'Upgrade failed with result {}!'.format(sqnup_result))
print('Please check your firmware file(s)')
else:
print("Invalid response after upgrade... aborting.")
reconnect_uart()
sys.exit(1)
self.__serial.write(b"AT\r\n")
self.__serial.write(b"AT\r\n")
time.sleep(0.5)
if 'success' in sqnup_result:
self.__serial.write(b"AT+SQNSUPGRADENTF=\"success\"\r\n")
self.__serial.read()
return True
elif sqnup_result is None:
print(
'Modem upgrade was unsucessfull. Please check your firmware file(s)'
)
return False
def __check_br(self, br_only=False, verbose=False, debug=False):
old_br = None
old_sw = None
if debug: print("Checking bootrom & application")
self.__serial.write(b"AT!=\"showver\"\r\n")
time.sleep(.5)
shver = self.read_rsp(2000)
if shver is not None:
for line in shver.decode('ascii').split('\n'):
if debug: print('Checking line {}'.format(line))
if "Bootloader0" in line:
old_br = "[33080]" in line
if debug: print("old_br: {}".format(old_br))
if "Software" in line:
old_sw = "[33080]" in line
if debug: print("old_sw: {}".format(old_sw))
if old_br is None or old_sw is None:
if debug: print("Returning: None")
return None
if old_br and (br_only or not old_sw):
if debug: print("Returning: True")
return True
if debug: print("Returning: False")
return False
def wakeup_modem(self,
baudrate,
port,
max_try,
delay,
debug,
msg='Attempting AT wakeup...'):
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
self.__serial = UART(1,
baudrate=baudrate,
pins=self.__pins,
timeout_chars=1)
MAX_TRY = max_try
count = 0
if msg is not None:
print(msg)
self.__serial.read()
self.__serial.write(b"AT\r\n")
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
while (not b'OK' in response) and (count < MAX_TRY):
count = count + 1
if debug: print('count={}'.format(count))
time.sleep(delay)
self.__serial.read()
self.__serial.write(b"AT\r\n")
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
if 'FiPy' in sysname or 'GPy' in sysname:
self.__serial = UART(1,
baudrate=baudrate,
pins=self.__pins,
timeout_chars=100)
return count < MAX_TRY
def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only,
debug):
MAX_TRY = max_try
count = 0
print('Attempting AT auto-negotiation...')
self.__serial.write(b"AT\r\n")
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
while (not b'OK' in response) and (count < MAX_TRY):
count = count + 1
if debug: print('count={}'.format(count))
time.sleep(1)
self.__serial.read()
self.__serial.write(b"AT\r\n")
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
if b'OK' in response:
self.__serial.read()
cmd = "AT+IPR=%d\n" % baudrate
if debug: print('Setting baudrate to {}'.format(baudrate))
self.__serial.write(cmd.encode())
response = self.read_rsp(size=6)
if debug: print('{}'.format(response))
if b'OK' in response:
if atneg_only:
return True
if 'FiPy' in self.__sysname or 'GPy' in self.__sysname:
self.__serial = UART(1,
baudrate=baudrate,
pins=self.__pins,
timeout_chars=100)
else:
self.__serial = None
self.__serial = serial.Serial(port,
baudrate,
bytesize=serial.EIGHTBITS,
timeout=0.1)
self.__serial.reset_input_buffer()
self.__serial.reset_output_buffer()
self.__serial.flush()
self.__serial.read()
if debug: print('Checking SMOD')
self.__serial.write(b"AT+SMOD?\r\n")
response = self.read_rsp(size=1)
if b'0' in response:
if debug: print("AT+SMOD? returned {}".format(response))
self.__serial.read()
return True
else:
print('ERROR in AT+SMOD returned {}'.format(response))
return False
else:
print('ERROR in AT+IPR={} returned {}'.format(
baudrate, response))
return False
else:
print(
'ERROR sending AT command... no response? {}'.format(response))
return False
time.sleep(1)
return True
def uart_mirror(self, color):
import pycom
pycom.heartbeat(False)
time.sleep(.5)
pycom.rgbled(color)
LTE.modem_upgrade_mode()
def success_message(self, port=None, verbose=False, debug=False):
print("Your modem has been successfully updated.")
print("Here is the current firmware version:\n")
self.show_version(port=port, verbose=verbose, debug=debug)
def upgrade(self,
ffile,
mfile=None,
baudrate=921600,
retry=False,
resume=False,
debug=False,
pkgdebug=False,
verbose=False,
load_fff=True):
success = True
if not retry and mfile is not None:
if resume or self.__check_br(
br_only=True, verbose=verbose, debug=debug):
success = False
success = self.__run(bootrom=True,
resume=resume,
switch_ffh=True,
direct=False,
debug=debug,
pkgdebug=pkgdebug,
verbose=verbose)
time.sleep(1)
else:
print('{} is not required. Resumining normal upgrade.'.format(
mfile))
mfile = None
success = True
if debug: print('Success1? {}'.format(success))
if success:
if mfile is not None:
success = False
success = self.__run(file_path=mfile,
load_ffh=True,
direct=False,
baudrate=baudrate,
debug=debug,
pkgdebug=pkgdebug,
verbose=verbose)
time.sleep(1)
else:
success = True
else:
print('Unable to upgrade bootrom.')
if debug: print('Success2? {}'.format(success))
if success:
if self.__run(file_path=ffile,
resume=True if mfile is not None else resume,
baudrate=baudrate,
direct=False,
debug=debug,
pkgdebug=pkgdebug,
verbose=verbose,
load_fff=False if mfile else load_fff):
if self.__check_br(verbose=verbose, debug=debug):
self.__run(bootrom=True,
debug=debug,
direct=False,
pkgdebug=pkgdebug,
verbose=verbose,
load_fff=True)
self.success_message(verbose=verbose, debug=debug)
else:
print('Unable to load updater from {}'.format(mfile))
def upgrade_uart(self,
ffh_mode=False,
mfile=None,
retry=False,
resume=False,
color=0x050505,
debug=False,
pkgdebug=False,
verbose=False,
load_fff=True):
success = False
try:
success = hasattr(LTE, 'modem_upgrade_mode')
except:
success = False
if not success:
print('Firmware does not support LTE.modem_upgrade_mode()!')
reconnect_uart()
sys.exit(1)
print('Preparing modem for upgrade...')
if not retry and ffh_mode:
success = False
success = self.__run(bootrom=True,
resume=resume,
switch_ffh=True,
direct=False,
debug=debug,
pkgdebug=pkgdebug,
verbose=verbose)
time.sleep(1)
if success:
if mfile is not None:
success = False
success = self.__run(file_path=mfile,
load_ffh=True,
direct=False,
debug=debug,
pkgdebug=pkgdebug,
verbose=verbose)
if debug: print('Success2? {}'.format(success))
if success:
self.__run(mirror=True,
load_ffh=False,
direct=False,
rgbled=color,
debug=debug,
verbose=verbose)
else:
print('Unable to load updater from {}'.format(mfile))
else:
self.__run(mirror=True,
load_ffh=ffh_mode,
direct=False,
rgbled=color,
debug=debug,
verbose=verbose)
else:
print('Unable to upgrade bootrom.')
def show_version(self, port=None, debug=False, verbose=False):
self.__run(port=port, debug=debug, version_only=True, verbose=verbose)
def upgrade_ext(self,
port,
ffile,
mfile,
resume=False,
debug=False,
pkgdebug=False,
verbose=False,
load_fff=True):
success = True
if mfile is not None:
success = False
success = self.__run(file_path=mfile,
load_ffh=True,
port=port,
debug=debug,
pkgdebug=pkgdebug,
verbose=verbose)
if success:
if self.__run(file_path=ffile,
resume=True if mfile is not None else resume,
direct=False,
port=port,
debug=debug,
pkgdebug=pkgdebug,
verbose=verbose,
load_fff=load_fff):
self.success_message(port=port, verbose=verbose, debug=debug)
else:
print('Unable to load updater from {}'.format(mfile))
#gps = UART(2, 9600, rx=12, tx=27) #gps.init(9600, rx=12, tx=27) gps_nrst = machine.Pin(21, machine.Pin.OUT) gps_nrst.value(0) #HPM partikkelsensor i kun skrivemodus for å unngå å blir overhumplet av data #hpm = UART(2, 9600, rx=32, tx=26) #hpm.init(9600, rx=32, tx=26) #hpm.flush() #hpm.read() #hpm.write(bytes([0x68, 0x01, 0x20, 0x77])) #Stop auto send #Setter HPM i skrive og lesemodus hpm = UART(2, 9600, rx=25, tx=26) hpm.init(9600, rx=25, tx=26) hpm.flush() hpm.write(bytes([0x68, 0x01, 0x20, 0x77])) #Stop auto send hpm.flush() hpm.write(bytes([0x68, 0x01, 0x01, 0x96])) #Start målinger (ikke autosend) #lora lora = UART(1, 57600, rx=16, tx=17) lora.init(57600, rx=16, tx=17) lora_nrst = machine.Pin(4, machine.Pin.OUT) lora_nrst.value(0) time.sleep(1) lora_nrst.value(1) time.sleep(2) #Funksjon for å skrive til lorabrikken
