Using EPICS-Hyppie CCD Detector control module¶

Usage of Python Class for EPICS LabView RT Detector control.

class py4syn.epics.HyppieCCDClass.HyppieCCD(pvName, mnemonic, scalerObject='')[source]¶

Python class to help configuration and control of Charge-Coupled Devices (CCD) via Hyppie over EPICS.

CCD is the most common mechanism for converting optical images to electrical signals. In fact, the term CCD is know by many people because of their use of video cameras and digital still cameras.

Constructor

Parameters:	pvName : string Charge-Coupled Device (CCD)’s naming of the PV (Process Variable) mnemonic : string Device mnemonic scalerObject : object It represents logically the Scaler device

acquire(waitComplete=False)[source]¶

Start process of image capturing.

Parameters:	waitComplete : boolean [OPTIONAL] Whether to wait for all of the reading process of the image to complete, or not. Note True – Wait for all image reading conclusion; False [DEFAULT] – DON’T wait for all image reading conclusion.

disableAutoIncrement()[source]¶

Set AutoIncrement property of device to 0 (ZERO), that is, disables it.

Parameters:	None

enableAutoIncrement()[source]¶

Set AutoIncrement property of device to 1 (ONE), that is, enables it.

Parameters:	None

getAcquireTime()[source]¶

Read acquisition time of a Charge-Coupled Device (CCD).

Returns:	float

getCommandInput(cmd)[source]¶

Return the input command submitted to the device.

Returns:	string

getCommandOutput(cmd)[source]¶

Return the output of command the command sent to device.

Returns:	string

getCompleteFileName()[source]¶

Return the full file name, with extension, of the current image which is being read.

Returns:	string

getCompletePreviousFileName()[source]¶

Return the full file name, with extension, of the image which were read previously.

Returns:	string

getFileName()[source]¶

Return the full file name of the current image which is being read.

Returns:	string

getFileNumber()[source]¶

Return the number sequence of the file of current image which is being read.

Returns:	integer

getFilePath()[source]¶

Return the full path where is the file of current image which is being read.

Returns:	string

getIntensity()[source]¶

Return the intensity of the scaler device.

Returns:	string

isDone()[source]¶

Check whether acquisition process has been concluded or not.

Returns:	boolean Note True – Acquisition has been concluded; False – Acquisition has NOT been concluded.

isDoneConfig()[source]¶

Check whether configuration process has been concluded or not.

Returns:	boolean Note True – Configuration has been concluded; False – Configuration has NOT been concluded.

onAcquireChange(value, **kw)[source]¶

Internal use method to check whether an acquisition in execution is done or not.

Parameters:	value : integer 0 (ZERO) Indicates the process has been concluded kw : matrix Internal array of parameters

onWaitChange(value, **kw)[source]¶

Internal use method to check whether a configuration change request sent to the Charge-Coupled device has been performed or not.

Parameters:	value : integer 0 (ZERO) Indicates the configuration change has been conclude kw : matrix Internal array of parameters

setAcquireTime(time)[source]¶

Set the acquisition time to the Charge-Coupled Device (CCD).

Parameters:	unit : float Time value to be configured for the acquire-time property of CCD.

setCommandInput(cmd)[source]¶

Set the input command to be submitted to the device.

Parameters:	unit : string Command to send to device.

setFileName(name)[source]¶

Set the full file name of current image which is being read.

Parameters:	unit : string Name of image file to capture.

setFileNumber(number)[source]¶

Set the number sequence of the file for the current image which is being read.

Parameters:	unit : integer Sequence number to set to the image file.

setFilePath(name)[source]¶

Set the full path where file of current image which is being read must be saved.

Parameters:	name : string Description of path where image file should be stored.

setNumImages(number)[source]¶

Set the number of images which should be read.

Parameters:	number : integer Number of images to be captured.

setROI(startX, sizeX, startY, sizeY)[source]¶

Method to determine the Region Of Interest (ROI) of a CCD device.

Parameters:	startX : float X position to start the region of interest of the Charge-Coupled Device (CCD) sizeX : float size of X positioning startY : float Y position to start the region of interest of the Charge-Coupled Device (CCD) sizeY : float size of Y positioning

Examples

>>> import py4syn.epics.HyppieCCDClass.HyppieCCD as hyppie_ccd
>>> hyppie_ccd.setROI(32, 100, 15, 49)

Note

This method must be used only after default configuration was set in the Charge-Coupled Devide (CCD)

wait()[source]¶

Method which keeps a sleeping period meanwhile any command execution is being performed.

Parameters:	None

waitConfig()[source]¶

Method which keeps a sleeping period meanwhile any configuration is being set.

Parameters:	None

Using EPICS Lauda thermostats module¶

Usage of Python class for EPICS Keithley Programmable Electrometer model 6514.

class py4syn.epics.Keithley6514Class.Keithley6514(pvName, mnemonic, timeBased=False)[source]¶

Python class to help configuration and control the Keithley 6514 Electrometer.

Keithley is an electrical instrument for measuring electric charge or electrical potential difference. This instrument is capable of measuring extremely low currents. E.g.: pico (10e-12), i.e.: 0,000 000 000 001.

For more information, please, refer to: Model 6514 System Electrometer Instruction Manual

Constructor To use this Keithley Class you must pass the PV (Process Variable) prefix.

Note

e.g.: SXS:K6514

Examples

>>> from KeithleyClass import *
>>> name = Keithley('SOL:K6514', 'k1')

canMonitor()[source]¶

Abstract method to check if the device can or cannot be used as monitor.

Returns:	out : bool

canStopCount()[source]¶

Abstract method to check if the device can or cannot stop the count and return values.

Returns:	out : bool

getAutoCurrentRange()[source]¶

Get the status of Auto Current Range (enable/disable). Default: enable.

Returns:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.getAutoCurrentRange()
>>> True

getAutoZeroing()[source]¶

Get the status of Auto Zero (enable/disable). Default: enable.

Returns:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.getAutoZeroing()
>>> True

getAverageCount()[source]¶

Get the number of filter count. Default: 10.

Returns:	Value: Integer, i.e.: 2 to 100.

Examples

>>> name.getAverageCount()
>>> 10.0

getAverageDigitalFilter()[source]¶

Get the status of Digital Filter (enable/disable). Default: enable.

Returns:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.getAverageDigitalFilter()
>>> True

getAverageTControl()[source]¶

Get the filter control. Default: REP.

Returns:	Value: String, i.e.: REP or MOV.

Examples

>>> name.getAverageTControl()
>>> 'REP'

getCountNumberReading()[source]¶

Count the number of reading(s).

Returns:	Value: Integer, e.g.: 963.

Examples

>>> name.CountNumberReading()
>>> 161.0

getCurrentRange()[source]¶

Get the value of range. Default: Auto range.

Returns:	Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA).

Examples

>>> name.getCurrentRange()
>>> 11

getIntegrationTime()[source]¶

Get the number of integration rate. Default: 1.

Returns:	Value: Float, i.e.: 0.01 to 10 (PLCs). Where 1 PLC for 60Hz is 16.67msec (1/60).

Examples

>>> name.getIntegrationTime()
>>> 1.0

getMedianFilter()[source]¶

Get the status of Median Filter (enable/disable). Default: enable.

Returns:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.getMedianFilter()
>>> True

getMedianRank()[source]¶

Get the value of Median Rank, this number of sample readings are between 1 to 5. Default: 5.

Returns:	Value: Integer, i.e.: 1 to 5.

Examples

>>> name.getMedianRank()
>>> 5.0

getStatusContinuesMode()[source]¶

Get the status of Continues Mode (enable/disable). Default: enable.

Returns:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.getStatusContinuesMode()
>>> True

getTriggerReading()[source]¶

Trigger and return reading(s).

Returns:	Value: Float, e.g.: -6.0173430000000003e-16.

Examples

>>> name.getTriggerReading()
>>> -1.0221850000000001e-15

