def get(dev_eui):
"""
:param dev_eui: bytes
:return:
"""
Assertions.a_eui(dev_eui)
info = db0.hgetall(ConstDB0.dev + hexlify(dev_eui).decode())
Logger.info(info)
try:
addr = info[b'addr']
app_eui = info[b'app_eui']
nwkskey = info[b'nwkskey']
appskey = info.get(b'appskey', b'')
fcnt_up = int(info[b'fcnt_up'])
fcnt_down = int(info[b'fcnt_down'])
dev_class = ClassType(info[b'dev_class'].decode())
adr = bool(int(info[b'adr']))
check_fcnt = bool(int(info[b'check_fcnt']))
return Device(dev_eui=dev_eui,
addr=addr,
app_eui=app_eui,
nwkskey=nwkskey,
appskey=appskey,
fcnt_up=fcnt_up,
fcnt_down=fcnt_down,
dev_class=dev_class,
adr=adr,
check_fcnt=check_fcnt)
except Exception as error:
Logger.error(action=Action.object,
type=IDType.device,
id=hexlify(dev_eui).decode(),
msg='Get Device ERROR: %s' % error)
class RequestHandler(object):
def __init__(self):
self.logger = Logger().get_logger()
def get(self, url, **kwargs):
try:
params = kwargs.get('params')
headers = kwargs.get('headers')
rsp = requests.get(url, params=params, headers=headers)
time_consuming = rsp.elapsed.microseconds / 1000
self.logger.info('请求耗时: %s ms' % (time_consuming))
return rsp
except Exception as e:
self.logger.error('Get 请求 %s 错误: %s' % (url, e))
def post(self, url, **kwargs):
try:
params = kwargs.get('params')
data = kwargs.get('data')
r_json = kwargs.get('json')
headers = kwargs.get('headers')
self.logger.info(f"请求地址: {url}")
rsp = requests.post(url,
params=params,
data=data,
json=r_json,
headers=headers)
time_consuming = rsp.elapsed.microseconds / 1000
self.logger.info('请求耗时: %s ms' % (time_consuming))
return rsp
except Exception as e:
self.logger.error('Post 请求 %s 错误: %s' % (url, e))
def get(self, gateway_id):
reslut = None
payload = {
'key': self.REQUEST_KEY,
'location': self.location_param,
'output': 'JSON'
}
try:
response = requests.get(self.REQUEST_URL,
params=payload,
timeout=self.TIMEOUT)
if response.status_code == requests.codes.ok:
response_data = response.json()
if response_data['status'] == '1':
self.normal_req(response_data, gateway_id)
code = response_data['regeocode']['addressComponent'][
'adcode']
reslut = code
else:
self.abnormal_req(response_data, gateway_id)
else:
Logger.warning(Action.get, 'Code API',
response.status_code, response.content)
except requests.exceptions.Timeout as e:
Logger.error(Action.get, 'Code API', '', 'ERROR: %s' % str(e))
# except ValueError as e:
# print('ERROR: %s' % str(e))
finally:
return reslut
def mic_verify(data, nwkskey, addr, fcnt, mic):
"""
:param data: bytes
:param nwkskey: bytes
:param addr: int
:param dir: Const.DIR_UP or Const.DIR_DOWN
:param fcnt: tuple
:param mic: bytes
:return:
"""
len_fcnt = len(fcnt)
if len_fcnt == 1:
mic_compute = LoRaCrypto.compute_mic(data, nwkskey, addr, Const.DIR_UP, fcnt[0])
if mic_compute == mic:
return fcnt[0]
else:
Logger.error(action=Action.mic, msg='fcnt:%s, data:%s, nwkskey:%s, addr:%s, dir_up:%s, mic_compute:%s, mic:%s' % (fcnt[0],data,nwkskey,addr,Const.DIR_UP, mic_compute,mic))
raise MICError()
elif len_fcnt == 2:
mic_compute = LoRaCrypto.compute_mic(data, nwkskey, addr, Const.DIR_UP, fcnt[0])
if mic_compute == mic:
return fcnt[0]
else:
mic_compute = LoRaCrypto.compute_mic(data, nwkskey, addr, Const.DIR_UP, fcnt[1])
if mic_compute == mic:
return fcnt[1]
else:
Logger.error(action=Action.mic, msg='fcnt:%s, data:%s, nwkskey:%s, addr:%s, dir_up:%s, mic_compute:%s, mic:%s' % (fcnt[1],data,nwkskey,addr,Const.DIR_UP, mic_compute,mic))
raise MICError()
else:
raise AssertionError('mic_verify Error')
def analyze_mac_cmd_ans(device, mac_cmd):
"""
:param mac_fhdr_fopts: bytes
:return:dict
"""
while len(mac_cmd) != 0:
cid = mac_cmd[0]
try:
if 128 <= cid <= 255:
Logger.info(action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg='Proprietary MAC CMD:% cid' % cid)
return
cmd_payload_len = MACConst.mac_cmd_up_len[cid]
cmd_payload = mac_cmd[1:cmd_payload_len + 1]
mac_cmd = mac_cmd[cmd_payload_len + 1:]
cid_switch(device, cid, cmd_payload)
except KeyError as error:
Logger.error(action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg='ERROR: %s' % error)
return
except AssertionError as error:
Logger.error(action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg='ERROR: %s' % error)
return
def write_join_accept_data(dev_eui, data):
join_device = JoiningDev.objects.get(dev_eui)
if join_device:
mac_addr_list = JoinDevGateway.list_mac_addr_by_score(dev_eui)
for mac_addr in mac_addr_list:
gateway = Gateway.objects.get(mac_addr)
trans_params = JoinTransParams.objects.get(dev_eui,
gateway.mac_addr)
pull_info = PullInfo.objects.get_pull_info(gateway.mac_addr)
if len(trans_params) > 0 and pull_info is not None:
txpk = pack_join_accept_data(trans_params, data,
join_device.app.freq_plan)
json_data = {'txpk': txpk}
prot_ver = bytes([pull_info.prot_ver])
packet = prot_ver + get_random_token(
) + Const.PULL_RESP_IDENTIFIER
packet = packet + json.dumps(json_data).encode()
msg_dn = OTAAMsgDn(app_eui=join_device.app.app_eui,
dev_eui=join_device.dev_eui,
trans_params=txpk,
ts=time.time())
msg_dn.publish()
return packet, pull_info
else:
Logger.error(action=Action.otaa,
type=IDType.device,
id=dev_eui,
msg='JoiningDev does not exists')
def base64_decode(data):
missing_padding = 4 - len(data) % 4
if missing_padding:
data += '=' * missing_padding
try:
return a2b_base64(data)
except binascii.Error:
Logger.error(action=Action.rxpk, msg='Invalid base64 string: %s' % data)
return None
def set_value(self, **kwargs):
pipe = db0.pipeline()
for name, value in kwargs.items():
if name in DevInfo.fields:
pipe.hset(self.key, name, value)
else:
Logger.error(action=Action.mac_cmd_get,
type=IDType.dev_info,
id=hexlify(self.dev_eui).decode(),
msg='DevInfo set_value unknow name:' % name)
return
pipe.execute()
def stat_rssi_snr(self, g_id=None, start_ts=0, end_ts=-1):
info = []
if end_ts == -1:
end_ts = float('inf')
if g_id is not None:
g_id = hexlify(g_id).decode()
cursor = 0
while True:
result = db15.scan(cursor=cursor,
match=ConstDB15.M + self.dev_eui + ':*')
cursor = result[0]
m_key_list = result[1]
for m_key in m_key_list:
try:
ts = int(m_key.decode().split(':')[2])
if start_ts < ts < end_ts:
lng, lat, alt = db15.hmget(m_key,
['lng', 'lat', 'alt'])
if g_id:
one = db15.hmget(
ConstDB15.G + self.dev_eui + ':' + g_id + ':' +
str(ts), ['rssi', 'lsnr'])
rssi = float(one[0])
lsnr = float(one[1])
else:
g_key_list = db2.zrevrange(
'%s%s:%s' %
(ConstDB2.up_gw_s, self.dev_eui, ts), 0, 0)
# pipe = db15.pipeline()
# for g_key in g_key_list:
# pipe.hmget(g_key, ['rssi', 'lsnr'])
# hh = pipe.execute()
# best = max(hh, key=lambda x: float(x[0]))
# lsnr = float(best[1])
# rssi = float(best[0])
g_key = g_key_list[0].decode()
best = db15.hmget(
'%s%s:%s:%s' %
(ConstDB15.G, self.dev_eui, g_key, ts),
['rssi', 'lsnr'])
rssi, lsnr = float(best[0]), float(best[1])
info.append({
'lng': float(lng),
'lat': float(lat),
'alt': float(alt),
'rssi': rssi,
'lsnr': lsnr
})
except Exception as error:
Logger.error('LoRaMote: %s' % error)
if cursor == 0:
break
return info
def get_pull_info(cls, mac_addr):
key = ConstDB0.gateway_pull + hexlify(mac_addr).decode()
info = db0.hgetall(key)
try:
ip_addr = PullInfo.ip_addr_str_to_tuple(
info[b'ip_addr'].decode())
prot_ver = int(info[b'prot_ver'])
return PullInfo(mac_addr, ip_addr, prot_ver)
except Exception as error:
Logger.error(action=Action.object,
type=IDType.pull_info,
id=key,
msg=str(error))
def p_to_c(self, *args):
pipe = db0.pipeline()
for arg in args:
value = db0.hget(self.key, 'p_' + arg)
if value is not None:
pipe.hset(self.key, arg, value)
pipe.hdel(self.key, 'p_' + arg)
else:
Logger.error(action=Action.mac_cmd_send,
type=IDType.dev_info,
id=hexlify(self.dev_eui).decode(),
msg='No P value can be set to C: %s' % arg)
return
pipe.execute()
def get(mac_addr):
info = db0.hmget(ConstDB0.gateway + hexlify(mac_addr).decode(),
Gateway.fields)
try:
user_id = int(info[0])
freq_plan = FrequencyPlan(info[1].decode())
public = bool(int(info[2]))
disable = bool(int(info[3]))
return Gateway(mac_addr, user_id, freq_plan, public, disable)
except Exception as error:
Logger.error(action=Action.object,
type=IDType.gateway,
id=hexlify(mac_addr).decode(),
msg='Get Gateway ERROR: %s' % error)
return None
def pack_down_data(trans_parms, data, rx_window, device):
FREQ_PLAN = frequency_plan[device.app.freq_plan]
tx_params = device.get_tx_params()
s_time = 0
txpk = {}
txpk['rfch'] = FREQ_PLAN.RF_CH
txpk['powe'] = 14
txpk['modu'] = trans_parms['modu']
if txpk['modu'] == 'LORA':
txpk['codr'] = trans_parms['codr']
txpk['ipol'] = True # rossi support
# elif txpk['modu'] == 'FSK':
# txpk['fdev'] = 3000
txpk['prea'] = 8
txpk['size'] = len(data)
txpk['data'] = b2a_base64(data).decode().rstrip('\n')
# txpk['ncrc'] = False
if device.dev_class == ClassType.b:
b_info = BTiming(ConstDB0.dev + hexlify(device.dev_eui).decode(), time.time())
s_time = b_info.ping_time()
txpk['time'] = datetime.utcfromtimestamp(s_time).isoformat() + 'Z'
txpk['freq'] = FREQ_PLAN.b_freq()
txpk['datr'] = FREQ_PLAN.DataRate(b_info.datr).name
elif rx_window == 1:
datr = FREQ_PLAN.DataRate[trans_parms['datr']]
txpk['datr'] = FREQ_PLAN.rx1_datr(datr.value, tx_params['RX1DRoffset']).name
txpk['freq'] = FREQ_PLAN.rx1_freq(float(trans_parms['freq']))
txpk['tmst'] = int(trans_parms['tmst']) + tx_params['RxDelay'] * 1000000 # 1us step upadd;
try:
ts = iso_to_utc_ts(trans_parms['time'])
s_time = ts + tx_params['RxDelay']
except Exception as error:
Logger.error(action=Action.downlink, type=IDType.device, id=device.dev_eui, msg=str(error))
elif rx_window == 2:
datr = FREQ_PLAN.DataRate(tx_params['RX2DataRate'])
txpk['datr'] = datr.name
txpk['freq'] = tx_params['RX2Frequency']
if device.dev_class == ClassType.c:
txpk['imme'] = True
s_time = time.time()
elif device.dev_class == ClassType.a:
txpk['tmst'] = int(trans_parms['tmst']) + (tx_params['RxDelay'] + 1) * 1000000
try:
ts = iso_to_utc_ts(trans_parms['time'])
s_time = ts + tx_params['RxDelay'] + 1
except Exception as error:
Logger.error(action=Action.downlink, type=IDType.device, id=device.dev_eui, msg=str(error))
return txpk, s_time
def _iterate(strat_file_name, coin, tf_ind: str = '15m'):
try:
strat_class = utils.import_file('strategy',
strat_file_name + '.py')
# Create a cerebro entity
# cerebro = bt.Cerebro(cheat_on_open=True)
cerebro = bt.Cerebro()
logger = Logger(logging.INFO, sys.stdout)
# Add a strategy
# cerebro.addstrategy(LiveBBStrategy, is_live=False)
cerebro.addstrategy(strat_class, is_live=False)
# Create a Data Feed
dump = Dump('binance', coin)
df = dump.get_data(tf_ind, hist_days)
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
df = dump.get_data('1m', hist_days)
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
# cerebro.resampledata(data, timeframe=bt.TimeFrame.Minutes, compression=tf_ind)
# Set our desired cash start
cerebro.broker.setcash(1000.0)
# Add a FixedSize sizer according to the stake
cerebro.addsizer(bt.sizers.PercentSizer, percents=95)
# Set the commission
cerebro.broker.setcommission(commission=0.001)
# cerebro.addobserver(bt.observers.DrawDown)
# Print out the starting conditions
# print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
# Run over everything
strat = cerebro.run(maxcpus=1)
res = int(strat[0].broker.getvalue())
ret = (res, '%s, tf_ind=%s' % (coin, tf_ind))
print(ret)
return ret
except Exception as e:
logger.error(e)
print(e)
return (0, str(e))
def _run(self):
result = write_join_accept_data(self.dev_eui, self.data)
if not result:
Logger.error(action=Action.otaa,
msg='No packet, pull_info return!!!')
return
packet = result[0]
pull_info = result[1]
if pull_info.prot_ver == 2:
resend = ReSender(pull_info, packet, self.server)
resend.start()
self.server.sendto(packet, pull_info.ip_addr)
Logger.info(action=Action.otaa,
type=IDType.ip_addr,
id='%s:%d' % pull_info.ip_addr,
msg='SENT JOIN ACCEPT %s' % packet)
def _iterate(*args):
try:
strat_file_name, coin, tf, kwargs = args
# coin = args[1]
# tf = args[2]
strat_class = utils.import_file('strategy',
strat_file_name + '.py')
cerebro = bt.Cerebro()
logger = Logger(logging.INFO, sys.stdout)
kwargs['is_live'] = False
cerebro.addstrategy(strat_class, **kwargs)
# Create a Data Feed
dump = Dump('binance', coin)
df = dump.get_data(tf, hist_days)
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
df = dump.get_data('1m', hist_days)
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
# Set our desired cash start
cerebro.broker.setcash(1000.0)
# Add a FixedSize sizer according to the stake
cerebro.addsizer(bt.sizers.PercentSizer, percents=95)
# Set the commission
cerebro.broker.setcommission(commission=0.001)
# Run over everything
strat = cerebro.run(maxcpus=1)
res = int(strat[0].broker.getvalue())
# ret = (res, '%s, coin=%s, tf=%s, stperiod=%s, mult=%s' % (res, coin, tf, kwargs['stperiod'], kwargs['mult']))
ret = (res,
'%s, %s, %s' % (res, ', '.join(args[:-1]), str(kwargs)))
print(ret)
return ret
except Exception as e:
logger.error(e)
print(e)
return (0, str(e))
def analyze_PingSlotFreqAns(device, cmd_payload):
assert len(cmd_payload) == 1, "WRONG MAC CMD PAYLOAD OF PingSlotFreqAns"
status = cmd_payload[0]
ch_ack = status & 0b1
dr_ack = status >> 1 & 0b1
rfu = status >> 2
if ch_ack & dr_ack == 1:
Logger.info(action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg='PingSlotFreqAns Success: %s, ch_ack: %s, dr_ack: %s' %
(cmd_payload, ch_ack, dr_ack))
else:
Logger.error(action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg='PingSlotFreqAns Fqil: %s, ch_ack: %s, dr_ack: %s' %
(cmd_payload, ch_ack, dr_ack))
def analyze_NewChannelAns(device, cmd_payload):
assert len(cmd_payload) == 1, 'WRONG MAC CMD PAYLOAD OF NewChannelAns'
# logger.info(ConstLog.mac_cmd+'analyze_NewChannelAns')
status = cmd_payload[0]
ch_ack = status & 0b1
dr_ack = status >> 1 & 0b1
rfu = status >> 2
if ch_ack & dr_ack == 1:
Logger.info(action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg='DevStatusAns Success: %s, ch_ack: %d, dr_ack: %d' %
(cmd_payload, ch_ack, dr_ack))
else:
Logger.error(action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg='DevStatusAns Fail: %s, ch_ack: %d, dr_ack: %d' %
(cmd_payload, ch_ack, dr_ack))
class AssertSetIF(object):
def __init__(self, project):
self.project = project
self.failList = []
self.logger = Logger(self.project).get_logger()
def assertIn(self, member, container, msg=''):
try:
if member in container:
self.logger.info('测试通过: %s' % msg)
else:
raise AssertionError
except Exception:
expectedMsg = '预期结果: %s' % (member)
failMsg = ('测试未通过: %s, %s' % (msg, expectedMsg))
self.logger.error(failMsg)
self.failList.append(failMsg)
def assertEqual(self, par1, par2, msg=''):
try:
if par1 == par2:
self.logger.info('测试通过: %s' % msg)
else:
raise AssertionError
except Exception:
expectedMsg = '预期结果: %s' % (par1)
failMsg = ('测试未通过: %s, %s' % (msg, expectedMsg))
self.logger.error(failMsg)
self.failList.append(failMsg)
def assertNotIn(self, member, container, msg=''):
try:
if member not in container:
self.logger.info('测试通过: %s' % msg)
else:
raise AssertionError
except Exception:
expectedMsg = '预期结果: %s' % (member)
failMsg = ('测试未通过: %s, %s' % (msg, expectedMsg))
self.logger.error(failMsg)
self.failList.append(failMsg)
def assertNotEqual(self, par1, par2, msg=''):
try:
if par1 != par2:
self.logger.info('测试通过: %s' % msg)
else:
raise AssertionError
except Exception:
expectedMsg = '预期结果: %s' % (par1)
failMsg = ('测试未通过: %s, %s' % (msg, expectedMsg))
self.logger.error(failMsg)
self.failList.append(failMsg)
def _run(strat_file_name, coin, tf, kwargs):
# def _run(*args):
try:
# strat_file_name, coin, tf, kwargs = args
strat_class = utils.import_file('strategy',
strat_file_name + '.py')
cerebro = bt.Cerebro()
logger = Logger(logging.INFO, sys.stdout)
kwargs['is_live'] = False
cerebro.addstrategy(strat_class, **kwargs)
# Create a Data Feed
dump = Dump('binance', coin)
df = dump.get_data(tf, hist_days)
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
df = dump.get_data('1m', hist_days)
data = bt.feeds.PandasData(dataname=df)
# cerebro.adddata(data)
# Set our desired cash start
cerebro.broker.setcash(1000.0)
# Add a FixedSize sizer according to the stake
cerebro.addsizer(bt.sizers.PercentSizer, percents=95)
# Set the commission
cerebro.broker.setcommission(commission=0.001)
# Run over everything
strat = cerebro.run(maxcpus=1)
# Print out the final result
print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())
# Plot the result
cerebro.plot()
except Exception as e:
logger.error(e)
print(e)
def obj_to_dict(self):
dd = {
FieldDevice.name: self.name,
FieldDevice.dev_eui: hexlify(self.dev_eui).decode(),
FieldDevice.app_eui: hexlify(self.app_eui).decode(),
FieldDevice.active_mode: self.active_mode.value,
'freq_plan': self.app.freq_plan.value,
}
if self.join_device:
dd[FieldDevice.appkey] = hexlify(self.join_device.appkey).decode()
if self.active_at:
dd[FieldDevice.active_at] = self.active_at.isoformat()
dd[FieldDevice.addr] = hexlify(self.addr).decode()
dd[FieldDevice.nwkskey] = hexlify(self.nwkskey).decode()
dd[FieldDevice.appskey] = hexlify(self.appskey).decode()
dd[FieldDevice.fcnt_up] = self.fcnt_up
dd[FieldDevice.fcnt_down] = self.fcnt_down
dd[FieldDevice.dev_class] = self.dev_class.value
if self.dev_class == ClassType.b:
dd[FieldDevice.datr] = self.datr
dd[FieldDevice.periodicity] = self.periodicity
dd[FieldDevice.adr] = self.adr
dd[FieldDevice.check_fcnt] = self.check_fcnt
dd['que_down'] = self.que_down.len()
last_up_link = getattr(
self.trans_status, 's_time',
getattr(self.trans_status, 'time',
None)) if self.trans_status else 'No Connection'
if last_up_link == '':
Logger.error(action=Action.get,
resource=Resource.trans_params,
id=self.dev_eui,
msg=str(self.trans_params))
dd['last_up_link'] = last_up_link
dd[FieldInfo.MaxDutyCycle] = self.MaxDutyCycle
dd[FieldInfo.RX1DRoffset] = self.RX1DRoffset
dd[FieldInfo.RX2DataRate] = self.RX2DataRate
dd[FieldInfo.RX2Frequency] = self.RX2Frequency
dd[FieldInfo.RxDelay] = self.RxDelay
dd[FieldInfo.battery] = self.battery
dd[FieldInfo.snr] = self.snr
return dd
def adr_base_on_pk_stg(device):
mac_addr = Gateway.objects.best_mac_addr(device.dev_eui)
if mac_addr is None:
Logger.error(action=Action.adr,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg="Gateway.objects.best_mac_addr return None")
return
tran_params = TransParams.objects.get(device.dev_eui, mac_addr)
pk_stg = float(tran_params['rssi']) + float(tran_params['lsnr']) * 0.25
FREQ_PLAN = frequency_plan[device.app.freq_plan]
recent_datr = FREQ_PLAN.DataRate[tran_params['datr']].value
required_datr = FREQ_PLAN.adr_schema(pk_stg, recent_datr)
if recent_datr < required_datr:
shift_to(device.dev_eui, recent_datr + 1, FREQ_PLAN)
elif recent_datr > required_datr:
shift_to(device.dev_eui, recent_datr - 1, FREQ_PLAN)
else:
Logger.info(action=Action.adr,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg="do not need to shift")
def _run(self):
self.ps.subscribe(CHANNEL_TX_ACK)
try:
for i in range(0, 3):
start = time.time()
while time.time() - start < 0.1:
sleep(0.05)
for item in self.ps.listen():
# item = self.ps.get_message(timeout=0.05)
Logger.debug(action=Action.resend,
type=IDType.ip_addr,
id=self.pull_info.ip_addr,
msg='Get Publish TX, %s' % item)
if item is not None and item['data'] == self.token:
Logger.info(action=Action.resend,
type=IDType.ip_addr,
id=self.pull_info.ip_addr,
msg='Get Publish TX, %s' % item)
self.ps.unsubscribe()
self.ps.close()
return
self.server.sendto(self.packet, self.pull_info.ip_addr)
Logger.error(action=Action.resend,
type=IDType.ip_addr,
id=self.pull_info.ip_addr,
msg='Resend data %s : %s' % (i, self.packet))
Logger.error(
action=Action.resend,
type=IDType.gateway,
id=self.pull_info.ip_addr,
msg='No TX_ACK got, PULL_RESP may not received by gateway')
except Exception as error:
logger.error(str(error))
finally:
try:
self.ps.unsubscribe()
self.ps.close()
except Exception as error:
logger.error(str(error))
def analyze_RXParamSetupAns(device, cmd_payload):
assert len(cmd_payload) == 1, 'WRONG MAC CMD PAYLOAD OF RXParamSetupAns'
status = cmd_payload[0]
channel_ack = status & 0b1
RX2DataRate_ack = status >> 1 & 0b1
RX1DRoffset_ack = status >> 2 & 0b1
rfu = status >> 3
if channel_ack & RX1DRoffset_ack & RX2DataRate_ack == 1:
Logger.info(action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg='RXParamSetupAns Success: %s' % cmd_payload)
DevInfo(device.dev_eui).p_to_c('RX1DRoffset', 'RX2DataRate',
'RX2Frequency')
else:
Logger.error(
action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg=
'RXParamSetupAns Fail: %s, channel_ack: %d, RX1DRoffset_ack: %d, RX2DataRate_ack: %d'
% (cmd_payload, channel_ack, RX1DRoffset_ack, RX2DataRate_ack))
def init_on_load(self):
if self.active_at:
info = db0.hgetall(ConstDB.dev + hexlify(self.dev_eui).decode())
try:
self.addr = info[b'addr']
self.nwkskey = info[b'nwkskey']
self.appskey = info.get(b'appskey', b'')
self.fcnt_up = int(info[b'fcnt_up'])
self.fcnt_down = int(info[b'fcnt_down'])
self.dev_class = ClassType(info[b'dev_class'].decode())
self.adr = bool(int(info[b'adr']))
self.check_fcnt = bool(int(info[b'check_fcnt']))
self.que_down = QueDownDev(self.dev_eui)
self.trans_status = TransStatus.objects.best(self.dev_eui)
self.__get_more_info()
if self.dev_class == ClassType.b:
self.get_b_info()
except (KeyError, TypeError) as error:
Logger.error(action=Action.get,
resource=Resource.device,
id=self.dev_eui,
msg=str(error))
def read_push_data(json_data, gateway, *args):
if isinstance(json_data, dict):
if 'rxpk' in json_data:
for data_raw in json_data['rxpk']:
gateway.frequency_statistics(data_raw['freq'])
data = base64_decode(data_raw.pop('data'))
if data is not None:
major = data[0] & 0b11
if major != 0:
Logger.error(action=Action.uplink, msg='ERROR: Major != 0, Major = %s' % major)
continue
mtype = data[0] >> 5
if mtype == MType.JOIN_REQUEST:
try:
otaa = OTAAJoin(request_msg=data, trans_params=data_raw, gateway=gateway)
otaa.start()
except Exception as error:
Logger.error(action=Action.otaa, msg='REQUEST: %s; ERROR: %s' % (data, error))
elif mtype == MType.UNCONFIRMED_DATA_UP or mtype == MType.CONFIRMED_DATA_UP:
dev_addr = endian_reverse(data[1:5])
device = Device.objects.get_device_by_addr(dev_addr)
if device is None:
Logger.error(action=Action.data_up, type=IDType.dev_addr, id=hexlify(dev_addr).decode(), msg='Can\'t Find Device for this DevAddr')
continue
if gateway.public is not True and device.app.user_id != gateway.user_id:
Logger.error(action=Action.data_up, msg='Gateway %s is not Public and device % s is not belong to the same user' % (gateway.mac_addr, device.dev_eui))
continue
ReadDataUp(device.dev_eui, gateway, data_raw, mtype, data, *args).start()
elif mtype == MType.PTY:
dev_addr == endian_reverse(data[1:5])
device = Device.objects.get_device_by_addr(dev_addr)
if device is None:
Logger.error(action=Action.proprietary, type=IDType.dev_addr, id=hexlify(dev_addr).decode(), msg='Can\'t Find Device for this DevAddr')
ReadPTY(dev_eui=device.dev_eui, gateway=gateway, trans_params=data_raw, mtype=mtype, data=data).start()
if 'stat' in json_data:
stat = json_data['stat']
gateway_stat = GatewayStatus(gateway.mac_addr, stat['lati'], stat['long'], stat['alti'])
gateway_stat.save()
class ReadData(object):
root_dir = os.path.abspath("test_data")
def __init__(self, file_name):
self.file_path = f"{self.root_dir}/{file_name}"
self.logger = Logger().get_logger()
def read_json(self):
try:
with open(self.file_path, encoding="utf-8") as file:
json_data = json.loads(file.read())
return json_data
except Exception as e:
self.logger.error(f"读取json文件错误: {e}")
def read_excel(self):
try:
data = list()
book = xlrd.open_workbook(self.file_path)
sheet = book.sheet_by_index(0)
rows = sheet.nrows
cols = sheet.ncols
# 第一行是标题, 从第二行读取
for r in range(1, rows):
row_data = list()
for c in range(cols):
ctype = sheet.cell(r, c).ctype # 表格的数据类型
cell = sheet.cell_value(r, c)
if ctype == 2 and cell % 1 == 0: # 整型
cell = int(cell)
elif ctype == 3:
# 转成datetime对象
date = datetime(*xldate_as_tuple(cell, 0))
cell = date.strftime('%Y/%d/%m %H:%M:%S')
elif ctype == 4:
cell = True if cell == 1 else False
row_data.append(cell)
data.append(row_data)
return data
except Exception as e:
self.logger.error(f"读取excel错误: {e}")
def read_csv(self):
try:
data = list()
with open(self.file_path, "r") as file:
reader = csv.reader(file)
# 忽略第一行title
next(reader)
for item in reader:
data.append(item)
return data
except Exception as e:
self.logger.error(f"读取csv错误: {e}")
def read_ymal(self):
return
def analyze_LinkADRAns(device, cmd_payload):
assert len(cmd_payload) == 1, 'WRONG MAC CMD PAYLOAD OF LinkADRAns'
cmd_payload = cmd_payload[0]
channel_mask_ack = cmd_payload & 0b1
data_rate_ack = cmd_payload >> 1 & 0b1
power_ack = cmd_payload >> 2 & 0b1
rfu = cmd_payload >> 3
if channel_mask_ack & data_rate_ack & power_ack == 1:
Logger.info(
action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg=
'LinkADRAns Success: %s, power_ack: %d, channel_mask_ack: %d, data_rate_ack: %d'
% (cmd_payload, power_ack, channel_mask_ack, data_rate_ack))
else:
Logger.error(
action=Action.mac_cmd_get,
type=IDType.device,
id=hexlify(device.dev_eui).decode(),
msg=
'LinkADRAns Fail: %s, power_ack: %d, channel_mask_ack: %d, data_rate_ack: %d'
% (cmd_payload, power_ack, channel_mask_ack, data_rate_ack))
def handle(self, data, address):
t0 = time.time()
protocol_version = data[0]
token = data[1:3]
data_type = data[3]
gateway_mac_addr = data[4:12]
gateway = Gateway.objects.get(gateway_mac_addr)
if gateway is not None:
p_token = g_token.get(gateway.mac_addr)
g_token[gateway.mac_addr] = token
gateway.set_time(time.time())
if data_type == Const.PUSH_DATA_IDENTIFIER:
try:
datagram = json.loads(data[12:].decode())
except Exception as error:
Logger.error(msg='%s' % error,
type=IDType.gateway,
action=Action.push_data,
id='%s' % hexlify(gateway.mac_addr).decode())
return
push_ack = write_push_ack(token, protocol_version)
self.socket.sendto(push_ack, address)
t1 = time.time()
Logger.info(msg='%s' % push_ack,
type=IDType.gateway,
action=Action.push_ack,
id='%s' % hexlify(gateway.mac_addr).decode())
if p_token != token:
Logger.info(msg='NEW: %s ' % data,
type=IDType.gateway,
action=Action.push_data,
id='%s' % hexlify(gateway.mac_addr).decode())
read_push_data(datagram, gateway, t0, t1)
else:
Logger.info(msg='UDP_RETRANSMISSION: %s' % data,
type=IDType.gateway,
action=Action.push_data,
id='%s' % hexlify(gateway.mac_addr).decode())
else:
Logger.error(msg='Get Unknow Data_type: %s' % data_type,
type=IDType.gateway,
action=Action.got,
id='%s' % hexlify(gateway.mac_addr).decode())
else:
Logger.error(msg='Not Imported',
type=IDType.gateway,
action=Action.pull_ack,
id='%s' % hexlify(gateway_mac_addr).decode())
class Assertions(object):
def __init__(self):
self.logger = Logger().get_logger()
def assert_code(self, expected_code, code):
'''
校验response code
'''
try:
assert expected_code == code
return True
except Exception as e:
self.logger.error(
'Error happened in assert_code func, meet error: %s' % e)
raise
def assert_body(self, body, expected_key):
'''
校验response是否包含指定字段
'''
try:
keys = body.keys()
assert expected_key in keys
except Exception as e:
self.logger.error(
'Error happened in assert_body func, meet error: %s' % e)
raise
def assert_value(self, body, expected_value, key):
'''
校验response指定字段的值是否正确
'''
try:
actual_value = body[key]
assert actual_value == expected_value
except Exception as e:
self.logger.error(
'Error happened in assert_text func, meet error: %s' % e)
raise
