Skip to content
Snippets Groups Projects

Apsct production

2 files
+ 373
300
Compare changes
  • Side-by-side
  • Inline

Files

+ 314
300
'''
"""
Copyright 2021 Stichting Nederlandse Wetenschappelijk Onderzoek Instituten,
Copyright 2021 Stichting Nederlandse Wetenschappelijk Onderzoek Instituten,
ASTRON Netherlands Institute for Radio Astronomy
ASTRON Netherlands Institute for Radio Astronomy
Licensed under the Apache License, Version 2.0 (the "License");
Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,254 +13,334 @@ limitations under the License.
@@ -13,254 +13,334 @@ limitations under the License.
Set APSCT_CLK
Set APSCT_CLK
'''
"""
import sys
import sys
import time
import time
sys.path.insert(0,'.')
sys.path.insert(0, '.')
import os
import os
if os.name =="posix":
if os.name == "posix":
from I2C_serial_pi2 import *
from I2C_serial_pi2 import *
else:
else:
from I2C_serial import *
from I2C_serial import *
DEBUG = False
I2CBUSNR = 5
I2CBUSNR=5
sleep_time = 0.15
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'
EEPROM = 0x50
dev_i2c_eeprom = I2C(0x50)
PLL_200M = 0x20
dev_i2c_eeprom.bus_nr = I2CBUSNR
PLL_160M = 0x21
CS = 6
CS = 6
SCLK = 4
SCLK = 4
SDO = 5
SDO = 5
SDI = 7
SDI = 7
PLL_200M = 0x20
PLL_160M = 0x21
class ApsctClass()
class ApsctClass:
#
#
# Toplevel class that contrains all parts of the APSCT
# Toplevel class that contrains all parts of the APSCT
#
#
def __init__(self):
def __init__(self):
self.reg_address
self.status = False
def Write_byte_PLL(reg_address, wr_data, ADDRESS=0x20):
self.eeprom = EepromClass()
#
self.pll_200 = PllClass(PLL_200M)
# Write Byte to the ADC
self.pll_160 = PllClass(PLL_160M)
#
self.sensors = ApsctSensors()
I2C_device = I2C(ADDRESS, BUSNR=I2CBUSNR)
PLL_rw = 0x00 # 0 for write, 1 for read
def read_IO_expanderis(self):
stri = "Write to address : 0x{1:{fill}2x} value 0x{0:{fill}2x}".format(wr_data, reg_address, fill='0')
#
print(stri)
# Read both IO-Expander lines and pints on the screen
I2C_device.write_bytes(0x06, 0x2C)
#
if DEBUG:
i2c_addr = [0x20, 0x21]
rd_bytes = I2C_device.read_bytes(0x06, 1)
for addr in i2c_addr:
stri = "IO expander wrote 0x{0:x}, read 0x{1}".format(0x2C, rd_bytes[1])
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)
print(stri)
data = (reg_address << 9) + (PLL_rw << 8) + wr_data
I2C_IO_device_A = I2C(0x20, BUSNR=I2CBUSNR)
bit_array = "{0:{fill}16b}".format(data, fill='0')
I2C_IO_device_A.write_bytes(0x06, 0x2C) # '0' is output
I2C_device.write_bytes(0x02, 0x02 | (0x1 << CS))
I2C_IO_device_A.write_bytes(0x07, 0x00) # '0' is output
for bit in bit_array:
I2C_IO_device_B = I2C(0x21, BUSNR=I2CBUSNR)
for clk in range(2):
I2C_IO_device_B.write_bytes(0x06, 0x2C) # '0' is output
Write_data = 0x02 | (0 << CS) | (clk << SCLK) | (int(bit) << SDI)
if state:
I2C_device.write_bytes(0x02, Write_data)
bits_to_set_A1 = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
for clk in range(2):
bits_to_set_A2 = 0x04
Write_data = 0x02 | (0 << CS) | (clk << SCLK)
bits_to_set_B1 = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
I2C_device.write_bytes(0x02, Write_data)
else:
for clk in range(2):
bits_to_set_A1 = 0x00 | (1 << CS) | (0 << SCLK) | (0 << SDI)
Write_data = 0x02 | (1 << CS) | (clk << SCLK)
bits_to_set_A2 = 0x00
I2C_device.write_bytes(0x02, Write_data)
bits_to_set_B1 = 0x00 | (1 << CS) | (0 << SCLK) | (0 << SDI)
if DEBUG:
Write_data = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
stri = "Bits to reg 0 0x{0:x}".format(bits_to_set_A1)
I2C_device.write_bytes(0x02, Write_data)
print(stri)
if DEBUG:
I2C_IO_device_A.write_bytes(0x02, bits_to_set_A1)
read_bits = Read_byte_PLL(reg_address, nof_bytes=1, ADDRESS=ADDRESS)
I2C_IO_device_A.write_bytes(0x03, bits_to_set_A2)
# stri = "Bits written 0x{0:x} to register 0x{1:x} read from PLL are {2}".format(wr_data, reg_address, read_bits)
I2C_IO_device_B.write_bytes(0x02, bits_to_set_B1)
# print(stri)
 
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)
def __init__(self, address=0x20):
PLL_rw = 0x01 # 0 for write, 1 for read
self.status = False
self.i2c_address = address
I2C_device.write_bytes(0x06, 0x2C)
self.dev_i2c_pll = I2C(self.i2c_address, BUSNR=I2CBUSNR)
data = ( reg_address << 7 ) + PLL_rw
if address == 0x20:
self.frequency = '200MHz'
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)
else:
else:
print("ACK nok")
self.frequency = '160MHz'
Write_data = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
I2C_device.write_bytes(0x02, Write_data)
def Write_byte_PLL(self, reg_address, wr_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)
# Write Byte to the PLL
return read_bit;
#
pll_rw = 0x00 # 0 for write, 1 for read
def read_all_regs_pll(pll_frequency='200MHz') :
stri = "Write to address : 0x{1:{fill}2x} value 0x{0:{fill}2x}".format(wr_data, reg_address, fill='0')
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))
print(stri)
print(stri)
self.dev_i2c_pll.write_bytes(0x06, 0x2C)
def read_IO_expanderis():
if DEBUG:
i2c_addr = [0x20, 0x21]
rd_bytes = self.dev_i2c_pll.read_bytes(0x06, 1)
for addr in i2c_addr:
stri = "IO expander wrote 0x{0:x}, read 0x{1}".format(0x2C, rd_bytes[1])
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)
print(stri)
data = (reg_address << 9) + (pll_rw << 8) + wr_data
def setup_pll(pll_frequency='200MHz') :
bit_array = "{0:{fill}16b}".format(data, fill='0')
I2C_device = I2C(0x20, BUSNR=I2CBUSNR) #clock selection
self.dev_i2c_pll.write_bytes(0x02, 0x02 | (0x1 << CS))
I2C_device.write_bytes(0x07, 0x00)
for bit in bit_array:
if pll_frequency == '160MHz':
for clk in range(2):
print("Set PLL to 160 MHz mode")
Write_data = 0x02 | (0 << CS) | (clk << SCLK) | (int(bit) << SDI)
pll_address = PLL_160M
self.dev_i2c_pll.write_bytes(0x02, Write_data)
I2C_device.write_bytes(0x03, 0x08)
for clk in range(2):
else:
Write_data = 0x02 | (0 << CS) | (clk << SCLK)
print("Set PLL to 200 MHz mode")
self.dev_i2c_pll.write_bytes(0x02, Write_data)
pll_address=PLL_200M
for clk in range(2):
I2C_device.write_bytes(0x03, 0x28)
Write_data = 0x02 | (1 << CS) | (clk << SCLK)
Write_byte_PLL(0x03, 0x0C, pll_address)
self.dev_i2c_pll.write_bytes(0x02, Write_data)
sleep(0.5)
Write_byte_PLL(0x03, 0x08, pll_address)
Write_data = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
Write_byte_PLL(0x03, 0x08, pll_address)
self.dev_i2c_pll.write_bytes(0x02, Write_data)
Write_byte_PLL(0x04, 0xCF, pll_address) # CF disable not used outputs, 00 enable all
Write_byte_PLL(0x05, 0x97, pll_address)
def Read_byte_PLL(self, reg_address, nof_bytes=1):
Write_byte_PLL(0x06, 0x10, pll_address) # cp inv = 0xF4 other 0xE4
#
Write_byte_PLL(0x07, 0x04, pll_address) # Divider R = 1 dec
# Read Byte from the PLL
Write_byte_PLL(0x08, 0x01, pll_address)
#
Write_byte_PLL(0x07, 0x00, pll_address)
pll_rw = 0x01 # 0 for write, 1 for read
Write_byte_PLL(0x09, 0x10, pll_address) # reset
self.dev_i2c_pll.write_bytes(0x06, 0x2C)
if pll_frequency == '160MHz' :
data = (reg_address << 7) + pll_rw
Write_byte_PLL(0x0A, 0x10, pll_address)
bit_array = "{0:{fill}8b}".format(data, fill='0')
else:
for bit in bit_array:
Write_byte_PLL(0x0A, 0x14, pll_address)
for clk in range(2):
Write_byte_PLL(0x09, 0x00, pll_address)
Write_data = 0x02 | (0 << CS) | (clk << SCLK) | (int(bit) << SDI)
Write_byte_PLL(0x0C, 0x8F, pll_address)
self.dev_i2c_pll.write_bytes(0x02, Write_data)
Write_byte_PLL(0x0D, 0x88, pll_address) # Dig CLK = 200/1 = 200 MHz
time.sleep(sleep_time)
Write_byte_PLL(0x0F, 0x08, pll_address) # RCU CLK = 200/1 = 200 MHz
read_bit = ''
Write_byte_PLL(0x11, 0x08, pll_address) # PPS ref CLK = 200/1 = 200 MHz
for cnt in range(8*nof_bytes):
Write_byte_PLL(0x13, 0x88, pll_address) # T.P. CLK = 200/1 = 200 MHz
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)
def power(state):
ret_ack, ret_value = self.dev_i2c_pll.read_bytes(0x00, 1)
stri = "Power to {}".format(state)
if ret_ack:
print(stri)
read_bit += str((int(ret_value, 16) >> SDO) & 0x01)
I2C_IO_device_A = I2C(0x20, BUSNR=I2CBUSNR)
else:
I2C_IO_device_A.write_bytes(0x06, 0x2C) # '0' is output
print("ACK nok")
I2C_IO_device_A.write_bytes(0x07, 0x00) # '0' is output
Write_data = 0x02 | (1 << CS) | (0 << SCLK) | (0 << SDI)
I2C_IO_device_B = I2C(0x21, BUSNR=I2CBUSNR)
self.dev_i2c_pll.write_bytes(0x02, Write_data)
I2C_IO_device_B.write_bytes(0x06, 0x2C) # '0' is output
stri = "Read back at address 0x{0:{fill}2x} result : 0x{1:{fill}2x} ".format(reg_address,
if state:
int(read_bit, 2), fill='0')
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)
print(stri)
I2C_IO_device_A.write_bytes(0x02, bits_to_set_A1)
return read_bit
I2C_IO_device_A.write_bytes(0x03, bits_to_set_A2)
I2C_IO_device_B.write_bytes(0x02, bits_to_set_B1)
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)
def __init__(self):
if ret_ack < 1:
#
print("EEPROM not found during write")
# All monitor. read and write functions for the EEPROM
return False
#
else:
self.dev_i2c_eeprom = I2C(EEPROM)
dev_i2c_eeprom.write_bytes(0x00, data)
self.dev_i2c_eeprom.bus_nr = I2CBUSNR
sleep(0.1)
return True
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):
def __init__(self):
ret_value = read_eeprom()
#
stri = "Wrote to EEPROM: 0x{0:X}, Read from EEPROM: 0x{1} ".format(value, ret_value)
# All monitor. read and write functions for the EEPROM
print(stri)
#
return True
self.dev_i2c_sensor = I2C(0x74)
self.dev_i2c_sensor.bus_nr = I2CBUSNR
def apsct_sensors():
for sens_line in range(7):
def apsct_sensors(self):
read_voltage(sens_line)
for sens_line in range(7):
read_temp()
self.read_voltage(sens_line)
self.read_temp()
def read_voltage(input_channel=0):
addr = 0x74
def read_voltage(self, input_channel=0):
Vref = 3.0
#
one_step = Vref/(2**(16))
# Function to read a voltages of APSCT
I2C_device = I2C(addr, BUSNR=I2CBUSNR)
#
channel_select_word = 0xB0 | ((input_channel%2) << 3) | ((input_channel >> 1) & 0x7)
# input_channel = sens port
if DEBUG:
# return value
stri = "Word to select sens input is 0x{0:x}".format(channel_select_word)
#
print(stri)
Vref = 3.0
sleep(0.1)
one_step = Vref/(2**16)
I2C_device.write_bytes(channel_select_word, 0xB8)
channel_select_word = 0xB0 | ((input_channel % 2) << 3) | ((input_channel >> 1) & 0x7)
sleep(0.5)
if DEBUG:
ret_ack, ret_value = I2C_device.read_last_reg(3)
stri = "Word to select sens input is 0x{0:x}".format(channel_select_word)
if 1: #ret_ack:
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:
if DEBUG:
stri = "Return value input 0 : 0x{0} ".format(ret_value)
stri = "Return value input 0 : 0x{0} ".format(ret_value)
print(stri)
print(stri)
@@ -272,91 +352,25 @@ def read_voltage(input_channel=0):
@@ -272,91 +352,25 @@ def read_voltage(input_channel=0):
voltage = ((4.7+2.2)/2.2)*2*voltage
voltage = ((4.7+2.2)/2.2)*2*voltage
string = "Voltage sens line {1} is {0:.4f} V".format(voltage, input_channel)
string = "Voltage sens line {1} is {0:.4f} V".format(voltage, input_channel)
print(string)
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)
Loading