getValue(**kwargs)[source]¶

Get the current value of a countable device.

Parameters:	kwargs : value Where needed informations can be passed, e.g. select which channel must be read.
Returns:	out : value Returns the current value of the device. Type of the value depends on device settings.

getZeroCheck()[source]¶

Get the status of Zero Check (enable/disable). Default: disable.

Returns:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.getZeroCheck()
>>> False

getZeroCorrect()[source]¶

Get the status of Zero Correct (enable/disable). Default: disable.

Returns:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.getZeroCorrect()
>>> False

setAutoCurrentRange(autorange)[source]¶

Set enable/disable for Auto Current Range.

Parameters:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).
Returns:	One value (1).

Examples

>>> name.setAutoCurrentRange(1)
>>> 1

setAutoZeroing(autozero)[source]¶

Set enable/disable for Auto Zero.

Parameters:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.setAutoZeroing(1)

setAverageCount(avercoun)[source]¶

Set the number of filter count.

Parameters:	Value: Integer, i.e.: 2 to 100.

Examples

>>> name.setAverageCount(80)

setAverageDigitalFilter(aver)[source]¶

Set enable/disable for Digital Filter.

Parameters:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.setAverageDigitalFilter(1)

setAverageTControl(tcon)[source]¶

Set the filter control.

Parameters:	Value: String, i.e.: ‘REP’ or ‘MOV’, where REP means ‘Repeat’ and MOV means ‘Moving’.

Examples

>>> name.setAverageTControl('MOV')

setCountTime(time)[source]¶

Method to set the count time of a Keithley device.

Note

Whenever the median filter is active, changing the count time results in the filter being reset, so the first measurement will take additional time to collect new data for the filter. The extra time is proportional to the median filter rank. After the first measurement, the following measurements will have the correct integration time.

Note

Unlike scalers, the count time is only an approximation. The requested integration time will be split into multiple parts, which includes the analog integration time (varying between approximatelly 10ms to 50ms), the digital integration time (that averages a set of 2 to 100 analog integrations), and other operations unrelated to integration, like auto zero calibration (triples the integration time) and calculation times. When calling this method, the digital average filter will be activated if it’s not already and the filter type will be set to repeat.

See also: setIntegrationTime(), setAverageCount()

Parameters:	time : value The target count time to be set. The allowed time range is 100ms to 15s (limited by software).
Returns:	out : None

setCurrentRange(curange)[source]¶

Set the range.

Parameters:	Value: Integer, i.e.: 0 (Undefined ZERO), 1 (Indefined UM), 2 (20 mA), 3 (2 mA), 4 (200 uA), 5 (20 uA), 6 (2 uA), 7 (200 nA), 8 (20 nA), 9 (2 nA), 10 (200 pA), 11 (20 pA).

Examples

>>> name.setCurrentRange(5)

setIntegrationTime(nplc)[source]¶

Set the number of integration rate.

Parameters:	Value: Float, i.e.: 0.01 to 10 (PLCs). Where 1 PLC for 60Hz is 16.67msec (1/60).

Examples

>>> name.setIntegrationTime(0.01)

setMedianFilter(med)[source]¶

Set enable/disable for Median Filter.

Parameters:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.setMedianFilter(1)

setMedianRank(medrank)[source]¶

Set the number of sample readings used for the median calculation.

Parameters:	Value: Integer, i.e.: 1 to 5.

Examples

>>> name.setMedianRank(3)

setPresetValue(channel, val)[source]¶

Abstract method to set the preset count of a countable target device.

Parameters:	channel : int The monitor channel number val : int The preset value
Returns:	out : None

setStatusContinuesMode(cmode)[source]¶

Set enable/disable to continues mode. Let this enable if you want a continuing measuring.

Parameters:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).

Examples

>>> name.setStatusContinuesMode(0)

setZeroCheck(check)[source]¶

Set enable/disable for Zero Check.

Parameters:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).
Returns:	One value (1).

Examples

>>> name.setZeroCheck(1)
>>> 1

setZeroCorrect(cor)[source]¶

Set enable/disable for Zero Correct.

Parameters:	Value: Boolean, i.e.: 0 - False (Off/Disable), 1 - True (On/Enable).
Returns:	One value (1).

Examples

>>> name.setZeroCorrect(1)
>>> 1

startCount()[source]¶

Abstract method trigger a count in a counter

stopCount()[source]¶

Abstract method stop a count in a counter

Using EPICS Lauda thermostats module¶

Usage of Python class for EPICS Lauda thermostats.

class py4syn.epics.LaudaClass.Lauda(pvPrefix='', mnemonic='')[source]¶

Python class to help configuration and control of Lauda devices via Hyppie over EPICS.

Examples

>>> from py4syn.epics.MotorClass import Motor
>>>    
>>> def createMotor(pvName=""):
...    
...    new_motor = ''
...    
...    try:
...        new_motor = Motor(PV)
...            print "Motor " + pvName + " created with success!"
...    except Exception,e:
...        print "Error: ",e
...    
...    return new_motor

Constructor See py4syn.epics.StandardDevice

Parameters:	pvPrefix : string Lauda’s device base naming of the PV (Process Variable) mnemonic : string Lauda’s mnemonic

Using EPICS Modem control module¶

Usage of Python class for EPICS Modem control.

class py4syn.epics.ModemClass.Modem(pvName, mnemonic)[source]¶

Using EPCIS Motoman DX100 controller module¶

Usage of Python class for EPICS Motoman DX100 controller.

class py4syn.epics.MotomanClass.Motoman(pvPrefix='', mnemonic='')[source]¶

Using the EPICS Motors control module¶

Usage of Python class using basic Motor Record fields.

class py4syn.epics.MotorClass.Motor(pvName, mnemonic)[source]¶

Class to control motor devices via EPICS.

Examples

>>> from py4syn.epics.MotorClass import Motor
>>>    
>>> def createMotor(pvName="", mne=""):
...    
...    new_motor = ''
...    
...    try:
...        new_motor = Motor(pvName, mne)
...            print "Motor " + pvName + " created with success!"
...    except Exception,e:
...        print "Error: ",e
...    
...    return new_motor

Constructor See py4syn.epics.StandardDevice

Parameters:	pvName : string Motor’s base naming of the PV (Process Variable) mnemonic : string Motor’s mnemonic

calculateBacklash(target)[source]¶

Calculates the backlash distance of a given motor

Returns:	double

canPerformMovement(target)[source]¶

Check if a movement to a given position is possible using the limit values and backlash distance

Returns:	boolean Note True – Motor CAN perform the desired movement; False – Motor CANNOT perform the desired movement.

canPerformMovementCalc(target)[source]¶

Check if a movement to a given position is possible using the limit values and backlash distance calculating the values

Returns:	boolean Note True – Motor CAN perform the desired movement; False – Motor CANNOT perform the desired movement.

getBacklashDistanceValue()[source]¶

Read the motor backlash distance based on the BDST (Backlash Distance, EGU) field of Motor Record

Returns:	double

getDescription()[source]¶

Read the motor descrition based on the DESC field of Motor Record

Returns:	string

getDialHighLimitValue()[source]¶

Read the motor dial high limit based on the DHLM (Dial High Limit) field of Motor Record

Returns:	double

getDialLowLimitValue()[source]¶

Read the motor dial low limit based on the DLLM (Dial Low Limit) field of Motor Record

Returns:	double

getDialPosition()[source]¶

Read the motor target DIAL position based on the DVAL (Dial Desired Value) field of Motor Record

Returns:	double

getDialRealPosition()[source]¶

Read the motor DIAL real position based on the DRBV (Dial Readback Value) field of Motor Record

Returns:	double

getDirection()[source]¶

Read the motor direction based on the DIR (User Direction) field of Motor Record

Returns:	integer Note Positive direction; Negative direction.

getEGU()[source]¶

Read the motor engineering unit based on the EGU (Engineering Units) field of Motor Record

