997 lines
28 KiB
Python
997 lines
28 KiB
Python
import machine
|
|
from machine import PWM
|
|
from machine import ADC
|
|
from machine import Filament
|
|
from machine import WDT
|
|
from machine import Pin
|
|
from machine import Fram
|
|
|
|
import sys
|
|
import time
|
|
import _thread
|
|
import json
|
|
import gc
|
|
import math
|
|
import os
|
|
from webserver import send_ws, send_ws_list, py_server
|
|
# ----------------------------------------------------------------------------
|
|
|
|
from script.umodbus.serial import ModbusRTU
|
|
|
|
wdt = None
|
|
mb_server = None
|
|
|
|
|
|
selfTestTime = 0
|
|
|
|
pwmDuty = 0
|
|
pwmDutyRayOn = 0
|
|
|
|
filament = Filament(3)
|
|
filament.init()
|
|
filament.set_relay(False)
|
|
|
|
#PWM
|
|
hvPwm = PWM('pwm1', 2, 46000, 0, 50, False)
|
|
hvPwmn = PWM('pwm1', 3, 46000, 1023, 50, False)
|
|
|
|
#ADC
|
|
hvAdc = ADC('adc1', 16) # HV Voltage
|
|
hiAdc = ADC('adc3', 0) # HV Current
|
|
tempAdc = ADC('adc2', 15) # HV NTC
|
|
hvAdc.average(50)
|
|
hiAdc.average(50)
|
|
tempAdc.average(50)
|
|
|
|
hvAdcValue = 0
|
|
hvKvValue = 0
|
|
hvSwitch = False
|
|
raySwitch = False
|
|
|
|
raySwitchPin = Pin(('GPIOC', 6))
|
|
raySwitchPin.init(Pin.IN)
|
|
|
|
rayStartTime = 0
|
|
|
|
web_socket_list = []
|
|
wslock = None
|
|
|
|
filaInfo = {
|
|
'relay_stat' : False,
|
|
'vout' : 0,
|
|
'iout' : 0,
|
|
'vin' : 0,
|
|
'iin' : 0
|
|
}
|
|
|
|
sysErrorList = []
|
|
sysInfoList = []
|
|
|
|
hiAdcValue = 0
|
|
hiMaValue = 0
|
|
himAOverLimitCount = 0
|
|
|
|
hvTempValue = 0
|
|
|
|
filamentCurrent = 0
|
|
filamentVoltage = 0
|
|
filamentDuty = 0
|
|
filamentLoadDuty = 0
|
|
|
|
averageBuffer = {
|
|
"hvIdleKv" : [],
|
|
"hvLoadKv" : [],
|
|
"fiPreheatCurrent": [],
|
|
"hvLoadMa": []
|
|
}
|
|
|
|
config = {
|
|
"dev" : {
|
|
"code" : "1#HVS",
|
|
"id" : "12345",
|
|
},
|
|
"mqtt" : {},
|
|
"hv" : {
|
|
"kV": 70,
|
|
"filament": {
|
|
"preheat": 300,
|
|
"limit": 1200
|
|
},
|
|
"mA": 0.7,
|
|
"xrayAdjustTime": 600,
|
|
"selfTest" : False
|
|
},
|
|
"var" : {
|
|
"hv" : {
|
|
"idlePwm" : 200,
|
|
"loadPwm" : 320,
|
|
"limitPwm" : 450
|
|
},
|
|
"filament" : {
|
|
"preheatPwm": 50,
|
|
"limitPwm": 300,
|
|
"normalPwm": 260
|
|
}
|
|
}
|
|
}
|
|
|
|
def averageBufferPut(key, value):
|
|
global averageBuffer
|
|
if key in averageBuffer:
|
|
averageBuffer[key].append(value)
|
|
if len(averageBuffer[key]) > 20:
|
|
averageBuffer[key].pop(0)
|
|
|
|
def averageBufferGetAverage(key, n):
|
|
global averageBuffer
|
|
if key in averageBuffer:
|
|
values = averageBuffer[key]
|
|
if len(values) < n:
|
|
return None
|
|
average = sum(values[:n]) / n
|
|
return average
|
|
return None
|
|
|
|
def mb_control_cb(reg_type, address, val):
|
|
global hvSwitch, raySwitch, sysInfoList
|
|
print('control',reg_type,address,val)
|
|
|
|
for value in val:
|
|
if address == 0:
|
|
hvSwitch = value == True
|
|
# mb_server.set_coil(7 - 0, hvSwitch)
|
|
print("hvSwitch:",hvSwitch)
|
|
|
|
info = {
|
|
"event" : "hvSwitch",
|
|
"from" : "modbus",
|
|
"value" : hvSwitch,
|
|
"time" : time.ticks_ms()
|
|
}
|
|
sysInfoList.append(info)
|
|
elif address == 1:
|
|
if value == True:
|
|
print('alarm clear')
|
|
# mb_server.set_coil(1, False)
|
|
elif address == 2:
|
|
if config['dev']['xray_ctrl_pin_enable']:
|
|
return
|
|
raySwitch = value == True
|
|
# mb_server.set_coil(7 - 2, raySwitch)
|
|
print("raySwitch:",raySwitch)
|
|
|
|
info = {
|
|
"event" : "raySwitch",
|
|
"from" : "modbus",
|
|
"value" : raySwitch,
|
|
"time" : time.ticks_ms()
|
|
}
|
|
sysInfoList.append(info)
|
|
address += 1
|
|
|
|
def mb_param_cb(reg_type, address, val):
|
|
print('param',reg_type,address,val)
|
|
for value in val:
|
|
if address == 0:
|
|
config['hv'].update({'kV' : value / 100.0})
|
|
elif address == 1:
|
|
config['hv'].update({'mA' : value / 1000.0})
|
|
elif address == 2:
|
|
config['hv']['filament'].update({'limit' : value})
|
|
elif address == 3:
|
|
config['hv']['filament'].update({'preheat' : value})
|
|
address += 1
|
|
save_config('hv')
|
|
|
|
mb_register_definitions = {
|
|
"COILS": {
|
|
"control": {
|
|
"register": 0,
|
|
"len": 10,
|
|
"val": [0,0,0,0,0,0,0,0,0,0],
|
|
"on_set_cb": mb_control_cb
|
|
}
|
|
},
|
|
"HREGS": {
|
|
"params": {
|
|
"register": 0,
|
|
"len": 10,
|
|
"val": [0,0,0,0,0,0,0,0,0,0],
|
|
"on_set_cb": mb_param_cb
|
|
}
|
|
},
|
|
"ISTS": {
|
|
"status": {
|
|
"register": 0,
|
|
"len": 10,
|
|
"val": [0,0,0,0,0,0,0,0,0,0]
|
|
}
|
|
},
|
|
"IREGS": {
|
|
"input": {
|
|
"register": 0,
|
|
"len": 10,
|
|
"val": [0,0,0,0,0,0,0,0,0,0]
|
|
}
|
|
}
|
|
}
|
|
|
|
def load_config():
|
|
global config
|
|
config_path = "/config/hv.json"
|
|
try:
|
|
with open(config_path, 'r') as f:
|
|
config['hv'] = json.load(f)
|
|
except OSError as e:
|
|
print("文件操作错误:", e)
|
|
except ValueError as e:
|
|
print("JSON 解析错误:", e)
|
|
|
|
config_path = "/config/mqtt.json"
|
|
try:
|
|
with open(config_path, 'r') as f:
|
|
config['mqtt'] = json.load(f)
|
|
except OSError as e:
|
|
print("文件操作错误:", e)
|
|
except ValueError as e:
|
|
print("JSON 解析错误:", e)
|
|
|
|
config_path = "/config/dev.json"
|
|
try:
|
|
with open(config_path, 'r') as f:
|
|
config['dev'] = json.load(f)
|
|
except OSError as e:
|
|
print("文件操作错误:", e)
|
|
except ValueError as e:
|
|
print("JSON 解析错误:", e)
|
|
|
|
config_path = "/config/var.json"
|
|
var = None
|
|
try:
|
|
varBuf = Fram.read(0, 512)
|
|
var = json.loads(varBuf)
|
|
except ValueError as e:
|
|
print("JSON 解析错误:", e)
|
|
var = None
|
|
|
|
if var:
|
|
config['var'] = var
|
|
with open(config_path, 'w') as f:
|
|
json.dump(var, f)
|
|
print('write var.json', var)
|
|
else:
|
|
try:
|
|
with open(config_path, 'r') as f:
|
|
config['var'] = json.load(f)
|
|
Fram.write(0, json.dumps(config['var']).encode() + b'\x00')
|
|
except OSError as e:
|
|
print("文件操作错误:", e)
|
|
except ValueError as e:
|
|
print("JSON 解析错误:", e)
|
|
|
|
def save_config(config_type):
|
|
if config_type == 'var':
|
|
Fram.write(0, json.dumps(config['var']).encode() + b'\x00')
|
|
return
|
|
try:
|
|
data = config[config_type]
|
|
config_path = "/config/" + config_type + '.json'
|
|
with open(config_path, 'w') as f:
|
|
f.write(json.dumps(data))
|
|
except OSError as e:
|
|
print("文件操作错误:", e)
|
|
|
|
def mb_init():
|
|
global mb_server
|
|
print("mb_init...")
|
|
mb_server = ModbusRTU(addr = config['dev']['mb_addr'],baudrate=115200,uart_id=4,ctrl_pin=-2)
|
|
mb_server.setup_registers(registers=mb_register_definitions)
|
|
|
|
mb_server.set_hreg(0, [
|
|
int(config['hv']['kV'] * 100),
|
|
int(config['hv']['mA'] * 1000),
|
|
int(config['hv']['filament']['limit']),
|
|
int(config['hv']['filament']['preheat']),
|
|
])
|
|
|
|
mb_server.set_coil(0, hvSwitch)
|
|
mb_server.set_coil(2, raySwitch)
|
|
|
|
# if not mb_server.get_bound_status():
|
|
# mb_server.bind(local_ip='0.0.0.0', local_port=502)
|
|
# print("start mb tcp server")
|
|
|
|
def adc2temp(adc_val):
|
|
Rt = adc_val * 10000.0 / (65535 - adc_val)
|
|
Rp = 10000.0
|
|
T2 = 273.15 + 25.0
|
|
Bx = 3950.0
|
|
Ka = 273.15
|
|
|
|
temp = 0.0
|
|
temp = Rt / Rp
|
|
temp = math.log(temp)
|
|
temp /= Bx
|
|
temp += (1 / T2)
|
|
temp = 1 / temp
|
|
temp -= Ka
|
|
|
|
return temp
|
|
|
|
def hvAdc2kV(hv):
|
|
return hv / 65535.0 * 3.0 * 3 * 10
|
|
|
|
def hiAdc2mA(hi):
|
|
return hi / 65535.0 * 3.0 * 3 / 4.4
|
|
|
|
#read hv voltage and current, num times, and return the average value
|
|
def hvAdcRead(num, delay):
|
|
global filaInfo
|
|
sumHv = 0
|
|
sumHi = 0
|
|
for i in range(num):
|
|
sumHv += hvAdc.read()
|
|
sumHi += hiAdc.read()
|
|
time.sleep_ms(delay)
|
|
|
|
sumHv /= num
|
|
sumHi /= num
|
|
|
|
filaInfo = filament.read()
|
|
fv = filaInfo['vout']
|
|
fi = filaInfo['iout']
|
|
return sumHv, sumHi, fv, fi
|
|
|
|
def hvAdcRead():
|
|
global filaInfo
|
|
sumHv = hvAdc.average()
|
|
sumHi = hiAdc.average()
|
|
|
|
filaInfo = filament.read()
|
|
fv = filaInfo['vout']
|
|
fi = filaInfo['iout']
|
|
return sumHv, sumHi, fv, fi
|
|
|
|
def hvAdcPoll(count, delay):
|
|
global hvAdcValue, hvKvValue, hiAdcValue, hiMaValue
|
|
global filamentDuty, filamentCurrent, filamentVoltage
|
|
|
|
hv, hi, fv, fi = hvAdcRead()
|
|
|
|
hvAdcValue = hv
|
|
hiAdcValue = hi
|
|
|
|
hvKvValue = hvAdc2kV(hv)
|
|
hiMaValue = hiAdc2mA(hi)
|
|
filamentCurrent = fi
|
|
filamentVoltage = fv
|
|
|
|
# control the filament current
|
|
def filamentPreheat(fiPreheat):
|
|
global filamentCurrent, filamentVoltage, filamentDuty
|
|
tmpDuty = filamentDuty
|
|
|
|
fi = filamentCurrent
|
|
|
|
if fi > fiPreheat + 100:
|
|
tmpDuty -= 2
|
|
elif fi > fiPreheat + 50:
|
|
tmpDuty -= 1
|
|
elif fi < fiPreheat - 100:
|
|
tmpDuty += 2
|
|
elif fi < fiPreheat - 50:
|
|
tmpDuty += 1
|
|
|
|
if tmpDuty < 0:
|
|
tmpDuty = 0
|
|
elif tmpDuty > 750:
|
|
tmpDuty = 750
|
|
|
|
filament.set_duty(tmpDuty)
|
|
filamentDuty = tmpDuty
|
|
# print('preheat', fiPreheat, tmpDuty)
|
|
|
|
# control the filament current
|
|
def filamentPreheatFast(fiPreheat):
|
|
global filamentCurrent, filamentVoltage, filamentDuty
|
|
if fiPreheat < 0.01:
|
|
tmpDuty = 0
|
|
filament.set_duty(tmpDuty)
|
|
filamentDuty = tmpDuty
|
|
return
|
|
tmpDuty = config['var']['filament']['preheatPwm']
|
|
|
|
fi = filamentCurrent
|
|
|
|
if tmpDuty > config['var']['filament']['limitPwm']:
|
|
tmpDuty = config['var']['filament']['limitPwm']
|
|
|
|
if filamentDuty != tmpDuty:
|
|
filament.set_duty(tmpDuty)
|
|
filamentDuty = tmpDuty
|
|
# print('preheat', fiPreheat, tmpDuty)
|
|
else:
|
|
averageBufferPut('fiPreheatCurrent', filamentCurrent)
|
|
|
|
# control the filament current
|
|
def filamentControlNormal(hiAim, fiLimit):
|
|
global filamentCurrent, filamentVoltage, filamentDuty
|
|
tmpDuty = filamentDuty
|
|
|
|
hi = hiMaValue
|
|
fi = filamentCurrent
|
|
|
|
|
|
delta = (hi - hiAim) * 1000
|
|
if delta < 0:
|
|
val = -delta
|
|
else:
|
|
val = delta
|
|
|
|
daDelta = 0
|
|
if val > 200:
|
|
daDelta = 2
|
|
elif val > 40:
|
|
daDelta = 1
|
|
elif val > 10:
|
|
daDelta = 0
|
|
elif val > 5:
|
|
daDelta = 0
|
|
else:
|
|
daDelta = 0
|
|
|
|
if fi > fiLimit:
|
|
tmpDuty -= 10
|
|
elif delta > 0:
|
|
tmpDuty -= daDelta
|
|
elif delta < 0:
|
|
tmpDuty += daDelta
|
|
|
|
if tmpDuty < 0:
|
|
tmpDuty = 0
|
|
elif tmpDuty > config['var']['filament']['limitPwm']:
|
|
tmpDuty = config['var']['filament']['limitPwm']
|
|
|
|
filament.set_duty(tmpDuty)
|
|
# filament.set_duty(0)
|
|
filamentDuty = tmpDuty
|
|
|
|
|
|
# control the filament current
|
|
def filamentControlFast(hiAim):
|
|
global filamentCurrent, filamentVoltage, filamentDuty, filamentLoadDuty
|
|
|
|
tmpDuty = filamentDuty
|
|
|
|
if raySwitch:
|
|
deltaTime = 0
|
|
if rayStartTime > 1:
|
|
now = time.ticks_ms()
|
|
deltaTime = time.ticks_diff(now, rayStartTime)
|
|
if deltaTime > config['hv']['xrayAdjustTime']:
|
|
if deltaTime > config['hv']['xrayAdjustTime'] + 200:
|
|
if hvKvValue > config['hv']['kV'] - 2 and filamentDuty >= config['var']['filament']['normalPwm']:
|
|
filamentLoadDuty = filamentDuty
|
|
averageBufferPut('hvLoadMa', hiMaValue)
|
|
elif hiMaValue > config['hv']['mA'] + 0.05 and filamentDuty >= config['var']['filament']['normalPwm']:
|
|
filamentLoadDuty = filamentDuty
|
|
averageBufferPut('hvLoadMa', hiMaValue)
|
|
return
|
|
|
|
if hiMaValue > hiAim:
|
|
tmpDuty = tmpDuty - 2
|
|
else:
|
|
aimDuty = config['var']['filament']['normalPwm']
|
|
|
|
if tmpDuty < aimDuty - 0.2:
|
|
tmpDuty = tmpDuty + 10
|
|
elif tmpDuty < aimDuty:
|
|
tmpDuty = tmpDuty + 5
|
|
if tmpDuty > aimDuty:
|
|
tmpDuty = aimDuty
|
|
|
|
if hvKvValue < config['hv']['kV'] - 2:
|
|
return
|
|
|
|
if tmpDuty > config['var']['filament']['limitPwm']:
|
|
tmpDuty = config['var']['filament']['limitPwm']
|
|
|
|
filamentDuty = int(tmpDuty)
|
|
filament.set_duty(filamentDuty)
|
|
#print('filamentDuty adjust', filamentDuty)
|
|
# filament.set_duty(0)
|
|
|
|
def hvControlFast(hvAim):
|
|
global pwmDuty, rayStartTime, pwmDutyRayOn
|
|
if not hvSwitch:
|
|
pwmDuty = 0
|
|
hvPwm.duty(pwmDuty)
|
|
hvPwmn.duty(1023 - pwmDuty)
|
|
return
|
|
|
|
if not raySwitch:
|
|
tmpDuty = config['var']['hv']['idlePwm']
|
|
if pwmDuty > tmpDuty:
|
|
pwmDuty = tmpDuty
|
|
hvPwm.duty(pwmDuty)
|
|
hvPwmn.duty(1023 - pwmDuty)
|
|
print("hv adjust to idle", pwmDuty)
|
|
elif pwmDuty < tmpDuty:
|
|
pwmDuty = pwmDuty + 3
|
|
if pwmDuty > tmpDuty:
|
|
pwmDuty = tmpDuty
|
|
hvPwm.duty(pwmDuty)
|
|
hvPwmn.duty(1023 - pwmDuty)
|
|
print("hv adjust to idle", pwmDuty)
|
|
else:
|
|
averageBufferPut('hvIdleKv', hvKvValue)
|
|
return
|
|
|
|
|
|
deltaTime = 0
|
|
if rayStartTime > 1:
|
|
now = time.ticks_ms()
|
|
deltaTime = time.ticks_diff(now, rayStartTime)
|
|
if deltaTime > config['hv']['xrayAdjustTime'] + 200:
|
|
averageBufferPut('hvLoadKv', hvKvValue)
|
|
pwmDutyRayOn = pwmDuty
|
|
if deltaTime > config['hv']['xrayAdjustTime']:
|
|
return
|
|
|
|
if pwmDuty == config['var']['hv']['loadPwm']:
|
|
return
|
|
|
|
tmpDuty = pwmDuty
|
|
|
|
if hiMaValue > config['hv']['mA']:
|
|
return
|
|
if hvKvValue < config['hv']['kV'] - 3:
|
|
tmpDuty = tmpDuty + 2
|
|
elif hvKvValue < config['hv']['kV']:
|
|
tmpDuty = tmpDuty + 1
|
|
|
|
if tmpDuty > config['var']['hv']['loadPwm']:
|
|
tmpDuty = config['var']['hv']['loadPwm']
|
|
|
|
if pwmDuty > config['var']['hv']['limitPwm']:
|
|
pwmDuty = config['var']['hv']['limitPwm']
|
|
|
|
pwmDuty = tmpDuty
|
|
hvPwm.duty(pwmDuty)
|
|
hvPwmn.duty(1023 - pwmDuty)
|
|
print("hv adjust", deltaTime, pwmDuty)
|
|
|
|
def hvControl(hvAim):
|
|
global pwmDuty
|
|
|
|
if not hvSwitch:
|
|
pwmDuty = 0
|
|
hvPwm.duty(pwmDuty)
|
|
hvPwmn.duty(1023 - pwmDuty)
|
|
return
|
|
|
|
hv = hvKvValue
|
|
pwmVal = pwmDuty
|
|
|
|
delta = (hv - hvAim) * 1000
|
|
if delta < 0:
|
|
val = -delta
|
|
else:
|
|
val = delta
|
|
|
|
pwmDelta = 0
|
|
if val > 20000:
|
|
pwmDelta = 3
|
|
elif val > 10000:
|
|
pwmDelta = 2
|
|
elif val > 1000:
|
|
pwmDelta = 1
|
|
else:
|
|
pwmDelta = 0
|
|
|
|
if delta > 0:
|
|
pwmVal -= pwmDelta
|
|
elif delta < 0:
|
|
pwmVal += pwmDelta
|
|
|
|
if pwmVal < 0:
|
|
pwmVal = 0
|
|
elif pwmVal > 300:
|
|
pwmVal = 300
|
|
|
|
#pwmVal = 30
|
|
|
|
hvPwm.duty(pwmVal)
|
|
hvPwmn.duty(1023 - pwmVal)
|
|
|
|
if pwmDuty != pwmVal:
|
|
pwmDuty = pwmVal
|
|
print("pwm:%d,%d"%(pwmDelta, pwmDuty))
|
|
|
|
def mb_reg_update():
|
|
mb_server.set_coil(0, hvSwitch)
|
|
mb_server.set_coil(2, raySwitch)
|
|
|
|
mb_server.set_ireg(0, [
|
|
int(hvKvValue * 100),
|
|
int(hiMaValue * 1000),
|
|
int(filamentCurrent),
|
|
int(hvTempValue)
|
|
])
|
|
|
|
def ws_status_update():
|
|
status = {
|
|
'param' : {
|
|
'kV' : config['hv']['kV'],
|
|
'mA' : config['hv']['mA']
|
|
},
|
|
'value' : {
|
|
'hv' : 'on' if hvSwitch else 'off',
|
|
'xray' : 'on' if raySwitch else 'off',
|
|
'kV' : hvKvValue,
|
|
'mA' : hiMaValue,
|
|
'fV' : filamentVoltage / 1000,
|
|
'fI' : filamentCurrent / 1000,
|
|
'Vin' : filaInfo['vin'] / 1000,
|
|
'Iin' : filaInfo['iin'] / 1000
|
|
}
|
|
}
|
|
|
|
send_ws_list('/dev/status/hsv', status)
|
|
|
|
def ws_cmd_handler(ws, payload):
|
|
global hvSwitch, raySwitch, sysInfoList, sysErrorList
|
|
obj = json.loads(payload)
|
|
msg = obj['message']
|
|
dev_id = msg['device_id']
|
|
dev_code = msg['device_code']
|
|
cmd = msg['command']
|
|
if cmd == 'set_params':
|
|
value = msg['value']
|
|
if 'filament' in value:
|
|
config['hv']['filament'].update(value['filament'])
|
|
del value['filament']
|
|
config['hv'].update(value)
|
|
mb_server.set_hreg(0, [
|
|
int(config['hv']['kV']),
|
|
int(config['hv']['mA'] * 1000),
|
|
int(config['hv']['filament']['limit']),
|
|
int(config['hv']['filament']['preheat']),
|
|
])
|
|
print(config['hv'])
|
|
save_config('hv')
|
|
elif cmd == 'get_params':
|
|
msg = config['dev']
|
|
msg['command'] = cmd
|
|
msg['value'] = config['hv']
|
|
send_ws(ws, '/dev/response/hsv', msg)
|
|
elif cmd == 'hv_control':
|
|
hvSwitch = msg['value'] == 'on'
|
|
mb_server.set_coil(0, hvSwitch)
|
|
print("hvSwitch:",hvSwitch)
|
|
send_ws(ws, '/dev/response/hsv', msg)
|
|
|
|
info = {
|
|
"event" : "hvSwitch",
|
|
"from" : "web",
|
|
"value" : hvSwitch,
|
|
"time" : time.ticks_ms()
|
|
}
|
|
sysInfoList.append(info)
|
|
elif cmd == 'ray_control':
|
|
if config['dev']['xray_ctrl_pin_enable']:
|
|
return
|
|
raySwitch = msg['value'] == 'on'
|
|
mb_server.set_coil(2, raySwitch)
|
|
print("raySwitch:",raySwitch)
|
|
send_ws(ws, '/dev/response/hsv', msg)
|
|
|
|
info = {
|
|
"event" : "raySwitch",
|
|
"from" : "web",
|
|
"value" : raySwitch,
|
|
"time" : time.ticks_ms()
|
|
}
|
|
sysInfoList.append(info)
|
|
elif cmd == 'get_var':
|
|
msg['command'] = cmd
|
|
msg['value'] = {
|
|
'time' : time.ticks_ms(),
|
|
'var' : config['var'],
|
|
'error' : sysErrorList,
|
|
'info' : sysInfoList
|
|
}
|
|
send_ws(ws, '/dev/response/hsv', msg)
|
|
elif cmd == 'set_var':
|
|
if 'var' in msg['value']:
|
|
value = msg['value']['var']
|
|
else:
|
|
value = msg['value']
|
|
config['var'].update(value)
|
|
save_config('var')
|
|
|
|
def hvVarCollect():
|
|
if not hvSwitch:
|
|
return
|
|
if raySwitch:
|
|
aim = config['hv']['mA']
|
|
if hiMaValue < aim * 1.05 and hiMaValue > aim * 0.95:
|
|
config['var']['hv']['loadPwm'] = pwmDuty
|
|
else:
|
|
aim = config['hv']['kV']
|
|
if hvKvValue < aim + 1 and hvKvValue > aim - 1:
|
|
config['var']['hv']['idlePwm'] = pwmDuty
|
|
|
|
def filamentVarCollect():
|
|
if not hvSwitch:
|
|
return
|
|
if raySwitch:
|
|
aim = config['hv']['mA']
|
|
if hiMaValue < aim * 1.05 and hiMaValue > aim * 0.95:
|
|
config['var']['filament']['normalPwm'] = filamentDuty
|
|
else:
|
|
aim = config['hv']['filament']['preheat']
|
|
if filamentCurrent < aim + 50 and filamentCurrent > aim - 50:
|
|
config['var']['filament']['preheatPwm'] = filamentDuty
|
|
|
|
def varCheckAndSave():
|
|
save_config('var')
|
|
|
|
def varUpdate():
|
|
hvIdleKv = averageBufferGetAverage('hvIdleKv', 10)
|
|
hvLoadKv = averageBufferGetAverage('hvLoadKv', 10)
|
|
fiPreheatCurrent = averageBufferGetAverage('fiPreheatCurrent', 10)
|
|
hvLoadMa = averageBufferGetAverage('hvLoadMa', 10)
|
|
|
|
print('hvIdleKv', hvIdleKv)
|
|
print('hvLoadKv', hvLoadKv)
|
|
print('fiPreheatCurrent', fiPreheatCurrent)
|
|
print('hvLoadMa', hvLoadMa)
|
|
|
|
if hvIdleKv and hvIdleKv > config['hv']['kV'] + 0.5:
|
|
config['var']['hv']['idlePwm'] = config['var']['hv']['idlePwm'] - 1
|
|
elif hvIdleKv and hvIdleKv < config['hv']['kV'] - 0.5:
|
|
config['var']['hv']['idlePwm'] = config['var']['hv']['idlePwm'] + 1
|
|
if config['var']['hv']['idlePwm'] > config['var']['hv']['limitPwm']:
|
|
config['var']['hv']['idlePwm'] = config['var']['hv']['limitPwm']
|
|
|
|
if hvLoadKv and hvLoadKv > config['hv']['kV'] + 0.5:
|
|
config['var']['hv']['loadPwm'] = config['var']['hv']['loadPwm'] - 1
|
|
elif hvLoadKv and hvLoadKv < config['hv']['kV'] - 0.5:
|
|
config['var']['hv']['loadPwm'] = config['var']['hv']['loadPwm'] + 1
|
|
if config['var']['hv']['loadPwm'] > config['var']['hv']['limitPwm']:
|
|
config['var']['hv']['loadPwm'] = config['var']['hv']['limitPwm']
|
|
elif hvLoadKv and pwmDutyRayOn > config['var']['hv']['idlePwm']:
|
|
config['var']['hv']['loadPwm'] = pwmDutyRayOn
|
|
|
|
if fiPreheatCurrent and fiPreheatCurrent > config['hv']['filament']['preheat'] + 50:
|
|
config['var']['filament']['preheatPwm'] = config['var']['filament']['preheatPwm'] - 1
|
|
elif fiPreheatCurrent and fiPreheatCurrent < config['hv']['filament']['preheat'] - 50:
|
|
config['var']['filament']['preheatPwm'] = config['var']['filament']['preheatPwm'] + 1
|
|
if config['var']['filament']['preheatPwm'] > config['var']['filament']['limitPwm']:
|
|
config['var']['filament']['preheatPwm'] = config['var']['filament']['limitPwm']
|
|
|
|
if hvLoadMa and hvLoadMa > config['hv']['mA']:
|
|
config['var']['filament']['normalPwm'] = filamentLoadDuty - 1
|
|
elif hvLoadMa and hvLoadMa < config['hv']['mA'] - 0.03:
|
|
config['var']['filament']['normalPwm'] = filamentLoadDuty + 1
|
|
if config['var']['filament']['normalPwm'] > config['var']['filament']['limitPwm']:
|
|
config['var']['filament']['normalPwm'] = config['var']['filament']['limitPwm']
|
|
|
|
save_config('var')
|
|
|
|
print(config['var'])
|
|
|
|
def main():
|
|
global config, hvSwitch, raySwitch, wslock, rayStartTime, wdt, selfTestTime, sysErrorList, himAOverLimitCount, hvTempValue
|
|
|
|
exitFlag = False
|
|
hvStopTime = 0
|
|
hvUpdateTime = 0
|
|
firstRun = True
|
|
try:
|
|
load_config()
|
|
print(config)
|
|
|
|
if config['dev']['watchdog_enable']:
|
|
wdt = WDT('wdt', 2)
|
|
_thread.stack_size(10240)
|
|
_thread.start_new_thread(py_server,(ws_cmd_handler,))
|
|
|
|
mb_init()
|
|
|
|
delay = 2
|
|
count = 0
|
|
print("pwm init success!")
|
|
|
|
print(hvPwm)
|
|
|
|
print("adc init success!")
|
|
|
|
time.sleep_ms(100)
|
|
|
|
while not exitFlag:
|
|
if hiMaValue < 0.85:
|
|
if himAOverLimitCount > 0:
|
|
himAOverLimitCount = himAOverLimitCount - 1
|
|
else:
|
|
error = {
|
|
"hiMaValue" : hiMaValue,
|
|
"hvKVValue" : hvKvValue,
|
|
"hvPwm" : pwmDuty,
|
|
"filamentPwm" : filamentDuty
|
|
}
|
|
if himAOverLimitCount < 5:
|
|
config['var']['filament']['normalPwm'] = config['var']['filament']['normalPwm'] - 10
|
|
himAOverLimitCount = himAOverLimitCount + 1
|
|
else:
|
|
raySwitch = False
|
|
hvSwitch = False
|
|
hvControl(0)
|
|
filament.set_duty(0)
|
|
time.sleep_ms(100)
|
|
error['type'] = 'maOverLimit'
|
|
error['time'] = time.ticks_ms()
|
|
if len(sysErrorList) > 5:
|
|
sysErrorList.pop(0)
|
|
sysErrorList.append(error)
|
|
|
|
if hvKvValue > 70:
|
|
error = {
|
|
"hiMaValue" : hiMaValue,
|
|
"hvKVValue" : hvKvValue,
|
|
"hvPwm" : pwmDuty,
|
|
"filamentPwm" : filamentDuty
|
|
}
|
|
hvSwitch = False
|
|
hvControl(0)
|
|
filament.set_duty(0)
|
|
error['type'] = 'kvOverLimit'
|
|
error['time'] = time.time_ms()
|
|
sysErrorList.append(error)
|
|
time.sleep_ms(100)
|
|
|
|
if selfTestTime > 0:
|
|
raySwitch = False
|
|
tim = time.ticks_diff(time.ticks_ms(), selfTestTime)
|
|
|
|
if tim > 10000:
|
|
selfTestTime = 0
|
|
|
|
hvAdcPoll(10, delay)
|
|
|
|
if config['hv']['selfTest'] or selfTestTime > 0:
|
|
time.sleep_ms(20)
|
|
else:
|
|
time.sleep_ms(10)
|
|
try:
|
|
mb_server.process()
|
|
except Exception as e:
|
|
print('Exception during execution: {}'.format(e))
|
|
|
|
count = count + 1
|
|
if count * delay * 10 > 500:
|
|
count = 0
|
|
if selfTestTime > 0:
|
|
print("selfTestTime: %d" % tim)
|
|
|
|
#print("pwm: %d %d"%(pwmDuty,filamentDuty))
|
|
#print("hv: %d, %.2fkV"%(hvAdcValue, hvKvValue))
|
|
#print("hi: %d, %.2fmA"%(hiAdcValue, hiMaValue))
|
|
#print("fv: %.2f, fi %d: %.2fA"%(filamentVoltage / 1000, filamentDuty, filamentCurrent / 1000))
|
|
#print("xray_ctrl_pin", raySwitchPin.value())
|
|
|
|
tempVal = tempAdc.average()
|
|
hvTempValue = adc2temp(tempVal) * 100
|
|
print(tempVal, hvTempValue)
|
|
|
|
print('\n')
|
|
#gc.collect()
|
|
#gc.dump_info()
|
|
mb_reg_update()
|
|
ws_status_update()
|
|
if wdt:
|
|
wdt.feed()
|
|
|
|
if config['hv']['selfTest'] or selfTestTime > 0:
|
|
if hvSwitch:
|
|
hvVarCollect()
|
|
filamentVarCollect()
|
|
varCheckAndSave()
|
|
|
|
kV_set = config['hv']['kV']
|
|
mA_set = config['hv']['mA']
|
|
fi_limit = config['hv']['filament']['limit']
|
|
fi_preheat = config['hv']['filament']['preheat']
|
|
|
|
|
|
if hvSwitch:
|
|
if hvStopTime > 0:
|
|
tim = time.ticks_diff(time.ticks_ms(), hvStopTime)
|
|
if tim > 30000: # 30s
|
|
selfTestTime = time.ticks_ms()
|
|
hvStopTime = 0
|
|
if firstRun:
|
|
firstRun = False
|
|
selfTestTime = time.ticks_ms()
|
|
|
|
if filaInfo['relay_stat'] != True:
|
|
filament.set_relay(True)
|
|
time.sleep_ms(20)
|
|
if config['hv']['selfTest'] or selfTestTime > 0:
|
|
hvControl(kV_set)
|
|
else:
|
|
hvControlFast(kV_set)
|
|
|
|
if (not config['hv']['selfTest']) and (selfTestTime == 0):
|
|
if config['dev']['xray_ctrl_pin_enable']:
|
|
raySwitch = not raySwitchPin.value()
|
|
else:
|
|
raySwitch = False
|
|
if hvStopTime < 1:
|
|
hvStopTime = time.ticks_ms()
|
|
hvControl(0)
|
|
if filaInfo['relay_stat'] != False:
|
|
filament.set_relay(False)
|
|
|
|
if not config['hv']['selfTest'] and rayStartTime > 1 and time.ticks_ms() > rayStartTime + 5000:
|
|
raySwitch = False
|
|
|
|
if raySwitch and hvSwitch:
|
|
hvUpdateTime = 0
|
|
if config['hv']['selfTest'] or selfTestTime > 0:
|
|
filamentControlNormal(mA_set, fi_limit)
|
|
else:
|
|
if rayStartTime < 1:
|
|
#清空平均缓冲区
|
|
averageBuffer['hvLoadKv'] = []
|
|
averageBuffer['hvLoadMa'] = []
|
|
|
|
rayStartTime = time.ticks_ms()
|
|
filamentControlFast(mA_set)
|
|
elif hvSwitch:
|
|
if hvUpdateTime < 1:
|
|
hvUpdateTime = time.ticks_ms()
|
|
|
|
if config['hv']['selfTest'] or selfTestTime > 0:
|
|
if count % 10 == 0:
|
|
filamentPreheat(fi_preheat)
|
|
else:
|
|
if rayStartTime > 0:
|
|
varUpdate()
|
|
averageBuffer['hvIdleKv'] = []
|
|
averageBuffer['fiPreheatCurrent'] = []
|
|
|
|
hvControlFast(kV_set)
|
|
elif hvUpdateTime > 0 and time.ticks_diff(time.ticks_ms(), hvUpdateTime) > 3 * 1000:
|
|
hvUpdateTime = time.ticks_ms()
|
|
varUpdate()
|
|
|
|
filamentPreheatFast(fi_preheat)
|
|
rayStartTime = 0
|
|
else:
|
|
hvUpdateTime = 0
|
|
rayStartTime = 0
|
|
filamentPreheat(fi_preheat)
|
|
|
|
print("main exit")
|
|
|
|
except Exception as e:
|
|
sys.print_exception(e)
|
|
finally:
|
|
exitFlag = True
|
|
filament.set_duty(0)
|
|
filament.set_relay(False)
|
|
hvAdc.deinit()
|
|
hiAdc.deinit()
|
|
hvPwm.deinit()
|
|
hvPwmn.deinit()
|
|
filament.deinit()
|
|
print('exit')
|
|
|
|
#time.sleep(1)
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
|