Merge branch 'master' of https://git.astron.nl/lofar2.0/python_test_scripts

CCD_I2C.py

+'''
+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 CCD
+
+'''
+import sys
+import time
+sys.path.insert(0,'.')
+import os
+if os.name =="posix":
+    from I2C_serial_pi2 import *
+else:
+    from I2C_serial import *
+
+DEBUG = False
+I2CBUSNR=1
+sleep_time = 0.05
+SET_PLL = True
+READ_LOCK = True
+READ_ALL = False
+CHECK_EEPROM = True
+PWR_RST = False
+READ_SENSOR = True
+
+CLK_FREQ = '200MHz'
+dev_i2c_eeprom = I2C(0x50)
+dev_i2c_eeprom.bus_nr = I2CBUSNR
+
+CS = 6
+SCLK = 4
+SDO = 5
+SDI = 7
+PLL_addr = 0x20
+
+
+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 : 0x{0:{fill}2x} to Address : 0x{1:{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])
+        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)
+
+
+def Read_byte_PLL(reg_address, nof_bytes=1, ADDRESS=0x20 ):
+    #
+    # Read Byte from the ADC
+    #
+    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)
+        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 setup_pll() :
+    I2C_device = I2C(0x20, BUSNR=I2CBUSNR) #clock selection
+    I2C_device.write_bytes(0x07, 0x00)
+    Write_byte_PLL(0x03, 0x08, PLL_addr)
+    Write_byte_PLL(0x04, 0xCF, PLL_addr) # CF disable not used outputs, 00 enable all
+    Write_byte_PLL(0x05, 0xF0, PLL_addr)
+    Write_byte_PLL(0x06, 0x40, PLL_addr)  # cp inv = 0xF4 other 0xE4
+    Write_byte_PLL(0x07, 0x04, PLL_addr)  # Divider R = 1 dec
+    Write_byte_PLL(0x08, 0x01, PLL_addr)
+    Write_byte_PLL(0x07, 0x00, PLL_addr)
+    Write_byte_PLL(0x09, 0x04, PLL_addr)
+    Write_byte_PLL(0x0A, 0x01, PLL_addr)
+    Write_byte_PLL(0x09, 0x00, PLL_addr)
+    Write_byte_PLL(0x0B, 0x40, PLL_addr)
+    Write_byte_PLL(0x0D, 0x01, PLL_addr)
+    Write_byte_PLL(0x0E, 0x00, PLL_addr)
+    Write_byte_PLL(0x0F, 0x01, PLL_addr)
+    Write_byte_PLL(0x10, 0x00, PLL_addr)
+    Write_byte_PLL(0x11, 0x01, PLL_addr)
+    Write_byte_PLL(0x12, 0x00, PLL_addr)
+    Write_byte_PLL(0x13, 0x01, PLL_addr)
+    Write_byte_PLL(0x14, 0x01, PLL_addr)
+
+
+
+def power(state):
+    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 write_eeprom( data=0x01):
+    #
+    # Write the EEPROM with the serial number etc.
+    #
+    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 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):
+    #
+    # Write and Read the EEPROM to check functionality
+    #
+    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 ccd_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.5)
+    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:
+        if DEBUG:
+            stri = "Return value input 0 : 0x{0} ".format(ret_value)
+            print(stri)
+        if int(ret_value, 16) >= 0xC00000:
+            print("over range")
+        else:
+            steps = (int(ret_value, 16) & 0x1FFFFF) >> 6
+            voltage = one_step * steps
+            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(0.5)
+    I2C_device.write_bytes(0xA0, 0xC0)
+    sleep(0.5)
+    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")
+
+
+if CHECK_EEPROM :
+    wr_rd_eeprom()
+
+if PWR_RST :
+    power(False)
+    sleep(10)
+    power(True)
+
+if SET_PLL :
+    setup_pll()
+
+if READ_LOCK:
+    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_SENSOR:
+    ccd_sensors()

Jupyter_Pages/README.md

