From e8e9db126bb95f7810b55b12307c5cb212ea37e7 Mon Sep 17 00:00:00 2001
From: Daniel <dccote@cervo.ulaval.ca>
Date: Thu, 3 Nov 2022 22:55:30 -0400
Subject: [PATCH 1/4] Create testHamamatsuSerial.py

Created and completed all tests to reverse engineer the H11890-01 photon counter from Hamamatsu.
---
 hardwarelibrary/tests/testHamamatsuSerial.py | 457 +++++++++++++++++++
 1 file changed, 457 insertions(+)
 create mode 100644 hardwarelibrary/tests/testHamamatsuSerial.py

diff --git a/hardwarelibrary/tests/testHamamatsuSerial.py b/hardwarelibrary/tests/testHamamatsuSerial.py
new file mode 100644
index 0000000..bc0562c
--- /dev/null
+++ b/hardwarelibrary/tests/testHamamatsuSerial.py
@@ -0,0 +1,457 @@
+import env
+import unittest
+from struct import *
+from time import sleep
+
+from hardwarelibrary.communication.usbport import *
+
+# class TestHamamatsuUSBPortBase(unittest.TestCase):
+#     def setUp(self):
+#         self.port = USBPort(idVendor=0x0661, idProduct = 0x3705)
+#         self.assertIsNotNone(self.port)
+#         self.port.open()
+#         self.assertTrue(self.port.isOpen)
+
+#         self.port.writeData(b'\r')
+#         self.port.flush()
+        
+#     def tearDown(self):
+#         # self.port.writeData(b"ZV")
+#         # self.assertEqual("ZV", self.readStringFromPMT())
+#         self.port.close()
+
+
+#     # def test01CreatePort(self):
+#     #     self.assertIsNotNone(self.port)
+
+#     # def test02OpenPort(self):
+#     #     self.assertTrue(self.port.isOpen)
+
+#     # # def test03SendDVCommand(self):
+#     # # This helped me figure out that the readData command would always 
+#     # # read 64 bytes.
+#     # #     port = USBPort(idVendor=0x0661, idProduct = 0x3705)
+#     # #     # port.terminator = b'\r'
+#     # #     self.assertIsNotNone(port)
+#     # #     port.open()
+#     # #     self.assertTrue(port.isOpen)
+#     # #     port.writeString(string="DV")
+#     # #     count = 64
+#     # #     while count > 0:
+#     # #         try:
+#     # #             print(count, port.readData(1))
+#     # #         except Exception as err:
+#     # #             print(err)
+#     # #             break
+#     # #         count = count -1
+
+#     # #     port.close()
+
+#     # # def test04SendDVZVCommand(self):
+#     # #  This never worked.
+#     # #     port = USBPort(idVendor=0x0661, idProduct = 0x3705)
+#     # #     # port.terminator = b'\r'
+#     # #     self.assertIsNotNone(port)
+#     # #     port.open()
+#     # #     self.assertTrue(port.isOpen)
+#     # #     port.write(string="DV")
+#     # #     count = 64
+#     # #     while count > 0:
+#     # #         try:
+#     # #             print(count, port.readData(1))
+#     # #         except Exception as err:
+#     # #             print(err)
+#     # #             break
+#     # #         count = count -1
+
+#     # #     port.writeString(string="ZV")
+#     # #     count = 64
+#     # #     while count > 0:
+#     # #         try:
+#     # #             print(count, port.readData(1))
+#     # #         except Exception as err:
+#     # #             print(err)
+#     # #             break
+#     # #         count = count -1
+
+#     # #     port.close()
+
+
+#     # # def test05SendDVZeroCommand(self):
+#     # #     self.port.writeData(b"DV\x00")
+#     # #     data = self.port.readData(64)
+#     # #     string = data.decode("utf-8")
+#     # #     for i,c in enumerate(string):
+#     # #         if c == '\x00':
+#     # #             string = string[:i]
+#     # #             break
+#     # #     self.port.close()
+
+#     # # def test06UseFunctionValidCommand(self):
+#     # # I created a function to read the pmt, it is flawed
+#     # # but up to here it works.
+#     # #     self.port.writeData(b"DV")
+#     # #     reply = self.readStringFromPMT()
+#     # #     self.assertEqual("DV", reply)
+
+#     # # def test07UseFunctionInvalidCommand(self):
+#     # # I figured out with these tests that BC is bad command
+#     # #
+#     # #     self.port.writeData(b"DV\n")
+#     # #     reply = self.readStringFromPMT()
+#     # #     self.assertEqual("BC", reply)
+#     # #
+#     # # def test07TurnOn(self):
+#     # #     This never worked, I understood the manual was not useful much.
+#     # #     I checked with various suffixes, but the DV needed to be 2 bytes
+#     # #     commands = self.extendCommand("DV")
+#     # #     self.validate(commands)
+
+#     # # def test07TurnOff(self):
+#     # #     This never worked, I figured out it was not a command.
+#     # #     I checked with various suffixes, but but nothing worked
+#     # #     commands = self.extendCommand("ZV")
+#     # #     are_valid = self.validate(commands)
+#     # #     self.assertTrue(any(are_valid))
+
+#     # #     commands = self.extendCommand("zv")
+#     # #     are_valid = self.validate(commands)
+#     # #     self.assertTrue(any(are_valid))
+
+#     # #     for i, is_valid in enumerate(are_valid):
+#     # #         print(commands[i], is_valid)
+
+#     # # def testFind2Letter_Commands(self):
+#     # # I brute forced it: what are the 2-letter commands?
+#     # # I checked all combinations and checked to see if it complained 'BC'
+#     # # If it did not I assumed this meant it is a command (which is wrong, see
+#     # # later).
+#     # #     for c1 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
+#     # #         for c2 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
+#     # #             commands = self.extendCommand(c1+c2)
+
+#     # #             replies, are_valid = self.validate(commands)
+
+#     # #             for i, is_valid in enumerate(are_valid):
+#     # #                 if is_valid:
+#     # #                     print(commands[i], replies[i])
+
+#     # # def testFind1Letter_Commands(self):
+#     # # I noticed that after 'C' I started getting stuff regularly.
+#     # # I figured 'C' was starting the count like in the documentatin
+#     # # but I needed to figure out how to understand the output.
+#     # #     for c1 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
+#     # #         commands = self.extendCommand(c1)
+#     # #         replies, are_valid = self.validate(commands)
+
+#     # #         for i, is_valid in enumerate(are_valid):
+#     # #             if is_valid:
+#     # #                 print(commands[i], replies[i])
+
+
+#     # # def testFind1Byte_Commands(self):
+#     # # Just in case, checked binary but no: nothing new
+#     # #     valid = []
+#     # #     for c1 in range(128):
+#     # #         print("{0:x}".format(c1))
+#     # #         if chr(c1) == 'D':
+#     # #             continue
+
+#     # #         commands = [chr(c1)]
+
+#     # #         replies, are_valid = self.validate(commands)
+
+#     # #         for i, is_valid in enumerate(are_valid):
+#     # #             if is_valid:
+#     # #                 print(commands[i], replies[i])
+#     # #                 valid.append(commands[i])
+
+#     # #     print(valid)
+
+#     # # def testFind2Byte_Commands(self):
+#     # # Same
+#     # #     for c1 in range(256):
+#     # #         print("-",c1)
+#     # #         for c2 in range(256):
+#     # #             commands = self.extendCommand(chr(c1)+chr(c2))
+
+#     # #             replies, are_valid = self.validate(commands)
+
+#     # #             for i, is_valid in enumerate(are_valid):
+#     # #                 if is_valid:
+#     # #                     print(commands[i], replies[i])
+
+#     # def validate(self, commands):
+#     #     are_valid = []
+#     #     replies = []
+#     #     one_valid = False
+#     #     for command in commands:
+#     #         try:
+#     #             self.port.flush()
+#     #             self.port.writeData(command)
+#     #             reply = self.readStringFromPMT()
+#     #             if reply != "BC":
+#     #                 are_valid.append(True)
+#     #             else:
+#     #                 are_valid.append(False)
+#     #             replies.append(reply)
+#     #         except Exception as err:
+#     #             are_valid.append(False)
+#     #             replies.append(None)
+
+#     #     return replies, are_valid
+
+#     # #     self.port.writeData(b"\r")
+
+#     # def test08StartCounting(self):
+#     #     """
+#     #     Here, I printed the read data for a while and noticed
+#     #     an indexed value going up by one. And some weird garbage values after.
+        
+#     #     """
+#     #     self.port.defaultTimeout = 5000
+
+#     #     self.port.writeData(b"C")
+
+#     #     count = 0
+#     #     while count < 4:
+#     #         try:
+#     #             replyData = self.port.readData(64)
+#     #             print(replyData)
+#     #             count += 1
+#     #         except Exception as err:
+#     #             print(err)
+#     #             pass
+
+
+#     # def test08GetIntegrationTimeself(self):
+#     #     """
+#     #     Here, I noticed the 'I' command appeared valid in my long list of attempts.
+#     #     I printed the reply data for a while and noticed
+#     #     an value corresponding to the letter 'I', a few zeros. And some weird garbage values after.
+        
+#     #     Eventually, I figured it out: the first 32 bits are the command letter ASCII
+#     #     code in a lttle endian 32-bit integer, and then the integration time also as a 32 bit
+#     #     integer. But then, the nuber was 100 000, not 1000 as expected. I assumed
+#     #     this meant my model was in 10µs units. 
+
+#     #     So 'I' replied with 'I',0x00,0x00,0x00,0xa0,0x86,0x01,0x00
+#     #     So I decided to try to send the same command back on the next test.
+#     #     """
+#     #     self.port.writeData(b"I")
+#     #     replyData = self.port.readData(64)
+#     #     replyData = replyData[0:8]
+#     #     print(replyData)
+#     #     index, photonCount = unpack("<II", replyData)
+
+#     #     print(chr(index), photonCount)
+
+#     # def test09SetIntegrationTimeself(self):
+#     #     """
+#     #     Knowing that 'I' replied with 'I',0x00,0x00,0x00,0xa0,0x86,0x01,0x00
+#     #     I decided to try to send the same command back: it worked.
+#     #     I started changing the value of the 32-bit integer to see what happened.
+#     #     For that I needed to test the 'C' command again.
+#     #     """
+#     #     self.port.writeData(b'I   \x10\x27\x00\x00')
+#     #     replyData = self.port.readData(64)
+#     #     replyData = replyData[0:8]
+#     #     print(replyData)
+#     #     index, photonCount = unpack("<II", replyData)
+
+#     #     print(index, photonCount)
+
+#     # def test10StartCountingProperly(self):
+#     #     """
+#     #     Finally, this appears perfect. 
+#     #     """
+#     #     self.port.defaultTimeout = 5000
+
+#     #     self.port.writeData(b"C")
+
+#     #     count = 0
+#     #     while count < 10:
+#     #         try:
+#     #             replyData = self.port.readData(64)
+#     #             replyData = replyData[0:8]
+#     #             index, photonCount = unpack("<II", replyData)
+#     #             print(index, photonCount)
+#     #             count += 1
+#     #         except Exception as err:
+#     #             print(err)
+#     #             pass
+
+#     #     self.port.writeData(b"\r")
+
+#     # def test09Extension(self):
+#     #     commands = self.extendCommand("DV")
+#     #     self.assertTrue(len(commands) == 6)
+
+#     # def test20GetRepCounter(self):
+#     #     self.port.writeData(b"R")
+#     #     replyData = self.port.readData(64)
+#     #     replyData = replyData[0:8]
+#     #     index, photonCount = unpack("<II", replyData)
+#     #     print("Repetition:", index, photonCount)
+
+#     def test20SetRepCounter(self):
+#         self.port.writeData(b"R\x00\x00\x00\x10\x00\x00\x00")
+#         replyData = self.port.readData(64)
+#         replyData = replyData[0:8]
+#         index, photonCount = unpack("<II", replyData)
+#         print("Set rep {0:x} {1:x} {2}".format(index, photonCount, chr(index)))
+
+#     def extendCommand(self, command):
+#         suffixes = [b"", b"\r", b"\n", b"\r\n", b"\n\r", b"\x00"]
+
+#         if type(command) == str:
+#             commandData = command.encode("utf-8")
+#         else:
+#             commandData = command
+
+#         return [ commandData + suffix for suffix in suffixes]
+
+        
+
+#     def readStringFromPMT(self):
+#         data = self.port.readData(64)
+#         string = ""
+#         for i,c in enumerate(data):
+#             if c == 0:
+#                 break
+                
+#             string += chr(c) # assume utf-8
+
+#         return string
+
+#     # def test900StartCounting(self):
+#     #     index, count = sendCommand(self.port, b"C")
+#     #     self.assertEqual(index, 0)
+#     #     print(count)
+
+
+from hardwarelibrary.physicaldevice import PhysicalDevice
+
+class PhotonCounter(PhysicalDevice):
+    classIdVendor = 0x0661
+    classIdProduct = 0x3705
+    def __init__(self):
+        PhysicalDevice.__init__(self, serialNumber="*", idVendor=0x0661, idProduct = 0x3705)
+
+    def doInitializeDevice(self):
+        self.port = USBPort(idVendor=0x0661, idProduct = 0x3705)
+        self.port.open()
+        self.stopCounting()
+
+    def doShutdownDevice(self):
+        self.stopCounting()
+        self.port.close()
+
+    def sendCommand(self, commandName, payload=None):
+        if payload is None:
+            commandData = commandName.encode("utf-8")
+        else:
+            commandData = pack("<II",ord(commandName), payload)
+
+        self.port.writeData(commandData)
+        return self.readReply()
+
+    def readReply(self):
+        replyData = self.port.readData(64)
+        replyData = replyData[0:8]
+        return unpack("<II", replyData)
+
+    def get_integration_time(self):
+        return self.sendCommand("I")
+
+    def set_integration_time(self, time_in_10us):
+        return self.sendCommand(commandName="I", payload=time_in_10us)
+
+    def get_repetition(self):
+        return self.sendCommand(commandName='R')
+
+    def set_repetition(self, repetitions):
+        return self.sendCommand(commandName="R", payload=repetitions)
+
+    def startCounting(self, correction=True):
+        if correction:
+            return self.port.writeData(b'M')
+        else:
+            return self.port.writeData(b'C')
+
+    def fetchAll(self, maxIndex=None):
+        counts = []
+        while True:
+            index, count = self.fetchOne()
+            if index is None:
+                break
+            counts.append( (index, count,) )
+        return counts
+
+    def fetchOne(self):
+        try:
+            return self.readReply()
+        except Exception as err:
+            return None, None
+
+    def stopCounting(self):
+        self.port.writeData(b'\r')
+        self.port.flush()
+
+
+class TestHamamatsuClass(unittest.TestCase):
+    def setUp(self):
+        self.device = PhotonCounter()
+        self.device.initializeDevice()
+
+    def tearDown(self):
+        self.device.shutdownDevice()
+
+    def testIntegration(self):
+        self.device.set_integration_time(10000)
+        _, actualIntegrationTime = self.device.get_integration_time()
+        self.assertEqual(actualIntegrationTime, 10000)
+
+    def testRepetition2(self):
+        self.device.set_repetition(123)
+        _, actualRepetitions = self.device.get_repetition()
+        self.assertEqual(actualRepetitions, 123)
+
+    def testStartStop(self):
+        self.device.startCounting()
+        self.device.stopCounting()
+
+    def testStartFetchStop(self):
+        self.device.set_repetition(0)
+        self.device.set_integration_time(10000)
+        self.device.startCounting()
+        self.device.fetchOne()
+        self.device.stopCounting()
+
+    def testStartFetchAllStop(self):
+        self.device.set_repetition(10)
+        self.device.set_integration_time(10000)
+        self.device.startCounting()
+        counts = self.device.fetchAll(maxIndex=10)
+        for i, (idx, c) in enumerate(counts):
+            self.assertEqual(i, idx)
+            self.assertTrue(c > 0)
+        self.device.stopCounting()
+
+    def testStartWaitFetchAllStop(self):
+        self.device.set_repetition(10)
+        self.device.set_integration_time(10000)
+        self.device.startCounting()
+        counts = self.device.fetchAll(maxIndex=10)
+        print(counts)
+        for i, (idx, c) in enumerate(counts):
+            self.assertEqual(i, idx)
+            self.assertTrue(c > 0,"{0}".format(c))
+        self.device.stopCounting()
+
+    def testStopStop(self):
+        self.device.stopCounting()
+        self.device.stopCounting()
+
+if __name__ == '__main__':
+    unittest.main()

