def __start__(self, comport=0):
serialThread = self.serialThread = eg.SerialThread()
serialThread.Open(comport, 115200)
serialThread.Start()
#serialThread.SetRts()
self.MyComIrDevice = ComIRDevice(mySerialThread=serialThread)
for dummyCounter in range(3):
sleep(0.05)
self.MyComIrDevice.ResetMode()
USBIrToyFWVer = self.MyComIrDevice.GetVersion()
print "USB IR Toy Version ", USBIrToyFWVer, " (vX07+ required)"
#if(USBIrToyFWVer!=self.__USBIRTOYFWVERSION):
# continue
print "Entering Sampling Mode..."
if (self.MyComIrDevice.EnterSamplingMode('S01') == False):
continue
print "Entered Sampling Mode!"
break
else:
serialThread.Close()
raise self.Exceptions.InitFailed
self.buffer = ""
serialThread.SetReadEventCallback(self.OnReceive)
self.sendQueue = Queue(50)
self.alive = True
Thread(target=self.SendLoop).start()
print "USB IR Toy Connection Successful!"
def __start__(self, port):
self.port = port
self.serialThread = eg.SerialThread()
self.serialThread.SetReadEventCallback(self.OnReceive)
self.serialThread.Open(port, 9600, '8N1')
#self.serialThread.SetRts()
self.serialThread.Start()
def __start__(self, port=0, address=0, baudrate=9600):
self.port = port
self.address = address
self.serialThread = eg.SerialThread()
self.serialThread.SetReadEventCallback(self.OnReceive)
self.serialThread.Open(port, baudrate)
self.serialThread.SetRts()
self.serialThread.Start()
def __start__(self):
self.timeTask = None
self.readBuffer = ""
global d2xx
try:
d2xx = windll.LoadLibrary("ftd2xx.dll")
except:
raise self.Exception(
"FHZ PC DLL not found (ftd2xx.dll).\n"
"Make sure you have installed the driver for the device!")
self.ftHandle = d2xx.FT_W32_CreateFile(
'ELV FHZ 1000 PC',
GENERIC_READ | GENERIC_WRITE,
0, # exclusive access
0, # no security
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED
| FT_OPEN_BY_DESCRIPTION,
0)
if self.ftHandle == INVALID_HANDLE_VALUE:
raise self.Exceptions.DriverNotFound
self.receiveThread = eg.SerialThread(self.ftHandle)
self.receiveThread._WriteFile = d2xx.FT_W32_WriteFile
self.receiveThread._ReadFile = d2xx.FT_W32_ReadFile
self.receiveThread._ClearCommError = d2xx.FT_W32_ClearCommError
self.receiveThread._CloseHandle = d2xx.FT_W32_CloseHandle
d2xx.FT_SetLatencyTimer(self.ftHandle, 2)
d2xx.FT_SetBaudRate(self.ftHandle, 9600)
d2xx.FT_SetDataCharacteristics(self.ftHandle, 8, 0, 0)
d2xx.FT_SetFlowControl(self.ftHandle, 0, 17, 19)
d2xx.FT_SetTimeouts(self.ftHandle, 1000, 1000)
self.receiveThread.Start()
# Say hello
self.WriteFhz(0xC9, 0x02, 0x01, 0x1f, 0x42)
self.ReadFhz()
# Request Status/Serial
self.WriteFhz(0x04, 0xc9, 0x01, 0x84, 0x57, 0x02, 0x08)
self.ReadFhz()
# HMS Init (if required)
self.WriteFhz(0x04, 0xc9, 0x01, 0x86)
# FS20 Init (if required)
self.WriteFhz(0x04, 0xc9, 0x01, 0x96)
# calculate the time of the current minute
t = list(time.localtime())
t[5] = 0
self.nextTaskTime = time.mktime(t)
self.WriteFhz(*self.GetTimeData())
self.nextTaskTime += 60.0
self.timeTask = eg.scheduler.AddTaskAbsolute(self.nextTaskTime,
self.TimeScheduleTask)
self.receiveThread.SetReadEventCallback(self.HandleReceive)
def __start__(self, port=0, remotes=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]):
self.remotes = remotes
self.port = port
self.lastActionEvent = None
self.serialThread = eg.SerialThread()
self.serialThread.Open(port, COMSPEED)
self.serialThread.SetReadEventCallback(self.HandleReceive)
self.serialThread.Start()
self.serialThread.Write("\x00\x00\x00")
def __start__(self, port, byteCount=6, init=True):
self.byteCount = byteCount
self.serialThread = serialThread = eg.SerialThread()
serialThread.Open(port, 9600)
serialThread.SetRts()
serialThread.SetDtr()
serialThread.Start()
time.sleep(0.05)
serialThread.Flush()
if init:
serialThread.Write("I")
time.sleep(0.05)
serialThread.Write("R")
if serialThread.Read(2, 1.0) != "OK":
self.serialThread.Close()
raise self.Exceptions.DeviceInitFailed
serialThread.SetReadEventCallback(self.OnReceive)
def ConnectPort(self):
if self.serialThread is not None:
try:
self.serialThread.Flush()
self.serialThread.Stop()
self.serialThread.Close()
except:
pass
self.serialThread = None
try:
self.serialThread = eg.SerialThread()
self.serialThread.Open(self.port, 9600, "8N1")
self.serialThread.SetRts()
self.serialThread.Start()
self.TriggerEvent(self.text.connect)
except:
self.serialThread = None
eg.PrintError(
self.text.info3 % (self.info.eventPrefix, self.port)
)
return
def __start__(self, comport=0):
serialThread = self.serialThread = eg.SerialThread()
serialThread.Open(comport, 115200)
serialThread.Start()
serialThread.SetRts()
for dummyCounter in range(3):
sleep(0.05)
serialThread.Flush()
serialThread.Write("\x23\xdd") # get version
if serialThread.Read(3, 0.2) != "\x01\x04\xFB":
continue
serialThread.Write("\x21\xdf") # set RAW mode
if serialThread.Read(1, 0.1) != "\x21":
continue
break
else:
serialThread.Close()
raise self.Exceptions.InitFailed
self.buffer = ""
serialThread.SetReadEventCallback(self.OnReceive)
self.sendQueue = Queue(50)
self.alive = True
Thread(target=self.SendLoop).start()
def __start__(
self,
port=0,
baudrate=9600,
bytesize=3,
parity=0,
stopbits=0,
generate_events=True,
prefix="Atric",
init=True,
bytecount=6,
):
text = self.text
global global_generate_events
global global_firmware_version
global global_access_string
global global_serial_thread
global global_serial_buffer
global_generate_events = generate_events
self.info.eventPrefix = prefix
bytesize = BYTESIZES[bytesize]
parity = PARITIES[parity]
stopbits = STOPBITS[stopbits]
self.bytecount = bytecount
global_serial_thread = eg.SerialThread()
global_serial_buffer = ""
global_serial_thread.Open(
port, baudrate, (str(bytesize) + str(parity) + str(stopbits)))
global_serial_thread.SetRts()
global_serial_thread.SetDtr()
global_serial_thread.Start()
time.sleep(0.05)
global_serial_thread.Flush()
global_serial_thread.SetReadEventCallback(self.on_receive)
if init is True:
print(text.init_start)
temp = write_advanced()
temp(data="I",
timeout=0.1,
read_num_bytes=0,
disable_infrared_while_write=False)
global_serial_thread.Flush()
returndata = temp(
data="R",
timeout=0,
read_returnformat="original",
read_num_bytes=2,
read_timeout=2,
disable_infrared_while_write=False,
)
if returndata == "OK":
eg.TriggerEvent(text.init_success % (port + 1))
else:
global_serial_thread.Close()
raise self.Exceptions.DeviceInitFailed
print(text.firmware_start)
temp = write_advanced()
global_serial_thread.Flush()
returndata = temp(
data="VV",
timeout=0,
read_num_bytes=2,
read_timeout=2,
read_returnformat="hex",
read_debug=False,
disable_infrared_while_write=False,
)
try:
returndata = float(returndata[0] + "." + returndata[1])
except:
returndata = -1
if returndata >= 0 and returndata < 1.2:
global_firmware_version = "<1.2"
global_access_string = ""
eg.TriggerEvent(text.firmware_success % (returndata))
elif returndata == 1.2:
global_firmware_version = "1.2"
global_access_string = "ACS"
eg.TriggerEvent(text.firmware_success % (returndata))
else:
global_firmware_version = "1.2"
global_access_string = "ACS"
eg.TriggerEvent(text.firmware_error %
(returndata, global_firmware_version))
