class ScaleThread(QThread):
def __init__(self, portName):
QThread.__init__(self)
self.portName = portName
self.txq = queue.queue()
self.running = True
def ser_out(self, s):
self.txq.put(s)
def ser_in(self, s):
display(s)
def run(self):
try:
self.scalePort = MettlerToledoDevice(port=self.portName)
except:
self.scalePort = None
if not self.scalePort:
print("Serial Port troubs")
self.running = False
while (self.running):
s = self.scalePort.get_weight()
if s:
num = s[0]
numstr = int.Parse(num)
self.ser_in(numstr)
if not self.txq.empty():
txd = str(self.txq.get())
self.ser_out(txd)
if self.scalePort:
self.scalePort.close()
self.scalePort = None
class Connection:
def __init__(self, address, device_id):
self.address = address
self.device_id = device_id
self.dev = MettlerToledoDevice(port=self.address)
def get_weight(self):
weight = self.dev.get_weight()
return {
'value': weight[0],
'unit': weight[1],
'stable': True if weight[2] is 'S' else False
}
def get_info(self):
data = self.dev.get_balance_data()
sn = self.dev.get_serial_number()
sw = self.dev.get_software_version()
if len(data) > 3:
info = {
'model': data[0],
'model-type': data[1],
'sn': sn,
'sw-version': sw[0],
'sw-type': sw[1],
'capacity': data[1],
'unit': data[2]
}
else:
info = {
'model': data[0],
'sn': sn,
'sw-version': sw[0],
'sw-type': sw[1],
'capacity': data[1],
'unit': data[2]
}
return info
def get_address(self):
return self.dev.get_port()
def close(self):
self.dev.close()
class Worker(QObject):
'''
Worker thread
Inherits from QRunnable to handler worker thread setup, signals and wrap-up.
:param callback: The function callback to run on this worker thread. Supplied args and
kwargs will be passed through to the runner.
:type callback: function
:param args: Arguments to pass to the callback function
:param kwargs: Keywords to pass to the callback function
'''
def __init__(self, name, max, **kwargs):
super(Worker, self).__init__()
# Store constructor arguments (re-used for processing)
self.name = name
self.max = max
self.kwargs = kwargs
self.signals = WorkerSignals()
self.running = True
self.isPaused = False
self.scalePort = MettlerToledoDevice(port=self.name)
# Add the callback to our kwargs
def stop(self):
self.event
@Slot()
def pause(self):
self.isPaused = True
@Slot()
def resume(self):
self.isPaused = False
def cancel(self):
self.scalePort.close()
self.running = False
def factor_conversion(self):
if 0 < self.maxed < 5001:
factor = 0.9
elif 5001 <= self.max < 20001:
factor = 0.99
elif 20001 <= self.max:
factor = 0.999
return factor
@Slot()
def run(self):
resultcounter = 0
resultarray = npy.array([])
deltaarray = npy.array([])
changecounter = 0
while (self.running):
while self.isPaused() == True:
time.wait(0)
try:
s = self.scalePort.get_weight()
if s:
resultcounter += 1
num = s[0]
inum = int(num)
result = str(num)
if resultcounter >= 5:
resultarray.append(result)
resultcounter = 0
changecounter += 1
p
if changecounter >= 5:
deltaarray.append(resultarray[len(resultarray) -
1] - resultarray[-1])
changecounter = 0
if deltaarray[len(deltaarray) -
1] - deltaarray[-1] <= 50:
self.cancel()
if len(resultarray) > 10:
if len(resultarray) < 25:
if sum(resultarray) / len(resultarray) <= 100:
self.cancel()
self.signals.result.emit(result)
self.signals.progress.emit(
100 * inum / int(0.9 * self.factor_conversion()))
if (inum > int(self.factor_conversion())):
self.cancel()
break
if self.scalePort is None:
self.cancel()
break
except:
self.cancel()
break
# Return the result of the processin
# Done
if (self.running == False):
self.signals.finished.emit()
class Worker(QRunnable):
'''
Worker thread
Inherits from QRunnable to handler worker thread setup, signals and wrap-up.
:param callback: The function callback to run on this worker thread. Supplied args and
kwargs will be passed through to the runner.
:type callback: function
:param args: Arguments to pass to the callback function
:param kwargs: Keywords to pass to the callback function
'''
def __init__(self, name, pumpname, max, isSerial, **kwargs):
super(Worker, self).__init__()
# Store constructor arguments (re-used for processing)
self.name = name
self.max = max
self.isPaused = False
self.pumpname = pumpname
self.resultsvector = []
self.changevector = []
self.isSerial = isSerial
self.kwargs = kwargs
self.signals = WorkerSignals()
self.running = True
if (self.isSerial == True):
try:
self.pumpPort = serial.Serial(port=self.pumpname,
baudrate=4800,
bytesize=serial.SEVENBITS,
parity=serial.PARITY_ODD,
timeout=1)
except:
self.pumpPort.close()
self.pumpPort = serial.Serial(port=self.pumpname,
baudrate=4800,
bytesize=serial.SEVENBITS,
parity=serial.PARITY_ODD,
timeout=1)
self.scalePort = MettlerToledoDevice(port=self.name)
# Add the callback to our kwargs
def stop(self):
self.event
def pause(self):
self.isPaused = True
def resume(self):
self.isPaused = False
def cancel(self):
if (self.isSerial == True):
try:
self.scalePort.close()
self.running = False
self.resultsvector = []
self.changevector = []
self.pumpPort.close()
except:
self.scalePort = None
self.pumpPort = None
else:
#self.signals.pumpStop.emit()
self.scalePort.close()
self.running = False
def factor_conversion(self):
if 0 < self.max < 5001:
factor = 0.9
elif 5001 <= self.max < 20001:
factor = 0.99
elif 20001 <= self.max:
factor = 0.999
return factor
def convertToVoltage(self, rpm):
volt = self.rpm * 0.016
@Slot()
def run(self):
if (self.isSerial == True):
if (self.pumpPort):
self.pumpPort.close()
while (self.running):
while self.isPaused:
time.sleep(0)
try:
s = self.scalePort.get_weight()
if s:
num = s[0]
inum = int(num)
result = str(num)
changes = []
self.resultsvector.append(int(inum))
self.signals.result.emit(result)
self.signals.progress.emit(100 * inum /
int(0.97 * self.max))
if (len(self.resultsvector) > 5):
if (self.resultsvector[-1] != self.resultsvector[-2]):
change = float(self.resultsvector[-1]) - float(
self.resultsvector[-2])
self.changevector.append(float(change))
if (len(self.changevector) > 5):
avg = sum(self.changevector) / len(
self.changevector)
if ((self.changevector[-1]) / avg < 0.1):
self.signals.result.emit(
"Air in the line or still clamped")
self.signals.error.emit((str(
self.changevector[-1]
), "Rate of change has fallen to low, check line"
))
self.cancel()
break
if (inum > int(0.999 * self.max)):
self.cancel()
break
if self.scalePort is None:
self.cancel()
break
except:
self.cancel()
break
# Return the result of the processin
# Done
if (self.running == False):
self.signals.finished.emit()
class Worker(QRunnable):
'''
Worker thread
Inherits from QRunnable to handler worker thread setup, signals and wrap-up.
:param callback: The function callback to run on this worker thread. Supplied args and
kwargs will be passed through to the runner.
:type callback: function
:param args: Arguments to pass to the callback function
:param kwargs: Keywords to pass to the callback function
'''
def __init__(self, name, pumpname, max, **kwargs):
super(Worker, self).__init__()
# Store constructor arguments (re-used for processing)
self.name = name
self.max = max
self.pumpname = pumpname
self.kwargs = kwargs
self.signals = WorkerSignals()
self.running = True
self.resultsvector = []
self.changevector = []
self.txq = queue.Queue()
self.scalePort = MettlerToledoDevice(port=self.name)
try:
self.pumpPort = serial.Serial(port=self.pumpname,
baudrate=4800,
bytesize=serial.SEVENBITS,
parity=serial.PARITY_ODD,
timeout=1)
except:
self.pumpPort.close()
self.pumpPort = serial.Serial(port=self.pumpname,
baudrate=4800,
bytesize=serial.SEVENBITS,
parity=serial.PARITY_ODD,
timeout=1)
# Add the callba ck to our kwargs
def stop(self):
self.event
def cancel(self):
try:
self.scalePort.close()
self.running = False
self.pumpPort.close()
self.resultsvector = []
self.changevector = []
except:
self.scalePort = None
self.pumpPort = None
@Slot()
def run(self):
if (self.pumpPort):
self.pumpPort.close()
while (self.running):
try:
s = self.scalePort.get_weight()
if s:
num = s[0]
inum = int(num)
result = str(num)
changes = []
self.resultsvector.append(int(inum))
self.signals.result.emit(result)
self.signals.progress.emit(100 * inum /
int(0.97 * self.max))
if (len(self.resultsvector) > 2):
if (self.resultsvector[-1] != self.resultsvector[-2]):
change = float(self.resultsvector[-1]) - float(
self.resultsvector[-2])
self.changevector.append(float(change))
if (len(self.changevector) > 5):
avg = sum(self.changevector) / len(self.changevector)
if (avg > 0 and (self.changevector[-1]) / avg < 0.1):
self.signals.result.emit(
"Air in the line or still clamped")
self.signals.error.emit(
(str(self.changevector[-1]),
"Rate of change has fallen to low, check line"
))
self.cancel()
break
elif (avg == 0 and len(self.changevector) < 2):
self.signals.result.emit(
"Air in the line or still clamped")
self.signals.error.emit(
(str(self.changevector[-1]),
"Rate of change has fallen to low, check line"
))
self.cancel()
break
if (inum > int(0.99 * self.max)):
self.cancel()
break
if self.scalePort is None:
self.cancel()
break
except:
traceback.print_exc()
exctype, value = sys.exc_info()[:2]
self.signals.error.emit(
(exctype, value, traceback.format_exc()))
self.cancel()
break
# Return the result of the processin
# Done
if (self.running == False):
self.signals.finished.emit()