From 229da66ed5bcafdbcb04dafbf6fd142cec62a6c1 Mon Sep 17 00:00:00 2001
From: Daniel <dccote@cervo.ulaval.ca>
Date: Fri, 4 Nov 2022 10:05:31 -0400
Subject: [PATCH 2/4] Completed the PhotonCounter class, added new commands

---
 .idea/workspace.xml                          |  10 +-
 hardwarelibrary/tests/testHamamatsuSerial.py | 118 +++++++++++++------
 2 files changed, 88 insertions(+), 40 deletions(-)

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 1fd78cc..797fe7d 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -81,7 +81,7 @@
       <recent name="$PROJECT_DIR$/hardwarelibrary/tests/deprecated" />
     </key>
   </component>
-  <component name="RunManager" selected="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testInstantiateStellarNetDevice">
+  <component name="RunManager" selected="Python tests.Python tests in testHamamatsuSerial.py">
     <configuration name="hardwarelibrary" type="PythonConfigurationType" factoryName="Python" nameIsGenerated="true">
       <module name="PyHardwareLibrary" />
       <option name="INTERPRETER_OPTIONS" value="" />
@@ -186,7 +186,7 @@
       <option name="_new_targetType" value="&quot;PYTHON&quot;" />
       <method v="2" />
     </configuration>
-    <configuration name="Python tests in testPhysicalDevice.py" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
+    <configuration name="Python tests in testHamamatsuSerial.py" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
       <module name="PyHardwareLibrary" />
       <option name="INTERPRETER_OPTIONS" value="" />
       <option name="PARENT_ENVS" value="true" />
@@ -197,7 +197,7 @@
       <option name="ADD_SOURCE_ROOTS" value="true" />
       <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
       <option name="_new_additionalArguments" value="&quot;&quot;" />
-      <option name="_new_target" value="&quot;$PROJECT_DIR$/hardwarelibrary/tests/testPhysicalDevice.py&quot;" />
+      <option name="_new_target" value="&quot;$PROJECT_DIR$/hardwarelibrary/tests/testHamamatsuSerial.py&quot;" />
       <option name="_new_targetType" value="&quot;PATH&quot;" />
       <method v="2" />
     </configuration>
@@ -208,15 +208,15 @@
       <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetStellarNetDevices" />
       <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testInstantiateStellarNetDevice" />
       <item itemvalue="Python tests.Python tests for testPyUSB.PyUSBTestCase" />
-      <item itemvalue="Python tests.Python tests in testPhysicalDevice.py" />
+      <item itemvalue="Python tests.Python tests in testHamamatsuSerial.py" />
     </list>
     <recent_temporary>
       <list>
+        <item itemvalue="Python tests.Python tests in testHamamatsuSerial.py" />
         <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testInstantiateStellarNetDevice" />
         <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetStellarNetDevices" />
         <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetConnectedDevices" />
         <item itemvalue="Python tests.Python tests for testPyUSB.PyUSBTestCase" />
