Пример #1
0
    def __init__(self, hostname="ppmac1", port=50000):
        self.logger = logging.getLogger('ppmacConsumer')
        self.logger.setLevel(logging.DEBUG)
        self.hostname = hostname
        self.port = port

        #setup threads for data logging
        self.logging_block = threading.Event() 
        self.logging_block.set()
        self.logging_lock = threading.Lock()
        self.conn = tcpClient(self.hostname, self.port)

        self.data = ""
        self.log_data_flag = False      
        self.buffer_len = 1000

        self.setup_motors()
        self.coord = ppmacCoord("main")
    def __init__(self, hostname="localhost", port=50001):
        self.logger = logging.getLogger('bbClient')
        self.logger.setLevel(logging.DEBUG)
        self.conn = tp.tcpClient(hostname,port,terminator="\r\n")
        self.local_terminator = "\r\n"

        self.drain = []
        self.drain.append({"V" : 0, "I" : 0})
        self.drain.append({"V" : 0, "I" : 0})
        self.drain.append({"V" : 0, "I" : 0})
        self.drain.append({"V" : 0, "I" : 0})

        self.gatea = []
        self.gatea.append({"V" : 0, "I" : 0})
        self.gatea.append({"V" : 0, "I" : 0})
        self.gatea.append({"V" : 0, "I" : 0})
        self.gatea.append({"V" : 0, "I" : 0})

        self.gateb = []
        self.gateb.append({"V" : 0, "I" : 0})
        self.gateb.append({"V" : 0, "I" : 0})
        self.gateb.append({"V" : 0, "I" : 0})
        self.gateb.append({"V" : 0, "I" : 0})
    def spectro_collect_data(self):
        self.spectro_event.clear()
        self.spectro_conn = tcpClient(self.hostname, self.spectro_port)

        self.spectro_conn.send("g")
        while not self.spectro_event.isSet():
            self.spectro_conn.recv_nbytes(4)
            data = self.spectro_conn.data_message
            no_samples = struct.unpack(">I",data)[0]
            for i in xrange(no_samples):
                self.spectro_conn.recv_nbytes(4112)
                data = self.spectro_conn.data_message
                tmp_data = struct.unpack(">128q128q128q128qdII",data)

                self.spectro_lock.acquire()
                self.dl.data_lock.acquire()
                self.spectro_frame = tmp_data[-1]
                self.a_pow = struct.unpack(">128Q",data[0:1024])
                self.b_pow = struct.unpack(">128Q", data[1024:2048])
                self.ab_real = struct.unpack(">128q", data[2048:3072])
                self.ab_imag = struct.unpack(">128q", data[3072:4096])
                self.spectro_timestamp = struct.unpack(">d", data[4096:4104])[0]
                self.spectro_frame = struct.unpack(">I", data[4104:4108])[0]
                self.tick = struct.unpack(">I", data[4108:4112])[0]

              
                self.dl.frame_buffer.append(self.spectro_frame)
                self.dl.tick_buffer.append(self.tick)
                self.dl.a_pow_buffer.append(self.a_pow)
                self.dl.b_pow_buffer.append(self.b_pow)
                self.dl.real_buffer.append(self.ab_real)
                self.dl.imag_buffer.append(self.ab_imag)

                if self.normalize is True:                    
                    self.a_pow = array(self.a_pow)/(self.acc_len*16)
                    self.b_pow = array(self.b_pow)/(self.acc_len*16)
                    self.ab_real = array(self.ab_real)/(self.acc_len*16)
                    self.ab_imag = array(self.ab_imag)/(self.acc_len*16)

                    
                corr_data = array(self.ab_real) + 1j*array(self.ab_imag)
                self.magnitude = abs(corr_data)
                
                if self.unwrap is True:
                    self.phase = unwrap(angle(corr_data))
                else:
                    self.phase = angle(corr_data)


                self.b_pow_ave.append(self.b_pow)
                self.a_pow_ave.append(self.a_pow)
                self.mag_ave.append(self.magnitude)
                self.phase_ave.append(self.phase)

                self.dl.data_lock.release()
                self.spectro_lock.release()
            time.sleep(0.1)
            self.spectro_conn.send("c")
            
            self.spectro_lock.acquire()
            self.ave_ch0_power = mean(self.a_pow_ave,axis=0)
            self.ave_ch1_power = mean(self.b_pow_ave,axis=0)
            self.ave_phase = mean(self.phase_ave,axis=0)
            self.ave_mag= mean(self.mag_ave,axis=0)

            #Catch exception if not enough entries
            try:
                self.dc_ch0_power = mean(ma.array(self.ave_ch0_power,mask=self.chan_mask))
                self.dc_ch1_power = mean(ma.array(self.ave_ch1_power,mask=self.chan_mask))
                self.dc_phase = mean(ma.array(self.ave_phase,mask=self.chan_mask))
                self.dc_mag= mean(ma.array(self.ave_mag,mask=self.chan_mask))
            except:
                pass

            self.spectro_lock.release()
            

        self.spectro_conn.sen("s") #stop 
        self.spectro_conn.close()
 def __init__(self, hostname="bbone", port=50020):
     self.logger = logging.getLogger('zx76_31Client')
     self.logger.setLevel(logging.DEBUG)
     self.conn = tp.tcpClient(hostname,port,terminator="\r\n")
     self.local_terminator = "\r\n"