HendiControlFirmware/Control/brewpi/hendiCtrl.py

#!/usr/bin/python3

import time
import serial
import sys

class HendiCtrl():
	def __init__(self, port, baudrate):
		self.ser = serial.Serial(port, baudrate)
		try:
			self.ser.open()
		except:
			self.ser.close()
			self.ser.open()

		self.ser.timeout = 1.000
		self.prompt = b':'
		self.caps = {
			"name"				: self.getSoftwareIdentifier(),
			"ver"				: self.getSoftwareVersion(),
			"pwr_watts_min"		: 500,
			"pwr_watts_max"		: 3500,
			"pwr_watts_step"	: 100,
			"pwr_digits_min"	: 4095,
			"pwr_digits_max"	: 500
		}

	def reset(self):
		self.ser.dtr = True
		self.ser.rts = False
		time.sleep(0.01)
		self.ser.dtr = True
		self.ser.rts = True

	def enter_bootloader(self):
		self.ser.dtr = True
		self.ser.rts = False
		time.sleep(0.01)
		self.ser.dtr = False
		self.ser.rts = True

	def firmware_update(self, filename):
		print("Start firmware update")
		self.enter_bootloader()
		self.ser.readline()

		self.ser.flushInput()
		with open(filename, 'r') as fp:
			line_count = 0
			while (True):
				s = fp.readline()
				if s == '':
					break
				data = s.encode()
				self.ser.write(data)
				ack = self.ser.read()
				sys.stdout.write(ack.decode('utf-8'))
				sys.stdout.flush()
				if line_count == 64:
					line_count = 0
					sys.stdout.write("\n")

				line_count += 1

		self.ser.readline()
		self.ser.flushInput()
		self.ser.write(b'q')
		self.ser.flushOutput()

	def __write(self, s):
		self.ser.flushInput()
		data = s.encode()
		self.ser.write(data + b'\r')

	def __read(self):
		# Read line echo
		self.ser.readline()

		# Read answer line
		answer = self.ser.readline().decode('utf-8').replace('\r', '').replace('\n', '')
		if ':' in answer:
			result = answer.split(':')
		else:
			result = answer

		return result

	def cmd(self, s):
		self.__write(s)
		rsp = self.__read()
		print(rsp)
		if "OK" in rsp[0]:
			return rsp[1]
		return None
	
	def getCapabilties(self):
		return self.caps

	def getInfo(self):
		result = {
			'caps'			: self.caps,
			'state'			: self.getState(),
			'pwr_digits'	: self.getPowerDigits(),
			'Switch_state'	: self.getSwitch()
		}
		return result

	def _debugEnable(self, enable):
		return self.cmd("D" + str(int(enable)))

	def _isDebugEnable(self):
		return self.cmd("D?")

	def getSoftwareIdentifier(self):
		return self.cmd("I?")

	def getSoftwareVersion(self):
		return self.cmd("V?")

	def getState(self):
		return self.cmd("T?")

	def remoteEnable(self, enable):
		return self.cmd("R" + str(int(enable)))

	def isRemoteEnable(self):
		return self.cmd("R?")

	def setPowerDigits(self, power_digits):
		return self.cmd("P" + str(power_digits))

	def getPowerDigits(self):
		return self.cmd("P?")

	def setSwitch(self, enable):
		return self.cmd("S" + str(int(enable)))

	def getSwitch(self):
		return self.cmd("S?")

	def setPowerWatts(self, power_watts):
		pwr_watts_min = self.caps['pwr_watts_min']
		pwr_watts_max = self.caps['pwr_watts_max']
		pwr_digits_min = self.caps['pwr_digits_min']
		pwr_digits_max = self.caps['pwr_digits_max']
		pwr_watts_step = self.caps['pwr_watts_step']

		pwr_watts_range = pwr_watts_max - pwr_watts_min
		pwr_digits_range = pwr_digits_max - pwr_digits_min
		digits_per_watt = pwr_digits_range/pwr_watts_range
		pwr_digits  =  pwr_digits_min + digits_per_watt * (power_watts - pwr_watts_min) + 0.5

		max_digits = max(pwr_digits_max, pwr_digits_min)
		min_digits = min(pwr_digits_max, pwr_digits_min)
		pwr_digits = int(min(max_digits, max(min_digits, pwr_digits)))
		self.setPowerDigits(pwr_digits)

	def getPowerWatts(self):
		pwr_watts_min = self.caps['pwr_watts_min']
		pwr_watts_max = self.caps['pwr_watts_max']
		pwr_digits_min = self.caps['pwr_digits_min']
		pwr_digits_max = self.caps['pwr_digits_max']

		pwr_watts_range = pwr_watts_max - pwr_watts_min
		pwr_digits_range = pwr_digits_max - pwr_digits_min
		digits_per_watt = pwr_digits_range/pwr_watts_range

		max_digits = max(pwr_digits_max, pwr_digits_min)
		min_digits = min(pwr_digits_max, pwr_digits_min)
		pwr_digits = int(self.getPowerDigits())

		pwr_watts = (pwr_digits - pwr_digits_min)/digits_per_watt + pwr_watts_min

		return int(pwr_watts)


if __name__ == '__main__':

	hendi = HendiCtrl('/dev/ttyUSB0', 115200)

#	hendi.firmware_update("HendiCtrl.srec")
#	hendi.reset()
	time.sleep(10)

	hendi.getState()
	hendi.getSoftwareIdentifier()
	hendi.getSoftwareVersion()

	try:	
		hendi.remoteEnable(True)
		hendi.setSwitch(1)
		for pwr in range(500, 3500, 100):
			hendi.setPowerWatts(pwr)
			time.sleep(0.1)
			pw = hendi.getPowerWatts()
			print("power_w", pw)
			time.sleep(1.0)

	except:
		pass
	
	hendi.setSwitch(0)
	hendi.remoteEnable(False)

	if 0:
		hendi.remoteEnable(True)
		if hendi.isRemoteEnable():
			hendi.setSwitch(True)
			for p in range(0, 4096, 100):
				hendi.setPowerDigits(p)
				time.sleep(1)

			hendi.setSwitch(False)
			hendi.remoteEnable(False)

	print ("End of program.")