Returns:	string

getFreezeOffset()[source]¶

Read the motor freeze offset based on the FOF (Freeze Offset) field of Motor Record

Returns:	integer

getHighLimitValue()[source]¶

Read the motor high limit based on the HLM (User High Limit) field of Motor Record

Returns:	double

getLVIO()[source]¶

Read the motor limit violation LVIO (Limit Violation) field of Motor Record

Returns:	short

getLowLimitValue()[source]¶

Read the motor low limit based on the LLM (User Low Limit) field of Motor Record

Returns:	double

getOffset()[source]¶

Read the motor offset based on the OFF (User Offset, EGU) field of Motor Record

Returns:	string

getPosition()[source]¶

Read the motor target position based on the VAL (User Desired Value) field of Motor Record

Returns:	double

getRawPosition()[source]¶

Read the motor RAW position based on the RVAL (Raw Desired Value) field of Motor Record

Returns:	double

getRawRealPosition()[source]¶

Read the motor RAW real position based on the RRBV (Raw Readback Value) field of Motor Record

Returns:	double

getRealPosition()[source]¶

Read the motor real position based on the RBV (User Readback Value) field of Motor Record

Returns:	double

getSETMode()[source]¶

Checks if the motor is in SET mode

Note

Motor will NOT move until it is in in USE mode

getValue()[source]¶

Get the current position of the motor. See py4syn.epics.IScannable

Returns:	double Read the current value (Motor Real Position)

getVariableOffset()[source]¶

Read the motor variable offset based on the VOF (Variable Offset) field of Motor Record

Returns:	integer

homeForward()[source]¶

Move the motor until it hits the forward limit switch or the software limit.

homeReverse()[source]¶

Move the motor until it hits the reverse limit switch or the software limit.

isAtHighLimitSwitch()[source]¶

Check if a motor high limit switch is activated, based on the HLS (At High Limit Switch) field of Motor Record

Returns:	boolean Note True – Motor is at High Limit; False – Motor is NOT at High Limit.

isAtLowLimitSwitch()[source]¶

Check if a motor low limit switch is activated, based on the LLS (At Low Limit Switch) field of Motor Record

Returns:	boolean Note True – Motor is at Low Limit; False – Motor is NOT at Low Limit.

isMoving()[source]¶

Check if a motor is moving or not based on the callback

Returns:	boolean Note True – Motor is moving; False – Motor is stopped.

isMovingPV()[source]¶

Check if a motor is moving or not from the PV

Returns:	boolean Note True – Motor is moving; False – Motor is stopped.

setAbsolutePosition(pos, waitComplete=False)[source]¶

Move the motor to an absolute position received by an input parameter

Parameters:	pos : double The desired position to set waitComplete : boolean (default is False) Note If True, the function will wait until the movement finish to return, otherwise don’t.

setAcceleration(accl)[source]¶

Set the motor acceleration time based on the ACCL (Seconds to Velocity) field from Motor Record

Parameters:	accl : double The desired acceleration to set

setDialHighLimitValue(val)[source]¶

Set the motor dial high limit based on the DHLM (Dial High Limit) field of Motor Record

Parameters:	val : double The desired value to set

setDialLowLimitValue(val)[source]¶

Set the motor dial low limit based on the DLLM (Dial Low Limit) field of Motor Record

Parameters:	val : double The desired value to set

setDialPosition(pos, waitComplete=False)[source]¶

Set the motor target DIAL position based on the DVAL (Dial Desired Value) field of Motor Record

Parameters:	pos : double The desired position to set waitComplete : boolean (default is False) Note If True, the function will wait until the movement finish to return, otherwise don’t.

setEGU(unit)[source]¶

Set the motor engineering unit to the EGU (Engineering Units) field of Motor Record

Parameters:	unit : string The desired engineering unit. Note Example: “mm.”, “deg.”

setFreezeOffset(val)[source]¶

Set the motor freeze offset based on the FOF (Freeze Offset) field of Motor Record

Parameters:	val : integer The desired value to set

setHighLimitValue(val)[source]¶

Set the motor high limit based on the HLM (User High Limit) field of Motor Record

Parameters:	val : double The desired value to set

setLowLimitValue(val)[source]¶

Set the motor low limit based on the LLM (User Low Limit) field of Motor Record

Parameters:	val : double The desired value to set

setOffset(val)[source]¶

Set the motor offset based on the OFF (User Offset, EGU) field of Motor Record

Parameters:	val : double The desired value to set

setRawPosition(position)[source]¶

Sets the motor RAW position based on the RVAL (Raw Desired Value) field of Motor Record

Returns:	double

setRelativePosition(pos, waitComplete=False)[source]¶

Move the motor a distance, received by an input parameter, to a position relative to that current one

Parameters:	pos : double The desired distance to move based on current position waitComplete : boolean (default is False)

setSETMode()[source]¶

Put the motor in SET mode

Note

Motor will NOT move until it is in in USE mode

setUSEMode()[source]¶

Put the motor in USE mode

setUpdateRequest(val)[source]¶

Set the motor update request flag based on the STUP (Status Update Request) field from Motor Record

Parameters:	val : integer The desired value to set for the flag

setValue(v)[source]¶

Set the desired motor position. See py4syn.epics.IScannable

Parameters:	v : double The desired value (Absolute Position) to set

setVariableOffset(val)[source]¶

Set the motor variable offset based on the VOF (Variable Offset) field of Motor Record

Parameters:	val : integer The desired value to set

setVelocity(velo)[source]¶

Set the motor velocity up based on the VELO (Velocity, EGU/s) field from Motor Record

Parameters:	velo : double The desired velocity to set

stop()[source]¶

Stop the motor

validateLimits()[source]¶

Verify if motor is in a valid position. In the case it has been reached the HIGH or LOW limit switch, an exception will be raised.

wait()[source]¶

Wait until the motor movement finishes

Using the Mythen detectors module¶

Usage of Python class for EPICS Mythen detectors (Microstrip system for time-resolved experiments).

class py4syn.epics.MythenClass.Mythen(pvPrefix, mnemonic)[source]¶

canMonitor()[source]¶

Abstract method to check if the device can or cannot be used as monitor.

Returns:	out : bool

canStopCount()[source]¶

Abstract method to check if the device can or cannot stop the count and return values.

Returns:	out : bool

getValue(**kwargs)[source]¶

Abstract method to get the current value of a countable device.

Parameters:	kwargs : value Where needed informations can be passed, e.g. select which channel must be read.
Returns:	out : value Returns the current value of the device. Type of the value depends on device settings.

isCounting()[source]¶

Abstract method to check if the device is counting or not.

Returns:	out : bool

setCountTime(t)[source]¶

Abstract method to set the count time of a countable target device.

Parameters:	t : value The target count time to be set.
Returns:	out : None

setPresetValue(channel, val)[source]¶

Abstract method to set the preset count of a countable target device.

Parameters:	channel : int The monitor channel number val : int The preset value
Returns:	out : None

startCount()[source]¶

Abstract method trigger a count in a counter

stopCount()[source]¶

Abstract method stop a count in a counter

wait()[source]¶

Abstract method to wait for a count to finish.

Returns:	out : bool

Using the PCO 2000 Camera module¶

Usage of Python class for EPICS PCO 2000 Camera Using LABVIEW IOC.

class py4syn.epics.PCO2000Class.PCO2000(pvName, mnemonic, imageBufferQueue=None, processName='')[source]¶

Using EPICS Photonic CCD module¶

Usage of Python class for EPICS Photonic CCD Detector control.

class py4syn.epics.PhotonicCCDClass.PhotonicCCD(pvName, mnemonic, scalerObject='')[source]¶

Using EPICS Pseudo-Motors control module¶

Usage of Python class for Pseudo-Motors control.

Using Pseudo-Counter control module¶

Usage of Python class for Pseudo-Counter control.