-        <item itemvalue="Python tests.Python tests in testPhysicalDevice.py" />
       </list>
     </recent_temporary>
   </component>
diff --git a/hardwarelibrary/tests/testHamamatsuSerial.py b/hardwarelibrary/tests/testHamamatsuSerial.py
index bc0562c..fd02b5a 100644
--- a/hardwarelibrary/tests/testHamamatsuSerial.py
+++ b/hardwarelibrary/tests/testHamamatsuSerial.py
@@ -5,20 +5,20 @@
 
 from hardwarelibrary.communication.usbport import *
 
-# class TestHamamatsuUSBPortBase(unittest.TestCase):
-#     def setUp(self):
-#         self.port = USBPort(idVendor=0x0661, idProduct = 0x3705)
-#         self.assertIsNotNone(self.port)
-#         self.port.open()
-#         self.assertTrue(self.port.isOpen)
-
-#         self.port.writeData(b'\r')
-#         self.port.flush()
+class TestHamamatsuUSBPortBase(unittest.TestCase):
+    def setUp(self):
+        self.port = USBPort(idVendor=0x0661, idProduct = 0x3705)
+        self.assertIsNotNone(self.port)
+        self.port.open()
+        self.assertTrue(self.port.isOpen)
+
+        self.port.writeData(b'\r')
+        self.port.flush()
         
-#     def tearDown(self):
-#         # self.port.writeData(b"ZV")
-#         # self.assertEqual("ZV", self.readStringFromPMT())
-#         self.port.close()
+    def tearDown(self):
+        # self.port.writeData(b"ZV")
+        # self.assertEqual("ZV", self.readStringFromPMT())
+        self.port.close()
 
 
 #     # def test01CreatePort(self):
@@ -203,7 +203,7 @@
 
 #     # #     self.port.writeData(b"\r")
 
-#     # def test08StartCounting(self):
+#     # def test08start_counting(self):
 #     #     """
 #     #     Here, I printed the read data for a while and noticed
 #     #     an indexed value going up by one. And some weird garbage values after.
@@ -261,7 +261,7 @@
 
 #     #     print(index, photonCount)
 
-#     # def test10StartCountingProperly(self):
+#     # def test10start_countingProperly(self):
 #     #     """
 #     #     Finally, this appears perfect. 
 #     #     """
@@ -324,7 +324,7 @@
 
 #         return string
 
-#     # def test900StartCounting(self):
+#     # def test900start_counting(self):
 #     #     index, count = sendCommand(self.port, b"C")
 #     #     self.assertEqual(index, 0)
 #     #     print(count)
@@ -341,20 +341,32 @@ def __init__(self):
     def doInitializeDevice(self):
         self.port = USBPort(idVendor=0x0661, idProduct = 0x3705)
         self.port.open()
-        self.stopCounting()
+        self.stop_counting() # We must stop counting first
+        self.turn_on()
+        self.set_integration_time(time_in_10us=1000)
 
     def doShutdownDevice(self):
-        self.stopCounting()
+        self.stop_counting()
+        self.turn_off()
         self.port.close()
 
     def sendCommand(self, commandName, payload=None):
+        commandInt = None
         if payload is None:
             commandData = commandName.encode("utf-8")
         else:
+            commandInt = ord(commandName)
             commandData = pack("<II",ord(commandName), payload)
 
         self.port.writeData(commandData)
-        return self.readReply()
+        replyInt, value = self.readReply()
+        # if replyInt == 0x4342:
+        #     raise ValueError("Bad command")
+        # elif commandInt is not None:
+        #     if commandInt != replyInt:
+        #         raise ValueError("Reply error: {0:x}".format(replyint))
+
+        return replyInt, value
 
     def readReply(self):
         replyData = self.port.readData(64)
@@ -370,10 +382,27 @@ def set_integration_time(self, time_in_10us):
     def get_repetition(self):
         return self.sendCommand(commandName='R')
 
-    def set_repetition(self, repetitions):
+    def set_repetition(self, repetitions=0):
         return self.sendCommand(commandName="R", payload=repetitions)
 
-    def startCounting(self, correction=True):
+    def turn_on(self):
+        self.set_high_voltage()
+
+    def turn_off(self):
+        self.set_high_voltage(value=0)
+
+    def get_high_voltage(self):
+        return self.sendCommand("V")
+
+    def set_high_voltage(self, value=None):
+        if value is None: 
+            return self.sendCommand("DV") # Default high voltage
+        if value == 0: 
+            return self.sendCommand("ZV") # Turn off high voltage
+
+        return self.sendCommand("V", value)
+
+    def start_counting(self, correction=True):
         if correction:
             return self.port.writeData(b'M')
         else:
@@ -389,12 +418,21 @@ def fetchAll(self, maxIndex=None):
         return counts
 
     def fetchOne(self):
+        idx = None
+        count = None
+
         try:
-            return self.readReply()
-        except Exception as err:
+            idx, count = self.readReply()
+        except usb.core.USBTimeoutError as err:
             return None, None
 
-    def stopCounting(self):
+        if (count & 0x8000) != 0:
+            raise ValueError("PMT overload")
+
+        return idx, count
+
+
+    def stop_counting(self):
         self.port.writeData(b'\r')
         self.port.flush()
 
@@ -418,40 +456,50 @@ def testRepetition2(self):
         self.assertEqual(actualRepetitions, 123)
 
     def testStartStop(self):
-        self.device.startCounting()
-        self.device.stopCounting()
+        self.device.start_counting()
+        self.device.stop_counting()
 
     def testStartFetchStop(self):
         self.device.set_repetition(0)
         self.device.set_integration_time(10000)
-        self.device.startCounting()
+        self.device.start_counting()
         self.device.fetchOne()
-        self.device.stopCounting()
+        self.device.stop_counting()
 
     def testStartFetchAllStop(self):
         self.device.set_repetition(10)
         self.device.set_integration_time(10000)
-        self.device.startCounting()
+        self.device.start_counting()
         counts = self.device.fetchAll(maxIndex=10)
         for i, (idx, c) in enumerate(counts):
             self.assertEqual(i, idx)
             self.assertTrue(c > 0)
-        self.device.stopCounting()
+        self.device.stop_counting()
 
     def testStartWaitFetchAllStop(self):
         self.device.set_repetition(10)
         self.device.set_integration_time(10000)
-        self.device.startCounting()
+        self.device.start_counting()
         counts = self.device.fetchAll(maxIndex=10)
-        print(counts)
         for i, (idx, c) in enumerate(counts):
             self.assertEqual(i, idx)
             self.assertTrue(c > 0,"{0}".format(c))
-        self.device.stopCounting()
+            self.assertTrue(c & 0x8000 == 0)
+        self.device.stop_counting()
 
     def testStopStop(self):
-        self.device.stopCounting()
-        self.device.stopCounting()
+        self.device.stop_counting()
+        self.device.stop_counting()
+
+    def testTurnOn(self):        
+        self.device.turn_on()
+
+    def testTurnOff(self):        
+        print(self.device.sendCommand("ZV"))
+        print(self.device.sendCommand("DV"))
+        print(self.device.sendCommand("ZV"))
+        print(self.device.sendCommand("V"))
+        print(self.device.sendCommand(commandName="V", payload=800))
 
 if __name__ == '__main__':
     unittest.main()

From 8fed8bb1f1212953632288ba99e1154e72835f4d Mon Sep 17 00:00:00 2001
From: Daniel <dccote@cervo.ulaval.ca>
Date: Fri, 4 Nov 2022 13:05:42 -0400
Subject: [PATCH 3/4] Finally separatted Hamamatsu serial and Device.

Ready for pull request.
---
 .idea/PyHardwareLibrary.iml                  |   2 +-
 .idea/misc.xml                               |   2 +-
 .idea/workspace.xml                          |  56 +-
 hardwarelibrary/__init__.py                  |   1 +
 hardwarelibrary/photoncounters/hamamatsu.py  | 112 +++
 hardwarelibrary/tests/testHamamatsuDevice.py |  96 +++
 hardwarelibrary/tests/testHamamatsuSerial.py | 765 ++++++++-----------
 7 files changed, 540 insertions(+), 494 deletions(-)
 create mode 100644 hardwarelibrary/photoncounters/hamamatsu.py
 create mode 100644 hardwarelibrary/tests/testHamamatsuDevice.py

diff --git a/.idea/PyHardwareLibrary.iml b/.idea/PyHardwareLibrary.iml
index 403d001..c68be6c 100644
--- a/.idea/PyHardwareLibrary.iml
+++ b/.idea/PyHardwareLibrary.iml
@@ -8,7 +8,7 @@
       <excludeFolder url="file://$MODULE_DIR$/venv" />
       <excludeFolder url="file://$MODULE_DIR$/hardwarelibrary/tests/htmlcov" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.8" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.10" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
   <component name="PyDocumentationSettings">
diff --git a/.idea/misc.xml b/.idea/misc.xml
index d1e22ec..dc9ea49 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10" project-jdk-type="Python SDK" />
 </project>
\ No newline at end of file
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 797fe7d..5541168 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -4,7 +4,11 @@
     <option name="autoReloadType" value="SELECTIVE" />
   </component>
   <component name="ChangeListManager">
-    <list default="true" id="e1a2b906-4e8f-4edb-8efe-d2e272bf62ab" name="Default Changelist" comment="60" />
+    <list default="true" id="e1a2b906-4e8f-4edb-8efe-d2e272bf62ab" name="Default Changelist" comment="60">
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/hardwarelibrary/__init__.py" beforeDir="false" afterPath="$PROJECT_DIR$/hardwarelibrary/__init__.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/hardwarelibrary/tests/testHamamatsuSerial.py" beforeDir="false" afterPath="$PROJECT_DIR$/hardwarelibrary/tests/testHamamatsuSerial.py" afterDir="false" />
+    </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
@@ -70,7 +74,7 @@
     <property name="node.js.path.for.package.tslint" value="project" />
     <property name="node.js.selected.package.eslint" value="(autodetect)" />
     <property name="node.js.selected.package.tslint" value="(autodetect)" />
