Python ContinuousLogger.enqueue_point_now方法代码示例

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
def main():
    """ Main loop """
    il800 = intellemetrics_il800.IL800(
        "/dev/serial/by-id/" + "usb-Prolific_Technology_Inc." + "_USB-Serial_Controller_D-if00-port0"
    )
    sqm160 = inficon_sqm160.InficonSQM160("/dev/serial/by-id/usb-1a86_USB2.0-Ser_-if00-port0")

    qcm1 = QcmReader(il800)
    qcm1.start()

    qcm2 = QcmReader(sqm160)
    qcm2.start()

    time.sleep(2.5)

    codenames = [
        "pvd309_qcm1_rate",
        "pvd309_qcm1_thickness",
        "pvd309_qcm1_frequency",
        "pvd309_qcm2_rate",
        "pvd309_qcm2_thickness",
        "pvd309_qcm2_frequency",
    ]

    loggers = {}
    loggers[codenames[0]] = ValueLogger(qcm1, comp_val=0.01, comp_type="lin", channel=0)
    loggers[codenames[1]] = ValueLogger(qcm1, comp_val=0.1, comp_type="lin", channel=1)
    loggers[codenames[2]] = ValueLogger(qcm1, comp_val=1, comp_type="lin", channel=2)
    loggers[codenames[3]] = ValueLogger(qcm2, comp_val=0.3, comp_type="lin", channel=0)
    loggers[codenames[4]] = ValueLogger(qcm2, comp_val=0.1, comp_type="lin", channel=1)
    loggers[codenames[5]] = ValueLogger(qcm2, comp_val=1, comp_type="lin", channel=2)
    for name in codenames:
        loggers[name].daemon = True
        loggers[name].start()

    livesocket = LiveSocket("pvd309 qcm logger", codenames)
    livesocket.start()

    socket = DateDataPullSocket("pvd309 qcm", codenames, timeouts=[1.0] * len(codenames))
    socket.start()

    db_logger = ContinuousLogger(
        table="dateplots_pvd309",
        username=credentials.user,
        password=credentials.passwd,
        measurement_codenames=codenames,
    )
    db_logger.start()

    while qcm1.isAlive() and qcm2.isAlive():
        time.sleep(0.25)
        for name in codenames:
            value = loggers[name].read_value()
            livesocket.set_point_now(name, value)
            socket.set_point_now(name, value)
            if loggers[name].read_trigged():
                print(name + ": " + str(value))
                db_logger.enqueue_point_now(name, value)
                loggers[name].clear_trigged()

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
def main():
    """The main method for the pressure logger"""

    # Open communication to the pressure measurement unit
    tpg = TPG262(port='/dev/ttyUSB0', baudrate=9600)
    LOGGER.info('Initiated driver to TPG 262')

    # Get a continuous logger
    codenames = ['thetaprobe_pressure_loadlock', 'thetaprobe_pressure_uvgun']
    db_logger = ContinuousLogger(table='dateplots_thetaprobe',
                                 username=credentials.USERNAME,
                                 password=credentials.PASSWORD,
                                 measurement_codenames=codenames)
    db_logger.start()
    LOGGER.info('Initiated and started database logger')

    livesocket = LiveSocket(codenames, 0.2)
    livesocket.start()

    loadlock_last = {'value': 1E20, 'time': 0}
    uvgun_last = {'value': 1E20, 'time': 0}

    try:
        while True:
            # get the values: returns:
            # (value1, (status_code1, status_message1),
            # value2, (status_code2, status_message2))
            value_ll, code_ll, value_uv, code_uv = tpg.pressure_gauges()
            livesocket.set_point_now('thetaprobe_pressure_loadlock', value_ll)
            livesocket.set_point_now('thetaprobe_pressure_uvgun', value_uv)

            ### Load lock
            if code_ll[0] in [0, 1]:  # If measurement is OK or underranged
                if logging_criteria(value_ll, loadlock_last):
                    LOGGER.info('Add value {} for load lock'.format(value_ll))
                    now_ll = db_logger.enqueue_point_now(
                        'thetaprobe_pressure_loadlock',
                        value_ll)
                    loadlock_last['value'] = value_ll
                    loadlock_last['time'] = now_ll

            ### UV gun
            if code_uv[0] in [0, 1]:  # If measurement is OK or underranged
                if logging_criteria(value_uv, uvgun_last):
                    LOGGER.info('Add value {} for UV gun'.format(value_uv))
                    now_uv = db_logger.enqueue_point_now(
                        'thetaprobe_pressure_uvgun',
                        value_uv)
                    uvgun_last['value'] = value_uv
                    uvgun_last['time'] = now_uv
    except KeyboardInterrupt:
        LOGGER.info('Keyboard interrupt. Shutting down')
        db_logger.stop()
        livesocket.stop()
        LOGGER.info('Database logger stoppped. Exiting!')

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
def main():
    """Main function"""
    chiller_port = '/dev/serial/by-id/'
    chiller_port += 'usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0'

    LOG.info('Using chiller port %s', chiller_port)
    reader = ChillerReader(chiller_port)
    reader.start()
    LOG.info('ChillerReader started')

    codenames = ['sputterchamber_chiller_temperature',
                 'sputterchamber_chiller_flow',
                 'sputterchamber_chiller_temperature_ambient',
                 'sputterchamber_chiller_pressure',
                 'sputterchamber_chiller_temperature_setpoint']
    LOG.debug('Using codenames %s', codenames)
    loggers = {}
    for i in range(0, len(codenames)):
        loggers[codenames[i]] = ValueLogger(reader, comp_val=0.1, channel=i)
        loggers[codenames[i]].start()

    live_socket_name = 'Sputterchamber chiller'
    live_socket = LiveSocket(live_socket_name, codenames, 2)
    live_socket.start()
    LOG.info('Live socket init and started with name "%s"', live_socket_name)

    db_table = 'dateplots_sputterchamber'
    db_logger = ContinuousLogger(table=db_table,
                                 username=credentials.user,
                                 password=credentials.passwd,
                                 measurement_codenames=codenames)
    db_logger.start()
    LOG.info('ContinuousLogger init and started on table "%s"', db_table)

    time.sleep(5)

    while reader.isAlive():
        time.sleep(0.25)
        for name in codenames:
            value = loggers[name].read_value()
            if not math.isnan(value):
                live_socket.set_point_now(name, value)
                if loggers[name].read_trigged():
                    LOG.debug('Log value %s for codename "%s"', value, name)
                    db_logger.enqueue_point_now(name, value)
                    loggers[name].clear_trigged()

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
                self.trigged = True
                self.last_recorded_time = time.time()
                self.last_recorded_value = self.pressure

logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)

pressure_measurement = XGSClass()
pressure_measurement.start()

time.sleep(2.5)

socket = DateDataSocket(['pressure'], timeouts=[1.0])
socket.start()

#livesocket = LiveSocket(['pressure'], 2)
#livesocket.start()

db_logger = ContinuousLogger(table='dateplots_ps', username='PS', password='PS', measurement_codenames=['ps_chamber_pressure'])
db_logger.start()

while True:
    time.sleep(0.25)
    p = pressure_measurement.read_pressure()
    socket.set_point_now('pressure', p)
    #livesocket.set_point_now('pressure', p)
    if pressure_measurement.trigged:
        print(p)
        db_logger.enqueue_point_now('ps_chamber_pressure', p)
        pressure_measurement.trigged = False

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
    livesocket = LiveSocket(['chamber_pressure', 'buffer_pressure'], 2)
    livesocket.start()

    db_logger = ContinuousLogger(table='dateplots_mgw', username=credentials.user, password=credentials.passwd, measurement_codenames=['mgw_pressure_chamber', 'mgw_pressure_buffer','mgw_reactor_pressure'])
    db_logger.start()
    time.sleep(5)
    while True:
        c = chamber_logger.read_pressure()
        b = buffer_logger.read_pressure()
        r = reactor_logger.value
        socket.set_point_now('chamber_pressure', c)
        socket.set_point_now('buffer_pressure', b)
        livesocket.set_point_now('chamber_pressure', c)
        livesocket.set_point_now('buffer_pressure', b)

        if reactor_logger.trigged:
            print(r)
            db_logger.enqueue_point_now('mgw_reactor_pressure', r)
            reactor_logger.trigged = False

        if chamber_logger.trigged:
            print(c)
            db_logger.enqueue_point_now('mgw_pressure_chamber', c)
            chamber_logger.trigged = False

        if buffer_logger.trigged:
            print(b)
            db_logger.enqueue_point_now('mgw_pressure_buffer', b)
            buffer_logger.trigged = False

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
logger = ValueLogger(flowreader, comp_val=0.1)
logger.start()

name = 'stm312_xray_waterflow'
codenames = ['stm312_xray_waterflow']
socket = DateDataPullSocket(name, codenames, timeouts=[1.0])
socket.start()

live_socket = LiveSocket(name, codenames, 2)
live_socket.start()