class py4syn.epics.PseudoCounterClass.PseudoCounter(mnemonic, backwardFormula)[source]¶

Class to control Pseudo-Counter (virtual counter).

Examples

>>> # Create a Simulated Counter    
>>> scaler = SimCountable("SOL:SCALER01", 2)
>>> 
>>> # Create two channels: det and mon
>>> createCounter("mon", scaler, 1)
>>> createCounter("det", scaler, 2)
>>> 
>>> # Create a Pseudo counter with the formula
>>> pseudoCounter = PseudoCounter("relation", "C[det]/C[mon]")
>>>
>>> # Create a new channel based on this pseudo-counter
>>> createCounter("relation", pseudoCounter)
>>> 
>>> # Start a count process
>>> ct(1)
>>> 

Pseudo Counter class Constructor

Parameters:	mnemonic : string Counter mnemonic backwardFormula : string Mathematical Formula used to calculate the Pseudo counter value position based on other counters

canMonitor()[source]¶

Abstract method to check if the device can or cannot be used as monitor.

Returns:	out : bool

canStopCount()[source]¶

Abstract method to check if the device can or cannot stop the count and return values.

Returns:	out : bool

getValue(**kwargs)[source]¶

Get the current value of a countable device.

Parameters:	kwargs : value Where needed informations can be passed, e.g. select which channel must be read.
Returns:	out : value Returns the current value of the device. Type of the value depends on device settings.

isCounting()[source]¶

Abstract method to check if the device is counting or not.

Returns:	out : bool

setCountTime(t)[source]¶

Abstract method to set the count time of a countable target device.

Parameters:	t : value The target count time to be set.
Returns:	out : None

setPresetValue(channel, val)[source]¶

Abstract method to set the preset count of a countable target device.

Parameters:	channel : int The monitor channel number val : int The preset value
Returns:	out : None

startCount()[source]¶

Abstract method trigger a count in a counter

stopCount()[source]¶

Abstract method stop a count in a counter

wait()[source]¶

Abstract method to wait for a count to finish.

Returns:	out : bool

Using EPICS Scaler control module¶

Usage of Python class using basic Motor Record fields.

class py4syn.epics.ScalerClass.Scaler(pvScalerName='', numberOfChannels=1, mnemonic='')[source]¶

setCountTime(time)[source]¶

Method to set the count time of a scaler device.

Parameters:	t : value Count time to set to scaler device .
Returns:	out : None

Using EPICS Shutter control module¶

Usage of Python class using basic Motor Record fields.

class py4syn.epics.ShutterClass.Shutter(pvStatusName='', pvControlName='', pvHutchName='', mnemonic='', invert=False)[source]¶

Using EPICS XIA Shutter control module¶

Usage of Python class for EPICS XIA Shutter control.

class py4syn.epics.XIADigitalClass.XIADigital(pvName='', pvHutchName='', mnemonic='')[source]¶

Using EPICS-Countable PV class¶

Usage of Python Class

class py4syn.epics.CountablePVClass.CountablePV(pvName, mnemonic)[source]¶

Class to add fake ICountable support for generic PV.

Examples

>>> from py4syn.epics.CountablePVClass import CountablePV
>>>
>>> myCountable = CountablePV('LNLS:ANEL:corrente','corrente')
>>> myCountable.getValue()
>>>     

Constructor See py4syn.epics.StandardDevice See py4syn.epics.ICountable

Parameters:	pvName : string PV name (Process Variable) mnemonic : string Mnemonic

canMonitor()[source]¶

Abstract method to check if the device can or cannot be used as monitor.

Returns:	out : bool

canStopCount()[source]¶

Abstract method to check if the device can or cannot stop the count and return values.

Returns:	out : bool

getValue(**kwargs)[source]¶

Get the current value of a countable device.

Parameters:	kwargs : value Where needed informations can be passed, e.g. select which channel must be read.
Returns:	out : value Returns the current value of the device. Type of the value depends on device settings.

isCounting()[source]¶

Abstract method to check if the device is counting or not.

Returns:	out : bool

setCountTime(t)[source]¶

Abstract method to set the count time of a countable target device.

Parameters:	t : value The target count time to be set.
Returns:	out : None

setPresetValue(channel, val)[source]¶

Abstract method to set the preset count of a countable target device.

Parameters:	channel : int The monitor channel number val : int The preset value
Returns:	out : None

startCount()[source]¶

Abstract method trigger a count in a counter

stopCount()[source]¶

Abstract method stop a count in a counter

wait()[source]¶

Abstract method to wait for a count to finish.

Returns:	out : bool

Using EPICS Kepco BOP GL power supply module¶

Usage of Python class for EPICS Kepco BOP GL power supplies.

class py4syn.epics.KepcoBOPClass.KepcoBOP(pvName, mnemonic)[source]¶

Class to control Kepco BOP GL power supplies via EPICS.

Examples

>>> from py4syn.epics.KepcoBOPClass import KepcoBOP
>>>    
>>> def configurePower(pv="", name="", voltage=5.0, currentLimit=1.0):
...    bop = KepcoBOP(pv, name)
...    bop.reset()
...    bop.setCurrentLimits(currentLimit, currentLimit)
...    bop.setVoltage(voltage)
...    return bop
...
>>> def smoothVoltageTransition(bop, initial=0.0, final=12.0, duration=2.0):
...    bop.setRampWaveform(duration, final-initial, (initial+final)/2)
...    bop.waveformStart()
...    bop.waveformWait()
...
>>> def noiseCurrent(bop):
...    bop.reset()
...    bop.setMode(KepcoBOP.MODE_CURRENT)
...    bop.setVoltageLimits(20, 20)
...    points = [random.uniform(-5, 5) for i in range(100)]
...    bop.clearWaveform()
...    bop.addWaveformPoints(points, [0.025])
...    bop.waveformStart()
...

Constructor See py4syn.epics.StandardDevice

Parameters:	pvName : string Power supply base naming of the PV (Process Variable) mnemonic : string Power supply mnemonic

addLevelWaveform(length, offset)[source]¶

Adds a fixed level wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type, but it’s faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device.

Adding points does not execute the program. The method waveformStart() must be called.

See also: waveformStart(), setLevelWaveform(), addWaveformPoints(), addSineWaveform(), addRampWaveform(), addTriangleWaveform(), addSquareWaveform()

Note

When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes.

Parameters:	length : float The duration of the level waveform. The allowed range is 500µs to 5s. The number of points used is 60. offset : float The level offset. The offset cannot exceed the configured device limits.

addRampWaveform(length, height, offset)[source]¶

Adds a ramp wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it’s faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device.

Adding points does not execute the program. The method waveformStart() must be called.

See also: waveformStart(), setRampWaveform(), addWaveformPoints(), addSineWaveform(), addTriangleWaveform(), addSquareWaveform(), addLevelWaveform()

Note

When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes.

Parameters:

length : float The ramp length. The allowed range is [1/532, 100] (1.88ms to 100s). The number of points used vary from 20, for smaller ramps, to 3840, for larger ramps. height : float The ramp height. The height can be positive or negative. It cannot exceed the range defined by the configured operating device limits. offset : float The offset of the ramp middle height. The offset cannot exceed the configured device limits.

addSineWaveform(frequency, amplitude, offset, start=0, stop=360)[source]¶

Adds a sine wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it’s faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device.

Adding points does not execute the program. The method waveformStart() must be called.

See also: waveformStart(), setSineWaveform(), addWaveformPoints(), addTriangleWaveform(), addRampWaveform(), addSquareWaveform(), addLevelWaveform()

Note

When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes.

Parameters:

frequency : float The sine wave frequency. The allowed range is 0.01Hz to 443Hz. The number of points used vary from 3840, for lower frequency waves to 24, for higher frequency waves. amplitude : float The sine wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : float The offset of the sine wave zero amplitude. The offset cannot exceed the configured device limits. start : float The starting angle for the sine wave, in degrees. Allowed range is [0.0, 359.99] stop : float The stop angle for the sine wave, in degrees. Allowed range is [0.01, 360.0]