-    <property name="settings.editor.selected.configurable" value="com.jetbrains.python.configuration.PythonContentEntriesConfigurable" />
+    <property name="settings.editor.selected.configurable" value="vcs.Git" />
   </component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
@@ -81,7 +85,7 @@
       <recent name="$PROJECT_DIR$/hardwarelibrary/tests/deprecated" />
     </key>
   </component>
-  <component name="RunManager" selected="Python tests.Python tests in testHamamatsuSerial.py">
+  <component name="RunManager" selected="Python tests.Python tests for testHamamatsuSerial.TestHamamatsuUSBPortBase">
     <configuration name="hardwarelibrary" type="PythonConfigurationType" factoryName="Python" nameIsGenerated="true">
       <module name="PyHardwareLibrary" />
       <option name="INTERPRETER_OPTIONS" value="" />
@@ -126,7 +130,7 @@
       <option name="INPUT_FILE" value="" />
       <method v="2" />
     </configuration>
-    <configuration name="Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetConnectedDevices" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
+    <configuration name="Python tests for testHamamatsuDevice.TestHamamatsuClass" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
       <module name="PyHardwareLibrary" />
       <option name="INTERPRETER_OPTIONS" value="" />
       <option name="PARENT_ENVS" value="true" />
@@ -137,11 +141,11 @@
       <option name="ADD_SOURCE_ROOTS" value="true" />
       <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
       <option name="_new_additionalArguments" value="&quot;&quot;" />
-      <option name="_new_target" value="&quot;testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetConnectedDevices&quot;" />
+      <option name="_new_target" value="&quot;testHamamatsuDevice.TestHamamatsuClass&quot;" />
       <option name="_new_targetType" value="&quot;PYTHON&quot;" />
       <method v="2" />
     </configuration>
-    <configuration name="Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetStellarNetDevices" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
+    <configuration name="Python tests for testHamamatsuSerial.TestHamamatsuClass.testSetDefaultManuallyOnlyD" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
       <module name="PyHardwareLibrary" />
       <option name="INTERPRETER_OPTIONS" value="" />
       <option name="PARENT_ENVS" value="true" />
@@ -152,11 +156,11 @@
       <option name="ADD_SOURCE_ROOTS" value="true" />
       <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
       <option name="_new_additionalArguments" value="&quot;&quot;" />
-      <option name="_new_target" value="&quot;testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetStellarNetDevices&quot;" />
+      <option name="_new_target" value="&quot;testHamamatsuSerial.TestHamamatsuClass.testSetDefaultManuallyOnlyD&quot;" />
       <option name="_new_targetType" value="&quot;PYTHON&quot;" />
       <method v="2" />
     </configuration>
-    <configuration name="Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testInstantiateStellarNetDevice" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
+    <configuration name="Python tests for testHamamatsuSerial.TestHamamatsuUSBPortBase" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
       <module name="PyHardwareLibrary" />
       <option name="INTERPRETER_OPTIONS" value="" />
       <option name="PARENT_ENVS" value="true" />
@@ -167,11 +171,11 @@
       <option name="ADD_SOURCE_ROOTS" value="true" />
       <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
       <option name="_new_additionalArguments" value="&quot;&quot;" />
-      <option name="_new_target" value="&quot;testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testInstantiateStellarNetDevice&quot;" />
+      <option name="_new_target" value="&quot;testHamamatsuSerial.TestHamamatsuUSBPortBase&quot;" />
       <option name="_new_targetType" value="&quot;PYTHON&quot;" />
       <method v="2" />
     </configuration>
-    <configuration name="Python tests for testPyUSB.PyUSBTestCase" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
+    <configuration name="Python tests in testHamamatsuSerial.py" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
       <module name="PyHardwareLibrary" />
       <option name="INTERPRETER_OPTIONS" value="" />
       <option name="PARENT_ENVS" value="true" />
@@ -182,41 +186,41 @@
       <option name="ADD_SOURCE_ROOTS" value="true" />
       <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
       <option name="_new_additionalArguments" value="&quot;&quot;" />
-      <option name="_new_target" value="&quot;testPyUSB.PyUSBTestCase&quot;" />
-      <option name="_new_targetType" value="&quot;PYTHON&quot;" />
+      <option name="_new_target" value="&quot;$PROJECT_DIR$/hardwarelibrary/tests/testHamamatsuSerial.py&quot;" />
+      <option name="_new_targetType" value="&quot;PATH&quot;" />
       <method v="2" />
     </configuration>
-    <configuration name="Python tests in testHamamatsuSerial.py" type="tests" factoryName="Autodetect" temporary="true" nameIsGenerated="true">
+    <configuration name="Unittests for testHamamatsuSerial.TestHamamatsuUSBPortBase.test03SendDVCommand" type="tests" factoryName="Unittests" temporary="true" nameIsGenerated="true">
       <module name="PyHardwareLibrary" />
       <option name="INTERPRETER_OPTIONS" value="" />
       <option name="PARENT_ENVS" value="true" />
-      <option name="SDK_HOME" value="" />
+      <option name="SDK_HOME" value="/Library/Frameworks/Python.framework/Versions/3.10/bin/python3" />
       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/hardwarelibrary/tests" />
       <option name="IS_MODULE_SDK" value="true" />
       <option name="ADD_CONTENT_ROOTS" value="true" />
       <option name="ADD_SOURCE_ROOTS" value="true" />
       <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
       <option name="_new_additionalArguments" value="&quot;&quot;" />
-      <option name="_new_target" value="&quot;$PROJECT_DIR$/hardwarelibrary/tests/testHamamatsuSerial.py&quot;" />
-      <option name="_new_targetType" value="&quot;PATH&quot;" />
+      <option name="_new_target" value="&quot;testHamamatsuSerial.TestHamamatsuUSBPortBase.test03SendDVCommand&quot;" />
+      <option name="_new_targetType" value="&quot;PYTHON&quot;" />
       <method v="2" />
     </configuration>
     <list>
       <item itemvalue="Python.hardwarelibrary" />
       <item itemvalue="Python.test" />
-      <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetConnectedDevices" />
-      <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetStellarNetDevices" />
-      <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testInstantiateStellarNetDevice" />
-      <item itemvalue="Python tests.Python tests for testPyUSB.PyUSBTestCase" />
       <item itemvalue="Python tests.Python tests in testHamamatsuSerial.py" />
+      <item itemvalue="Python tests.Python tests for testHamamatsuSerial.TestHamamatsuClass.testSetDefaultManuallyOnlyD" />
+      <item itemvalue="Python tests.Python tests for testHamamatsuDevice.TestHamamatsuClass" />
+      <item itemvalue="Python tests.Python tests for testHamamatsuSerial.TestHamamatsuUSBPortBase" />
+      <item itemvalue="Python tests.Unittests for testHamamatsuSerial.TestHamamatsuUSBPortBase.test03SendDVCommand" />
     </list>
     <recent_temporary>
       <list>
+        <item itemvalue="Python tests.Python tests for testHamamatsuSerial.TestHamamatsuUSBPortBase" />
+        <item itemvalue="Python tests.Unittests for testHamamatsuSerial.TestHamamatsuUSBPortBase.test03SendDVCommand" />
+        <item itemvalue="Python tests.Python tests for testHamamatsuDevice.TestHamamatsuClass" />
+        <item itemvalue="Python tests.Python tests for testHamamatsuSerial.TestHamamatsuClass.testSetDefaultManuallyOnlyD" />
         <item itemvalue="Python tests.Python tests in testHamamatsuSerial.py" />
-        <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testInstantiateStellarNetDevice" />
-        <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetStellarNetDevices" />
-        <item itemvalue="Python tests.Python tests for testPhysicalDevice.TestPhysicalDeviceCompatibilityClasses.testGetConnectedDevices" />
-        <item itemvalue="Python tests.Python tests for testPyUSB.PyUSBTestCase" />
       </list>
     </recent_temporary>
   </component>
@@ -245,6 +249,7 @@
       <workItem from="1656018359548" duration="14482000" />
       <workItem from="1656249319552" duration="3372000" />
       <workItem from="1656254916479" duration="2746000" />
+      <workItem from="1667569420358" duration="3711000" />
     </task>
     <servers />
   </component>
