def extractValidFrameFromUART(uart):
timeout_count = 0
while True:
start_byte = uart.read(1)
#print("start byte? {} timeout:{}".format(start_byte,timeout_count))
timeout_count += 1
if start_byte == b'\x76':
#print("found start byte")
break
if timeout_count > 24 * 4:
return None
timeout_count = 0
while True:
timeout_count += 1
if uart.any() >= 23:
break
elif timeout_count > 100:
print("uart rx time out")
return None
data_frame = start_byte + uart.read(23)
#print("data frame {}".format(ubinascii.hexlify(data_frame)))
crc = crc16.crc(data_frame[:22])
rx_crc = int.from_bytes(data_frame[22:24], 0)
#print("rx_crc: {} crc:{}".format(rx_crc,crc))
if (rx_crc == crc):
return data_frame
else:
return None
def dataSendLoop(addData_callbackFunc, p):
global MAX_FORCE_VALUE
mySrc = Communicate()
mySrc.data_signal.connect(addData_callbackFunc)
n = np.linspace(0, 499, 500)
y = 50 + 25 * np.sin(n / 8.3) + 10 * np.sin(n / 7.5) - 5 * np.sin(n / 1.5)
i = 0
adc_val = [0]
while True:
time.sleep(0.001)
ind = 0
wait_bytes = p.in_waiting
coming_pack = ''
crc_pack = ''
if wait_bytes >= 7:
f_byte = p.read(1)
while chr(f_byte[0]).encode('utf-8') != '\x06':
f_byte = p.read(1)
s_byte = p.read(1)
if s_byte == '\x85':
coming_pack = p.read(3)
crc_pack = p.read(2)
calc_crc = crc16.crc(coming_pack)
rec_crc = struct.unpack('H', crc_pack[0:2])
if calc_crc == rec_crc[0]:
adc_val = struct.unpack('h', coming_pack[:2])
mySrc.data_signal.emit(-adc_val[0] * SCALE_GRAPH_VAL)
writeData.append((time.time() - start_time,
-adc_val[0] * SCALE_GRAPH_VAL))
if int(-adc_val[0] * SCALE_GRAPH_VAL) > MAX_FORCE_VALUE:
MAX_FORCE_VALUE = -adc_val[0] * SCALE_GRAPH_VAL
def prepareacket(command, payload, parameters):
packet = ['AA', 'AA', 'AA', command] + payload
if len(parameters) > 0:
packet += parameters
checksum = crc16.crc(packet)
hexPacket = b''
for i in range(0, len(packet)):
hexPacket += struct.pack(">B", packet[i])
hexPacket += checksum
return hexPacket
def setDAC(self):
sendData = b'\x03'
heater = b'\x00\x01'
sendData += self.spinBox.value().to_bytes(
2, byteorder='big', signed=True) + heater + b'\x00\x00'
calc_crc = crc16.crc(sendData)
sendData = b'\x06\x85'+sendData + \
calc_crc.to_bytes(2, byteorder='big', signed=False)
print(sendData)
self.p.write(sendData)
DACfile = open('dac.txt', 'w')
DACfile.write(str(self.spinBox.value()))
DACfile.close()
def data_frame(self, frame):
crc_valid = None
crc = crc16.crc(
bytes(frame[0:22])
)
if((frame[22]<<8 | frame[23]) == crc):
crc_valid = True
else:
crc_valid = False
if(crc_valid):
self.Byte0 = frame[0]
self.Len = frame[1]
self.RunState = frame[2]
self.ErrState = frame[3]
self.SupplyV_MSB = frame[4]
self.SupplyV_LSB = frame[5]
self.FanRPM_MSB = frame[6]
self.FanRPM_LSB = frame[7]
self.FanVoltage_MSB = frame[8]
self.FanVoltage_LSB = frame[9]
self.HeatExchgTemp_MSB = frame[10]
self.HeatExchgTemp_LSB = frame[11]
self.GlowPlugVoltage_MSB = frame[12]
self.GlowPlugVoltage_LSB = frame[13]
self.GlowPlugCurrent_MSB = frame[14]
self.GlowPlugCurrent_LSB = frame[15]
self._ActualPumpFreq = frame[16]
self._StoredErrorCode = frame[17]
self._Unknown1 = frame[18]
self._FixedPumpFreq = frame[19]
self._Unknown2 = frame[20]
self._Unknown3 = frame[21]
self.CRC_MSB = frame[22]
self.CRC_LSB = frame[23]
return (bytes([self.Byte0, self.Len, self.RunState, self.ErrState, self.SupplyV_MSB,
self.SupplyV_LSB, self.FanRPM_MSB, self.FanRPM_LSB, self.FanVoltage_MSB,
self.FanVoltage_LSB, self.HeatExchgTemp_MSB, self.HeatExchgTemp_LSB,
self.GlowPlugVoltage_MSB, self.GlowPlugVoltage_LSB, self.GlowPlugCurrent_MSB,
self.GlowPlugCurrent_LSB, self._ActualPumpFreq, self._StoredErrorCode,
self._Unknown1, self._FixedPumpFreq, self._Unknown2, self._Unknown3,
self.CRC_MSB, self.CRC_LSB]),crc_valid)
else:
return None
def stopMoving(self):
sendData = b'\x04'
sendData += (0).to_bytes(2, byteorder='big', signed=True) + (
0).to_bytes(2, byteorder='big', signed=True) + (0).to_bytes(
2, byteorder='big', signed=True)
calc_crc = crc16.crc(sendData)
sendData = b'\x06\x85' + sendData + \
calc_crc.to_bytes(2, byteorder='big', signed=False)
self.p.write(sendData)
print(sendData)
fileData = open('DataSingle.txt', 'w')
for elem in writeData:
fileData.write(str(elem[0]) + ';' + str(elem[1]) + '\n')
fileData.close()
writeData.clear()
self.labelTestFreq.setText('MAX VALUE: ' + str(MAX_FORCE_VALUE))
def modeSelection(self):
global SCALE_GRAPH_VAL
global start_time
up_limit = 5000
down_limit = -22000
count = 1
sendData = b'\x02'
recordData = True
start_time = time.time()
if self.cb_mode.currentText() == 'Cyclic':
up_limit = -self.upLim.value() / SCALE_GRAPH_VAL
down_limit = -self.downLim.value() / SCALE_GRAPH_VAL
count = self.count.value()
sendData = b'\x01'
recordData = False
sendData += int(up_limit).to_bytes(2, byteorder='big', signed=True)
sendData += int(down_limit).to_bytes(2, byteorder='big', signed=True)
sendData += int(count).to_bytes(2, byteorder='big', signed=True)
calc_crc = crc16.crc(sendData)
sendData = b'\x06\x85' + sendData + \
calc_crc.to_bytes(2, byteorder='big', signed=False)
print(sendData)
self.p.write(sendData)
def data_frame(self, frame=None, run_crc=True):
crc_valid = None
if frame:
crc = crc16.crc(bytes(frame[0:22]))
if ((frame[22] << 8 | frame[23]) == crc):
crc_valid = True
else:
crc_valid = False
if (crc_valid):
self.Byte0 = frame[0]
self.Len = frame[1]
self.Command = frame[2]
self._ActualTemperature = frame[3]
self.DesiredDemand = frame[4]
self._MinPumpFreq = frame[5]
self._MaxPumpFreq = frame[6]
self.MinFanRPM_MSB = frame[7]
self.MinFanRPM_LSB = frame[8]
self.MaxFanRPM_MSB = frame[9]
self.MaxFanRPM_LSB = frame[10]
self._OperatingVoltage = frame[11]
self.FanSensor = frame[12]
self.OperatingMode = frame[13]
self.MinTemperature = frame[14]
self.MaxTemperature = frame[15]
self.GlowDrive = frame[16]
self.Prime = frame[17]
self.Unknown1_MSB = frame[18]
self.Unknown1_LSB = frame[19]
self.Altitude_MSB = frame[20]
self.Altitude_LSB = frame[21]
self.CRC_MSB = frame[22]
self.CRC_LSB = frame[23]
if run_crc:
crc = crc16.crc(
bytes([
self.Byte0, self.Len, self.Command,
self._ActualTemperature, self.DesiredDemand,
self._MinPumpFreq, self._MaxPumpFreq, self.MinFanRPM_MSB,
self.MinFanRPM_LSB, self.MaxFanRPM_MSB, self.MaxFanRPM_LSB,
self._OperatingVoltage, self.FanSensor, self.OperatingMode,
self.MinTemperature, self.MaxTemperature, self.GlowDrive,
self.Prime, self.Unknown1_MSB, self.Unknown1_LSB,
self.Altitude_MSB, self.Altitude_LSB
]))
self.CRC_MSB = crc >> 8 & 0xFF
self.CRC_LSB = crc & 0xFF
crc_valid = True
return (bytes([
self.Byte0, self.Len, self.Command, self._ActualTemperature,
self.DesiredDemand, self._MinPumpFreq, self._MaxPumpFreq,
self.MinFanRPM_MSB, self.MinFanRPM_LSB, self.MaxFanRPM_MSB,
self.MaxFanRPM_LSB, self._OperatingVoltage, self.FanSensor,
self.OperatingMode, self.MinTemperature, self.MaxTemperature,
self.GlowDrive, self.Prime, self.Unknown1_MSB, self.Unknown1_LSB,
self.Altitude_MSB, self.Altitude_LSB, self.CRC_MSB, self.CRC_LSB
]), crc_valid)
count = 100
else:
extraCount = 100 - count
cursor.execute(
'SELECT mii.initial, mii.miidata, artisan.miidata FROM mii, artisan WHERE mii.craftsno=artisan.craftsno ORDER BY mii.likes DESC LIMIT %s',
[count])
popularMiis = cursor.fetchall()
cursor.execute(
'SELECT mii.initial, mii.miidata, artisan.miidata FROM mii, artisan WHERE mii.permlikes < 25 AND mii.craftsno=artisan.craftsno ORDER BY mii.permlikes DESC LIMIT %s',
[extraCount])
extraMiis = cursor.fetchall()
db.close()
ql = WSR().build(popularMiis + extraMiis)
with open('decfiles/wiisports.dec', 'wb') as file:
file.write(ql)
path = config['miicontest_path']
with open('{}/dd/wiisports.dec'.format(path), 'wb') as file:
file.write(crc(ql).to_bytes(2, "big") + ql)
#symlink all miidd country code files to wiisports.enc with its FULL directory path
system(
"python ./sign_encrypt.py -t enc -in '{}/dd/wiisports.dec' -out '{}/dd/wiisports.enc' -key 91D9A5DD10AAB467491A066EAD9FDD6F -rsa /var/rc24/key/miidd.pem"
.format(path, path))
