KALYPSO2_5_GUI/offset_value_gen.py

import numpy as np
import sys
import matplotlib.pyplot as plt
import matplotlib as mpl
from scipy import signal
import scipy.integrate as spi
from scipy import asarray as ar, exp, sqrt
from scipy.optimize import curve_fit
#from astropy import modeling


pixels = 512*2
TAIL = [0xba98,0xfedc]*16
DEAD = [0xdea1,0xdead,0xdea2,0xdead,0xdea3,0xdead,0xdea4,0xdead,0xdea5,0xdead,0xdea6,0xdead,0xdea7,0xdead,0xdea8,0xdead]

def strip_data(filename, number_pixels, orbits, offset = None):
        global data

        ###############----------Read data from memory----------############################################
        np.set_printoptions(threshold='nan')
        data = np.fromfile(str(filename), dtype=np.uint16)
        #if offset is None:
        # data = np.memmap( str(filename), dtype=np.dtype('<u2'), mode='r')
        #else:
        #    data = np.memmap( str(filename), dtype=np.dtype('<u2'), offset = (2*pixels*offset),mode='r')


        ###############----------Remove Header----------####################################################

        if (data[0] == 0x1111 and data[15] == 0xF888):
            print ('Removing header .....')
            data = data[16:]
        else:
            print ('No data header....')
            data = data

        ##############--------Search and remove for TAIL--------############################################
        offset = 0
        tailoffset = offset
        while np.any((data[tailoffset : tailoffset + len(TAIL)] != TAIL)):
            tailoffset += 8
            if tailoffset + len(TAIL) > len(data):
                print('Could not find tail')
                sys.exit(-1)
        print('Found tail at offset ' + str(tailoffset))

        ##############--------Search and remove for DEAD filling--------##################################
        deadcnt = 0
        deadoffset = tailoffset
        while np.any(data[deadoffset - len(DEAD) : deadoffset] == DEAD):
            deadcnt +=1
            deadoffset -= len(DEAD)

        print('Removed %d bytes of DEAD' %(deadcnt))

        ##############--------Set the pure data --------###################################################

        data = np.frombuffer((data[offset:deadoffset]), dtype = np.uint16)

        #dead = np.where(data == 0xdea1)
        #loc = np.amin(dead)
        #data = data[0:loc]

        ############-------Swap the data bytes and change from 16 bit to 14 bit---------####################

        data = data.byteswap()
        data = data >> 2

        #############---------Index decoder for the jesd data for 16 input mode----------###################
        odd_inner_idx_1 = [23,22,7,6,21,20,5,4,19,18,3,2,17,16,1,0] # working one
        odd_inner_idx_2 = [8,9,24,25,10,11,26,27,12,13,28,29,14,15,30,31]    # non interleaved

        odd_index_1 = np.zeros([256], dtype=np.int64)
        odd_index_2 = np.zeros([256], dtype=np.int64)
        for i in range(16):
            for j in range(16):
                odd_index_1[i * 16 + j] = odd_inner_idx_1[i] +  j * 64

        for i in range(16):
            for j in range(16):
                odd_index_2[i * 16 + j] = odd_inner_idx_2[i] +  j * 64


        even_inner_idx_1 = [55,54,39,38,53,52,37,36,51,50,35,34,49,48,33,32] # working one
        even_inner_idx_2 = [40,41,56,57,42,43,58,59,44,45,60,61,46,47,62,63]    # non interleaved

        even_index_1 = np.zeros([256], dtype=np.int64)
        even_index_2 = np.zeros([256], dtype=np.int64)
        for i in range(16):
            for j in range(16):
                even_index_1[i * 16 + j] = even_inner_idx_1[i] +  j * 64

        for i in range(16):
            for j in range(16):
                even_index_2[i * 16 + j] = even_inner_idx_2[i] +  j * 64


        ################------working part---------###########################################################
        #index_interleave = np.ravel(np.column_stack((index_1,index_2)))  #interleaving the pixels, NOTE: interchange index_1 & index_2 if the pixels are swapped
        #k = 32
        #pixel_map = []
        #a = index_interleave

        #for i in range(0, len(a), k):
        #    pixel_map.extend((a[i:i + k])[::-1])
        ######################################################################################################
        l = 16
        odd_adc_2 = []
        odd_b = odd_index_2
        for i in range(0, len(odd_b), l):
            odd_adc_2.extend((odd_b[i:i + l])[::-1])

        even_adc_2 = []
        even_b = even_index_2
        for i in range(0, len(even_b), l):
            even_adc_2.extend((even_b[i:i + l])[::-1])

        #index_interleave = np.concatenate((odd_index_1,odd_adc_2),axis = 0)    # for concatenated pixels
        #odd_index_interleave = np.concatenate((odd_index_1,odd_adc_2),axis = 0)    # for concatenated pixels
        #even_index_interleave = np.concatenate((even_index_1,even_adc_2),axis = 0)    # for concatenated pixels

        #odd_index_interleave = np.ravel(np.column_stack((odd_index_1,odd_adc_2)))    # for interleaved pixels
        #even_index_interleave = np.ravel(np.column_stack((even_index_1,even_adc_2)))    # for interleaved pixels

        #splitting the even part of the ADC since on the sensor they belong to the outer 256 x 2
        #even_index_interleave_left = even_index_interleave[0:256]
        #even_index_interleave_right = even_index_interleave[256:512]

        #splitting the even part of the ADC since on the sensor they belong to the outer 256 x 2
        odd_left_1 = odd_index_1[0:128]
        odd_right_1 = odd_index_1[128:256]

        odd_left_2 = odd_adc_2[0:128]
        odd_right_2 = odd_adc_2[128:256]

        #final_1024_index = np.concatenate((even_index_interleave_left,odd_index_interleave,even_index_interleave_right),axis = 0)
        #######################
        final_1024_index = np.concatenate((odd_left_1,even_index_1,odd_right_1,odd_left_2,even_adc_2,odd_right_2),axis = 0)  # for concatenated pixels

        ##############-------------Reshape the data as pixel x orbits-------------------###################
        if (orbits):
            data = data[0:orbits*512*2]

        data = np.reshape(data,(-1,pixels))

        data = data[:,final_1024_index]

        orb, pix = np.shape(data)

        return (data, orb)