@@ -383,7 +388,7 @@
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testPhysicalDevice_TestSpectrometerPhysicalDevice_testPhysicalDeviceRecognizedByDeviceManagerSynchronously.coverage" NAME="Unittests for testPhysicalDevice.TestSpectrometerPhysicalDevice.testPhysicalDeviceRecognizedByDeviceManagerSynchronously Coverage Results" MODIFIED="1633319357042" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$__main__.coverage" NAME="__main__ Coverage Results" MODIFIED="1633237489450" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testPyUSB_PyUSBTestCase.coverage" NAME="Unittests for testPyUSB.PyUSBTestCase Coverage Results" MODIFIED="1656216273536" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
-    <SUITE FILE_PATH="coverage/PyHardwareLibrary$.coverage" NAME=" Coverage Results" MODIFIED="1656258239460" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
+    <SUITE FILE_PATH="coverage/PyHardwareLibrary$.coverage" NAME=" Coverage Results" MODIFIED="1667581389988" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testLinearMotionDevice.coverage" NAME="Unittests for testLinearMotionDevice Coverage Results" MODIFIED="1633280168464" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testPhysicalDevice_TestSpectrometerPhysicalDevice_testConfiguredStateAfterInitialize.coverage" NAME="Unittests for testPhysicalDevice.TestSpectrometerPhysicalDevice.testConfiguredStateAfterInitialize Coverage Results" MODIFIED="1633293814434" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testPhysicalDevice.coverage" NAME="Unittests for testPhysicalDevice Coverage Results" MODIFIED="1633662737770" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
@@ -395,6 +400,7 @@
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testDeviceManager_TestDeviceManager_testNotificationReceivedFromAddingDevices.coverage" NAME="Unittests for testDeviceManager.TestDeviceManager.testNotificationReceivedFromAddingDevices Coverage Results" MODIFIED="1633304367282" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testIntegraDevice_TestIntegraDevice_testDeviceVersion.coverage" NAME="Unittests for testIntegraDevice.TestIntegraDevice.testDeviceVersion Coverage Results" MODIFIED="1633446759666" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testPhysicalDevice_TestEchoPhysicalDevice.coverage" NAME="Unittests for testPhysicalDevice.TestEchoPhysicalDevice Coverage Results" MODIFIED="1633662453043" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
+    <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testHamamatsuSerial_TestHamamatsuUSBPortBase_test03SendDVCommand.coverage" NAME="Unittests for testHamamatsuSerial.TestHamamatsuUSBPortBase.test03SendDVCommand Coverage Results" MODIFIED="1667581385581" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testPhysicalDevice_TestSpectrometerPhysicalDevice.coverage" NAME="Unittests for testPhysicalDevice.TestSpectrometerPhysicalDevice Coverage Results" MODIFIED="1633447053482" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$Unittests_for_testPhysicalDevice_TestPowerMeterPhysicalDevice_testCommandHelp.coverage" NAME="Unittests for testPhysicalDevice.TestPowerMeterPhysicalDevice.testCommandHelp Coverage Results" MODIFIED="1633468673310" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$/hardwarelibrary/tests" />
     <SUITE FILE_PATH="coverage/PyHardwareLibrary$daq.coverage" NAME="daq Coverage Results" MODIFIED="1647703284586" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="true" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
diff --git a/hardwarelibrary/__init__.py b/hardwarelibrary/__init__.py
index 3b777e7..4c20feb 100644
--- a/hardwarelibrary/__init__.py
+++ b/hardwarelibrary/__init__.py
@@ -14,6 +14,7 @@
 import hardwarelibrary.spectrometers
 import hardwarelibrary.oscilloscope
 import hardwarelibrary.motion
+import hardwarelibrary.photoncounters
 # import hardwarelibrary.cameras
 
 #import sources #TODO: Not much to see here yet
\ No newline at end of file
diff --git a/hardwarelibrary/photoncounters/hamamatsu.py b/hardwarelibrary/photoncounters/hamamatsu.py
new file mode 100644
index 0000000..6c2c1bc
--- /dev/null
+++ b/hardwarelibrary/photoncounters/hamamatsu.py
@@ -0,0 +1,112 @@
+from enum import Enum, IntEnum
+import hardwarelibrary.utils
+from hardwarelibrary.notificationcenter import NotificationCenter
+from hardwarelibrary.physicaldevice import PhysicalDevice
+from hardwarelibrary.communication.usbport import *
+from struct import *
+
+class HamamatsuH11890Device(PhysicalDevice):
+    classIdVendor = 0x0661
+    classIdProduct = 0x3705
+
+    class BadCommand(Exception):
+        pass
+
+    class Overload(Exception):
+        pass
+
+    def __init__(self):
+        PhysicalDevice.__init__(self, serialNumber="*", idVendor=0x0661, idProduct = 0x3705)
+
+    def doInitializeDevice(self):
+        self.port = USBPort(idVendor=0x0661, idProduct = 0x3705)
+        self.port.open()
+        self.stop_counting() # We must stop counting first
+        self.turn_on()
+        self.set_integration_time(time_in_10us=1000)
+
+    def doShutdownDevice(self):
+        self.stop_counting()
+        self.turn_off()
+        self.port.close()
+
+    def sendCommand(self, commandName, payload=None):
+        commandInt = None
+        if payload is None:
+            commandData = commandName.encode("utf-8")
+        else:
+            commandInt = ord(commandName)
+            commandData = pack("<II",ord(commandName), payload)
+
+        self.port.writeData(commandData)
+        replyInt, value = self.readReply()
+        if replyInt == 0x4342:
+            raise HamamatsuH11890Device.BadCommand()
+
+        return replyInt, value
+
+    def readReply(self):
+        replyData = self.port.readData(64)
+        replyData = replyData[0:8]
+        return unpack("<II", replyData)
+
+    def get_integration_time(self):
+        return self.sendCommand("I")
+
+    def set_integration_time(self, time_in_10us):
+        return self.sendCommand(commandName="I", payload=time_in_10us)
+
+    def get_repetition(self):
+        return self.sendCommand(commandName='R')
+
+    def set_repetition(self, repetitions=0):
+        return self.sendCommand(commandName="R", payload=repetitions)
+
+    def turn_on(self):
+        self.set_high_voltage()
+
+    def turn_off(self):
+        self.set_high_voltage(value=0)
+
+    def get_high_voltage(self):
+        return self.sendCommand("V")
+
+    def set_high_voltage(self, value=None):
+        if value is None: 
+            return self.sendCommand("DV") # Default high voltage
+
+        return self.sendCommand("V", value)
+
+    def start_counting(self, correction=True):
+        if correction:
+            return self.port.writeData(b'M')
+        else:
+            return self.port.writeData(b'C')
+
+    def fetchAll(self, maxIndex=None):
+        counts = []
+        while True:
+            index, count = self.fetchOne()
+            if index is None:
+                break
+            counts.append( (index, count,) )
+        return counts
+
+    def fetchOne(self):
+        idx = None
+        count = None
+
+        try:
+            idx, count = self.readReply()
+        except usb.core.USBTimeoutError as err:
+            return None, None
+
+        if (count & 0x8000) != 0:
+            raise HamamatsuH11890Device.Overload()
+
+        return idx, count
+
+
+    def stop_counting(self):
+        self.port.writeData(b'\r')
+        self.port.flush()
diff --git a/hardwarelibrary/tests/testHamamatsuDevice.py b/hardwarelibrary/tests/testHamamatsuDevice.py
new file mode 100644
index 0000000..d4adfb5
--- /dev/null
+++ b/hardwarelibrary/tests/testHamamatsuDevice.py
@@ -0,0 +1,96 @@
+import env
+import unittest
+from hardwarelibrary.photoncounters.hamamatsu import HamamatsuH11890Device
+
+
+class TestHamamatsuClass(unittest.TestCase):
+    def setUp(self):
+        self.device = HamamatsuH11890Device()
+        self.device.initializeDevice()
+
+    def tearDown(self):
+        self.device.shutdownDevice()
+
+    def testIntegration(self):
+        self.device.set_integration_time(10000)
+        _, actualIntegrationTime = self.device.get_integration_time()
+        self.assertEqual(actualIntegrationTime, 10000)
+
+    def testBadCommand(self):
+        with self.assertRaises(HamamatsuH11890Device.BadCommand):
+            self.device.sendCommand('B')
+
+    def testRepetition2(self):
+        self.device.set_repetition(123)
+        _, actualRepetitions = self.device.get_repetition()
+        self.assertEqual(actualRepetitions, 123)
+
+    def testStartStop(self):
+        self.device.start_counting()
+        self.device.stop_counting()
+
+    def testStartFetchStop(self):
+        self.device.set_repetition(0)
+        self.device.set_integration_time(10000)
+        self.device.start_counting(correction=True)
+        self.device.fetchOne()
+        self.device.stop_counting()
+
+    def testStartFetchStopWithoutCorrection(self):
+        self.device.set_repetition(0)
+        self.device.set_integration_time(10000)
+        self.device.start_counting(correction=False)
+        self.device.fetchOne()
+        self.device.stop_counting()
+
+    def testStartFetchAllStop(self):
+        self.device.set_repetition(10)
+        self.device.set_integration_time(10000)
+        self.device.start_counting()
+        counts = self.device.fetchAll(maxIndex=10)
+        for i, (idx, c) in enumerate(counts):
+            self.assertEqual(i, idx)
+            self.assertTrue(c > 0)
+        self.device.stop_counting()
+
+    def testStartWaitFetchAllStop(self):
+        self.device.set_repetition(10)
+        self.device.set_integration_time(10000)
+        self.device.start_counting()
+        counts = self.device.fetchAll(maxIndex=10)
+        for i, (idx, c) in enumerate(counts):
+            self.assertEqual(i, idx)
+            self.assertTrue(c > 0,"{0}".format(c))
+            self.assertTrue(c & 0x8000 == 0)
+        self.device.stop_counting()
+
+    def testStopStop(self):
+        self.device.stop_counting()
+        self.device.stop_counting()
+
+    def testTurnOnAndOff(self):
+        self.device.turn_on()
+        self.device.turn_off()
+
+    def testSetDefaultVoltage(self):
+        print(self.device.set_high_voltage())
+        _, actualVoltage = self.device.get_high_voltage()
+        self.assertEqual(actualVoltage, 1000)
+
+    def testSetNullVoltage(self):
+        self.device.set_high_voltage(0)
+        _, actualVoltage = self.device.get_high_voltage()
+        self.assertEqual(actualVoltage, 0)
+
+    def testSetSomeVoltage(self):
+        self.device.set_high_voltage(800)
+        _, actualVoltage = self.device.get_high_voltage()
+        self.assertEqual(actualVoltage, 800)
+
+    def testSetDefaultManuallyOnlyD(self):
+        with self.assertRaises(HamamatsuH11890Device.BadCommand):
+            self.device.sendCommand('D') # it's really DV
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/hardwarelibrary/tests/testHamamatsuSerial.py b/hardwarelibrary/tests/testHamamatsuSerial.py
index fd02b5a..a57ca6a 100644
--- a/hardwarelibrary/tests/testHamamatsuSerial.py
+++ b/hardwarelibrary/tests/testHamamatsuSerial.py
@@ -1,7 +1,6 @@
 import env
 import unittest
 from struct import *