db_logger = ContinuousLogger(table='dateplots_stm312',
                             username=credentials.user,
                             password=credentials.passwd,
                             measurement_codenames=codenames)
db_logger.start()

time.sleep(2)

while True:
    time.sleep(0.25)
    flow = logger.read_value()
    socket.set_point_now(name, flow)
    live_socket.set_point_now(name, flow)
    if logger.read_trigged():
        print flow
        db_logger.enqueue_point_now(name, flow)
        logger.clear_trigged()

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
class MainTui(threading.Thread):
    """ Temperature reader """
    def __init__(self,):
        threading.Thread.__init__(self)
        #from mytui import CursesTui
        self.quit = False
        self.codenames = ['tabs_guard_temperature_setpoint',
                     'tabs_floor_temperature_setpoint',
                     'tabs_ceiling_temperature_setpoint',
                     'tabs_cooling_temperature_setpoint',
                     ]
        sockname = 'tabs_setpoints'
        self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
        self.PullSocket.start()
        
        self.TUI = CursesTui(self.codenames)
        self.TUI.start()
        #time.sleep(5)
        
        chlist = {'tabs_guard_temperature_setpoint': 0,
                  'tabs_floor_temperature_setpoint': 1,
                  'tabs_ceiling_temperature_setpoint': 2,
                  'tabs_cooling_temperature_setpoint': 3}
        self.loggers = {}
        for key in self.codenames:
            self.loggers[key] = ValueLogger(self.TUI, comp_val = 0.2, maximumtime=60,
                                            comp_type = 'lin', channel = chlist[key])
            self.loggers[key].start()
        #livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
        #livesocket.start()
        
        
        
        self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
        #print('Hostname of db logger: ' + db_logger.host)
        self.db_logger.start()
    
    def run(self):
        i = 0
        while not self.quit:
            #print(i)
            if self.TUI.isAlive():
                pass
            else:
                print('TUI has shutdown')
                self.quit = True
            try:
                #print(i)
                time.sleep(2)
                for name in self.codenames:
                    v = self.loggers[name].read_value()
                    #print('Status: ', name , v)
                    #livesocket.set_point_now(name, v)
                    self.PullSocket.set_point_now(name, v)
                    if self.loggers[name].read_trigged():
                        #if __name__ == '__main__':
                        #    print('Log: ', i, name, v)
                        #print('Log: ', name, v)
                        self.db_logger.enqueue_point_now(name, v)
                        self.loggers[name].clear_trigged()
            except:
                print('run error')
                pass
                #self.TUI.stop()
                #report error and proceed
            i += 1
        self.stop()
        
    def stop(self):
        self.quit = True
        self.TUI.stop()
        self.PullSocket.stop()
        self.db_logger.stop()
        for key in self.codenames:
            self.loggers[key].status['quit'] = True

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
class MainPID(threading.Thread):
    """ pid controller """
    def __init__(self,):
        logging.info('MainPID class started')
        threading.Thread.__init__(self)
        #from datalogger import TemperatureReader
        self.quit = False
        self.codenames = ['tabs_guard_pid_value',
                 'tabs_floor_pid_value',
                 'tabs_ceiling_pid_value',
                 'tabs_cooling_pid_value',
                 
                 'tabs_guard_valve_heating',
                 'tabs_floor_valve_heating',
                 'tabs_ceiling_valve_heating',
                 
                 'tabs_guard_valve_cooling',
                 'tabs_floor_valve_cooling',
                 'tabs_ceiling_valve_cooling',
                 'tabs_cooling_valve_cooling',
                 ]
        sockname = 'tabs_pids'
        self.PullSocket = DateDataPullSocket(sockname, self.codenames, timeouts=[60.0]*len(self.codenames), port = socketinfo.INFO[sockname]['port'])
        self.PullSocket.start()
    
        self.PTC = PidTemperatureControl(self.codenames)
        self.PTC.daemon = True
        self.PTC.start()
        #time.sleep(5)
    
        chlist = {'tabs_guard_pid_value': 0,
                  'tabs_floor_pid_value': 1,
                  'tabs_ceiling_pid_value': 2,
                  'tabs_cooling_pid_value': 3,
                  
                  'tabs_guard_valve_heating': 4,
                  'tabs_floor_valve_heating': 5,
                  'tabs_ceiling_valve_heating': 6,
                  
                  'tabs_guard_valve_cooling': 7,
                  'tabs_floor_valve_cooling': 8,
                  'tabs_ceiling_valve_cooling': 9,
                  'tabs_cooling_valve_cooling': 10}
        self.loggers = {}
        for key in self.codenames:
            self.loggers[key] = ValueLogger(self.PTC, comp_val = 0.10, maximumtime=60,
                                        comp_type = 'lin', channel = chlist[key])
            self.loggers[key].start()
        #livesocket = LiveSocket('tabs_temperature_logger', codenames, 2)
        #livesocket.start()

    
        self.db_logger = ContinuousLogger(table='dateplots_tabs', username=credentials.user, password=credentials.passwd, measurement_codenames=self.codenames)
        self.db_logger.start()

    def run(self,):
        i = 0
        while not self.quit and self.PTC.isAlive():
            try:
                #print(i)
                time.sleep(1)
                for name in self.codenames:
                    v = self.loggers[name].read_value()
                    #print('Status: ', name , v)
                    #livesocket.set_point_now(name, v)
                    self.PullSocket.set_point_now(name, v)
                    if self.loggers[name].read_trigged():
                        if __name__ == '__main__':
                            print('Log: ', i, name, v)
                        #print(i, name, v)
                        self.db_logger.enqueue_point_now(name, v)
                        self.loggers[name].clear_trigged()
            except (KeyboardInterrupt, SystemExit):
                self.quit = True
                pass
                #self.PTC.stop()
                #report error and proceed
            i += 1
        self.stop()

    def stop(self):
        self.quit = True
        self.PTC.stop()
        self.PullSocket.stop()
        self.db_logger.stop()
        for key in self.codenames:
            self.loggers[key].status['quit'] = True

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
logging.basicConfig(level=logging.ERROR)