addSquareWaveform(frequency, amplitude, offset)[source]¶

Adds a square wave (constant 50% duty cycle, starts with positive excursion) to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it’s faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device.

Adding points does not execute the program. The method waveformStart() must be called.

See also: waveformStart(), setSquareWaveform(), addWaveformPoints(), addSineWaveform(), addTriangleWaveform(), addRampWaveform(), addLevelWaveform()

Note

When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes.

Parameters:

frequency : float The square wave frequency. The allowed range is 0.02Hz to 1000Hz. The number of points used vary from 3840, for lower frequency waves to 10, for higher frequency waves. amplitude : float The square wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : float The offset of the square wave zero amplitude. The offset cannot exceed the configured device limits.

addTriangleWaveform(frequency, amplitude, offset, start=0, stop=360)[source]¶

Adds a triangle wave to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. The other way is sending the complete array of points for the waveform. This method is limited to a specific waveform type and it also consumes a lot of points, but it’s faster to program than uploading individual points. When the final desired waveform can be composed of simple waveform segments, this is the best way to program the device.

Adding points does not execute the program. The method waveformStart() must be called.

See also: waveformStart(), setTriangleWaveform(), addWaveformPoints(), addSineWaveform(), addRampWaveform(), addSquareWaveform(), addLevelWaveform()

Note

When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes.

Parameters:

frequency : float The triangle wave frequency. The allowed range is 0.01Hz to 443Hz. The number of points used vary from 3840, for lower frequency waves to 24, for higher frequency waves. amplitude : float The triangle wave peak to peak amplitude. The peak to peak amplitude cannot exceed the range defined by the configured operating device limits. offset : float The offset of the triangle wave zero amplitude. The offset cannot exceed the configured device limits. start : float The starting angle for the triangle wave, in degrees. Allowed range is [0.0, 359.99] stop : float The stop angle for the triangle wave, in degrees. Allowed range is [0.01, 360.0]

addWaveform(type, param1, param2, param3=None)[source]¶

Helper method that implements adding waveform segments.

addWaveformPoints(points, times)[source]¶

Adds a set of points to the waveform program. This is one of the ways that the device can be programmed to generate a complex waveform. It’s the most flexible way, allowing arbitrary waveforms, but it’s also the slowest one (a 10 second waveform may take at least 4 seconds just to upload the program). This method adds more points to the current waveform program. It does not overwrite the existing program.

Adding points does not execute the program. The method waveformStart() must be called.

See also: setWaveformPoints(), addSineWaveform(), addTriangleWaveform(), addRampWaveform(), addSquareWaveform(), addLevelWaveform(), waveformStart()

Note

When changing operating mode, the waveform program must be cleared if necessary, because the device will prohibit mixing points from different modes.

Parameters:

points : array of floats The array of points to be added to the program. The total number of allowed points may vary, depending on the times array. When the times array has exactly one element, the maximum number of points is 5900. When the times array has at most 126 distinct values, the maximum number of points is 3933. When the times array has more than 126 distinct values, the maximum number of points is 2950. times : array of floats The dwell times for each point. Either there must be one time entry for each point, or the array of times must contain exactly one element, which sets the time for all points. The allowed time range is [93e-6, 34e-3] (93µs to 34ms).

cachedMode()[source]¶

Helper method to return cached operating mode

checkError()[source]¶

Helper method to raise an exception if the device reports an error.

clearWaveform()[source]¶

Clears the programmed waveform data. This is required when building a new waveform program. Waveform data can only be cleared while the program is not running.

defaults()[source]¶

Helper method to reset internal data.

getCurrent()[source]¶

Measures the current value. The measured value that is read back is known to have an error (less than 1%) and a delay (up to 320ms).

Returns:	float

getCurrentLimits()[source]¶

Gets the negative and positive current limits allowed for operation. The specific limit type that is read depends on the operating mode. When in current mode, the limit set is a main channel limit: it defines the limits of the current that can be programmed by the user. When in voltage mode, the limit is a protection limit: it defines the current limits that the load may impose because of the requested voltage. When changing the operating modes, the set limits no longer apply: they are different for the new mode.

See also: setMode()

Returns:	negative : float The absolute value of the negative limit positive : float The absolute value of the positive limit

getError()[source]¶

Helper method to pop the last error from the device error queue.

getHighLimitValue()[source]¶

Gets either the voltage or current high limit value, depending on operation mode.

Returns:	float

getLimits(device, mode)[source]¶

Helper method that implements getVoltageLimits() and :meth: getCurrentLimits

getLowLimitValue()[source]¶

Gets either the voltage or current low limit value, depending on operation mode.

Returns:	float

getOperationFlag()[source]¶

Returns the real time value of the device operation condition register. The register contains a set of bits representing the following flags: “list running” (16384), “list complete” (4096), “sample complete” (2048), “constant current mode” (1024), “transient complete” (512)”, “constant voltage mode” (256), “transient armed” (64), “waiting for trigger” (32). Refer to the Kepco BOP GL manual for specific details. The relevant flag used by the library is the “list running” flag, which indicates that theres a waveform program running.

See also: isWaveformRunning(), waveformWait()

Returns:	int

getProgramLength()[source]¶

Helper method that returns the number of points in current waveform program.

getValue()[source]¶

Returns either the readback voltage or the current, depending on operating mode.

Returns:	float

getVoltage()[source]¶

Measures the voltage value. The measured value that is read back is known to have an error (less than 1%) and a delay (up to 320ms).

Returns:	float

getVoltageLimits()[source]¶

Gets the negative and positive voltage limits allowed for operation. The specific limit type that is read depends on the operating mode. When in voltage mode, the limit set is a main channel limit: it defines the limits of the voltages that can be programmed by the user. When in current mode, the limit is a protection limit: it defines the voltage limits that the load may impose because of the requested current. When changing the operating modes, the set limits no longer apply: they are different for the new mode.

See also: setMode()

Returns:	negative : float The absolute value of the negative limit positive : float The absolute value of the positive limit

getWaveformRepeat()[source]¶

Gets the last requested waveform repeat count.

See also: setWaveformRepeat()

Returns:	int

isWaveformRunning()[source]¶

Returns whether there’s a running waveform program.

See also: getOperationFlag(), waveformWait()

Returns:	bool

procAndGet(device, pv)[source]¶

Helper method to synchronously execute a query in the device.

reset()[source]¶

Resets the device to a known state. Possible reset states may vary with the device configuration, but generally will be a zero value output (either voltage or current) with low protection limits. The device error queue will be cleared.

setCurrent(current, wait=True)[source]¶

Sets the current value. This method can only be used when in current mode. The current values must be within the power supply acceptable range and also within the configured limit values.

See also: setMode(), setCurrentLimits()

Parameters:	current : float The desired current value

setCurrentLimits(negative=None, positive=None)[source]¶

Sets the negative and positive current limits allowed for operation. The specific limit type that is set depends on the operating mode. When in current mode, the limit set is a main channel limit: it defines the limits of the current that can be programmed by the user. When in voltage mode, the limit is a protection limit: it defines the current limits that the load may impose because of the requested voltage. When changing the operating modes, the set limits no longer apply: they must be set again for the new mode.

See also: setMode()

Parameters:	negative : float The absolute value of the negative limit positive : float The absolute value of the positive limit

setLevelWaveform(length, offset)[source]¶

A shortcut to clearing the waveform program, adding a level waveform and setting the repeat count to 1.

See also: clearWaveform(), addLevelWaveform(), setWaveformRepeat()

Parameters:	length : float Parameter passed to addLevelWaveform() offset : float Parameter passed to addLevelWaveform()

setLimits(device, mode, negative=None, positive=None, maximum=1e+100)[source]¶

Helper method that implements setVoltageLimits() and setCurrentLimits()