-from time import sleep
 
 from hardwarelibrary.communication.usbport import *
 
@@ -21,485 +20,317 @@ def tearDown(self):
         self.port.close()
 
 
-#     # def test01CreatePort(self):
-#     #     self.assertIsNotNone(self.port)
-
-#     # def test02OpenPort(self):
-#     #     self.assertTrue(self.port.isOpen)
-
-#     # # def test03SendDVCommand(self):
-#     # # This helped me figure out that the readData command would always 
-#     # # read 64 bytes.
-#     # #     port = USBPort(idVendor=0x0661, idProduct = 0x3705)
-#     # #     # port.terminator = b'\r'
-#     # #     self.assertIsNotNone(port)
-#     # #     port.open()
-#     # #     self.assertTrue(port.isOpen)
-#     # #     port.writeString(string="DV")
-#     # #     count = 64
-#     # #     while count > 0:
-#     # #         try:
-#     # #             print(count, port.readData(1))
-#     # #         except Exception as err:
-#     # #             print(err)
-#     # #             break
-#     # #         count = count -1
-
-#     # #     port.close()
-
-#     # # def test04SendDVZVCommand(self):
-#     # #  This never worked.
-#     # #     port = USBPort(idVendor=0x0661, idProduct = 0x3705)
-#     # #     # port.terminator = b'\r'
-#     # #     self.assertIsNotNone(port)
-#     # #     port.open()
-#     # #     self.assertTrue(port.isOpen)
-#     # #     port.write(string="DV")
-#     # #     count = 64
-#     # #     while count > 0:
-#     # #         try:
-#     # #             print(count, port.readData(1))
-#     # #         except Exception as err:
-#     # #             print(err)
-#     # #             break
-#     # #         count = count -1
-
-#     # #     port.writeString(string="ZV")
-#     # #     count = 64
-#     # #     while count > 0:
-#     # #         try:
-#     # #             print(count, port.readData(1))
-#     # #         except Exception as err:
-#     # #             print(err)
-#     # #             break
-#     # #         count = count -1
-
-#     # #     port.close()
-
-
-#     # # def test05SendDVZeroCommand(self):
-#     # #     self.port.writeData(b"DV\x00")
-#     # #     data = self.port.readData(64)
-#     # #     string = data.decode("utf-8")
-#     # #     for i,c in enumerate(string):
-#     # #         if c == '\x00':
-#     # #             string = string[:i]
-#     # #             break
-#     # #     self.port.close()
-
-#     # # def test06UseFunctionValidCommand(self):
-#     # # I created a function to read the pmt, it is flawed
-#     # # but up to here it works.
-#     # #     self.port.writeData(b"DV")
-#     # #     reply = self.readStringFromPMT()
-#     # #     self.assertEqual("DV", reply)
-
-#     # # def test07UseFunctionInvalidCommand(self):
-#     # # I figured out with these tests that BC is bad command
-#     # #
-#     # #     self.port.writeData(b"DV\n")
-#     # #     reply = self.readStringFromPMT()
-#     # #     self.assertEqual("BC", reply)
-#     # #
-#     # # def test07TurnOn(self):
-#     # #     This never worked, I understood the manual was not useful much.
-#     # #     I checked with various suffixes, but the DV needed to be 2 bytes
-#     # #     commands = self.extendCommand("DV")
-#     # #     self.validate(commands)
-
-#     # # def test07TurnOff(self):
-#     # #     This never worked, I figured out it was not a command.
-#     # #     I checked with various suffixes, but but nothing worked
-#     # #     commands = self.extendCommand("ZV")
-#     # #     are_valid = self.validate(commands)
-#     # #     self.assertTrue(any(are_valid))
-
-#     # #     commands = self.extendCommand("zv")
-#     # #     are_valid = self.validate(commands)
-#     # #     self.assertTrue(any(are_valid))
-
-#     # #     for i, is_valid in enumerate(are_valid):
-#     # #         print(commands[i], is_valid)
-
-#     # # def testFind2Letter_Commands(self):
-#     # # I brute forced it: what are the 2-letter commands?
-#     # # I checked all combinations and checked to see if it complained 'BC'
-#     # # If it did not I assumed this meant it is a command (which is wrong, see
-#     # # later).
-#     # #     for c1 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
-#     # #         for c2 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
-#     # #             commands = self.extendCommand(c1+c2)
-
-#     # #             replies, are_valid = self.validate(commands)
-
-#     # #             for i, is_valid in enumerate(are_valid):
-#     # #                 if is_valid:
-#     # #                     print(commands[i], replies[i])
-
-#     # # def testFind1Letter_Commands(self):
-#     # # I noticed that after 'C' I started getting stuff regularly.
-#     # # I figured 'C' was starting the count like in the documentatin
-#     # # but I needed to figure out how to understand the output.
-#     # #     for c1 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
-#     # #         commands = self.extendCommand(c1)
-#     # #         replies, are_valid = self.validate(commands)
-
-#     # #         for i, is_valid in enumerate(are_valid):
-#     # #             if is_valid:
-#     # #                 print(commands[i], replies[i])
-
-
-#     # # def testFind1Byte_Commands(self):
-#     # # Just in case, checked binary but no: nothing new
-#     # #     valid = []
-#     # #     for c1 in range(128):
-#     # #         print("{0:x}".format(c1))
-#     # #         if chr(c1) == 'D':
-#     # #             continue
-
-#     # #         commands = [chr(c1)]
-
-#     # #         replies, are_valid = self.validate(commands)
-
-#     # #         for i, is_valid in enumerate(are_valid):
-#     # #             if is_valid:
-#     # #                 print(commands[i], replies[i])
-#     # #                 valid.append(commands[i])
-
-#     # #     print(valid)
-
-#     # # def testFind2Byte_Commands(self):
-#     # # Same
-#     # #     for c1 in range(256):
-#     # #         print("-",c1)
-#     # #         for c2 in range(256):
-#     # #             commands = self.extendCommand(chr(c1)+chr(c2))
-
-#     # #             replies, are_valid = self.validate(commands)
-
-#     # #             for i, is_valid in enumerate(are_valid):
-#     # #                 if is_valid:
-#     # #                     print(commands[i], replies[i])
-
-#     # def validate(self, commands):
-#     #     are_valid = []
-#     #     replies = []
-#     #     one_valid = False
-#     #     for command in commands:
-#     #         try:
-#     #             self.port.flush()
-#     #             self.port.writeData(command)
-#     #             reply = self.readStringFromPMT()
-#     #             if reply != "BC":
-#     #                 are_valid.append(True)
-#     #             else:
-#     #                 are_valid.append(False)
-#     #             replies.append(reply)
-#     #         except Exception as err:
-#     #             are_valid.append(False)
-#     #             replies.append(None)
-
-#     #     return replies, are_valid
-
-#     # #     self.port.writeData(b"\r")
-
-#     # def test08start_counting(self):
-#     #     """
-#     #     Here, I printed the read data for a while and noticed
-#     #     an indexed value going up by one. And some weird garbage values after.
-        
-#     #     """
-#     #     self.port.defaultTimeout = 5000
-
-#     #     self.port.writeData(b"C")
-
-#     #     count = 0
-#     #     while count < 4:
-#     #         try:
-#     #             replyData = self.port.readData(64)
-#     #             print(replyData)
-#     #             count += 1
-#     #         except Exception as err:
-#     #             print(err)
-#     #             pass
-
-
-#     # def test08GetIntegrationTimeself(self):
-#     #     """
-#     #     Here, I noticed the 'I' command appeared valid in my long list of attempts.
-#     #     I printed the reply data for a while and noticed
-#     #     an value corresponding to the letter 'I', a few zeros. And some weird garbage values after.
-        
-#     #     Eventually, I figured it out: the first 32 bits are the command letter ASCII
-#     #     code in a lttle endian 32-bit integer, and then the integration time also as a 32 bit
-#     #     integer. But then, the nuber was 100 000, not 1000 as expected. I assumed
-#     #     this meant my model was in 10µs units. 
-
-#     #     So 'I' replied with 'I',0x00,0x00,0x00,0xa0,0x86,0x01,0x00
-#     #     So I decided to try to send the same command back on the next test.
-#     #     """
-#     #     self.port.writeData(b"I")
-#     #     replyData = self.port.readData(64)
-#     #     replyData = replyData[0:8]
-#     #     print(replyData)
-#     #     index, photonCount = unpack("<II", replyData)
-
-#     #     print(chr(index), photonCount)
-
-#     # def test09SetIntegrationTimeself(self):
-#     #     """
-#     #     Knowing that 'I' replied with 'I',0x00,0x00,0x00,0xa0,0x86,0x01,0x00
-#     #     I decided to try to send the same command back: it worked.
-#     #     I started changing the value of the 32-bit integer to see what happened.
-#     #     For that I needed to test the 'C' command again.
-#     #     """
-#     #     self.port.writeData(b'I   \x10\x27\x00\x00')
-#     #     replyData = self.port.readData(64)
-#     #     replyData = replyData[0:8]
-#     #     print(replyData)
-#     #     index, photonCount = unpack("<II", replyData)
-
-#     #     print(index, photonCount)
-
-#     # def test10start_countingProperly(self):
-#     #     """
-#     #     Finally, this appears perfect. 
-#     #     """
-#     #     self.port.defaultTimeout = 5000
-
-#     #     self.port.writeData(b"C")
-
-#     #     count = 0
-#     #     while count < 10:
-#     #         try:
-#     #             replyData = self.port.readData(64)
-#     #             replyData = replyData[0:8]
-#     #             index, photonCount = unpack("<II", replyData)
-#     #             print(index, photonCount)
-#     #             count += 1
-#     #         except Exception as err:
-#     #             print(err)
-#     #             pass
-
-#     #     self.port.writeData(b"\r")
-
-#     # def test09Extension(self):
-#     #     commands = self.extendCommand("DV")
-#     #     self.assertTrue(len(commands) == 6)
-
-#     # def test20GetRepCounter(self):
-#     #     self.port.writeData(b"R")
-#     #     replyData = self.port.readData(64)
-#     #     replyData = replyData[0:8]
-#     #     index, photonCount = unpack("<II", replyData)
-#     #     print("Repetition:", index, photonCount)
-
-#     def test20SetRepCounter(self):
-#         self.port.writeData(b"R\x00\x00\x00\x10\x00\x00\x00")
-#         replyData = self.port.readData(64)
-#         replyData = replyData[0:8]
-#         index, photonCount = unpack("<II", replyData)
-#         print("Set rep {0:x} {1:x} {2}".format(index, photonCount, chr(index)))
-
-#     def extendCommand(self, command):
-#         suffixes = [b"", b"\r", b"\n", b"\r\n", b"\n\r", b"\x00"]
-
-#         if type(command) == str:
-#             commandData = command.encode("utf-8")
-#         else:
-#             commandData = command
-
-#         return [ commandData + suffix for suffix in suffixes]
-
-        
-
-#     def readStringFromPMT(self):
-#         data = self.port.readData(64)
-#         string = ""
-#         for i,c in enumerate(data):
-#             if c == 0:
-#                 break
-                
-#             string += chr(c) # assume utf-8
-
-#         return string
-
-#     # def test900start_counting(self):
-#     #     index, count = sendCommand(self.port, b"C")
-#     #     self.assertEqual(index, 0)
-#     #     print(count)
-
-
-from hardwarelibrary.physicaldevice import PhysicalDevice
-
-class PhotonCounter(PhysicalDevice):
-    classIdVendor = 0x0661
-    classIdProduct = 0x3705
-    def __init__(self):
-        PhysicalDevice.__init__(self, serialNumber="*", idVendor=0x0661, idProduct = 0x3705)
+    def test01CreatePort(self):
+        self.assertIsNotNone(self.port)
 