strip_data('f12345_2020-09-07T16h14m21s_Si01_m.bin',1024,1)
np.set_printoptions(formatter={'int':hex})

pixel_num = np.arange(1,513,1)
modulated_data = data.astype(np.uint16)
orbits, pixels = np.shape(modulated_data)
ad = np.transpose(modulated_data)
offset_to = ad - ad + 850
offset_value = ad - offset_to

x = 16

print('ADC1 0x90A0')
###########
print('Register 38 is',offset_value[4,:])  #D/E
print('Register 36 is',offset_value[4+x,:])  #F/10
print('Register 34 is',offset_value[4+2*x,:])  #11/12
print('Register 32 is',offset_value[4+3*x,:])  #13/14

print('Register 2C is',offset_value[4+4*x,:])  #19/1A
print('Register 2A is',offset_value[4+5*x,:])  #1B/1C
print('Register 28 is',offset_value[4+6*x,:]) #1D/1E
print('Register 26 is',offset_value[4+7*x,:]) #1F/20
###########
print('Register 37 is',offset_value[4+8*x,:])  #D/E
print('Register 35 is',offset_value[4+9*x,:])  #F/10
print('Register 33 is',offset_value[4+10*x,:])  #11/12
print('Register 31 is',offset_value[4+11*x,:])  #13/14

print('Register 2B is',offset_value[4+12*x,:])  #19/1A
print('Register 29 is',offset_value[4+13*x,:])  #1B/1C
print('Register 27 is',offset_value[4+14*x,:]) #1D/1E
print('Register 25 is',offset_value[4+15*x,:]) #1F/20

print('Register 1F is',offset_value[4+16*x,:]) #25/26
print('Register 1D is',offset_value[4+17*x,:]) #27/28
print('Register 1B is',offset_value[4+18*x,:]) #29/2A
print('Register 19 is',offset_value[4+19*x,:]) #2B/2C

print('Register 13 is',offset_value[4+20*x,:]) #31/32
print('Register 11 is',offset_value[4+21*x,:]) #33/34
print('Register F is' ,offset_value[4+22*x,:]) #35/36
print('Register D is'  ,offset_value[4+23*x,:]) #37/38
###########
print('Register 20 is',offset_value[4+24*x,:]) #25/26
print('Register 1E is',offset_value[4+25*x,:]) #27/28
print('Register 1C is',offset_value[4+26*x,:]) #29/2A
print('Register 1A is',offset_value[4+27*x,:]) #2B/2C

print('Register 14 is',offset_value[4+28*x,:]) #31/32
print('Register 12 is',offset_value[4+29*x,:]) #33/34
print('Register 10 is' ,offset_value[4+30*x,:]) #35/36
print('Register  E is'  ,offset_value[4+31*x,:]) #37/38
###################################################################
print('ADC2 0x90A4')

print('Register E is'  ,offset_value[4+32*x,:]) #D/E
print('Register 10 is' ,offset_value[4+33*x,:]) #F/10
print('Register 12 is',offset_value[4+34*x,:]) #11/12
print('Register 14 is',offset_value[4+35*x,:]) #13/14

print('Register 1A is',offset_value[4+36*x,:]) #19/1A
print('Register 1C is',offset_value[4+37*x,:]) #1B/1C
print('Register 1E is',offset_value[4+38*x,:]) #1D/1E
print('Register 20 is',offset_value[4+39*x,:]) #1F/20

print('Register D is'  ,offset_value[4+40*x,:]) #D/E
print('Register F is' ,offset_value[4+41*x,:]) #F/10
print('Register 11 is',offset_value[4+42*x,:]) #11/12
print('Register 13 is',offset_value[4+43*x,:]) #13/14

print('Register 19 is',offset_value[4+44*x,:]) #19/1A
print('Register 1B is',offset_value[4+45*x,:]) #1B/1C
print('Register 1D is',offset_value[4+46*x,:]) #1D/1E
print('Register 1F is',offset_value[4+47*x,:]) #1F/20

print('Register 25 is',offset_value[4+48*x,:]) #25/26
print('Register 27 is',offset_value[4+49*x,:]) #27/28
print('Register 29 is',offset_value[4+50*x,:]) #29/2A
print('Register 2B is',offset_value[4+51*x,:]) #2B/2C

print('Register 31 is',offset_value[4+52*x,:]) #31/32
print('Register 33 is',offset_value[4+53*x,:]) #33/34
print('Register 35 is',offset_value[4+54*x,:]) #35/36
print('Register 37 is',offset_value[4+55*x,:]) #37/38

print('Register 26 is',offset_value[4+56*x,:]) #25/26
print('Register 28 is',offset_value[4+57*x,:]) #27/28
print('Register 2A is',offset_value[4+58*x,:]) #29/2A
print('Register 2C is',offset_value[4+59*x,:]) #2B/2C

print('Register 32 is',offset_value[4+60*x,:]) #31/32
print('Register 34 is',offset_value[4+61*x,:]) #33/34
print('Register 36 is',offset_value[4+62*x,:]) #35/36
print('Register 38 is',offset_value[4+63*x,:]) #37/38

plt.show()