setMode(mode)[source]¶

Changes the operating mode. Supported modes are voltage mode and current mode. In the voltage mode, the device tries to set a specific voltage, while staying within the current protection limits. In current mode, the device tries to set a specific current, while staying within the voltage protection limits. See also: setCurrentLimits(), setVoltageLimits()

Parameters:	mode : {KepcoBOP.MODE_CURRENT, KepcoBOP.MODE_VOLTAGE} The desired mode

setRampWaveform(length, height, offset)[source]¶

A shortcut to clearing the waveform program, adding ramp waveform and setting the repeat count to 1.

See also: clearWaveform(), addRampWaveform(), setWaveformRepeat()

Parameters:	length : float Parameter passed to addRampWaveform() height : float Parameter passed to addRampWaveform() offset : float Parameter passed to addRampWaveform()

setSineWaveform(frequency, amplitude, offset, start=0, stop=360)[source]¶

A shortcut to clearing the waveform program, adding sine waveform and setting the repeat count to 1.

See also: clearWaveform(), addSineWaveform(), setWaveformRepeat()

Parameters:	frequency : float Parameter passed to addSineWaveform() amplitude : float Parameter passed to addSineWaveform() offset : float Parameter passed to addSineWaveform() start : float Parameter passed to addSineWaveform() stop : float Parameter passed to addSineWaveform()

setSquareWaveform(frequency, amplitude, offset)[source]¶

A shortcut to clearing the waveform program, adding square waveform and setting the repeat count to 1.

See also: clearWaveform(), addSquareWaveform(), setWaveformRepeat()

Parameters:	frequency : float Parameter passed to addSquareWaveform() amplitude : float Parameter passed to addSquareWaveform() offset : float Parameter passed to addSquareWaveform()

setTriangleWaveform(frequency, amplitude, offset, start=0, stop=360)[source]¶

A shortcut to clearing the waveform program, adding triangle waveform and setting the repeat count to 1.

See clearWaveform(), addTriangleWaveform(), setWaveformRepeat()

Parameters:	frequency : float Parameter passed to addTriangleWaveform() amplitude : float Parameter passed to addTriangleWaveform() offset : float Parameter passed to addTriangleWaveform() start : float Parameter passed to addTriangleWaveform() stop : float Parameter passed to addTriangleWaveform()

setValue(v, wait=True)[source]¶

Sets either the current voltage or current, depending on operating mode.

Parameters:	v : float Either voltage, or current to set, depending on operating mode.

setVoltage(voltage, wait=True)[source]¶

Sets the voltage value. This method can only be used when in voltage mode. The voltage values must be within the power supply acceptable range and also within the configured limit values.

See also: setMode(), setVoltageLimits()

Parameters:	voltage : float The desired voltage value

setVoltageLimits(negative=None, positive=None)[source]¶

Sets the negative and positive voltage limits allowed for operation. The specific limit type that is set depends on the operating mode. When in voltage mode, the limit set is a main channel limit: it defines the limits of the voltages that can be programmed by the user. When in current mode, the limit is a protection limit: it defines the voltage limits that the load may impose because of the requested current. When changing the operating modes, the set limits no longer apply: they must be set again for the new mode.

See also: setMode()

Parameters:	negative : float The absolute value of the negative limit positive : float The absolute value of the positive limit

setWaveformAngle(start=0, stop=360)[source]¶

Helper method that configures start and stop angles for sine and triangle waveforms.

setWaveformPoints(points, times)[source]¶

A shortcut to clearing the waveform program, adding waveform points and setting the repeat count to 1.

See also: clearWaveform(), addWaveformPoints(), setWaveformRepeat()

Parameters:	points : array of floats Parameter passed to addWaveformPoints() times : array of floats Parameter passed to addWaveformPoints()

setWaveformRepeat(repeat)[source]¶

Set the number of times the waveform program will run. By default, the program runs an indeterminate number of times, until it’s explicitly stopped. This method is used to specify the number of times the waveform program will repeat.

A waveform may also have separate one-shot part and repeatable part. Use the method setWaveformRepeatMark() to separate them.

See also: setWaveformRepeatMark(), waveformStop(), waveformAbort()

Parameters:	repeat : int Number of times the programmed waveform will run. A value of zero means run until explicitly stopped.

setWaveformRepeatMark(position=None)[source]¶

Separates the one-short part from the repeating part in the waveform program. By default, the whole waveform repeats, according to the repeat count. This method marks the separation point that allows the definition of an initial one-shot part of the wave. The part before the marked point will be the one-shot part and after the marked point will be the repeating part.

See also: setWaveformRepeat()

Parameters:	position : int Desired position of the setWaveformRepeatMark, representing the point in the waveform that starts the repeating part. If unset, the current first free position in the waveform is set as the mark.

wait()[source]¶

Does the same as waveformWait().

waveformAbort()[source]¶

Immediatelly stops a running waveform. The final output value will be the value before running the waveform program.

See also: waveformStop(), waveformWait()

waveformStart()[source]¶

Executes a waveform program. The program must be already defined by using the waveform add methods. This methods triggers the execution and returns immediatelly. It does not wait for the complete waveform execution to finish.

By default, the waveform will repeat until it is explicitly stopped, but this can be configured by the setWaveformRepeat() method. To stop the waveform execution, the methods waveformStop() and waveformAbort() can be used. For a program with finite repeat count, it’s possible to wait until the waveform finishes with waveformWait().

See also: addWaveformPoints(), addSineWaveform(), addTriangleWaveform(), addRampWaveform(), addSquareWaveform(), addLevelWaveform(), waveformStop(), waveformAbort(), waveformWait(), isWaveformRunning()

waveformStop()[source]¶

Requests to stop a running waveform. The waveform will execute until the end and then will stop, without repeating the program again. The final output value will be the final point in the program.

See also: waveformAbort(), waveformWait()

Note

Because it’s not possible to reliably stop a program with finite repeat count without potentially triggering an “already finished” error, this command is only enabled for stopping waveform programs with inifinite repeat count. For finite repeat counts, use waveformAbort(), or waveformWait() instead.

waveformWait()[source]¶

Waits until the whole waveform program finishes, including all repetitions. It’s only possible to wait for waveform programs with finite repeat counts.

Note

When using the Kepco power supply with a serial port, it’s not possible to receive a notification from the device when the waveform finishes, so this method works by repeatedly polling the device requesting the operation flag. Because of this, the recommended way to use this method is first sleeping for as much time as possible to avoid the loop and only on the last second call this method. Example of a helper function that accomplishes this:

Examples

>>> def runAndWait(bop, totalTime):
...     bop.waveformStart()
...     sleep(max(totalTime-1, 0))
...     bop.waveformWait()
...

Using EPICS Omron E5CK temperature controller module¶

Usage of Python class for EPICS Omron E5CK temperature controllers.

class py4syn.epics.OmronE5CKClass.OmronE5CK(pvName, mnemonic)[source]¶

Class to control Omron E5CK temperature controllers via EPICS.

Examples

>>> from py4syn.epics.OmronE5CKClass import OmronE5CK
>>> 
>>> def showTemperature(pv='', name=''):
...     e5ck = OmronE5CK(pv, name)
...     print('Temperature is: %d' % e5ck.getValue())
...
>>> def fastRaiseTemperature(e5ck, amount, rate=30):
...     e5ck.setRate(rate)
...     e5ck.setValue(e5ck.getValue() + amount)
...
>>> def complexRamp(e5ck):
...     e5ck.setRate(10)
...     e5ck.setValue(200)
...     e5ck.wait()
...     e5ck.setRate(2)
...     e5ck.setValue(220)
...     e5ck.wait()
...     sleep(500)
...     e5ck.setRate(5)
...     e5ck.setValue(100)
...     e5ck.wait()
...     e5ck.stop()
...
>>> import py4syn
>>> from py4syn.epics.ScalerClass import Scaler
>>> from py4syn.utils.counter import createCounter
>>> from py4syn.utils.scan import scan
>>> 
>>> def temperatureScan(start, end, rate, pv='', counter='', channel=2):
...     e5ck = OmronE5CK(pv, 'e5ck')
...     py4syn.mtrDB['e5ck'] = e5ck
...     c = Scaler(counter, channel, 'simcountable')
...     createCounter('counter', c, channel)
...     e5ck.setRate(rate)
...     scan('e5ck', start, end, 10, 1)
...     e5ck.stop()
...