-    def doInitializeDevice(self):
-        self.port = USBPort(idVendor=0x0661, idProduct = 0x3705)
-        self.port.open()
-        self.stop_counting() # We must stop counting first
-        self.turn_on()
-        self.set_integration_time(time_in_10us=1000)
+    def test02OpenPort(self):
+        self.assertTrue(self.port.isOpen)
 
-    def doShutdownDevice(self):
-        self.stop_counting()
-        self.turn_off()
+    def test03SendDVCommand(self):
+        """
+        This helped me figure out that the readData command would always
+        read 64 bytes.
+        """
+        self.port.writeString(string="DV")
+        count = 64
+        while count > 0:
+            try:
+                print(count, self.port.readData(1))
+            except Exception as err:
+                print(err)
+                break
+            count = count -1
+
+    @unittest.expectedFailure
+    def test04SendDVZVCommand(self):
+        """
+        This never worked.
+        """
+
+        self.port.writeString(string="DV")
+        count = 64
+        while count > 0:
+           try:
+               print(count, self.port.readData(1))
+           except Exception as err:
+               print(err)
+               break
+           count = count -1
+
+        self.port.writeString(string="ZV")
+        count = 64
+        while count > 0:
+           try:
+               print(count, self.port.readData(1))
+           except Exception as err:
+               print(err)
+               break
+           count = count -1
+
+    def test05SendDVZeroCommand(self):
+        """
+
+        """
+
+        self.port.writeData(b"DV\x00")
+        data = self.port.readData(64)
+        string = data.decode("utf-8")
+        for i,c in enumerate(string):
+           if c == '\x00':
+               string = string[:i]
+               break
         self.port.close()
 
-    def sendCommand(self, commandName, payload=None):
-        commandInt = None
-        if payload is None:
-            commandData = commandName.encode("utf-8")
-        else:
-            commandInt = ord(commandName)
-            commandData = pack("<II",ord(commandName), payload)
-
-        self.port.writeData(commandData)
-        replyInt, value = self.readReply()
-        # if replyInt == 0x4342:
-        #     raise ValueError("Bad command")
-        # elif commandInt is not None:
-        #     if commandInt != replyInt:
-        #         raise ValueError("Reply error: {0:x}".format(replyint))
-
-        return replyInt, value
-
-    def readReply(self):
+    def test06UseFunctionValidCommand(self):
+        """
+        I created a function to read the pmt, it is flawed
+        but up to here it works.
+        """
+        self.port.writeData(b"DV")
+        reply = self.readStringFromPMT()
+        self.assertEqual("DV", reply)
+
+    def test07UseFunctionInvalidCommand(self):
+        """
+        I figured out with these tests that BC is bad command
+        """
+
+        self.port.writeData(b"DV\n")
+        reply = self.readStringFromPMT()
+        self.assertEqual("BC", reply)
+
+    def test07TurnOn(self):
+        """
+        This never worked, I understood the manual was not useful much.
+        I checked with various suffixes, but the DV needed to be 2 bytes
+        """
+
+        commands = self.extendCommand("DV")
+        self.validate(commands)
+
+    def test07TurnOff(self):
+        """
+        This never worked, I figured out it was not a command.
+        I checked with various suffixes, but but nothing worked
+    """
+        commands = self.extendCommand("ZV")
+        are_valid = self.validate(commands)
+        self.assertTrue(any(are_valid))
+
+        commands = self.extendCommand("zv")
+        are_valid = self.validate(commands)
+        self.assertTrue(any(are_valid))
+
+        for i, is_valid in enumerate(are_valid):
+            print(commands[i], is_valid)
+
+    def testFind2Letter_Commands(self):
+        """
+        I brute forced it: what are the 2-letter commands?
+        I checked all combinations and checked to see if it complained 'BC'
+        If it did not I assumed this meant it is a command (which is wrong, see
+        later).
+        """
+        for c1 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
+            for c2 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
+                commands = self.extendCommand(c1+c2)
+
+                replies, are_valid = self.validate(commands)
+
+                for i, is_valid in enumerate(are_valid):
+                    if is_valid:
+                        print(commands[i], replies[i])
+
+    def testFind1Letter_Commands(self):
+        """
+        I noticed that after 'C' I started getting stuff regularly.
+        I figured 'C' was starting the count like in the documentatin
+        but I needed to figure out how to understand the output.
+        """
+        for c1 in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ":
+            commands = self.extendCommand(c1)
+            replies, are_valid = self.validate(commands)
+
+            for i, is_valid in enumerate(are_valid):
+                if is_valid:
+                    print(commands[i], replies[i])
+
+    def testFind1Byte_Commands(self):
+        """
+        Just in case, checked binary but no: nothing new
+        """
+        valid = []
+        for c1 in range(128):
+            print("{0:x}".format(c1))
+            if chr(c1) == 'D':
+                continue
+
+            commands = [chr(c1)]
+
+            replies, are_valid = self.validate(commands)
+
+            for i, is_valid in enumerate(are_valid):
+                if is_valid:
+                    print(commands[i], replies[i])
+                    valid.append(commands[i])
+
+        print(valid)
+
+    def testFind2Byte_Commands(self):
+        """
+        Same
+        """
+        for c1 in range(256):
+            print("-",c1)
+            for c2 in range(256):
+                commands = self.extendCommand(chr(c1)+chr(c2))
+
+                replies, are_valid = self.validate(commands)
+
+                for i, is_valid in enumerate(are_valid):
+                    if is_valid:
+                        print(commands[i], replies[i])
+
+    def validate(self, commands):
+        are_valid = []
+        replies = []
+        one_valid = False
+        for command in commands:
+            try:
+                self.port.flush()
+                self.port.writeData(command)
+                reply = self.readStringFromPMT()
+                if reply != "BC":
+                    are_valid.append(True)
+                else:
+                    are_valid.append(False)
+                replies.append(reply)
+            except Exception as err:
+                are_valid.append(False)
+                replies.append(None)
+
+        return replies, are_valid
+
+        #     self.port.writeData(b"\r")
+
+    def test08start_counting(self):
+        """
+        Here, I printed the read data for a while and noticed
+        an indexed value going up by one. And some weird garbage values after.        
+        """
+        self.port.defaultTimeout = 5000
+
+        self.port.writeData(b"C")
+
+        count = 0
+        while count < 4:
+            try:
+                replyData = self.port.readData(64)
+                print(replyData)
+                count += 1
+            except Exception as err:
+                print(err)
+                count += 1
+                pass
+
+
+    def test08GetIntegrationTimeself(self):
+        """
+        Here, I noticed the 'I' command appeared valid in my long list of attempts.
+        I printed the reply data for a while and noticed
+        an value corresponding to the letter 'I', a few zeros. And some weird garbage values after.
+        
+        Eventually, I figured it out: the first 32 bits are the command letter ASCII
+        code in a lttle endian 32-bit integer, and then the integration time also as a 32 bit
+        integer. But then, the nuber was 100 000, not 1000 as expected. I assumed
+        this meant my model was in 10µs units.
+
+        So 'I' replied with 'I',0x00,0x00,0x00,0xa0,0x86,0x01,0x00
+        So I decided to try to send the same command back on the next test.
+        """
+        self.port.writeData(b"I")
         replyData = self.port.readData(64)
         replyData = replyData[0:8]
