|
|
import os
|
|
|
import struct
|
|
|
import time
|
|
|
from pathlib import Path
|
|
|
from PyQt5.QtCore import QTimer
|
|
|
|
|
|
import numpy
|
|
|
|
|
|
from Agreement.CS.skio.define import AOdataPacket, DIdataPacket, AIdataPacket, HSdataPacket
|
|
|
from Agreement.CS.skio.manage import SkIO
|
|
|
from utils.WorkModels import PointModel
|
|
|
|
|
|
|
|
|
class IOMapping:
|
|
|
def __init__(self, path, uri):
|
|
|
super().__init__()
|
|
|
|
|
|
self.skio = SkIO()
|
|
|
self.skio.setup(uri, Path(os.path.join(path, 'demo')))
|
|
|
self.D_index = None
|
|
|
self.AO_index = None
|
|
|
self.AI_index = None
|
|
|
self.current_value = []
|
|
|
# self.current_value1 = None
|
|
|
# self.current_value2 = None
|
|
|
# self.current_value3 = None
|
|
|
# self.current_value4 = None
|
|
|
self.Packet_serial_No = 0x00000000
|
|
|
self.setupvalue()
|
|
|
|
|
|
def setupvalue(self):
|
|
|
self.DO_index = set()
|
|
|
self.DI_index = set()
|
|
|
self.AO_index = set()
|
|
|
self.AI_index = set()
|
|
|
self.DO_dic = {}
|
|
|
self.DI_dic = {}
|
|
|
self.AO_dic = {}
|
|
|
self.AI_dic = {}
|
|
|
self.dic = {}
|
|
|
for i in PointModel.select():
|
|
|
if i.sig_type in ('DO-24V', 'DO-48V', 'DO'):
|
|
|
self.DO_index.add(int(i.reg))
|
|
|
if i.sig_type in ('DI-24V', 'DI-48V', 'DI'):
|
|
|
self.DI_index.add(int(i.reg))
|
|
|
# if i.sig_type == 'AO' or i.sig_type == 'PT100' or i.sig_type == 'TC/T' or i.sig_type == 'RTD' or i.sig_type == 'TC':
|
|
|
if i.sig_type == 'AO' or i.sig_type == 'PT100' or i.sig_type == 'TC/T' or i.sig_type == 'RTD' or i.sig_type == 'TC/K':
|
|
|
self.AO_index.add(int(i.reg))
|
|
|
if i.sig_type == 'AI':
|
|
|
self.AI_index.add(int(i.reg))
|
|
|
self.DO_index = sorted(list(self.DO_index))
|
|
|
self.DI_index = sorted(list(self.DI_index))
|
|
|
self.AO_index = sorted(list(self.AO_index))
|
|
|
self.AI_index = sorted(list(self.AI_index))
|
|
|
self.ALL_index = list(set(self.DO_index + self.DI_index + self.AO_index + self.AI_index))
|
|
|
for i in self.DO_index:
|
|
|
self.DO_dic[i] = set()
|
|
|
for j in PointModel.select().where(PointModel.reg == i):
|
|
|
if j.sig_type in ('DO-24V', 'DO-48V', 'DO'):
|
|
|
self.DO_dic[i].add(int(j.channel))
|
|
|
for i in self.DI_index:
|
|
|
self.DI_dic[i] = set()
|
|
|
for j in PointModel.select().where(PointModel.reg == i):
|
|
|
if j.sig_type in ('DI-24V', 'DI-48V', 'DI'):
|
|
|
self.DI_dic[i].add(int(j.channel))
|
|
|
for i in self.AO_index:
|
|
|
self.AO_dic[i] = set()
|
|
|
for j in PointModel.select().where(PointModel.reg == i):
|
|
|
# if j.sig_type == 'AO' or j.sig_type == 'PT100' or j.sig_type == 'TC/T' or j.sig_type == 'RTD' or j.sig_type == 'TC':
|
|
|
if j.sig_type == 'AO' or j.sig_type == 'PT100' or j.sig_type == 'TC/T' or j.sig_type == 'RTD' or j.sig_type == 'TC/K':
|
|
|
self.AO_dic[i].add(int(j.channel))
|
|
|
for i in self.AI_index:
|
|
|
self.AI_dic[i] = set()
|
|
|
for j in PointModel.select().where(PointModel.reg == i):
|
|
|
if j.sig_type == 'AI':
|
|
|
self.AI_dic[i].add(int(j.channel))
|
|
|
for i in self.ALL_index:
|
|
|
self.dic[i] = set()
|
|
|
for j in PointModel.select().where(PointModel.reg == i):
|
|
|
self.dic[i].add(int(j.channel))
|
|
|
try:
|
|
|
for z in range(max(self.ALL_index)):
|
|
|
if z in [i-1 for i in self.ALL_index]:
|
|
|
self.current_value.append([0 for x in range(max(self.dic[z+1]))])
|
|
|
else:
|
|
|
self.current_value.append([0 for x in range(8)])
|
|
|
except:
|
|
|
return
|
|
|
# if self.DO_index == []:
|
|
|
# self.current_value1 = []
|
|
|
# else:
|
|
|
# self.current_value1 = [self.current_value[i - 1][min(self.DO_dic[i])-1:max(self.DO_dic[i])] for i in self.DO_index]
|
|
|
# if self.DI_index == []:
|
|
|
# self.current_value2 = []
|
|
|
# else:
|
|
|
# self.current_value2 = [self.current_value[i - 1][min(self.DI_dic[i])-1:max(self.DI_dic[i])] for i in self.DI_index]
|
|
|
# if self.AO_index == []:
|
|
|
# self.current_value3 = []
|
|
|
# else:
|
|
|
# self.current_value3 = [self.current_value[i - 1][min(self.AO_dic[i])-1:max(self.AO_dic[i])] for i in self.AO_index]
|
|
|
# if self.AI_index == []:
|
|
|
# self.current_value4 = []
|
|
|
# else:
|
|
|
# self.current_value4 = [self.current_value[i - 1][min(self.AI_dic[i])-1:max(self.AI_dic[i])] for i in self.AI_index]
|
|
|
self.force_value = {point.sig_name: None for point in PointModel.all_points()}
|
|
|
self.force_value_stact = {point.sig_name: False for point in PointModel.all_points()}
|
|
|
|
|
|
# def setupvalue(self):
|
|
|
# self.D_index = set()
|
|
|
# self.AO_index = set()
|
|
|
# self.AI_index = set()
|
|
|
# self.AOR_index = set()
|
|
|
# for i in PointModel.select():
|
|
|
# if i.sig_type in ('DO-24V', 'DO-48V', 'DI-24V', 'DI-48V', 'DO', 'DI'):
|
|
|
# self.D_index.add(int(i.reg))
|
|
|
# if i.sig_type == 'AO' or i.sig_type == 'PT100' or i.sig_type == 'TC/T':
|
|
|
# if '热电偶' in i.slot or 'RTD' in i.slot:
|
|
|
# self.AOR_index.add(int(i.reg))
|
|
|
# continue
|
|
|
# self.AO_index.add(int(i.reg))
|
|
|
# if i.sig_type == 'AI':
|
|
|
# self.AI_index.add(int(i.reg))
|
|
|
# self.D_index = sorted(list(self.D_index))
|
|
|
# self.AO_index = sorted(list(self.AO_index))
|
|
|
# self.AI_index = sorted(list(self.AI_index))
|
|
|
# self.AOR_index = sorted(list(self.AOR_index))
|
|
|
# self.ALL_index = self.D_index + self.AO_index + self.AI_index
|
|
|
# try:
|
|
|
# for z in range(max(self.ALL_index)):
|
|
|
# if z in [i - 1 for i in self.AO_index]:
|
|
|
# self.current_value.append([0 for x in range(32)])
|
|
|
# elif z in [i - 1 for i in self.AOR_index]:
|
|
|
# self.current_value.append([0 for x in range(16)])
|
|
|
# else:
|
|
|
# self.current_value.append([0 for x in range(8)])
|
|
|
# except:
|
|
|
# return
|
|
|
# if self.D_index == []:
|
|
|
# self.current_value1 = []
|
|
|
# else:
|
|
|
# self.current_value1 = [self.current_value[i - 1] for i in self.D_index]
|
|
|
# if self.AO_index == []:
|
|
|
# self.current_value2 = []
|
|
|
# else:
|
|
|
# self.current_value2 = [self.current_value[i - 1] for i in (self.AO_index + self.AOR_index)]
|
|
|
# if self.AI_index == []:
|
|
|
# self.current_value3 = []
|
|
|
# else:
|
|
|
# self.current_value3 = [self.current_value[i - 1] for i in self.AI_index]
|
|
|
# self.force_value = {point.sig_name: None for point in PointModel.all_points()}
|
|
|
# self.force_value_stact = {point.sig_name: False for point in PointModel.all_points()}
|
|
|
|
|
|
# 写AO
|
|
|
def setAOcurrent(self):
|
|
|
# if self.current_value2 == None:
|
|
|
# return
|
|
|
data1 = []
|
|
|
lis = [self.current_value[i - 1][min(self.AO_dic[i])-1:max(self.AO_dic[i])] for i in self.AO_index]
|
|
|
for i in lis:
|
|
|
for j in i:
|
|
|
# print(j)
|
|
|
data1.append(j)
|
|
|
# print(data1)
|
|
|
data = AOdataPacket(1, 640, self.Packet_serial_No, data1)
|
|
|
self.skio.AOwrite(data)
|
|
|
self.Packet_serial_No += 1
|
|
|
for i in zip(lis, list(self.AO_index)):
|
|
|
self.current_value[int(i[-1]) - 1][min(self.AO_dic[i[-1]])-1:max(self.AO_dic[i[-1]])] = i[0]
|
|
|
self.write_storeData(tim=time.time(), data=self.current_value)
|
|
|
|
|
|
# 写DO
|
|
|
def setDIcurrent(self):
|
|
|
# if self.current_value1 == None:
|
|
|
# return
|
|
|
DO_index = [self.DO_index[-1], self.DO_index[0]]
|
|
|
data1 = [self.current_value[i - 1][min(self.DO_dic[i])-1:max(self.DO_dic[i])] for i in self.DO_index]
|
|
|
data1 = [data1[-1],data1[0]]
|
|
|
print(data1)
|
|
|
data = DIdataPacket(2, 64, self.Packet_serial_No, data1)
|
|
|
self.skio.DIwrite(data)
|
|
|
self.Packet_serial_No += 1
|
|
|
for i in zip(data1, list(DO_index)):
|
|
|
self.current_value[int(i[-1]) - 1][min(self.DO_dic[i[-1]])-1:max(self.DO_dic[i[-1]])] = i[0]
|
|
|
self.write_storeData(tim=time.time(), data=self.current_value)
|
|
|
|
|
|
# 读AI
|
|
|
def upAIcurrent(self):
|
|
|
# # if self.current_value3 == None:
|
|
|
# # return
|
|
|
# data = AIdataPacket(3, 0, self.Packet_serial_No)
|
|
|
# data1 = self.skio.AIread(data)
|
|
|
# data2 = list(map(int, average(data1)))
|
|
|
# data3 = []
|
|
|
# for i in range(len(data2)):
|
|
|
# if i % 8 != 0:
|
|
|
# continue
|
|
|
# data3.append(data2[i:i+8])
|
|
|
# # self.current_value3 = [data1[-1][0:8], data1[-1][8:16], data1[-1][16:24]]
|
|
|
# self.current_value4 = data3
|
|
|
# self.Packet_serial_No += 1
|
|
|
# for i in zip(self.current_value4, list(self.AI_index)):
|
|
|
# self.current_value[int(i[-1]) - 1][min(self.AI_dic[i[-1]])-1:max(self.AI_dic[i[-1]])] = i[0]
|
|
|
# if self.current_value3 == None:
|
|
|
# return
|
|
|
data = AIdataPacket(3, 0, self.Packet_serial_No)
|
|
|
data1 = self.skio.AIread(data)
|
|
|
data2 = [float(x) for x in average(data1)]
|
|
|
data2 = getRealAI(data2)
|
|
|
|
|
|
# data2 = list(data1[0])
|
|
|
# average
|
|
|
data3 = []
|
|
|
|
|
|
# for i in range(len(data2)):
|
|
|
# if i % 8 != 0:
|
|
|
# continue
|
|
|
# data3.append(data2[i:i+8])
|
|
|
# print(data1,'data1')
|
|
|
# print(data2,'data2')
|
|
|
# print(data3,'data3')
|
|
|
# self.current_value3 = [data1[-1][0:8], data1[-1][8:16], data1[-1][16:24]]
|
|
|
|
|
|
self.current_value4 = data2
|
|
|
self.Packet_serial_No += 1
|
|
|
# print(self.AI_index, self.AI_dic, type(data2))
|
|
|
for i in zip(self.current_value4, list(self.AI_index)):
|
|
|
# print(i,999999)
|
|
|
self.current_value[int(i[-1]) - 1][min(self.AI_dic[i[-1]])-1:max(self.AI_dic[i[-1]])] = self.current_value4
|
|
|
|
|
|
# 读DI
|
|
|
def upDIcurrent(self):
|
|
|
# # if self.current_value1 == None:
|
|
|
# # return
|
|
|
# data = AIdataPacket(4, 0, self.Packet_serial_No)
|
|
|
# data1 = self.skio.DIread(data)
|
|
|
# data2 = list(map(int, average(data1)))
|
|
|
# data3 = []
|
|
|
# for i in range(len(data2)):
|
|
|
# if i % 4 != 0:
|
|
|
# continue
|
|
|
# data3.append(data2[i:i + 4])
|
|
|
# self.current_value2 = data3
|
|
|
# self.Packet_serial_No += 1
|
|
|
# for i in zip(self.current_value2, list(self.DI_index)):
|
|
|
# self.current_value[int(i[-1]) - 1][min(self.DI_dic[i[-1]])-1:max(self.DI_dic[i[-1]])] = i[0]
|
|
|
# # for i in zip(self.current_value2, list(self.DI_index)):
|
|
|
# # self.current_value[int(i[-1]) - 1] = i[0]
|
|
|
# if self.current_value1 == None:
|
|
|
# return
|
|
|
data = AIdataPacket(4, 0, self.Packet_serial_No)
|
|
|
data1 = self.skio.DIread(data)
|
|
|
data2 = data1[0]
|
|
|
# print(data2, len(data2), 'qweqwe')
|
|
|
data3 = []
|
|
|
for i in range(len(data2)):
|
|
|
if i % 4 != 0:
|
|
|
continue
|
|
|
data3.append(data2[i:i + 4])
|
|
|
self.current_value2 = data3
|
|
|
self.Packet_serial_No += 1
|
|
|
# print(i)
|
|
|
# print(self.DI_dic)
|
|
|
D_index = [self.DI_index[-1], self.DI_index[0]]
|
|
|
# print(data3)
|
|
|
for i in zip(self.current_value2, list(D_index)):
|
|
|
self.current_value[int(i[-1]) - 1][min(self.DI_dic[i[-1]])-1:max(self.DI_dic[i[-1]])] = i[0]
|
|
|
# for i in zip(self.current_value2, list(self.DI_index)):
|
|
|
# self.current_value[int(i[-1]) - 1] = i[0]
|
|
|
|
|
|
def High_speed_test(self, type, x):
|
|
|
"""下发高速实验命令开始"""
|
|
|
if self.current_value == []:
|
|
|
return
|
|
|
# self.current_value.append(type)
|
|
|
lis = self.current_value
|
|
|
# print(lis[9][11:18])
|
|
|
H_List = []
|
|
|
H_List+=(lis[9][10:18])
|
|
|
# print(lis[9][11:18])
|
|
|
H_List+=(lis[10][10:18])
|
|
|
# print(lis[10][11:18])
|
|
|
H_List+=(lis[1][0:8])
|
|
|
# print(lis[1][0:8])
|
|
|
H_List+=(lis[2][0:8])
|
|
|
# print(lis[2][0:8])
|
|
|
H_List+=(lis[7][0:16])
|
|
|
# print(lis[7][0:16])
|
|
|
H_List+=(lis[10][0:4])
|
|
|
print(lis[10][0:4])
|
|
|
H_List+=(lis[11][4:8])
|
|
|
print(lis[11][4:8])
|
|
|
H_List.append(type)
|
|
|
print(len(H_List))
|
|
|
|
|
|
|
|
|
# if len(l2) < 12:
|
|
|
# print(len(lis))
|
|
|
data = HSdataPacket(7, 4, self.Packet_serial_No, H_List)
|
|
|
# num = self.Packet_serial_No + 1
|
|
|
# self.skio.start_high_speed_test(data, num)
|
|
|
self.skio.start_high_speed_test(data)
|
|
|
self.Packet_serial_No = self.Packet_serial_No + 1
|
|
|
|
|
|
def receive_data(self):
|
|
|
"""接受高速实验数据"""
|
|
|
data = self.skio.receive_data()
|
|
|
# data = self.skio.receive_data()[0]
|
|
|
# self.Packet_serial_No = self.skio.receive_data()[1]
|
|
|
return data
|
|
|
|
|
|
def readall(self):
|
|
|
if self.current_value == []:
|
|
|
return
|
|
|
self.upAIcurrent()
|
|
|
self.upDIcurrent()
|
|
|
self.write_storeData(tim=time.time(), data=self.current_value)
|
|
|
|
|
|
def read(self, name):
|
|
|
# self.upAIcurrent()
|
|
|
# self.upDIcurrent()
|
|
|
point = PointModel.get(PointModel.sig_name == name)
|
|
|
if point.offset:
|
|
|
return get_bit_val(self.current_value[int(point.reg) - 1][int(point.channel) - 1], point.offset)
|
|
|
else:
|
|
|
return self.current_value[int(point.reg) - 1][int(point.channel) - 1]
|
|
|
|
|
|
def write(self, name, value):
|
|
|
point = PointModel.get(PointModel.sig_name == name)
|
|
|
if point.sig_type in ('DO-24V', 'DO-48V', 'DO'):
|
|
|
val = self.current_value[int(point.reg) - 1][int(point.channel) - 1]
|
|
|
value = set_bit_val(byte=val, val=int(value), index=int(point.offset))
|
|
|
elif point.sig_type == 'AO':
|
|
|
value = float(value)
|
|
|
elif point.sig_type == 'TC/K':
|
|
|
value = TC_K(value)
|
|
|
elif point.sig_type == 'TC/T':
|
|
|
value = TC_T(value)
|
|
|
elif point.sig_type == 'TC/E':
|
|
|
value = TC_E(value)
|
|
|
elif point.sig_type == 'PT100':
|
|
|
value = pt100_t2r(value)
|
|
|
|
|
|
self.current_value[int(point.reg) - 1][int(point.channel) - 1] = value
|
|
|
if point.sig_type in ('DO-24V', 'DO-48V', 'DO'):
|
|
|
self.setDIcurrent()
|
|
|
elif point.sig_type == 'AO' or point.sig_type == 'PT100' or point.sig_type == 'TC/T' or point.sig_type == 'TC/K':
|
|
|
self.setAOcurrent()
|
|
|
return value
|
|
|
|
|
|
def runWrite(self, name, value):
|
|
|
point = PointModel.get(PointModel.sig_name == name)
|
|
|
if point.sig_type in ('DO-24V', 'DO-48V', 'DO'):
|
|
|
val = self.current_value[int(point.reg) - 1][int(point.channel) - 1]
|
|
|
value = set_bit_val(byte=val, val=int(value), index=int(point.offset))
|
|
|
elif point.sig_type == 'AO':
|
|
|
var = value
|
|
|
highValue = float(point.rhi)
|
|
|
lowValue = float(point.rlo)
|
|
|
var = self.getRealAO(var, highValue, lowValue)
|
|
|
value = float(var)
|
|
|
elif point.sig_type == 'TC/K':
|
|
|
value = TC_K(value)
|
|
|
elif point.sig_type == 'TC/T':
|
|
|
value = TC_T(value)
|
|
|
elif point.sig_type == 'TC/E':
|
|
|
value = TC_E(value)
|
|
|
elif point.sig_type == 'PT100':
|
|
|
value = pt100_t2r(value)
|
|
|
print(value, 'test')
|
|
|
|
|
|
self.current_value[int(point.reg) - 1][int(point.channel) - 1] = value
|
|
|
# if point.sig_type in ('DO-24V', 'DO-48V', 'DO'):
|
|
|
# elif point.sig_type == 'AO' or point.sig_type == 'PT100' or point.sig_type == 'TC/T' or point.sig_type == 'TC/K':
|
|
|
# self.setDIcurrent()
|
|
|
# self.setAOcurrent()
|
|
|
return value
|
|
|
|
|
|
def getRealAO(self,x,highValue, lowValue):
|
|
|
if highValue:
|
|
|
return (16 * (x - lowValue) + 4 * (highValue-lowValue))/(1000 * (highValue - lowValue))
|
|
|
else:
|
|
|
return x/1000
|
|
|
|
|
|
def doWrite(self):
|
|
|
self.setDIcurrent()
|
|
|
self.setAOcurrent()
|
|
|
|
|
|
def GS_write(self, name, value, type):
|
|
|
print(name, value, type, 3333333333333333333333)
|
|
|
try:
|
|
|
point = PointModel.get(PointModel.sig_name == name)
|
|
|
except Exception as e:
|
|
|
print(list(name),2222222222222222222222)
|
|
|
return e
|
|
|
if point.sig_type in ('DO-24V', 'DO-48V','DO'):
|
|
|
val = self.current_value[int(point.reg) - 1][int(point.channel) - 1]
|
|
|
value = set_bit_val(byte=val, val=int(value), index=int(point.offset))
|
|
|
elif point.sig_type == 'AO':
|
|
|
highValue = float(point.rhi)
|
|
|
lowValue = float(point.rlo)
|
|
|
var = self.getRealAO(value, highValue, lowValue)
|
|
|
value = float(var)
|
|
|
elif point.sig_type == 'TC/K':
|
|
|
value = TC_K(value)
|
|
|
elif point.sig_type == 'TC/T':
|
|
|
value = TC_T(value)
|
|
|
elif point.sig_type == 'TC/E':
|
|
|
value = TC_E(value)
|
|
|
elif point.sig_type == 'PT100':
|
|
|
value = pt100_t2r(value)
|
|
|
self.current_value[int(point.reg) - 1][int(point.channel) - 1] = value
|
|
|
|
|
|
def start_gather(self,parent):
|
|
|
from PyQt5.QtCore import QTimer
|
|
|
data = AIdataPacket(5, 0, self.Packet_serial_No)
|
|
|
self.skio.start_gather(data)
|
|
|
print('低速开始')
|
|
|
self.timer = QTimer(parent)
|
|
|
self.timer.start(500)
|
|
|
self.timer.timeout.connect(self.readall)
|
|
|
# self.readall()
|
|
|
self.Packet_serial_No += 1
|
|
|
|
|
|
def stop_gather(self):
|
|
|
data = AIdataPacket(6, 0, self.Packet_serial_No)
|
|
|
print(data, '低速结束')
|
|
|
self.skio.stop_gather(data)
|
|
|
try:
|
|
|
self.timer.stop()
|
|
|
except:
|
|
|
pass
|
|
|
self.Packet_serial_No += 1
|
|
|
|
|
|
def START_GS_experiment(self):
|
|
|
"""高速实验开始"""
|
|
|
data = AIdataPacket(9, 0, self.Packet_serial_No)
|
|
|
print(data, '高速开始')
|
|
|
self.skio.stop_gather(data)
|
|
|
self.Packet_serial_No += 1
|
|
|
|
|
|
def STOP_GS_experiment(self):
|
|
|
"""告诉实验停止"""
|
|
|
data = AIdataPacket(10, 0, self.Packet_serial_No)
|
|
|
self.skio.stop_gather(data)
|
|
|
self.Packet_serial_No += 1
|
|
|
|
|
|
def write_storeData(self, tim, data):
|
|
|
lis = []
|
|
|
# for key in self.DO_dic:
|
|
|
# lis.append(struct.pack('Q' * len(self.DO_dic[key]), *data[key - 1][min(self.DO_dic[key])-1:max(self.DO_dic[key])]))
|
|
|
# for key in self.DI_dic:
|
|
|
# lis.append(struct.pack('Q' * len(self.DI_dic[key]), *data[key - 1][min(self.DI_dic[key])-1:max(self.DI_dic[key])]))
|
|
|
# for key in self.AI_dic:
|
|
|
# lis.append(struct.pack('d' * len(self.AI_dic[key]), *data[key - 1][min(self.AI_dic[key])-1:max(self.AI_dic[key])]))
|
|
|
# for key in self.AO_dic:
|
|
|
# lis.append(struct.pack('d' * len(self.AO_dic[key]), *data[key - 1][min(self.AO_dic[key])-1:max(self.AO_dic[key])]))
|
|
|
for i in data:
|
|
|
lis.append((struct.pack('d' * len(i), *i)))
|
|
|
data1 = struct.pack('64s64s64s64s64s256s128s128s64s144s144s64s', *lis)
|
|
|
self.skio.storeData.write(tim, data1)
|
|
|
|
|
|
def getRealAO(x,highValue, lowValue):
|
|
|
if highValue:
|
|
|
return (16 * (x - lowValue) + 4 * (highValue-lowValue))/(1000 * (highValue - lowValue))
|
|
|
else:
|
|
|
return x/1000
|
|
|
|
|
|
def get_bit_val(byte, index):
|
|
|
"""
|
|
|
得到某个字节中某一位（Bit）的值
|
|
|
|
|
|
:param byte: 待取值的字节值
|
|
|
:param index: 待读取位的序号，从右向左0开始，0-7为一个完整字节的8个位
|
|
|
:returns: 返回读取该位的值，0或1
|
|
|
"""
|
|
|
if byte & (1 << index):
|
|
|
return 1
|
|
|
else:
|
|
|
return 0
|
|
|
|
|
|
|
|
|
def set_bit_val(byte, index, val):
|
|
|
"""
|
|
|
更改某个字节中某一位（Bit）的值
|
|
|
|
|
|
:param byte: 准备更改的字节原值
|
|
|
:param index: 待更改位的序号，从右向左0开始，0-7为一个完整字节的8个位
|
|
|
:param val: 目标位预更改的值，0或1
|
|
|
:returns: 返回更改后字节的值
|
|
|
"""
|
|
|
if val:
|
|
|
return byte | (1 << index)
|
|
|
else:
|
|
|
return byte & ~(1 << index)
|
|
|
|
|
|
|
|
|
def pt100_t2r(t):
|
|
|
"""
|
|
|
PT100, 温度到电阻转换公式
|
|
|
|
|
|
从0℃~850℃：
|
|
|
Rt=R0（1+A*t+B*t^2）
|
|
|
|
|
|
从-200℃~0℃：
|
|
|
Rt=R0[1+A*t+Bt^2+C(t-100)*t^3]
|
|
|
式中：
|
|
|
Rt----温度为t时的铂电阻的阻值
|
|
|
R0----温度为0时的铂电阻的阻值，即100Ω
|
|
|
|
|
|
A=3.9083*10^(-3)℃^(-1)
|
|
|
B=-5.775*10^(-7) ℃^(-2)
|
|
|
C=-4.183*10^(-12) ℃^(-4)
|
|
|
|
|
|
"""
|
|
|
A = 3.9083 * (10 ** -3)
|
|
|
B = -5.775 * (10 ** -7)
|
|
|
C = -4.183 * (10 ** -12)
|
|
|
R0 = 100
|
|
|
if 0 <= t <= 850:
|
|
|
Rt = R0 * (1 + A * t + B * t * t)
|
|
|
return Rt
|
|
|
elif -200 <= t < 0:
|
|
|
Rt = R0 * (1 + A * t + B * t * t + C * (t - 100) * t ** 3)
|
|
|
return Rt
|
|
|
else:
|
|
|
raise ValueError("温度超范围 -200 ~ 800 度")
|
|
|
|
|
|
|
|
|
def TC_T(t):
|
|
|
'''
|
|
|
https://max.book118.com/html/2018/0907/8061021016001123.shtm
|
|
|
RTD_T 热电偶 温度转电动势 计算函数
|
|
|
输入 ： t (摄氏度)
|
|
|
输出 ： e (毫伏)
|
|
|
'''
|
|
|
if -270 <= t <= 0:
|
|
|
a0 = 0.000_000_000_0 * 10 ** 0
|
|
|
a1 = 3.874_810_636_4 * 10 ** 1
|
|
|
a2 = 4.419_443_434_7 * 10 ** -2
|
|
|
a3 = 1.184_432_310_5 * 10 ** -4
|
|
|
a4 = 2.003_297_355_4 * 10 ** -5
|
|
|
a5 = 9.013_801_955_9 * 10 ** -7
|
|
|
a6 = 2.265_115_420_5 * 10 ** -8
|
|
|
a7 = 3.607_115_659_3 * 10 ** -10
|
|
|
a8 = 3.849_393_988_3 * 10 ** -12
|
|
|
a9 = 2.821_352_192_5 * 10 ** -14
|
|
|
a10 = 1.425_159_477_9 * 10 ** -16
|
|
|
a11 = 4.876_866_228_6 * 10 ** -19
|
|
|
a12 = 1.079_553_927_0 * 10 ** -21
|
|
|
a13 = 1.394_502_706_2 * 10 ** -24
|
|
|
a14 = 7.979_515_392_7 * 10 ** -28
|
|
|
result = sum([
|
|
|
a0 * t ** 0,
|
|
|
a1 * t ** 1,
|
|
|
a2 * t ** 2,
|
|
|
a3 * t ** 3,
|
|
|
a4 * t ** 4,
|
|
|
a5 * t ** 5,
|
|
|
a6 * t ** 6,
|
|
|
a7 * t ** 7,
|
|
|
a8 * t ** 8,
|
|
|
a9 * t ** 9,
|
|
|
a10 * t ** 10,
|
|
|
a11 * t ** 11,
|
|
|
a12 * t ** 12,
|
|
|
a13 * t ** 13,
|
|
|
a14 * t ** 14,
|
|
|
]) / 1000
|
|
|
elif 0 < t <= 400:
|
|
|
a0 = 0.000_000_000_0 * 10 ** 0
|
|
|
a1 = 3.874_810_636_4 * 10 ** 1
|
|
|
a2 = 3.329_222_788_0 * 10 ** -2
|
|
|
a3 = 2.061_824_340_4 * 10 ** -4
|
|
|
a4 = -2.188_225_684_6 * 10 ** -6
|
|
|
a5 = 1.099_688_092_8 * 10 ** -8
|
|
|
a6 = -3.081_575_877_2 * 10 ** -11
|
|
|
a7 = 4.547_913_529_0 * 10 ** -14
|
|
|
a8 = -2.751_290_167_3 * 10 ** -17
|
|
|
result = sum([
|
|
|
a0 * t ** 0,
|
|
|
a1 * t ** 1,
|
|
|
a2 * t ** 2,
|
|
|
a3 * t ** 3,
|
|
|
a4 * t ** 4,
|
|
|
a5 * t ** 5,
|
|
|
a6 * t ** 6,
|
|
|
a7 * t ** 7,
|
|
|
a8 * t ** 8,
|
|
|
]) / 1000
|
|
|
return result - 0.011
|
|
|
|
|
|
|
|
|
def TC_E(t):
|
|
|
'''TC/E 热电偶 温度转电动势 计算函数
|
|
|
输入 ： t (摄氏度)
|
|
|
输出 ： e (毫伏)
|
|
|
'''
|
|
|
if -270 <= t <= 0:
|
|
|
a0 = 0.000_000_000_0 * 10 ** 0
|
|
|
a1 = 5.866_550_870_8 * 10 ** 1
|
|
|
a2 = 4.541_097_712_4 * 10 ** -2
|
|
|
a3 = -7.799_804_868_6 * 10 ** -4
|
|
|
a4 = -2.580_016_084_3 * 10 ** -5
|
|
|
a5 = -5.945_258_305_7 * 10 ** -7
|
|
|
a6 = -9.321_405_866_7 * 10 ** -9
|
|
|
a7 = -1.028_760_553_4 * 10 ** -10
|
|
|
a8 = -8.037_012_362_1 * 10 ** -13
|
|
|
a9 = -4.397_949_739_1 * 10 ** -15
|
|
|
a10 = -1.641_477_635_5 * 10 ** -17
|
|
|
a11 = -3.967_361_951_6 * 10 ** -20
|
|
|
a12 = -5.582_732_872_1 * 10 ** -23
|
|
|
a13 = -3.465_784_201_3 * 10 ** -26
|
|
|
return sum([
|
|
|
a0 * t ** 0,
|
|
|
a1 * t ** 1,
|
|
|
a2 * t ** 2,
|
|
|
a3 * t ** 3,
|
|
|
a4 * t ** 4,
|
|
|
a5 * t ** 5,
|
|
|
a6 * t ** 6,
|
|
|
a7 * t ** 7,
|
|
|
a8 * t ** 8,
|
|
|
a9 * t ** 9,
|
|
|
a10 * t ** 10,
|
|
|
a11 * t ** 11,
|
|
|
a12 * t ** 12,
|
|
|
a13 * t ** 13,
|
|
|
]) / 1000
|
|
|
elif 0 < t <= 100:
|
|
|
a0 = 0.000_000_000_0 * 10 ** 0
|
|
|
a1 = 5.866_550_871_0 * 10 ** 1
|
|
|
a2 = 4.503_227_558_2 * 10 ** -2
|
|
|
a3 = 2.890_840_721_2 * 10 ** -5
|
|
|
a4 = -3.305_689_665_2 * 10 ** -7
|
|
|
a5 = 6.502_440_327_0 * 10 ** -10
|
|
|
a6 = -1.919_749_550_4 * 10 ** -13
|
|
|
a7 = -1.253_660_049_7 * 10 ** -15
|
|
|
a8 = 2.148_921_756_9 * 10 ** -18
|
|
|
a9 = -1.438_804_178_2 * 10 ** -21
|
|
|
a10 = 3.596_089_948_1 * 10 ** -25
|
|
|
return sum([
|
|
|
a0 * t ** 0,
|
|
|
a1 * t ** 1,
|
|
|
a2 * t ** 2,
|
|
|
a3 * t ** 3,
|
|
|
a4 * t ** 4,
|
|
|
a5 * t ** 5,
|
|
|
a6 * t ** 6,
|
|
|
a7 * t ** 7,
|
|
|
a8 * t ** 8,
|
|
|
a9 * t ** 9,
|
|
|
a10 * t ** 10,
|
|
|
]) / 1000
|
|
|
|
|
|
|
|
|
def TC_K(t):
|
|
|
'''TC/T 热电偶 温度转电动势 计算函数
|
|
|
输入 ： t (摄氏度)
|
|
|
输出 ： e (毫伏)
|
|
|
'''
|
|
|
if -270 <= t <= 0:
|
|
|
a0 = 0.000_000_000_0 * 10 ** 0
|
|
|
a1 = 3.945_012_802_5 * 10 ** 1
|
|
|
a2 = 2.362_237_359_8 * 10 ** -2
|
|
|
a3 = -3.285_890_678_4 * 10 ** -4
|
|
|
a4 = -4.990_482_877_7 * 10 ** -6
|
|
|
a5 = -6.750_905_917_3 * 10 ** -8
|
|
|
a6 = -5.741_032_742_8 * 10 ** -10
|
|
|
a7 = -3.108_887_289_4 * 10 ** -12
|
|
|
a8 = -1.045_160_936_5 * 10 ** -14
|
|
|
a9 = -1.988_926_687_8 * 10 ** -17
|
|
|
a10 = -1.632_269_748_6 * 10 ** -20
|
|
|
return sum([
|
|
|
a0 * t ** 0,
|
|
|
a1 * t ** 1,
|
|
|
a2 * t ** 2,
|
|
|
a3 * t ** 3,
|
|
|
a4 * t ** 4,
|
|
|
a5 * t ** 5,
|
|
|
a6 * t ** 6,
|
|
|
a7 * t ** 7,
|
|
|
a8 * t ** 8,
|
|
|
a9 * t ** 9,
|
|
|
a10 * t ** 10,
|
|
|
]) / 1000
|
|
|
elif 0 < t <= 1300:
|
|
|
a0 = -1.760_041_368_6 * 10 ** 1
|
|
|
a1 = 3.892_120_497_5 * 10 ** 1
|
|
|
a2 = 1.855_877_003_2 * 10 ** -2
|
|
|
a3 = -9.945_759_287_4 * 10 ** -5
|
|
|
a4 = 3.184_094_571_9 * 10 ** -7
|
|
|
a5 = -5.607_284_488_9 * 10 ** -10
|
|
|
a6 = 5.607_505_905_9 * 10 ** -13
|
|
|
a7 = -3.202_072_000_3 * 10 ** -16 #
|
|
|
a8 = 9.715_114_715_2 * 10 ** -20
|
|
|
a9 = -1.210_472_127_5 * 10 ** -23
|
|
|
c0 = 1.185_976 * 10 ** 2
|
|
|
c1 = -1.183_432 * 10 ** -4
|
|
|
# return (sum([
|
|
|
# a0 * t ** 0 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a1 * t ** 1 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a2 * t ** 2 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a3 * t ** 3 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a4 * t ** 4 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a5 * t ** 5 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a6 * t ** 6 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a7 * t ** 7 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a8 * t ** 8 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# a9 * t ** 9 + c0 * math.exp(c1 * (t - 126.968_6) ** 2),
|
|
|
# ]) + a0) / 1000
|
|
|
result = (((((((((a9 * t + a8) * t + a7) * t + a6) * t + a5) * t + a4) * t + a3) * t + a2) * t + a1) * t + a0) / 1000
|
|
|
|
|
|
if 0 < t <= 19:
|
|
|
result += 0.02
|
|
|
elif 21 <= t <= 39 :
|
|
|
result += 0.04
|
|
|
elif 40 <= t <= 49 :
|
|
|
result += 0.05
|
|
|
elif 50 <= t <= 69 :
|
|
|
result += 0.06
|
|
|
elif 70 <= t <= 79 :
|
|
|
result += 0.07
|
|
|
elif 80 <= t <= 89 :
|
|
|
result += 0.08
|
|
|
elif 90 <= t <= 99 :
|
|
|
result += 0.09
|
|
|
elif 100 <= t <= 119 :
|
|
|
result += 0.1
|
|
|
elif 120 <= t <= 149 :
|
|
|
result += 0.11
|
|
|
elif 150 <= t <= 169 :
|
|
|
result += 0.12
|
|
|
elif 170 <= t <= 179 :
|
|
|
result += 0.11
|
|
|
elif 180 <= t <= 189 :
|
|
|
result += 0.1
|
|
|
elif 190 <= t <= 199 :
|
|
|
result += 0.08
|
|
|
elif 200 <= t <= 209 :
|
|
|
result += 0.07
|
|
|
elif 210 <= t <= 219 :
|
|
|
result += 0.06
|
|
|
elif 220 <= t <= 229 :
|
|
|
result += 0.05
|
|
|
elif 230 <= t <= 239 :
|
|
|
result += 0.03
|
|
|
elif 240 <= t <= 269 :
|
|
|
result += 0.02
|
|
|
elif 270 <= t <= 299 :
|
|
|
result += 0.01
|
|
|
return result
|
|
|
|
|
|
def average(lis):
|
|
|
c = numpy.array(lis)
|
|
|
return list(c.mean(axis=0))
|
|
|
|
|
|
def getRealAI(data):
|
|
|
# self.set_current_value()
|
|
|
data_ = []
|
|
|
data_c = []
|
|
|
# for xList in data:
|
|
|
# xList = list(xList)
|
|
|
vList = data
|
|
|
# print(vList)
|
|
|
# vList = [xList[0:8], xList[8:16], xList[16:24], xList[24:32]]
|
|
|
# for value in zip(vList, sorted(self.AI_index)):
|
|
|
# print(sorted(self.AI_index)[0:3])
|
|
|
# print(value)
|
|
|
for index, x in enumerate(vList):
|
|
|
try:
|
|
|
i = PointModel.get(PointModel.reg == 6, PointModel.channel == index + 1)
|
|
|
# print(i)
|
|
|
highValue = i.rhi
|
|
|
lowValue = i.rlo
|
|
|
z = (x * 1000 - 4) * (highValue - lowValue) / 16 + lowValue
|
|
|
# print(z, x, x * 1000)
|
|
|
data_c.append(z)
|
|
|
except:
|
|
|
data_c.append(x)
|
|
|
# data_.append(data_c)
|
|
|
# data_c = []
|
|
|
# print(data_, 5555555)
|
|
|
|
|
|
return data_c |