pc_measurement = PcClass()
pc_measurement.start()

pressure_measurement = PiraniClass()
pressure_measurement.start()

time.sleep(2)

datasocket = DateDataSocket(['pirani', 'pc'], timeouts=[1.0, 1.0])
datasocket.start()

db_logger = ContinuousLogger(table='dateplots_stm312', username='stm312', password='stm312', measurement_codenames=['stm312_pirani', 'stm312_pc'])
db_logger.start()

while True:
    pirani = pressure_measurement.read_pressure()
    pc = pc_measurement.read_pressure()
    datasocket.set_point_now('pirani', pirani)
    datasocket.set_point_now('pc', pc)
    if pressure_measurement.trigged:
        print(pirani)
        db_logger.enqueue_point_now('stm312_pirani', pirani)
        pressure_measurement.trigged = False

    if pc_measurement.trigged:
        print(pc)
        db_logger.enqueue_point_now('stm312_pc', pc)
        pc_measurement.trigged = False

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
                                port=9000)
Datasocket.start()

Pushsocket = DataPushSocket(unichr(0x03BC) + '-reactor_mfc_control',
                            action='enqueue')
Pushsocket.start()
Livesocket = LiveSocket(unichr(0x03BC) + '-reactor_mfc_control', devices, 1)
Livesocket.start()

fc = FlowControl(MFCs, Datasocket, Pushsocket, Livesocket)
fc.start()

Logger = ValueLogger(fc, comp_val=1, comp_type='log', low_comp=0.0001)
Logger.start()

codename = 'microreactorng_pressure_reactor'
db_logger = ContinuousLogger(table='dateplots_microreactorNG',
                             username=credentials.user,
                             password=credentials.passwd,
                             measurement_codenames=[codename])
db_logger.start()

while True:
    time.sleep(0.25)
    v = Logger.read_value()
    if Logger.read_trigged():
        print v
        db_logger.enqueue_point_now(codenam, v)
        Logger.clear_trigged()

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
            val_trigged = not (self.last_recorded_value * 0.9 < self.pressure < self.last_recorded_value * 1.1)
            if self.pressure < 0.01:
                val_trigged = False
            if (time_trigged or val_trigged):
                self.trigged = True
                self.last_recorded_time = time.time()
                self.last_recorded_value = self.pressure

logging.basicConfig(filename="logger.txt", level=logging.ERROR)
logging.basicConfig(level=logging.ERROR)

pressure_measurement = BaratronClass()
pressure_measurement.start()

time.sleep(2)

datasocket = DateDataSocket(['baratron'], timeouts=[1.0])
datasocket.start()

db_logger = ContinuousLogger(table='dateplots_stm312', username='stm312', password='stm312', measurement_codenames=['stm312_hp_baratron'])
db_logger.start()