-        return unpack("<II", replyData)
-
-    def get_integration_time(self):
-        return self.sendCommand("I")
-
-    def set_integration_time(self, time_in_10us):
-        return self.sendCommand(commandName="I", payload=time_in_10us)
-
-    def get_repetition(self):
-        return self.sendCommand(commandName='R')
-
-    def set_repetition(self, repetitions=0):
-        return self.sendCommand(commandName="R", payload=repetitions)
-
-    def turn_on(self):
-        self.set_high_voltage()
-
-    def turn_off(self):
-        self.set_high_voltage(value=0)
-
-    def get_high_voltage(self):
-        return self.sendCommand("V")
+        print(replyData)
+        index, photonCount = unpack("<II", replyData)
+
+        print(chr(index), photonCount)
+
+    def test09SetIntegrationTimeself(self):
+        """
+        Knowing that 'I' replied with 'I',0x00,0x00,0x00,0xa0,0x86,0x01,0x00
+        I decided to try to send the same command back: it worked.
+        I started changing the value of the 32-bit integer to see what happened.
+        For that I needed to test the 'C' command again.
+        """
+        self.port.writeData(b'I   \x10\x27\x00\x00')
+        replyData = self.port.readData(64)
+        replyData = replyData[0:8]
+        print(replyData)
+        index, photonCount = unpack("<II", replyData)
+
+        print(index, photonCount)
+
+    def test10start_countingProperly(self):
+        """
+        Finally, this appears perfect.
+        """
+        self.port.defaultTimeout = 5000
+
+        self.port.writeData(b"C")
+
+        count = 0
+        while count < 10:
+            try:
+                replyData = self.port.readData(64)
+                replyData = replyData[0:8]
+                index, photonCount = unpack("<II", replyData)
+                print(index, photonCount)
+                count += 1
+            except Exception as err:
+                print(err)
+                pass
+
+        self.port.writeData(b"\r")
+
+    def test09Extension(self):
+        commands = self.extendCommand("DV")
+        self.assertTrue(len(commands) == 6)
+
+    def test20GetRepCounter(self):
+        self.port.writeData(b"R")
+        replyData = self.port.readData(64)
+        replyData = replyData[0:8]
+        index, photonCount = unpack("<II", replyData)
+        print("Repetition:", index, photonCount)
 
-    def set_high_voltage(self, value=None):
-        if value is None: 
-            return self.sendCommand("DV") # Default high voltage
-        if value == 0: 
-            return self.sendCommand("ZV") # Turn off high voltage
+    def test20SetRepCounter(self):
+        self.port.writeData(b"R\x00\x00\x00\x10\x00\x00\x00")
+        replyData = self.port.readData(64)
+        replyData = replyData[0:8]
+        index, photonCount = unpack("<II", replyData)
+        print("Set rep {0:x} {1:x} {2}".format(index, photonCount, chr(index)))
 
-        return self.sendCommand("V", value)
+    def extendCommand(self, command):
+        suffixes = [b"", b"\r", b"\n", b"\r\n", b"\n\r", b"\x00"]
 
-    def start_counting(self, correction=True):
-        if correction:
-            return self.port.writeData(b'M')
+        if type(command) == str:
+            commandData = command.encode("utf-8")
         else:
-            return self.port.writeData(b'C')
-
-    def fetchAll(self, maxIndex=None):
-        counts = []
-        while True:
-            index, count = self.fetchOne()
-            if index is None:
-                break
-            counts.append( (index, count,) )
-        return counts
+            commandData = command
 
-    def fetchOne(self):
-        idx = None
-        count = None
+        return [ commandData + suffix for suffix in suffixes]
 
-        try:
-            idx, count = self.readReply()
-        except usb.core.USBTimeoutError as err:
-            return None, None
-
-        if (count & 0x8000) != 0:
-            raise ValueError("PMT overload")
-
-        return idx, count
-
-
-    def stop_counting(self):
-        self.port.writeData(b'\r')
-        self.port.flush()
-
-
-class TestHamamatsuClass(unittest.TestCase):
-    def setUp(self):
-        self.device = PhotonCounter()
-        self.device.initializeDevice()
+    def readStringFromPMT(self):
+        data = self.port.readData(64)
+        string = ""
+        for i,c in enumerate(data):
+            if c == 0:
+                break
+                
+            string += chr(c) # assume utf-8
 
-    def tearDown(self):
-        self.device.shutdownDevice()
-
-    def testIntegration(self):
-        self.device.set_integration_time(10000)
-        _, actualIntegrationTime = self.device.get_integration_time()
-        self.assertEqual(actualIntegrationTime, 10000)
-
-    def testRepetition2(self):
-        self.device.set_repetition(123)
-        _, actualRepetitions = self.device.get_repetition()
-        self.assertEqual(actualRepetitions, 123)
-
-    def testStartStop(self):
-        self.device.start_counting()
-        self.device.stop_counting()
-
-    def testStartFetchStop(self):
-        self.device.set_repetition(0)
-        self.device.set_integration_time(10000)
-        self.device.start_counting()
-        self.device.fetchOne()
-        self.device.stop_counting()
-
-    def testStartFetchAllStop(self):
-        self.device.set_repetition(10)
-        self.device.set_integration_time(10000)
-        self.device.start_counting()
-        counts = self.device.fetchAll(maxIndex=10)
-        for i, (idx, c) in enumerate(counts):
-            self.assertEqual(i, idx)
-            self.assertTrue(c > 0)
-        self.device.stop_counting()
-
-    def testStartWaitFetchAllStop(self):
-        self.device.set_repetition(10)
-        self.device.set_integration_time(10000)
-        self.device.start_counting()
-        counts = self.device.fetchAll(maxIndex=10)
-        for i, (idx, c) in enumerate(counts):
-            self.assertEqual(i, idx)
-            self.assertTrue(c > 0,"{0}".format(c))
-            self.assertTrue(c & 0x8000 == 0)
-        self.device.stop_counting()
-
-    def testStopStop(self):
-        self.device.stop_counting()
-        self.device.stop_counting()
-
-    def testTurnOn(self):        
-        self.device.turn_on()
-
-    def testTurnOff(self):        
-        print(self.device.sendCommand("ZV"))
-        print(self.device.sendCommand("DV"))
-        print(self.device.sendCommand("ZV"))
-        print(self.device.sendCommand("V"))
-        print(self.device.sendCommand(commandName="V", payload=800))
+        return string
 
 if __name__ == '__main__':
     unittest.main()

From b394e52b48dcac10cadf420e9298954fe803a2f3 Mon Sep 17 00:00:00 2001
From: Daniel <dccote@cervo.ulaval.ca>
Date: Thu, 10 Nov 2022 13:39:53 -0500
Subject: [PATCH 4/4] Update testHamamatsuSerial.py

Aesthetic improvements
---
 hardwarelibrary/tests/testHamamatsuSerial.py | 22 +++++++++++++-------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/hardwarelibrary/tests/testHamamatsuSerial.py b/hardwarelibrary/tests/testHamamatsuSerial.py
index a57ca6a..fdd7654 100644
--- a/hardwarelibrary/tests/testHamamatsuSerial.py
+++ b/hardwarelibrary/tests/testHamamatsuSerial.py
@@ -41,10 +41,9 @@ def test03SendDVCommand(self):
                 break
             count = count -1
 
-    @unittest.expectedFailure
     def test04SendDVZVCommand(self):
         """
-        This never worked.
+        This never worked: ZV is not a good command.
         """
 
         self.port.writeString(string="DV")
@@ -62,6 +61,7 @@ def test04SendDVZVCommand(self):
         while count > 0:
            try:
                print(count, self.port.readData(1))
+               # This will print 'B', 'C' etc...
            except Exception as err:
                print(err)
                break
@@ -108,13 +108,15 @@ def test07TurnOn(self):
         commands = self.extendCommand("DV")
         self.validate(commands)
 
+    @unittest.expectedFailure
     def test07TurnOff(self):
         """
-        This never worked, I figured out it was not a command.
+        This never really worked, I figured out it ZV was not a command.
         I checked with various suffixes, but but nothing worked
-    """
+        """=
         commands = self.extendCommand("ZV")
-        are_valid = self.validate(commands)
+        all_commands, are_valid = self.validate(commands)
+        print(are_valid)
         self.assertTrue(any(are_valid))
 
         commands = self.extendCommand("zv")
@@ -124,6 +126,7 @@ def test07TurnOff(self):
         for i, is_valid in enumerate(are_valid):
             print(commands[i], is_valid)
 
+    @unittest.skip("Long test only useful once: brute force attempting to find commands")
     def testFind2Letter_Commands(self):
         """
         I brute forced it: what are the 2-letter commands?
@@ -141,6 +144,7 @@ def testFind2Letter_Commands(self):
                     if is_valid:
                         print(commands[i], replies[i])
 
+    @unittest.skip("Long test only useful once: brute force attempting to find commands")
     def testFind1Letter_Commands(self):
         """
         I noticed that after 'C' I started getting stuff regularly.
@@ -155,6 +159,7 @@ def testFind1Letter_Commands(self):
                 if is_valid:
                     print(commands[i], replies[i])
 
+    @unittest.skip("Long test only useful once: brute force attempting to find commands")
     def testFind1Byte_Commands(self):
         """
         Just in case, checked binary but no: nothing new
@@ -176,6 +181,7 @@ def testFind1Byte_Commands(self):
 
         print(valid)
 
+    @unittest.skip("Long test only useful once: brute force attempting to find commands")
     def testFind2Byte_Commands(self):
         """
         Same
@@ -234,7 +240,7 @@ def test08start_counting(self):
                 pass
 
 
-    def test08GetIntegrationTimeself(self):
+    def test08GetIntegrationTime(self):
         """
         Here, I noticed the 'I' command appeared valid in my long list of attempts.
         I printed the reply data for a while and noticed
@@ -256,7 +262,7 @@ def test08GetIntegrationTimeself(self):
 
         print(chr(index), photonCount)
 
-    def test09SetIntegrationTimeself(self):
+    def test09SetIntegrationTime(self):
         """
         Knowing that 'I' replied with 'I',0x00,0x00,0x00,0xa0,0x86,0x01,0x00
         I decided to try to send the same command back: it worked.
@@ -271,7 +277,7 @@ def test09SetIntegrationTimeself(self):
 
         print(index, photonCount)
 
-    def test10start_countingProperly(self):
+    def test90start_countingProperly(self):
         """
         Finally, this appears perfect.
         """