+# Committing changes from Jupyter
+
+To commit updates when running this from a station's Jupyter Notebook, do:
+
+    ssh tangosys@station
+    cd git/tango/jupyter-notebooks/python_test_scripts/Jupyter_Pages
+
+If you cannot login as lofarsys, ask for your public key to be added to `~tangosys/.ssh/authorized_keys`. 
+
+Git commits require you to state your identity, as to know who did this commit. Do this manually each session:
+
+    export GIT_AUTHOR_NAME="Your Name"
+    export GIT_AUTHOR_EMAIL="you@astron.nl"
+    export GIT_COMMITTER_NAME="$GIT_AUTHOR_NAME"
+    export GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"
+
+    # add file(s) to commit list
+    git add <notebook>.ipynb
+
+    # do the commit
+    git commit -m "i added this very cool notebook update"
+
+    # push it to the server
+    git push
+
+If you don't provide your name and e-mail, ``git`` will tempt you to configure the name and email permanently. Doing so means all checkins from this system will be done under your name, however.
+
+To make the above easier, you could put the ``export`` commands in a personal ``myname.sh`` file which you then run in your shell using ``source myname.sh`` before running ``git commit``:
+
+    # do this once
+    cat > ~/myname_creds.sh <<HEREDOC
+    export GIT_AUTHOR_NAME="Your Name"
+    export GIT_AUTHOR_EMAIL="you@astron.nl"
+    export GIT_COMMITTER_NAME="\$GIT_AUTHOR_NAME"
+    export GIT_COMMITTER_EMAIL="\$GIT_AUTHOR_EMAIL"
+    HEREDOC
+
+    # before committing just do this
+    source ~/myname_creds.sh
+

set_ccd.py

+'''
+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 PCC_CLK
+
+'''
+import sys
+import time
+sys.path.insert(0,'.')
+import os
+if os.name =="posix":
+    from I2C_serial_pi import *
+else:
+    from I2C_serial import *
+
+I2CBUSNR=1
+sleep_time=0.05
+PWR_RST = False
+SET_PLL = True
+READ_LOCK = True
+INT_POWER_CYCLE = False
+RESET_PLL = False
+UPDATE_PLL = False
+READ_ALL = True
+
+CS   = 6
+SCLK = 4
+SDO = 5
+SDI = 7
+
+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 : 0x{0:{fill}2x} to Address : 0x{1:{fill}2x}".format(wr_data, reg_address, fill='0')
+    print(stri)
+    I2C_device.write_bytes(0x06, 0x2C)
+    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)
+
+def Read_byte_PLL(reg_address, nof_bytes=1, ADDRESS=0x20 ):
+    #
+    # Read Byte from the ADC
+    #
+    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
+
+#    print("write read command")
+
+    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:
+            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 power(state):
+    ADDRESS_IO = 0x20
+    I2C_IO_device = I2C(ADDRESS_IO, BUSNR=I2CBUSNR)
+    I2C_IO_device.write_bytes(0x06, 0x2C)
+    if state:
+        bits_to_set = 0x42
+    else:
+        bits_to_set = 0x40
+    I2C_IO_device.write_bytes(0x02, bits_to_set)
+
+
+if PWR_RST :
+    power(False)
+    sleep(1)
+    power(True)
+
+
+if INT_POWER_CYCLE :
+    print("Power OFF")
+    Write_byte_PLL(0x03, 0x88) # Device down
+    sleep(1)
+    print("Power ON")
+    Write_byte_PLL(0x03, 0x08) # Device up
+    print("Done")
+
+if RESET_PLL :
+    print("Reset PLL")
+    Write_byte_PLL(0x03, 0x0C) # Device reset
+    print("Enable PLL")
+    Write_byte_PLL(0x03, 0x08) # Device reset
+    sleep(0.1)
+    print("Done")
+
+if SET_PLL :
+    # Check PLL is in lock
+#    Read_byte_PLL(0x00, nof_bytes = 23)
+
+#    Write_byte_PLL(0x01, 0x00) # cp inv = 0xF4 other 0xE4
+#    Write_byte_PLL(0x02, 0x04) # cp inv = 0xF4 other 0xE4
+    Write_byte_PLL(0x05, 0xF0)
+    Write_byte_PLL(0x06, 0x40) # cp inv = 0xF4 other 0xE4
+    Write_byte_PLL(0x07, 0x04) # Divider R = 1 dec
+    Write_byte_PLL(0x08, 0x01)
+    Write_byte_PLL(0x07, 0x00)
+#    Write_byte_PLL(0x09, 0x10) # reset
+    Write_byte_PLL(0x0A, 0x01)
+    Write_byte_PLL(0x09, 0x00)
+#    Write_byte_PLL(0x0D, 0x02) # Dig CLK     = 200/2 = 100 MHz
+    Write_byte_PLL(0x0D, 0x01) # Dig CLK     = 200/1 = 200 MHz
+    Write_byte_PLL(0x0F, 0x01) # RCU CLK     = 200/1 = 200 MHz
+    Write_byte_PLL(0x11, 0x01) # PPS ref CLK = 200/1 = 200 MHz
+    Write_byte_PLL(0x13, 0x01) # T.P.    CLK = 200/1 = 200 MHz
+
+
+if READ_LOCK:
+    ret_value = Read_byte_PLL(0x00, nof_bytes = 1)
+    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_ALL:
+    Read_byte_PLL(0x00, nof_bytes = 23)
+
+
+if UPDATE_PLL:
+    Write_byte_PLL(0x05, 0x97)