MarkoprintWiFi/MkpWIFI/printer.py

import socket
import json
import time

import commands as cmd

class MarkoPrinter:
	def __init__(self, configFilePath, LOGGER):
		self.LOGGER = LOGGER
		self.inkStatCounter = 0
		self.printSock = None
		self.headStatus = dict()
		self.connected = False
		self.sending = False
		self.reading = False
		with open(configFilePath, "r") as setFile:
			self.settings = json.load(setFile)
		self.data = self.settings["printcmd"]
		self.debug = True

	def log(self, *logtxt):
		if self.debug:
			print(*logtxt)

	def connetti(self):
		if not self.connected:
			if self.printSock is None:
				try:
					self.printSock = socket.socket(
						socket.AF_INET, socket.SOCK_STREAM)
					self.printSock.connect(
						(self.settings["ip"], self.settings["port"]))
					self.connected = True
					self.printSock.settimeout(0.5)
					self.checkStatus()
					self.LOGGER.info("Connessione Riuscita")
				except socket.error as e:
					self.printSock = None
					self.connected = False
					self.LOGGER.debug("Connessione Fallita: {}".format(e))
			else:
				self.keepaliveTimer.cancel()
				self.printSock.close()
				self.printSock = None
				self.connetti()
		return self.connected

	def disconnetti(self):
		if self.connected:
			self.printSock.close()
			self.printSock = None
			self.connected = False
		return self.connected

	def checkStatus(self):
		statusUpdated = False
		if self.connected:
			try:
				self.printSock.send(b"\x1BS1\r")
				time.sleep(1)
				c = self.printSock.recv(1)
				inData = b""
				while c != b"\r":
					inData += c
					if len(inData) > 200:
						self.LOGGER.error("Status Message Length Error")
						raise IOError
					c = self.printSock.recv(1)
				inData = str(inData, "ascii")
				inData = inData.split(":")
				for index, key in enumerate(self.data["headstatus"]):
					if key != "txt":
						self.headStatus[key] = int(inData[index])
					else:
						self.headStatus[key] = str(inData[index])
				self.LOGGER.info("Status: {}".format(self.headStatus))
				statusUpdated = True
			except:
				self.LOGGER.error("Status retreive error!")
		return statusUpdated

	def upload(self, descr, datastr):
		self.sending = True
		response = ""
		if self.connected:
			cmdstr = "\x02TZ" + self.data["filename"] + \
				";" + self.data["printmode"] + "\r"
			self.log(bytearray(descr, "ascii"))
			descr = descr.replace("\n", "\t")
			outstr = cmdstr + datastr + "\03\r"
			self.printSock.settimeout(1.0)
			try:
				self.printSock.send(bytearray(outstr, "ascii"))
				retval = self.printSock.recv(1)
				self.log("ACK: ", retval)
				if retval == b'\x06':
					retval = self.printSock.recv(6)
					if retval == b'\x021OK\x03':
						self.log("RESP: ", retval)
						response = "Invio Riuscito!"
						self.log("Printer OK")
					else:
						response = "Invio Fallito!"
						self.log("Printer Error")
				else:
					self.log("Send Error")
				self.printSock.settimeout(0.5)
				statusUpdated = self.checkStatus()
				if self.headStatus["ink"] == 2:
					response = "CARTUCCIA ESAURITA\nSostituire!"
				elif self.headStatus["ink"] == 1:
					response = "Cartuccia in Esaurimento"
			except socket.error as e:
				self.log("Socket error: ", e)
				self.printSock.settimeout(0.5)
				response = "Invio Fallito!"
				self.printSock.sendall(b"\r"*5)
				self.printSock.recv(5)
		self.sending = False
		return response, statusUpdated
	
	def sendCommand(self, c):
		self.sending = True
		if self.connected:
			try:
				self.printSock.settimeout(1.0)
				sent=self.printSock.send(bytearray(c,'ascii'))
				self.printSock.settimeout(0.5)
				self.sending = False
				if sent < len(c):
					raise RuntimeError("Stampante Disconnessa")
				return True
			except socket.error as e:
				self.LOGGER.error('Socket Error: {}'.format(e))
				self.sending = False
				return False
		pass

	def readResponse(self, c):
		self.reading = True
		buf = bytearray()
		respTerm = bytearray(cmd.DEFprefix['end'] if cmd.MKPcommands[c]['defPrefix'] else cmd.MKPcommands[c]['end'], 'ascii')
		if self.connected:
			try:
				# lettura bloccante del socket in attesa di conferma
				self.printSock.settimeout(5)
				c = self.printSock.recv(1)
				while c != respTerm:
					buf += c
					c = self.printSock.recv(1)
				# disattivo lettura bloccante
				self.printSock.settimeout(0.5)
				# VERIFICARE SE VA BENE
				self.reading = False
				return str(buf, 'ascii')
			except socket.timeout as t:
				self.reading = False
				raise t
			except socket.error as e:
				self.LOGGER.error('Socket Error: {}'.format(e))
				return False
		self.reading = False
		pass

	def keepalive(self):
		statusUpdated = False
		keepCmd = b"\x1B*\r"
		self.LOGGER.debug("Keepalive")
		if not self.sending and not self.reading:
			if self.connected:
				try:
					sent = self.printSock.send(keepCmd)
					if sent < len(keepCmd):
						raise RuntimeError("Stampante Disconnessa")
					self.LOGGER.debug(str(self.printSock.recv(5)))
					if self.inkStatCounter <= self.settings["inkstat"]:
						self.inkStatCounter += 1
					else:
						statusUpdated = self.checkStatus()
						self.inkStatCounter = 0
				except socket.timeout as t:
					raise RuntimeError("Stampante Disconnessa: {}".format(t))
			return self.connected, statusUpdated