while True:
    time.sleep(1)
    baratron = pressure_measurement.read_pressure()
    datasocket.set_point_now('baratron', baratron)
    if pressure_measurement.trigged:
        print(baratron)
        db_logger.enqueue_point_now('stm312_hp_baratron', baratron)
        pressure_measurement.trigged = False

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
Sniffer_Logger = ValueLogger(fc, comp_val=1, comp_type='log', low_comp=0.0001, channel=2)
Sniffer_Logger.start()


db_logger = ContinuousLogger(table='dateplots_microreactor',
                             username=credentials.user,
                             password=credentials.passwd,
                             measurement_codenames=['mr_reactor_pressure'])
db_logger.start()

db_logger_sniffer = ContinuousLogger(table='dateplots_sniffer',
                                     username=credentials_sniffer.user,
                                     password=credentials_sniffer.passwd,
                                     measurement_codenames=['sniffer_chip_pressure'])
db_logger_sniffer.start()
time.sleep(5)
while True:
    time.sleep(0.25)
    v = Logger.read_value()
    if Logger.read_trigged():
        print v
        db_logger.enqueue_point_now('mr_reactor_pressure', v)
        Logger.clear_trigged()

    s = Sniffer_Logger.read_value()
    if Sniffer_Logger.read_trigged():
        print s
        db_logger_sniffer.enqueue_point_now('sniffer_chip_pressure', s)
        Sniffer_Logger.clear_trigged()

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
                                 username=credentials.user,
                                 password=credentials.passwd,
                                 measurement_codenames=['fr307_furnace_1_T',
                                                        'fr307_furnace_2_T'])

    ports = {}
    ports[1] = 'usb-FTDI_USB-RS485_Cable_FTWGRL9C-if00-port0'
    ports[2] = 'usb-FTDI_USB-RS485_Cable_FTWGRN2W-if00-port0'
    furnaces = {}
    loggers = {}
    for i in [1, 2]:
        print i
        furnaces[i] = TemperatureReader(ports[i])
        furnaces[i].daemon = True
        furnaces[i].start()
        loggers[i] = TemperatureLogger(furnaces[i])
        loggers[i].start()

    db_logger.start()
    time.sleep(5)
    values = {}
    while True:
        time.sleep(0.1)
        for i in [1, 2]:
            values[i] = loggers[i].read_value()
            datasocket.set_point_now('T' + str(i), values[i])
            if loggers[i].trigged:
                print 'Furnace: ' + str(i) + ': ' + str(values[i])
                db_logger.enqueue_point_now('fr307_furnace_' + str(i) + '_T', values[i])
                loggers[i].trigged = False

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
pressurereader.daemon = True
pressurereader.start()

logger = ValueLogger(pressurereader, comp_val = 0.5)
logger.start()

socket = DateDataPullSocket('hall_n5_argon_pressure',
                            ['n5_argon_pressure'], timeouts=[1.0])
socket.start()

live_socket = LiveSocket('hall_n5_argon_pressure', ['n5_argon_pressure'], 2)
live_socket.start()

db_logger = ContinuousLogger(table='dateplots_hall',
                                 username=credentials.user,
                                 password=credentials.passwd,
                                 measurement_codenames=['n5_argon_pressure'])
db_logger.start()

time.sleep(2)

while True:
    time.sleep(0.25)
    p = logger.read_value()
    socket.set_point_now('n5_argon_pressure', p)
    live_socket.set_point_now('n5_argon_pressure', p)
    if logger.read_trigged():
        print p
        db_logger.enqueue_point_now('n5_argon_pressure', p)
        logger.clear_trigged()

# 需要导入模块: from PyExpLabSys.common.loggers import ContinuousLogger [as 别名]
# 或者: from PyExpLabSys.common.loggers.ContinuousLogger import enqueue_point_now [as 别名]
                                port=9000)
Datasocket.start()

Pushsocket = DataPushSocket('sniffer_mfc_control', action='enqueue')
Pushsocket.start()
Livesocket = LiveSocket('sniffer_mfc_control', devices)
Livesocket.start()

fc = FlowControl(MFCs, Datasocket, Pushsocket, Livesocket)
fc.start()

Logger = ValueLogger(fc, comp_val=1, comp_type='log', low_comp=0.0001, channel=1)
Logger.start()

db_logger = ContinuousLogger(table='dateplots_sniffer',
                             username=credentials.user,
                             password=credentials.passwd,
                             measurement_codenames=['sniffer_chip_pressure'])
db_logger.start()

time.sleep(5)
while True:
    time.sleep(0.25)
    v = Logger.read_value()
    if Logger.read_trigged():
        print v
        db_logger.enqueue_point_now('sniffer_chip_pressure', v)
        Logger.clear_trigged()