def start_measurement(self, comment):
""" Start a measurement """
data_set_saver = DataSetSaver("measurements_dummy", "xy_values_dummy",
"dummy", "dummy")
data_set_saver.start()
data_set_time = time.time()
metadata = {
"Time": CustomColumn(data_set_time, "FROM_UNIXTIME(%s)"),
"comment": comment,
"type": 65,
"preamp_range": 9,
"sem_voltage": -1
}
labels = [
"2W Heater 1", "2W Heater 2", "2W RTD Source", "2W RTD Sense",
"Short circuit check", "RTD Source Sense Left",
"RTD Source Sense Right", "4W RTD", "Temperature", "Temperature 2"
]
for label in labels:
metadata["mass_label"] = label
data_set_saver.add_measurement(label, metadata)
for i in range(0, 99999999):
self.update_values()
for label in labels:
print(
str(i) + ': Channel: ' + label + ': ' +
str(self.data[label]))
data_set_saver.save_point(
label, (time.time() - data_set_time, self.data[label]))
time.sleep(1)
def db_saver(self):
"""Autoclosing db_saver yield_fixture"""
# Init db_saver
db_saver = DataSetSaver('measurements_dummy', 'xy_values_dummy',
'dummy', 'dummy')
db_saver.start()
yield db_saver
db_saver.stop()
def __init__(self):
# Initialize power supply
# Initialize flow meter driver
"""Try to connect to the COM port of the flow meter and ask for the serial number"""
print("Try and connect to red flow meter")
try:
self.red_flow_meter = RedFlowMeter(ramp.RED_FLOW_METER_COM_PORT,
slave_address=2)
except SerialException:
message = 'Cannot find red flow meter on {}'.format(
ramp.RED_FLOW_METER_COM_PORT)
raise RuntimeError(message)
# Test serial number reply
if self.red_flow_meter.read_value('serial') != 181787:
raise RuntimeError('Incorrect reply to serial number')
# Print actual flow value
print(self.red_flow_meter.read_value('fluid_name'),
self.red_flow_meter.read_value('flow'))
self.red_flow_meter.set_address(247)
print(self.red_flow_meter.read_value('fluid_name'),
self.red_flow_meter.read_value('flow'))
# Try to conect to power supply
print("Try and connect to power supply")
try:
self.cpx = CPX400DPDriver(output=1,
interface='serial',
device=ramp.POWER_SUPPLY_COM_PORT)
except SerialException:
message = 'Cannot find power supply on {}'.format(
ramp.POWER_SUPPLY_COM_PORT)
raise RuntimeError(message)
if 'CPX400DP' not in self.cpx.read_software_version():
raise RuntimeError('Incorrect software version reply')
pass
# Print the set point voltage
print("The voltage set point is {}".format(
self.cpx.read_set_voltage()))
self.ramp = ramp.RAMP
self.metadata = ramp.metadata
self.verify_ramp()
self.data_set_saver = DataSetSaver(
'measurements_large_CO2_MEA',
'xy_values_large_CO2_MEA',
credentials.USERNAME,
credentials.PASSWORD,
)
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.settimeout(0.1)
self.host = ramp.RASPPI_HOST
self.port = ramp.RASSPI_PORT
self.message = 'json_wn#' + json.dumps({'no_voltages_to_set': True})
def __init__(self, mux, smu, comment, user):
self.data_set_saver = DataSetSaver("measurements_" + user,
"xy_values_" + user, user, user)
self.data_set_saver.start()
self.data_set_time = time.time() # Update for each scan...
self.comment = comment
self.mux = mux
self.smu = smu
mux.scpi_comm(
'INSTRUMENT:DMM OFF') # Turn off DMM to allow use as mux device
self.smu.set_current_limit(0.01) # Current limit, 10mA
self.smu.set_current_measure_range(
current_range=0.01) # Measurement range 10mA
self.smu.set_integration_time(1)
def __init__(self, hostname, anode):
threading.Thread.__init__(self)
self.agilent = agilent_34972A.Agilent34972ADriver(interface='lan',
hostname=hostname)
self.calib = 500 # Analyser voltage pr. input voltage
self.chamber_name = "dummy"
self.data_set_saver = DataSetSaver("measurements_" + self.chamber_name,
"xy_values_" + self.chamber_name,
credentials.user,
credentials.passwd)
self.data_set_saver.start()
if anode == 'Mg':
self.x_ray = 1253.44
if anode == 'Al':
self.x_ray = 1487.0
def init_logging(self):
if self.log_data:
self.comment = 'Run'
self.data_set_saver = DataSetSaver('measurements_mailscan',
'xy_values_mailscan',
credentials.user,
credentials.passwd)
self.data_set_saver.start()
# PyExpLabSys does does not excell in db-normalization - add
# metadata to all channels
metadata = {
"Time": CustomColumn(self.start_time, "FROM_UNIXTIME(%s)"),
"comment": self.comment,
"type": 1,
"label": None,
"processes": self.number_of_threads()[1]
}
metadata['label'] = 'Avg export speed'
self.data_set_saver.add_measurement(metadata['label'], metadata)
metadata['label'] = 'Total export size'
self.data_set_saver.add_measurement(metadata['label'], metadata)
metadata['label'] = 'Total users'
self.data_set_saver.add_measurement(metadata['label'], metadata)
metadata['label'] = 'Total memory'
self.data_set_saver.add_measurement(metadata['label'], metadata)
metadata['label'] = 'Total CPU'
self.data_set_saver.add_measurement(metadata['label'], metadata)
metadata['label'] = 'Total Mails'
self.data_set_saver.add_measurement(metadata['label'], metadata)
for scanner in self.amqp_messages.keys():
if scanner == 'global':
continue
metadata['processes'] = 1
metadata['label'] = '{} memory'.format(scanner)
self.data_set_saver.add_measurement(metadata['label'],
metadata)
metadata['label'] = '{} exported users'.format(scanner)
self.data_set_saver.add_measurement(metadata['label'],
metadata)
def __init__(self, args):
super(VoltageCurrentProgram, self).__init__()
# Form channel_id e.g: EA1
self.channel_id = args.power_supply + args.output
### Required by the stepped program runner
# Accepted capabilities are: can_edit, can_play,
# can_stop, can_quit
self.capabilities = ('can_stop', 'can_start', 'can_edit')
# Status fields (in order)
self.status_fields = (
# Status
{
'codename': 'status_field',
'title': 'Status'
},
# Voltage
{
'codename': self.channel_id + '_voltage',
'title': 'Voltage',
'formatter': '{:.3f}',
'unit': 'V'
},
# Voltage setpoint
{
'codename': self.channel_id + '_voltage_setpoint',
'title': 'Voltage Setpoint',
'formatter': '{:.3f}',
'unit': 'V'
},
# Current
{
'codename': self.channel_id + '_current',
'title': 'Current',
'formatter': '{:.3f}',
'unit': 'A'
},
# Current limit
{
'codename': self.channel_id + '_current_limit',
'title': 'Current limit',
'formatter': '{:.3f}',
'unit': 'A'
},
# Charge
{
'codename': self.channel_id + '_accum_charge',
'title': 'Accumulated charge',
'formatter': '{:.3f}',
'unit': 'C'
},
# Time elapsed (step)
{
'codename': 'elapsed',
'title': 'Time elapsed (step)',
'formatter': '{:.1f}',
'unit': 's'
},
# Time remaining (step)
{
'codename': 'remaining',
'title': 'Time remaining (step)',
'formatter': '{:.1f}',
'unit': 's'
},
# Time elapsed (total)
{
'codename': 'elapsed_total',
'title': 'Time elapsed (total)',
'formatter': '{:.1f}',
'unit': 's'
},
# Time remaining (total)
{
'codename': 'remaining_total',
'title': 'Time remaining (total)',
'formatter': '{:.1f}',
'unit': 's'
},
# Iteration time
{
'codename': 'iteration_time',
'title': 'Iteration time',
'formatter': '{:.2f}',
'unit': 's'
},
)
self.extra_capabilities = {
'psuchannel': {
'help_text': ('Used for simple PSU control when not on\n'
'a ramp. Possibly usages are:\n'
' psuchannel voltage=1.23\n'
'which will set the voltage and\n'
' psuchannel off\n'
'which will set the output off'),
'completions': [
'psuchannel',
'psuchannel voltage=',
'psuchannel off',
]
}
}
# Queue for GUI updates
self.message_queue = Queue()
# The GUI also looks in self.config, see below
### Normal program
# Setup my program
with open(path.join(THIS_DIR, args.program_file)) as file__:
self.config, self.steps = parse_ramp(file__)
# The GUI will look for keys: program_title in config
self.say('Using power supply channel: ' + self.channel_id)
self.say('Loaded with config:\n' + pformat(self.config))
self.active_step = 0
self.send_steps()
# Add completions for the edits
self._completion_additions = []
for number, step in enumerate(self.steps):
base = 'edit {} '.format(number)
self._completion_additions.append(base)
for field in sorted(step.fields):
self._completion_additions.append('{}{}='.format(base, field))
# Base for the status
self.status = {'status_field': 'Initialized'}
# General variables
self.stop = False
self.ok_to_start = False
# Create a partial function with the output substitued in
self.send_command = partial(
_send_command,
args.output,
args.power_supply,
)
# Setup power supply
self.power_supply_on_off(True, self.config['maxcurrent_start'])
# Power supply commands, must match order with self.codenames
self.power_supply_commands = ('read_actual_current',
'read_actual_voltage',
'read_set_voltage', 'read_current_limit')
# Setup dataset saver and live socket
self.codenames = [
self.channel_id + id_
for id_ in ('_current', '_voltage', '_voltage_setpoint',
'_current_limit')
]
self.live_socket = LiveSocket('H2O2_proactive_' + self.channel_id,
self.codenames +
[self.channel_id + '_accum_charge'],
no_internal_data_pull_socket=True)
self.live_socket.reset(self.codenames)
self.live_socket.start()
self.data_set_saver = DataSetSaver(credentials.measurements,
credentials.xy_values,
username=credentials.username,
password=credentials.password)
self.data_set_saver.start()
# Done with init, send status
self.send_status()
import time
from PyExpLabSys.common.database_saver import DataSetSaver, CustomColumn
import credentials
## EDIT HERE
comment = "First run"
## EDIT HERE
# Create data set saver object
data_set_saver = DataSetSaver(
"measurements_dummy",
"xy_values_dummy",
credentials.USERNAME,
credentials.PASSWORD,
)
data_set_saver.start()
# Create measurement specs i.e. entires entries in the metadata table
data_set_time = time.time()
metadata = {
"time": CustomColumn(data_set_time, "FROM_UNIXTIME(%s)"),
"comment": comment,
"type": 64,
"preamp_range": 0,
"sem_voltage": 0
}
# Only the labels differ, so we generate the metadata with a loop
for label in [
"p_korr", "i_korr", "total_korr", "ph_setpoint", "ph_value",
"pump_rate"
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
import time
from PyExpLabSys.common.database_saver import DataSetSaver, CustomColumn
import credentials
data_set_saver = DataSetSaver(
'measurements_large_CO2_MEA',
'xy_values_large_CO2_MEA',
credentials.USERNAME,
credentials.PASSWORD,
)
data_set_saver.start()
now = time.time()
now_custom_column = CustomColumn(now, 'FROM_UNIXTIME(%s)')
#CREATE TABLE `measurements_large_CO2_MEA` (
# `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
# `time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
# `type` int(10) unsigned NOT NULL COMMENT 'Type of measurement, as found in the types table',
# `comment` varchar(128) NOT NULL COMMENT 'Comment',
# `cathode_gas_type` varchar(128) NOT NULL COMMENT 'Cathode gas type',
# `anode_gas_type` varchar(128) NOT NULL COMMENT 'Anode gas type',
# `cathode_catalyst_description` varchar(128) NOT NULL COMMENT 'Cathode catalyst description',
# `anode_catalyst_description` varchar(128) NOT NULL COMMENT 'Anode catalyst description',
def main():
"""Main function"""
parser = argparse.ArgumentParser(
description='Run the infamous ph control script.')
# ph_setpoint, ph_direction (string [up, down]), kick_in_rate (float)
# Main (constant), secondary (regulation)
# python ph_increment.py 10.0 --direction up --main-offset=24.0 --second-min=10.0 --second-max=40.0 --second-offset=17.0
parser.add_argument('setpoint', type=float, help='The Ph setpoint.')
parser.add_argument('--direction',
default=None,
help='Pumping direction. Must be up or down.',
required=True)
parser.add_argument('--main-offset',
type=float,
default=None,
help='Start pumping speed for the main pump.',
required=True)
parser.add_argument('--second-min',
type=float,
default=None,
help='Minimum pumping speed for the secondary pump.',
required=True)
parser.add_argument('--second-max',
type=float,
default=None,
help='Maximum pumping speed for the secondary pump.',
required=True)
parser.add_argument('--second-offset',
type=float,
default=None,
help='Start pumping value for the secondary pump.',
required=True)
parser.add_argument('--comment',
default=None,
help='Optional comment',
required=True)
args = parser.parse_args()
## Edit comment
comment = "pH " + str(args.setpoint) + " // p: 0.02 // start rate " + str(
args.second_offset) + " // " + args.comment
## Edit comment
# raise SystemExit('All good')
# Init pumps, Omegabus, PID and data saver
pump_main = AL1000(
"/dev/serial/by-id/usb-FTDI_USB-RS232_Cable_FTV9X9TM-if00-port0")
pump_second = AL1000(
"/dev/serial/by-id/usb-FTDI_USB-RS232_Cable_FTWZCJLU-if00-port0")
obus = OmegaBus(
"/dev/serial/by-id/usb-FTDI_USB-RS232_Cable_FTWZCGSW-if00-port0",
baud=9600,
)
data_set_saver = DataSetSaver("measurements_dummy", "xy_values_dummy",
"dummy", "dummy")
pid = PID(pid_p=0.04, pid_i=0.0, pid_d=0, p_max=9999, p_min=-9)
pid.update_setpoint(args.setpoint)
# time_start = time.time()
#Pre flight check.
pump_main_check = pump_main.get_firmware()
print("main: " + pump_main_check)
pump_second_check = pump_second.get_firmware()
print("second: " + pump_second_check)
obus_check = obus.read_value(1)
obus_check = current_to_ph(obus_check)
if pump_main_check != "NE1000V3.923":
print("Main pump failed")
raise SystemExit(1)
if pump_second_check != "NE1000V3.923":
print("Secondary pump failed")
raise SystemExit(1)
if obus_check < 0:
print("OmegaBus failed")
raise SystemExit(1)
#Set initial condition for pumps
pump_second.set_direction("INF")
pump_main.set_direction("INF")
if args.direction == "up":
pump_second.set_rate(args.second_offset)
rate_second = args.second_offset
pump_main.set_rate(0)
rate_main = 0
if args.direction == "down":
pump_second.set_rate(0)
rate_second = 0
pump_main.set_rate(args.main_offset)
rate_main = args.main_offset
pump_second.set_vol(9999)
pump_main.set_vol(9999)
pump_second.start_program()
pump_main.start_program()
# Setup database saver
data_set_saver.start()
data_set_time = time.time()
metadata = {
"Time": CustomColumn(data_set_time, "FROM_UNIXTIME(%s)"),
"comment": comment,
"type": 64,
"preamp_range": 0,
"sem_voltage": 0
}
for label in [
"p_korr", "i_korr", "total_korr", "ph_setpoint", "ph_value",
"pump_rate"
]:
metadata["mass_label"] = label
data_set_saver.add_measurement(label, metadata)
# Run PID
try:
time_start = time.time()
run(pump_second, pump_main, obus, pid, data_set_saver, time_start,
args.setpoint, rate_second, rate_main, args.second_offset,
args.main_offset, args.second_min, args.second_max, args.direction,
minutes)
except KeyboardInterrupt:
# Clean up
pump_main.set_rate(0)
pump_second.set_rate(0)
pump_main.stop_program()
pump_second.stop_program()
data_set_saver.stop()
raise SystemExit(" Sequence stopped.")
# Clean up
pump_main.set_rate(0)
pump_second.set_rate(0)
pump_main.stop_program()
pump_second.stop_program()
# Log pH during ageing
try:
while True:
value = obus.read_value(1)
value = current_to_ph(value)
print("pH: " + str(round(value, 3)))
data_set_saver.save_point("ph_value",
(time.time() - time_start, value))
data_set_saver.save_point(
"ph_setpoint", (time.time() - time_start, args.setpoint))
time.sleep(8)
except KeyboardInterrupt:
data_set_saver.stop()
pass
from __future__ import print_function
import os
import time
import logging
# logging.basicConfig(level=logging.DEBUG) # Comment in for more logging output
from collections import defaultdict
from PyExpLabSys.file_parsers.chemstation import Sequence
from PyExpLabSys.common.database_saver import DataSetSaver
from PyExpLabSys.common.database_saver import CustomColumn
import credentials
# Instantiate the data set saver
data_set_saver = DataSetSaver('measurements_vhp_setup', 'xy_values_vhp_setup',
credentials.USERNAME, credentials.PASSWORD)
data_set_saver.start()
# Get the set of aleady uploaded files
already_uploaded = data_set_saver.get_unique_values_from_measurements('relative_path')
print('Fetched relative paths for {} known sequences'.format(len(already_uploaded)))
# This is the measurement path, should be generated somehow
basefolder = '/home/cinf/Desktop/Shared_folder'
sequence_identifyer = 'sequence.acaml'
for root, dirs, files in os.walk(basefolder):
if sequence_identifyer in files:
# Check if file is known
relative_path = root.replace(basefolder, '').strip(os.sep)
if relative_path in already_uploaded:
continue
if database_saver:
self.data_set_saver.save_point(self.codename, (t, reading))
print(reading, t, status)
except KeyboardInterrupt:
break
print('Emptying buffer..')
time.sleep(1)
if self.ser.inWaiting() > 0:
self.ser.readline()
print('Done')
if database_saver:
self.data_set_saver.stop()
if __name__ == '__main__':
from PyExpLabSys.common.database_saver import DataSetSaver
import credentials2 as cred
port = '/dev/serial/by-id/usb-Prolific_Technology_Inc._USB-Serial_Controller-if00-port0'
data_set_saver = DataSetSaver('measurements_dummy', 'xy_values_dummy',
cred.user, cred.passwd)
dmm = Keithley(port,
data_set_saver=data_set_saver,
codename='keithley_voltage')
time.sleep(1)
print(dmm.comm('*IDN?'))
dmm.read_voltage(meas_range=20, database_saver=False, count=10)
