diff --git a/apsct_lib.py b/apsct_lib.py
index 9c9e22af8a560716b0f53261a6c612c53b14a60f..357f09e9aa6f250dc5069bbd4678a66eebbc9604 100644
--- a/apsct_lib.py
+++ b/apsct_lib.py
@@ -1,4 +1,4 @@
-'''
+"""
 Copyright 2021 Stichting Nederlandse Wetenschappelijk Onderzoek Instituten,
 ASTRON Netherlands Institute for Radio Astronomy
 Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,254 +13,334 @@ limitations under the License.
 
 Set APSCT_CLK
 
-'''
+"""
 import sys
 import time
-sys.path.insert(0,'.')
+sys.path.insert(0, '.')
 import os
-if os.name =="posix":
+if os.name == "posix":
     from I2C_serial_pi2 import *
 else:
     from I2C_serial import *
 
-DEBUG = False
-I2CBUSNR=5
+I2CBUSNR = 5
 sleep_time = 0.15
-SET_PLL = True
-READ_LOCK = True
-READ_ALL = False
-CHECK_EEPROM = False
-PWR_RST = False #True #False
-READ_SENSOR = False #True
-READ_REGS = False #True
 
-CLK_FREQ = '200MHz'
-dev_i2c_eeprom = I2C(0x50)
-dev_i2c_eeprom.bus_nr = I2CBUSNR
+EEPROM = 0x50
+PLL_200M = 0x20
+PLL_160M = 0x21
 
 CS = 6
 SCLK = 4
 SDO = 5
 SDI = 7
 
-PLL_200M = 0x20
-PLL_160M = 0x21
-class ApsctClass()
+
+
+class ApsctClass:
     #
     # Toplevel class that contrains all parts of the APSCT
     #
     def __init__(self):
-        self.reg_address
-def Write_byte_PLL(reg_address, wr_data, ADDRESS=0x20):
-    #
-    # Write Byte to the ADC
-    #
-    I2C_device = I2C(ADDRESS, BUSNR=I2CBUSNR)
-    PLL_rw = 0x00 # 0 for write, 1 for read
-    stri = "Write to address : 0x{1:{fill}2x} value  0x{0:{fill}2x}".format(wr_data, reg_address, fill='0')
-    print(stri)
-    I2C_device.write_bytes(0x06, 0x2C)
-    if DEBUG:
-        rd_bytes = I2C_device.read_bytes(0x06, 1)
-        stri = "IO expander wrote 0x{0:x}, read 0x{1}".format(0x2C, rd_bytes[1])
+        self.status = False
+        self.eeprom = EepromClass()
+        self.pll_200 = PllClass(PLL_200M)
+        self.pll_160 = PllClass(PLL_160M)
+        self.sensors = ApsctSensors()
+
+    def read_IO_expanderis(self):
+        #
+        # Read both IO-Expander lines and pints on the screen
+        #
+        i2c_addr = [0x20, 0x21]
+        for addr in i2c_addr:
+            i2c_device = I2C(addr, BUSNR=I2CBUSNR)  # clock selection
+            for reg_cnt in range(8):
+                ack, ret_value = i2c_device.read_bytes(reg_cnt, 2)
+                stri = "Expander : 0x{:0>2x}, Reg 0x{:0>2x}, value 0x{}{}".format(addr, reg_cnt, ret_value[0],
+                                                                                  ret_value[1])  # [start+2:start])
+                print(stri)
+
+    def power(self, state):
+        #
+        # Set power supply APSCTs in the give state
+        #
+        # state is True: Power on
+        # state is False: Power off
+        #
+        stri = "Power to {}".format(state)
         print(stri)
-    data = (reg_address << 9) + (PLL_rw << 8) + wr_data
-    bit_array = "{0:{fill}16b}".format(data, fill='0')
-    I2C_device.write_bytes(0x02, 0x02 | (0x1 << CS))
-    for bit in bit_array:
-        for clk in range(2):
-            Write_data = 0x02 | (0 << CS) | (clk << SCLK) | (int(bit) << SDI)
-            I2C_device.write_bytes(0x02, Write_data)
-    for clk in range(2):
-            Write_data = 0x02 | (0 << CS) | (clk << SCLK)
-            I2C_device.write_bytes(0x02, Write_data)
-    for clk in range(2):
-            Write_data = 0x02 | (1 << CS) | (clk << SCLK)
-            I2C_device.write_bytes(0x02, Write_data)
-
-    Write_data = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
-    I2C_device.write_bytes(0x02, Write_data)
-    if DEBUG:
-        read_bits = Read_byte_PLL(reg_address, nof_bytes=1, ADDRESS=ADDRESS)
-#        stri = "Bits written 0x{0:x} to register 0x{1:x} read from PLL are {2}".format(wr_data, reg_address, read_bits)
-#        print(stri)
+        I2C_IO_device_A = I2C(0x20, BUSNR=I2CBUSNR)
+        I2C_IO_device_A.write_bytes(0x06, 0x2C)  # '0' is output
+        I2C_IO_device_A.write_bytes(0x07, 0x00)  # '0' is output
+        I2C_IO_device_B = I2C(0x21, BUSNR=I2CBUSNR)
+        I2C_IO_device_B.write_bytes(0x06, 0x2C)  # '0' is output
+        if state:
+            bits_to_set_A1 = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
+            bits_to_set_A2 = 0x04
+            bits_to_set_B1 = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
+        else:
+            bits_to_set_A1 = 0x00 | (1 << CS) | (0 << SCLK) | (0 << SDI)
+            bits_to_set_A2 = 0x00
+            bits_to_set_B1 = 0x00 | (1 << CS) | (0 << SCLK) | (0 << SDI)
+        if DEBUG:
+            stri = "Bits to reg 0 0x{0:x}".format(bits_to_set_A1)
+            print(stri)
+        I2C_IO_device_A.write_bytes(0x02, bits_to_set_A1)
+        I2C_IO_device_A.write_bytes(0x03, bits_to_set_A2)
+        I2C_IO_device_B.write_bytes(0x02, bits_to_set_B1)
+
+    def set_apsct(self, state):
+        #
+        # set APSCT to 200MHz, 160MHz or off
+        #
+        if state == "200MHz":
+            self.power(True)
+            self.pll_200.setup_pll()
+        elif state == "160MHz":
+            self.power(True)
+            self.pll_160.setup_pll()
+        else:
+            self.power(False)
 
 
-def Read_byte_PLL(reg_address, nof_bytes=1, ADDRESS=0x20 ):
+class PllClass:
     #
-    # Read Byte from the ADC
+    # Toplevel class that contrains all parts of the PLL
     #
-    I2C_device = I2C(ADDRESS, BUSNR=I2CBUSNR)
-    PLL_rw    = 0x01 # 0 for write, 1 for read
-
-    I2C_device.write_bytes(0x06, 0x2C)
-    data =  ( reg_address << 7 ) + PLL_rw
-
-    bit_array = "{0:{fill}8b}".format(data, fill='0')
-    for bit in bit_array:
-        for clk in range(2):
-            Write_data = 0x02 | (0 << CS) | (clk << SCLK) | ( int(bit) << SDI)
-            I2C_device.write_bytes(0x02, Write_data)
-            sleep(sleep_time)
-
-#    print("read byte")
-    read_bit = ''
-    for cnt in range(8*nof_bytes):
-        for clk in [0, 1]: # Read after rizing edge
-            Write_data = 0x02 | (clk << SCLK) | ( int(bit) << SDI )
-            I2C_device.write_bytes(0x02, Write_data)
-        ret_ack, ret_value = I2C_device.read_bytes(0x00, 1)
-#        stri= "ret_value = {}".format(int(ret_value,16))
-#        print(stri)
-        if ret_ack:
-            read_bit += str((int(ret_value, 16) >> SDO) & 0x01)
+    def __init__(self, address=0x20):
+        self.status = False
+        self.i2c_address = address
+        self.dev_i2c_pll = I2C(self.i2c_address, BUSNR=I2CBUSNR)
+        if address == 0x20:
+            self.frequency = '200MHz'
         else:
-            print("ACK nok")
-    Write_data = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
-    I2C_device.write_bytes(0x02, Write_data)
-    stri = "Read back at address 0x{0:{fill}2x} result : 0x{1:{fill}2x} ".format(reg_address, int(read_bit, 2), fill='0')
-    print(stri)
-    return read_bit;
-
-def read_all_regs_pll(pll_frequency='200MHz') :
-    I2C_device = I2C(0x20, BUSNR=I2CBUSNR) #clock selection
-    I2C_device.write_bytes(0x07, 0x00)
-    if pll_frequency == '160MHz':
-        print("Read PLL 160 MHz")
-        pll_address = PLL_160M
-#        I2C_device.write_bytes(0x03, 0x0F)
-    else:
-        print("Read PLL 200 MHz")
-        pll_address=PLL_200M
-#        I2C_device.write_bytes(0x03, 0xF8)
-#    for reg_cnt in range(0x15):
-    bytes_to_read = 24
-    ret_value = Read_byte_PLL(0, nof_bytes = bytes_to_read, ADDRESS=pll_address)
-    for cnt in range(bytes_to_read):
-        start = cnt*8
-        stri = "Reg nr 0x{:0>2x} value: 0x{:0>2x}".format(cnt, int(ret_value[start:start+8], 2))
+            self.frequency = '160MHz'
+
+    def Write_byte_PLL(self, reg_address, wr_data):
+        #
+        # Write Byte to the PLL
+        #
+        pll_rw = 0x00  # 0 for write, 1 for read
+        stri = "Write to address : 0x{1:{fill}2x} value  0x{0:{fill}2x}".format(wr_data, reg_address, fill='0')
         print(stri)
-
-def read_IO_expanderis():
-    i2c_addr = [0x20, 0x21]
-    for addr in i2c_addr:
-        I2C_device = I2C(addr, BUSNR=I2CBUSNR) #clock selection
-        for reg_cnt in range(8):
-            ack, ret_value = I2C_device.read_bytes(reg_cnt, 2)
-            stri = "Expander : 0x{:0>2x}, Reg 0x{:0>2x}, value 0x{}{}".format(addr, reg_cnt, ret_value[0], ret_value[1]) #[start+2:start])
+        self.dev_i2c_pll.write_bytes(0x06, 0x2C)
+        if DEBUG:
+            rd_bytes = self.dev_i2c_pll.read_bytes(0x06, 1)
+            stri = "IO expander wrote 0x{0:x}, read 0x{1}".format(0x2C, rd_bytes[1])
             print(stri)
-
-def setup_pll(pll_frequency='200MHz') :
-    I2C_device = I2C(0x20, BUSNR=I2CBUSNR) #clock selection
-    I2C_device.write_bytes(0x07, 0x00)
-    if pll_frequency == '160MHz':
-        print("Set PLL to 160 MHz mode")
-        pll_address = PLL_160M
-        I2C_device.write_bytes(0x03, 0x08)
-    else:
-        print("Set PLL to 200 MHz mode")
-        pll_address=PLL_200M
-        I2C_device.write_bytes(0x03, 0x28)
-    Write_byte_PLL(0x03, 0x0C, pll_address)
-    sleep(0.5)
-    Write_byte_PLL(0x03, 0x08, pll_address)
-    Write_byte_PLL(0x03, 0x08, pll_address)
-    Write_byte_PLL(0x04, 0xCF, pll_address) # CF disable not used outputs, 00 enable all
-    Write_byte_PLL(0x05, 0x97, pll_address)
-    Write_byte_PLL(0x06, 0x10, pll_address) # cp inv = 0xF4 other 0xE4
-    Write_byte_PLL(0x07, 0x04, pll_address) # Divider R = 1 dec
-    Write_byte_PLL(0x08, 0x01, pll_address)
-    Write_byte_PLL(0x07, 0x00, pll_address)
-    Write_byte_PLL(0x09, 0x10, pll_address) # reset
-    if pll_frequency == '160MHz' :
-        Write_byte_PLL(0x0A, 0x10, pll_address)
-    else:
-        Write_byte_PLL(0x0A, 0x14, pll_address)
-    Write_byte_PLL(0x09, 0x00, pll_address)
-    Write_byte_PLL(0x0C, 0x8F, pll_address)
-    Write_byte_PLL(0x0D, 0x88, pll_address) # Dig CLK     = 200/1 = 200 MHz
-    Write_byte_PLL(0x0F, 0x08, pll_address) # RCU CLK     = 200/1 = 200 MHz
-    Write_byte_PLL(0x11, 0x08, pll_address) # PPS ref CLK = 200/1 = 200 MHz
-    Write_byte_PLL(0x13, 0x88, pll_address) # T.P.    CLK = 200/1 = 200 MHz
-
-
-def power(state):
-    stri = "Power to {}".format(state)
-    print(stri)
-    I2C_IO_device_A = I2C(0x20, BUSNR=I2CBUSNR)
-    I2C_IO_device_A.write_bytes(0x06, 0x2C) # '0' is output
-    I2C_IO_device_A.write_bytes(0x07, 0x00) # '0' is output
-    I2C_IO_device_B = I2C(0x21, BUSNR=I2CBUSNR)
-    I2C_IO_device_B.write_bytes(0x06, 0x2C) # '0' is output
-    if state:
-        bits_to_set_A1 = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
-        bits_to_set_A2 = 0x04
-        bits_to_set_B1 = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
-    else:
-        bits_to_set_A1 = 0x00 | (1 << CS) | (0 << SCLK) | (0 << SDI)
-        bits_to_set_A2 = 0x00
-        bits_to_set_B1 = 0x00 | (1 << CS) | (0 << SCLK) | (0 << SDI)
-    if DEBUG :
-        stri = "Bits to reg 0 0x{0:x}".format(bits_to_set_A1)
+        data = (reg_address << 9) + (pll_rw << 8) + wr_data
+        bit_array = "{0:{fill}16b}".format(data, fill='0')
+        self.dev_i2c_pll.write_bytes(0x02, 0x02 | (0x1 << CS))
+        for bit in bit_array:
+            for clk in range(2):
+                Write_data = 0x02 | (0 << CS) | (clk << SCLK) | (int(bit) << SDI)
+                self.dev_i2c_pll.write_bytes(0x02, Write_data)
+        for clk in range(2):
+            Write_data = 0x02 | (0 << CS) | (clk << SCLK)
+            self.dev_i2c_pll.write_bytes(0x02, Write_data)
+        for clk in range(2):
+            Write_data = 0x02 | (1 << CS) | (clk << SCLK)
+            self.dev_i2c_pll.write_bytes(0x02, Write_data)
+
+        Write_data = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
+        self.dev_i2c_pll.write_bytes(0x02, Write_data)
+
+    def Read_byte_PLL(self, reg_address, nof_bytes=1):
+        #
+        # Read Byte from the PLL
+        #
+        pll_rw = 0x01  # 0 for write, 1 for read
+        self.dev_i2c_pll.write_bytes(0x06, 0x2C)
+        data = (reg_address << 7) + pll_rw
+        bit_array = "{0:{fill}8b}".format(data, fill='0')
+        for bit in bit_array:
+            for clk in range(2):
+                Write_data = 0x02 | (0 << CS) | (clk << SCLK) | (int(bit) << SDI)
+                self.dev_i2c_pll.write_bytes(0x02, Write_data)
+                time.sleep(sleep_time)
+        read_bit = ''
+        for cnt in range(8*nof_bytes):
+            for clk in [0, 1]:  # Read after rizing edge
+                Write_data = 0x02 | (clk << SCLK) | (int(bit_array[-1]) << SDI)
+                self.dev_i2c_pll.write_bytes(0x02, Write_data)
+            ret_ack, ret_value = self.dev_i2c_pll.read_bytes(0x00, 1)
+            if ret_ack:
+                read_bit += str((int(ret_value, 16) >> SDO) & 0x01)
+            else:
+                print("ACK nok")
+        Write_data = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
+        self.dev_i2c_pll.write_bytes(0x02, Write_data)
+        stri = "Read back at address 0x{0:{fill}2x} result : 0x{1:{fill}2x} ".format(reg_address,
+                                                                                     int(read_bit, 2), fill='0')
         print(stri)
-    I2C_IO_device_A.write_bytes(0x02, bits_to_set_A1)
-    I2C_IO_device_A.write_bytes(0x03, bits_to_set_A2)
-    I2C_IO_device_B.write_bytes(0x02, bits_to_set_B1)
+        return read_bit
+
+    def setup_pll(self):
+        #
+        # Set registers on the PLL
+        #
+        self.dev_i2c_pll.write_bytes(0x07, 0x00)
+        if self.frequency == '160MHz':
+            self.dev_i2c_pll.write_bytes(0x03, 0x08)
+        else:
+            self.dev_i2c_pll.write_bytes(0x03, 0x28)
+        self.Write_byte_PLL(0x03, 0x0C)
+        sleep(0.5)
+        self.Write_byte_PLL(0x03, 0x08)
+        self.Write_byte_PLL(0x03, 0x08)
+        self.Write_byte_PLL(0x04, 0xCF)  # CF disable not used outputs, 00 enable all
+        self.Write_byte_PLL(0x05, 0x97)
+        self.Write_byte_PLL(0x06, 0x10)  # cp inv = 0xF4 other 0xE4
+        self.Write_byte_PLL(0x07, 0x04)  # Divider R = 1 dec
+        self.Write_byte_PLL(0x08, 0x01)
+        self.Write_byte_PLL(0x07, 0x00)
+        self.Write_byte_PLL(0x09, 0x10)  # reset
+        if self.frequency == '160MHz':
+            self.Write_byte_PLL(0x0A, 0x10)
+        else:
+            self.Write_byte_PLL(0x0A, 0x14)
+        self.Write_byte_PLL(0x09, 0x00)
+        self.Write_byte_PLL(0x0C, 0x8F)
+        self.Write_byte_PLL(0x0D, 0x88)  # Dig CLK     = 200/1 = 200 MHz
+        self.Write_byte_PLL(0x0F, 0x08)  # RCU CLK     = 200/1 = 200 MHz
+        self.Write_byte_PLL(0x11, 0x08)  # PPS ref CLK = 200/1 = 200 MHz
+        self.Write_byte_PLL(0x13, 0x88)  # T.P.    CLK = 200/1 = 200 MHz
+
+    def read_all_regs_pll(self):
+        #
+        # Read all registers on the PLL and print on screen
+        #
+        self.dev_i2c_pll.write_bytes(0x07, 0x00)
+        bytes_to_read = 24
+        ret_value = self.Read_byte_PLL(0, nof_bytes=bytes_to_read)
+        for cnt in range(bytes_to_read):
+            start = cnt*8
+            stri = "Reg nr 0x{:0>2x} value: 0x{:0>2x}".format(cnt, int(ret_value[start:start+8], 2))
+            print(stri)
 
-def write_eeprom( data=0x01):
+    def read_lol(self, pll_frequency='200MHz'):
+        #
+        # Read loss of lock status
+        #
+        I2C_IO_device_A = I2C(0x20, BUSNR=I2CBUSNR)
+        I2C_IO_device_A.write_bytes(0x06, 0x2C)  # '0' is output
+        I2C_IO_device_A.write_bytes(0x07, 0x00)  # '0' is output
+        I2C_IO_device_B = I2C(0x21, BUSNR=I2CBUSNR)
+        I2C_IO_device_B.write_bytes(0x06, 0x2C)  # '0' is output
+        I2C_IO_device_B.write_bytes(0x07, 0xFF)  # '0' is output
+
+        ack, ret_value = I2C_IO_device_B.read_bytes(0x01, 1)
+        status_reg = int(ret_value, 16)
+        if (pll_frequency == '200MHz') & ((status_reg & 0x10) > 0):
+            print("lost lock 200MHz")
+        if ((status_reg & 0x20) > 0) & (pll_frequency == '160MHz'):
+            print("lost lock 160MHz")
+        ack, ret_value = I2C_IO_device_A.read_bytes(0x01, 1)
+        old_reg = int(ret_value, 16)
+        I2C_IO_device_A.write_bytes(0x03, (old_reg | 0x10))  # '0' is output
+        sleep(1)
+        I2C_IO_device_A.write_bytes(0x03, (old_reg & 0xEF))  # '0' is output
+
+
+class EepromClass:
     #
-    # Write the EEPROM with the serial number etc.
+    # Class to handle EEPROM communication
     #
-    ret_ack, ret_value = dev_i2c_eeprom.read_bytes(0)
-    if ret_ack < 1:
-        print("EEPROM not found during write")
-        return False
-    else:
-        dev_i2c_eeprom.write_bytes(0x00, data)
-        sleep(0.1)
-        return True
+    def __init__(self):
+        #
+        # All monitor. read and write functions for the EEPROM
+        #
+        self.dev_i2c_eeprom = I2C(EEPROM)
+        self.dev_i2c_eeprom.bus_nr = I2CBUSNR
+
+    def write_eeprom(self, data="APSPU", address=0):
+        #
+        # Write the EEPROM with the serial number etc.
+        #
+        # Data = data to write in string formal
+        # Address = address to write the data to
+        # Return True if successfully
+        #
+        ret_ack, ret_value = self.dev_i2c_eeprom.read_bytes(0)
+        if ret_ack < 1:
+            print("EEPROM not found during write")
+            return False
+        else:
+            wr_data = bytearray(data.encode("utf-8", errors="ignore"))
+            for loc, data_byte in enumerate(wr_data):
+                self.dev_i2c_eeprom.write_bytes(address + loc, data_byte)
+                sleep(0.1)
+            return True
+
+    def read_eeprom(self, address=0, nof_bytes=5):
+        #
+        # Read the EEPROM with the serial number etc.
+        #
+        # Address = address to read from
+        # nof_bytes = number of bytes to read
+        # return string with the data from the flash
+        #
+        ret_ack, ret_value = self.dev_i2c_eeprom.read_last_reg(1)
+        if ret_ack < 1:
+            print("no EEPROM found during read")
+            return False
+        else:
+            ret_ack, ret_value = self.dev_i2c_eeprom.read_bytes(address, nof_bytes)
+            str_return = bytes.fromhex(ret_value[:nof_bytes * 2]).decode('UTF-8')
+            return str_return
+
+    def wr_rd_eeprom(self, value="APSPU-1", address=0):
+        #
+        # Write and Read the EEPROM to check functionality
+        #
+        # value = string with data to write
+        # address = address to write the data to
+        # return True if read back is same as write value
+        #
+        if self.write_eeprom(value, address=0):
+            ret_value = self.read_eeprom(address=0, nof_bytes=len(value))
+            stri = "Wrote to EEPROM register 0x{2:x} : {0}, Read from EEPROM: {1}".format(value, ret_value, address)
+            print(stri)
+            if ret_value == value:
+                return True
+            else:
+                return False
 
-def read_eeprom():
-    #
-    # Read the EEPROM with the serial number etc.
-    #
-    ret_ack, ret_value = dev_i2c_eeprom.read_last_reg(1)
-    if ret_ack < 1:
-        print("no EEPROM found during read")
-        return False
-    else:
-        ret_ack, ret_value = dev_i2c_eeprom.read_bytes(0x00, 1)
-        return ret_value
 
-def wr_rd_eeprom(value=0x34):
+class ApsctSensors:
     #
-    # Write and Read the EEPROM to check functionality
+    # All monitor. read and write functions for the voltage sensors on APSCT
     #
-    if write_eeprom(value):
-        ret_value = read_eeprom()
-        stri = "Wrote to EEPROM: 0x{0:X}, Read from EEPROM: 0x{1} ".format(value, ret_value)
-        print(stri)
-    return True
-
-def apsct_sensors():
-    for sens_line in range(7):
-        read_voltage(sens_line)
-    read_temp()
-
-def read_voltage(input_channel=0):
-    addr = 0x74
-    Vref = 3.0
-    one_step = Vref/(2**(16))
-    I2C_device = I2C(addr, BUSNR=I2CBUSNR)
-    channel_select_word = 0xB0 | ((input_channel%2) << 3) | ((input_channel >> 1) & 0x7)
-    if DEBUG:
-        stri = "Word to select sens input is 0x{0:x}".format(channel_select_word)
-        print(stri)
-    sleep(0.1)
-    I2C_device.write_bytes(channel_select_word, 0xB8)
-    sleep(0.5)
-    ret_ack, ret_value = I2C_device.read_last_reg(3)
-    if 1: #ret_ack:
+    def __init__(self):
+        #
+        # All monitor. read and write functions for the EEPROM
+        #
+        self.dev_i2c_sensor = I2C(0x74)
+        self.dev_i2c_sensor.bus_nr = I2CBUSNR
+
+    def apsct_sensors(self):
+        for sens_line in range(7):
+            self.read_voltage(sens_line)
+        self.read_temp()
+
+    def read_voltage(self, input_channel=0):
+        #
+        # Function to read a voltages of APSCT
+        #
+        # input_channel = sens port
+        # return value
+        #
+        Vref = 3.0
+        one_step = Vref/(2**16)
+        channel_select_word = 0xB0 | ((input_channel % 2) << 3) | ((input_channel >> 1) & 0x7)
+        if DEBUG:
+            stri = "Word to select sens input is 0x{0:x}".format(channel_select_word)
+            print(stri)
+        sleep(0.1)
+        self.dev_i2c_sensor.write_bytes(channel_select_word, 0xB8)
+        sleep(0.5)
+        ret_ack, ret_value = self.dev_i2c_sensor.read_last_reg(3)
         if DEBUG:
             stri = "Return value input 0 : 0x{0} ".format(ret_value)
             print(stri)
@@ -272,91 +352,25 @@ def read_voltage(input_channel=0):
             voltage = ((4.7+2.2)/2.2)*2*voltage
             string = "Voltage sens line {1} is {0:.4f} V".format(voltage, input_channel)
             print(string)
-    else:
-        stri = " No ACK on device 0x{0:x} ".format(addr)
-        print(stri)
-
-def read_temp():
-    Vref = 3.0
-    addr = 0x74
-    one_step = Vref/(2**(16))
-    I2C_device = I2C(addr, BUSNR=I2CBUSNR)
-    temp_slope = 93.5E-6 * 2**(16+1) / Vref
-    sleep(1.0)
-    I2C_device.write_bytes(0xA0, 0xC0)
-    sleep(1.0)
-    ret_ack, ret_value = I2C_device.read_last_reg(3)
-    if ret_ack:
-        raw_value  = (int(ret_value, 16) & 0x1FFFFF) >> 6
-        temperature_K = (raw_value/temp_slope)
-        temperature = temperature_K-273
-        stri = "Temperature : {0:.2f} gr. C".format(temperature)
-        print(stri)
-    else:
-        print("Error reading tempeature")
 
+    def read_temp(self):
+        #
+        # Function to read temperature of APSCT
+        #
+        # return value
+        #
+        Vref = 3.0
+        temp_slope = 93.5E-6 * 2**(16+1) / Vref
+        sleep(1.0)
+        self.dev_i2c_sensor.write_bytes(0xA0, 0xC0)
+        sleep(1.0)
+        ret_ack, ret_value = self.dev_i2c_sensor.read_last_reg(3)
+        if ret_ack:
+            raw_value = (int(ret_value, 16) & 0x1FFFFF) >> 6
+            temperature_K = (raw_value/temp_slope)
+            temperature = temperature_K-273
+            stri = "Temperature : {0:.2f} gr. C".format(temperature)
+            print(stri)
+        else:
+            print("Error reading tempeature")
 
-def read_lol(pll_frequency='200MHz'):
-    I2C_IO_device_A = I2C(0x20, BUSNR=I2CBUSNR)
-    I2C_IO_device_A.write_bytes(0x06, 0x2C)  # '0' is output
-    I2C_IO_device_A.write_bytes(0x07, 0x00)  # '0' is output
-    I2C_IO_device_B = I2C(0x21, BUSNR=I2CBUSNR)
-    I2C_IO_device_B.write_bytes(0x06, 0x2C)  # '0' is output
-    I2C_IO_device_B.write_bytes(0x07, 0xFF)  # '0' is output
-
-    ack, ret_value = I2C_IO_device_B.read_bytes(0x01, 1)
-    status_reg = int(ret_value,16)
-    if (pll_frequency=='200MHz') & ((status_reg & 0x10) > 0):
-        print("lost lock 200MHz")
-    if ((status_reg & 0x20) > 0) & (pll_frequency=='160MHz'):
-        print("lost lock 160MHz")
-    ack, ret_value = I2C_IO_device_A.read_bytes(0x01, 1)
-    old_reg = int(ret_value,16)
-    I2C_IO_device_A.write_bytes(0x03, (old_reg | 0x10))  # '0' is output
-    sleep(1)
-    I2C_IO_device_A.write_bytes(0x03, (old_reg & 0xEF))  # '0' is output
-
-
-
-
-
-#if READ_REGS:
-#    read_all_regs_pll(CLK_FREQ)
-
-read_temp()
-
-if CHECK_EEPROM :
-    wr_rd_eeprom()
-
-if PWR_RST :
-    power(False)
-    sleep(10)
-    power(True)
-
-if SET_PLL :
-    setup_pll(CLK_FREQ)
-
-if READ_LOCK:
-    if CLK_FREQ == '160MHz' :
-        pll_addr = PLL_160M
-    else:
-        pll_addr = PLL_200M
-    ret_value = Read_byte_PLL(0x00, nof_bytes = 1, ADDRESS=pll_addr)
-    status_pll = int(ret_value,2)
-    if status_pll == 0x04:
-        print("PLL in lock")
-    elif (status_pll & 0x10) > 0:
-        print("Not Locked --> No 10 MHz ref")
-    else:
-        print("Not locked --> PLL Error")
-
-if READ_REGS:
-    read_all_regs_pll(CLK_FREQ)
-
-if READ_ALL:
-    read_all_regs_pll(CLK_FREQ)
-    read_IO_expanderis()
-
-if READ_SENSOR:
-    apsct_sensors()
-read_lol(CLK_FREQ) 
diff --git a/production_apsct.py b/production_apsct.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a48f11be00b78a14993eee2793f869273931a91
--- /dev/null
+++ b/production_apsct.py
@@ -0,0 +1,59 @@
+"""
+Copyright 2021 Stichting Nederlandse Wetenschappelijk Onderzoek Instituten,
+ASTRON Netherlands Institute for Radio Astronomy
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+Set APSCT_CLK
+
+"""
+import time
+import apsct_lib
+
+DEBUG = False
+SET_PLL = True
+READ_LOCK = True
+READ_ALL = True
+CHECK_EEPROM = False
+PWR_RST = False  # True
+READ_SENSOR = False  # True
+READ_REGS = False  # True
+
+CLK_FREQ = '200MHz'
+
+apsct = apsct_lib.ApsctClass()
+apsct.sensors.read_temp()
+
+if CHECK_EEPROM:
+    apsct.eeprom.wr_rd_eeprom()
+
+if PWR_RST:
+    apsct.power(False)
+    time.sleep(10)
+    apsct.power(True)
+
+if SET_PLL:
+    apsct.set_apsct(CLK_FREQ)
+
+if READ_LOCK:
+    apsct.pll_200.read_lol()
+
+if READ_REGS:
+    apsct.pll_200.read_all_regs_pll()
+
+if READ_ALL:
+    apsct.pll_200.read_all_regs_pll()
+    apsct.pll_160.read_all_regs_pll()
+    apsct.read_IO_expanderis()
+
+if READ_SENSOR:
+    apsct.sensors.apsct_sensors()
+
+apsct.pll_200.read_lol(CLK_FREQ)