Constructor See py4syn.epics.StandardDevice

Parameters:	pvName : string Power supply base naming of the PV (Process Variable) mnemonic : string Temperature controller mnemonic

advance()[source]¶

Helper method to skip the current program step and execute the next one.

getD()[source]¶

Return the current D value at the furnace

Returns:	double

getHighLimitValue()[source]¶

Returns the controller high limit temperature.

Returns:	float

getI()[source]¶

Return the current I value at the furnace

Returns:	double

getLowLimitValue()[source]¶

Returns the controller low limit temperature.

Returns:	float

getNumPIDElements()[source]¶

Return the number of all parameters at a PID table

Returns:	int

getP()[source]¶

Return the current P value at the furnace

Returns:	double

getPIDTable()[source]¶

Return the current PID table at the furnace

Returns:	array

getPower()[source]¶

Return the current Power value at the furnace

Returns:	double

getRealPosition()[source]¶

Returns the same as getValue().

See: getValue()

Returns:	float

getStepNumber()[source]¶

Helper method to get the current program step.

Returns:	int

getStepNumberSync()[source]¶

Helper module to retrieve an up-to-date value for the current program step number. Similar to getStepNumber(), but it doesn’t rely on monitor value and instead does a synchronous caget() call.

See: getStepNumber()

Returns:	int

getTarget()[source]¶

Returns the current target temperature. If the device is running, the target temperature is the temperature the device is changing to. If the device is not running, the target temperature is ignored.

Returns:	float

getTimeScale()[source]¶

Returns the time scale being used by the controller. The timescale can either be zero, for hours:minutes, or one, for minutes:seconds.

Returns:	int

getValue()[source]¶

Returns the current measured temperature.

Returns:	float

isPaused()[source]¶

Returns true if the controller is paused (keep temperature).

Returns:	bool

isRunning()[source]¶

Returns true if the controller is in program mode. Whenever it is program mode, it is following a target temperature.

Returns:	bool

onProgrammingChange(value, **kwargs)[source]¶

Helper callback that tracks when the IOC finished programming the device.

onStepChange(value, **kwargs)[source]¶

Helper callback that indicates when a new program step has been reached

onTemperatureChange(value, **kwargs)[source]¶

Helper callback that indicates when the measured temperature has changed

pause()[source]¶

Pauses current ramp program. To resume program, use run()

See: run()

preset()[source]¶

Makes the controler enter a well defined known state. This method creates and runs an “empty” ramp program. The program simply mantains the current temperature forever, whatever that temperature is. This is mostly a helper function, to allow making complex temperature ramps starting from a known state and reusing the preset values.

Note

Running a new program requires stopping the current program. While the program is stopped, the controller power generation drops to zero. Because of this power drop, this method may be slow to stabilize.

program(programTable)[source]¶

Set a programTable to the furnace

run()[source]¶

Starts or resumes executing the current temperature program.

sendCommand(command)[source]¶

Helper method to send a custom command to the controller.

Parameters:	command : str The command to be send

setPIDTable(pidTable)[source]¶

Set a PIDtable to the furnace

setRate(r)[source]¶

Sets the ramp speed in degrees per minutes for use with setValue(). This method does not send a command to the controller, it only stores the rate for the next ramps.

See: setValue()

Parameters:	r : float Ramp speed in °C/min

setTimeScale(minutes)[source]¶

Changes the time scale being used by the controller. The timescale can either be zero, for hours:minutes, or one, for minutes:seconds. This operation requires switching the controller operation mode to be successful, and then a reset is issued after it. The whole operation takes more than 5 seconds.

Parameters:	minutes : int Set to 1 for minutes:seconds, or 0 for hours:minutes

setValue(v)[source]¶

Changes the temperature to a new value. This method calls preset if it has not already been called first. The speed that the new temperature is reached is set with setRate(). The default rate is 5 °C/minute.

See: setRate()

Parameters:	v : float The target temperature in °C

setVelocity(velo)[source]¶

Same as setRate().

See: setRate()

Parameters:	r : float Ramp speed in °C/min

stop()[source]¶

Stops executing the current temperature program and puts the device in idle state. In the idle state, the device will not try to set a target temperature.

synchronizeStep(current)[source]¶

Helper method to set up a constant temperature right before running a ramp program. This method detects if a current ramp program is running or not. If it’s not, then it doesn’t do anything. If there is a ramp running, then it configures and advances to a “synchronization step”, that is, a step where the temperature does not change. This step marks the beginning of the new ramp.

The method returns the resulting step number

Parameters:	current : float The temperature target for the synchronization step
Returns:	int

timeToValue(t)[source]¶

Helper method to convert between minutes to the format used by the controller.

Parameters:	t : float The desired time, in minutes
Returns:	float

wait()[source]¶

Blocks until the requested temperature is achieved.

Using EPICS MarCCD camera module¶

Usage of Python class for EPICS MarCCD cameras.

class py4syn.epics.MarCCDClass.MarCCD(mnemonic, address)[source]¶

Class to control MarCCD cameras via TCP sockets.

Examples

>>> from shutil import move
>>> from py4syn.epics.MarCCDClass import MarCCD
>>> from py4syn.epics.ShutterClass import SimpleShutter
>>> 
>>> def getImage(host='localhost', port=2222, fileName='image.tif', shutter=''):
...     shutter = SimpleShutter(shutter, shutter)
...     camera = MarCCD(name, (host, port))
...     camera.setCountTime(10)
...     camera.startCount()
...     shutter.open()
...     camera.wait()
...     camera.stopCount()
...     shutter.close()
...     camera.writeImage('/remote/' + fileName)
...     move('/remote/' + fileName, '/home/user/' + fileName)
...     camera.close()
...
>>> def acquireSetWithCorrection(camera, shutter, exposure=10, count=10, prefix='data'):
...     try:
...         shutter.close()
...         camera.darkNoise()
...         camera.setCountTime(exposure)
...         camera.setSubScan(count=2)
...
...         for i in range(count):
...             remote = '/remote/%s-%02d.tif' % (prefix, i)
...             local = '/home/user/%s-%02d.tif' % (prefix, i)
...             camera.startCount()
...             shutter.open()
...             camera.wait()
...             camera.stopCount()
...             shutter.close()
...             camera.waitForIdle()
...             camera.startCount()
...             shutter.open()
...             camera.wait()
...             camera.stopCount()
...             shutter.close()
...             camera.dezinger()
...             camera.correct()
...             camera.writeImage(remote)
...             move(remote, local)
...     finally:
...         camera.close()
...         shutter.close()
...

Constructor See py4syn.epics.StandardDevice

Parameters:	mnemonic : string Camera mnemonic address : tuple Camera host server Internet address

close()[source]¶

Cleans up and closes camera remote connection. This method must be called when finishing operation with the camera.

correct()[source]¶

Queues image correction on the MarCCD server. After the image is corrected, it can be saved to a file.

There are three corrections applied: dark noise image subtraction, flat field correction and geometric correction. The dark noise correction uses a dark image to fix the reference (zero) intensity levels for each pixel. The flat field correction uses a bright image to correct the gain for each pixel. The geometric correction fixes distortion from the fiber optic taper.

Note

The dark noise image should be frequently generated. Use the method darkNoise() for that.

See: darkNoise()

darkNoise(delay=0)[source]¶

Prepares a dark noise image to be used as a correction image by the server. One of the steps after acquiring an image is to correct it by subtracting the dark noise image from it. This method is used to generate the dark noise image to be used later in the acquisitions. The method must be called with the camera covered. A dark noise image must be generated at least once after starting the MarCCD server.

Note

The following guideline is available on the MarCCD user guide: “The background doesn’t have to be retaken for every data image taken, but generally should be retaken at the start of every new data set, or once every half hour, whichever is sooner (depending on the thermal stability of the hutch). For the MarCCD detector, if a mismatch in the level of the 4 quadrants of data frames is noticed, the bias is probably drifting and should be recollected (and maybe should be set to be collected more often).”

Parameters:

delay : float The time for each background acquisition. The MarCCD camera can either be calibrated with a zero delay between the acquisitions (this is called a bias frame acquisition in MarCCD manual), or with a non-zero (a standard dark frame acquisition). Note that 2 background acquisitions are done. They are then passed through the dezinger algorithm, which averages and removes outlier spots in the image.

dezinger()[source]¶

Apply the dezinger correction algorithm in 2 images and store the resulting image in the MarCCD server. The dezinger algorithm averages corresponding pixels from each image, but if they deviate too much, it discards the brighter one and keeps the lower value. This removes the “zingers”, bright spots in the image, which are not caused by the input light.

To be able to use the dezinger method, 2 images must be present in server memory. This can be accomplished by calling setSubScan() before the acquisition.

Note

The following guildeline is present in MarCCD manual: “Dezingering does require special care that the two images are truly identical (same X-ray dose, same movement of the sample, etc.); otherwise the statistical test will yield unpredictable results. In particular, if the X-ray beam is not constant intensity, or the sample is decaying, then the exposure times and diffractometer motions must compensate for that. If there are significant differences between the frames, then the artifacts created by dezingering may yield worse results than simply using normal, single-read images with zingers in them. Though they are not aethetically pleasing, some kinds of data analysis can tolerate many zingers.

Examples

>>> def acquireTwiceAndDezinger(marccd, time):
...     marccd.setCountTime(time)
...     marccd.setSubScan(count=2)
...     marccd.startCount()
...     marccd.wait()
...     marccd.stopCount()
...     marccd.waitForIdle()
...     marccd.startCount()
...     marccd.wait()
...     marccd.stopCount()
...     marccd.dezinger()
...

getState(timeout=60)[source]¶

Returns the camera state. The state can be used to check for errors, to find out which operations are queued or being executed and if the server is busy interpreting a command.

The camera state is an integer with a 4-bit value, plus five 4-bit fields: acquire, read, correct, write and (highest) dezinger. The low 4-bit state value can be 0, for idle, 7 for bad request and 8 for busy. Each 4-bit field has 4 flags: queued (0x1), executing (0x2), error (0x4) and reserved (0x8). For example, the state 0x011200 means that a read is executing, a correction is queued and a write is queued. The state mask 0x444444 can be used to look for an error on any operation. The lowest field (state) uses the value 8 to indicate it’s busy processing a command, so state 0x8 means “interpreting command”.

Parameters:	timeout : float Time to wait for camera answer
Returns:	int

getValue(**kwargs)[source]¶

This is a dummy getValue method that always returns zero, which is part of the py4syn.epics.ICountable interface. The MarCCD does not return a value while scanning. Instead, it stores a file with the resulting image.

setCountTime(t)[source]¶

Sets the image acquisition time.

Parameters:	t : float Acquisition time

setImageSize(width, height)[source]¶

Chooses the acquired image size.

Parameters:	width: `int` Image width. Must be either 512, 1024 or 2048 and must be the equal to the image height. height: `int` Image height. Must be either 512, 1024 or 2048 and must be the equal to the image width.

setState(state, timeout=60)[source]¶

Changes the camera state bit field. This method does not change the operating state, just the reported integer value. It is a helper method to deal with a quirk in the MarCCD server that makes the error and busy bits to get stuck and never reset. Usually the only value that makes sense for the state is zero, to clear all the bits.

See: getState()

Parameters:	state : int Time to wait for camera answer timeout : float Time to wait for camera answer

setSubScan(count=2)[source]¶

Configure the MarCCD object to know that each acquisition will be done in multiple steps. This effectivelly means that a series of acquisitions will be done in sequence, which will be processed together, resulting in a single final image. This method is mainly required for the dezinger() method to work.

Parameters:	count : int Number of sub scans that will compose a single final image. Can be either 1, to disable sub scan logic, or 2, which will make stopCount() store images alternatedly in “scratch” (auxiliary) memory and “raw” (main) memory.

startCount()[source]¶

Starts acquiring an image. This will acquire image data until asked to stop with stopCount().

Note

Due to way the camera protocol is currently implemented, this method ignores the configured acquisition count time. Because of that, the proper way to do a timed acquisition is to follow this method call with wait(), then immediatelly call stopCount(). The py4syn.utils.scan.scan() function in Py4Syn executes this method sequence.

See: setCountTime(), stopCount(), wait()

Examples

>>> def acquire(marccd, time):
...     marccd.setCountTime(time)
...     marccd.startCount()
...     marccd.wait()
...     marccd.stopCount()
...

stateRequest(request, timeout=60)[source]¶

Helper method used to get or set camera state.

Parameters:	request : string Command to be passed to the camera timeout : float Time to wait for camera answer
Returns:	int

stopCount()[source]¶

Stops acquiring the image and stores it into server memory. The acquired image will be available to apply corrections and to be written to an output file.

If no call to startCount() was done before calling this method, then nothing is done.

wait()[source]¶

Blocks until the configured count time passes since the call to startCount(). The time amount is configured with setCountTime(), or 1 second by default.

If an acquisition has not been started, this method returns immediatelly.

See: setCountTime(), startCount()

waitForIdle()[source]¶

Blocks until the camera server is completely idle. This is required because the camera and the server are slow and certain operations, in particular, multiple sequential acquisitions would fail without waiting for some time. Acquiring two images and dezingering them only works with this method being called between the acquisitions.

waitForImage()[source]¶

Blocks until the acquired image has been corrected and written to disk. This can be used any time after calling stopCount() to make sure file operations can be performed on the resulting image (copied, post-processed, etc.)

waitUntil(condition, timeout=60)[source]¶

Blocks until the camera state asserts a certain condition. This method can be used to confirm that an operation has started, or if the camera is reporting an error. The condition is a bit mask with the same meanings as described in getState(). For example, calling this method with condition set to 0x20 blocks until an aquisition is executing.

This method detects errors automatically by raising an exception if any error bit is set.

See: getState()

Parameters:	condition : int State condition mask. If any of the condition bits is set, the condition is considered to be true. timeout : float Time to wait for the condition to be deasserted

waitWhile(condition, timeout=60)[source]¶

Blocks while the camera state asserts a certain condition. This method can be used to confirm that an operation has finished, or if the camera is reporting an error. The condition is a bit mask with the same meanings as described in getState(). For example, calling this method with condition set to 0x30 blocks while an aquisition is either queued or executing. Similarly, it’s possible to block while the camera server is either processing or writing the image with condition set to 0x333308.

This method detects errors automatically by raising an exception if any error bit is set.

See: getState()

Parameters:	condition : int State condition mask. If any of the condition bits is set, the condition is considered to be true. timeout : float Time to wait for the condition to be deasserted

waitWhileOrUntil(condition, timeout=60, until=False)[source]¶

Helper method that implements waitWhile() and waitUntil()

writeImage(fileName, wait=True)[source]¶

Write the image stored in MarCCD server memory in a file. This method does not store the resulting image in the local machine. Since current MarCCD server protocol does not allow locally downloading the resulting image, this method only asks for the MarCCD camera server to store the image in a remote location. To make the file accessible locally, other means must be used, for example, by instructing the server to save the image in shared storage.

Parameters:	fileName : string Target file name in remote MarCCD server wait : bool Set to True if the method should block until the image is written to disk