Galil Drivers

Classes:

GalilDMC4133Arm(controller)	Module to control probe arm. It is assumed that the chip to be probed has one or more rows with each row having one or more pads. Design of the chip to be probed should resemble the following::.
GalilDMC4133Controller(name, address, **kwargs)	Driver for Galil DMC-4133 Controller
GalilDMC4133Motor(parent, name, **kwargs)	Class to control a single motor (independent of possible other motors)
GalilDMC4133VectorMode(parent, name, **kwargs)	Class to control motors in vector mode

class qcodes.instrument_drivers.Galil.GalilDMC4133Arm(controller: GalilDMC4133Controller)

Bases: object

Module to control probe arm. It is assumed that the chip to be probed has one or more rows with each row having one or more pads. Design of the chip to be probed should resemble the following:

|--------------------------|
|--------------------------|
|--------------------------|
|--------------------------|
|--------------------------|

Needle head for the arm in assumed to have rows of needles which is a divisor of the number of rows in the chip and number of needles in each row of the needle head is a divisor for the number of pads in each row of the chip.

Initializes the arm class

Parameters:

controller – an instance of DMC4133Controller

Attributes:

current_row
current_pad
left_bottom_position
left_top_position
right_top_position
arm_pick_up_distance
speed
acceleration
deceleration

Methods:

set_arm_kinematics([speed, acceleration, ...])	sets the arm kinematics values for speed, acceleration and deceleration in micro meters/sec and micro meters/sec^2 respectively
set_pick_up_distance([distance])	sets pick up distance in micrometers for the arm
set_left_bottom_position()
set_left_top_position()
set_right_top_position()
move_motor_a_by(distance)	Moves motor A by distance given in micro meters
move_motor_b_by(distance)	Moves motor B by distance given in micro meters
move_motor_c_by(distance)	Moves motor B by distance given in micro meters
move_towards_left_bottom_position()
move_to_next_row()
move_to_begin_row_pad_from_end_row_last_pad()
move_to_row(num)
move_to_pad(num)
set_motor_a_forward_limit()
set_motor_a_reverse_limit()
set_motor_b_forward_limit()
set_motor_b_reverse_limit()
set_motor_c_forward_limit()
set_motor_c_reverse_limit()

property current_row: int | None

property current_pad: int | None

property left_bottom_position: tuple[int, int, int] | None

property left_top_position: tuple[int, int, int] | None

property right_top_position: tuple[int, int, int] | None

property arm_pick_up_distance: int

property speed: int

property acceleration: int

property deceleration: int

set_arm_kinematics(speed: int = 100, acceleration: int = 2048, deceleration: int = 2048) → None

sets the arm kinematics values for speed, acceleration and deceleration in micro meters/sec and micro meters/sec^2 respectively

set_pick_up_distance(distance: float = 3000) → None

sets pick up distance in micrometers for the arm

set_left_bottom_position() → None

set_left_top_position() → None

set_right_top_position() → None

move_motor_a_by(distance: float) → None

Moves motor A by distance given in micro meters

move_motor_b_by(distance: float) → None

Moves motor B by distance given in micro meters

move_motor_c_by(distance: float) → None

Moves motor B by distance given in micro meters

move_towards_left_bottom_position() → None

move_to_next_row() → None

move_to_begin_row_pad_from_end_row_last_pad() → None

move_to_row(num: int) → None

move_to_pad(num: int) → None

set_motor_a_forward_limit() → None

set_motor_a_reverse_limit() → None

set_motor_b_forward_limit() → None

set_motor_b_reverse_limit() → None

set_motor_c_forward_limit() → None

set_motor_c_reverse_limit() → None

class qcodes.instrument_drivers.Galil.GalilDMC4133Controller(name: str, address: str, **kwargs: Unpack[InstrumentBaseKWArgs])

Bases: GalilMotionController

Driver for Galil DMC-4133 Controller

Initializes the DMC4133Controller class

Parameters:

• name – name for the instance

• address – address of the controller burned in

• **kwargs – kwargs are forwarded to base class.

Attributes:

position_format_decimals	sets number of decimals in the format of the position
absolute_position	gets absolute position of the motors from the set origin
wait	controller will wait for the amount of time specified before executing the next command

Methods:

end_program()	ends the program
define_position_as_origin()	defines current motors position as origin
tell_error()	reads error
stop()	stop the motion of all motors
abort()	aborts motion and the program operation
motors_off()	turn all motors off
begin_motors()	begin motion of all motors simultaneously
wait_till_motion_complete()	this method waits for the motion on all motors to complete

position_format_decimals: Parameter = self.add_parameter( "position_format_decimals", get_cmd=None, set_cmd="PF 10.{}", vals=Ints(0, 4), docstring="sets number of decimals in the format of the position", )

sets number of decimals in the format of the position

absolute_position: Parameter = self.add_parameter( "absolute_position", get_cmd=self._get_absolute_position, set_cmd=None, unit="quadrature counts", docstring="gets absolute position of the motors from the set origin", )

gets absolute position of the motors from the set origin

wait: Parameter = self.add_parameter( "wait", get_cmd=None, set_cmd="WT {}", unit="ms", vals=Multiples(min_value=2, max_value=2147483646, divisor=2), docstring="controller will wait for the amount of " "time specified before executing the next " "command", )

controller will wait for the amount of time specified before executing the next command

end_program() → None

ends the program

define_position_as_origin() → None

defines current motors position as origin

tell_error() → str

reads error

stop() → None

stop the motion of all motors

abort() → None

aborts motion and the program operation

motors_off() → None

turn all motors off

begin_motors() → None

begin motion of all motors simultaneously

wait_till_motion_complete() → None

this method waits for the motion on all motors to complete

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.Galil.GalilDMC4133Motor(parent: GalilDMC4133Controller, name: str, **kwargs: Unpack[InstrumentBaseKWArgs])

Bases: InstrumentChannel

Class to control a single motor (independent of possible other motors)

Initializes individual motor submodules

Parameters:

• parent – an instance of DMC4133Controller

• name – name of the motor to be controlled

• **kwargs – kwargs are forwarded to base class.

Attributes:

relative_position	sets relative position for the motor's move
speed	speed for motor's motion
acceleration	acceleration for motor's motion
deceleration	deceleration for motor's motion
off_when_error_occurs	enables or disables the motor to automatically turn off when error occurs
reverse_sw_limit	can be used to set software reverse limit for the motor.
forward_sw_limit	can be used to set software forward limit for the motor.

Methods:

off()	turns motor off
on_off_status()	tells motor on off status
servo_here()	servo at the motor
begin()	begins motion of the motor (returns immediately)
is_in_motion()	checks if the motor is in motion or not.
wait_till_motor_motion_complete()	wait for motion on the motor to complete
error_magnitude()	gives the magnitude of error, in quadrature counts, for this motor a count is directly proportional to the micro-stepping resolution of the stepper drive.

relative_position: Parameter = self.add_parameter( "relative_position", unit="quadrature counts", get_cmd=f"MG _PR{self._axis}", get_parser=lambda s: int(float(s)), set_cmd=self._set_relative_position, vals=Ints(-2147483648, 2147483647), docstring="sets relative position for the motor's move", )

sets relative position for the motor’s move

speed: Parameter = self.add_parameter( "speed", unit="counts/sec", get_cmd=f"MG _SP{self._axis}", get_parser=lambda s: int(float(s)), set_cmd=self._set_speed, vals=Multiples(min_value=0, max_value=3000000, divisor=2), docstring="speed for motor's motion", )

speed for motor’s motion

acceleration: Parameter = self.add_parameter( "acceleration", unit="counts/sec2", get_cmd=f"MG _AC{self._axis}", get_parser=lambda s: int(float(s)), set_cmd=self._set_acceleration, vals=Multiples(min_value=1024, max_value=1073740800, divisor=1024), docstring="acceleration for motor's motion", )

acceleration for motor’s motion

deceleration: Parameter = self.add_parameter( "deceleration", unit="counts/sec2", get_cmd=f"MG _DC{self._axis}", get_parser=lambda s: int(float(s)), set_cmd=self._set_deceleration, vals=Multiples(min_value=1024, max_value=1073740800, divisor=1024), docstring="deceleration for motor's motion", )

deceleration for motor’s motion

off_when_error_occurs: Parameter = self.add_parameter( "off_when_error_occurs", get_cmd=self._get_off_when_error_occurs, set_cmd=self._set_off_when_error_occurs, val_mapping={ "disable": 0, "enable for position, amp error or abort": 1, "enable for hw limit switch": 2, "enable for all": 3, }, docstring="enables or disables the motor to " "automatically turn off when error occurs", )

enables or disables the motor to automatically turn off when error occurs

reverse_sw_limit: Parameter = self.add_parameter( "reverse_sw_limit", unit="quadrature counts", get_cmd=f"MG _BL{self._axis}", get_parser=lambda s: int(float(s)), set_cmd=self._set_reverse_sw_limit, vals=Ints(-2147483648, 2147483647), docstring="can be used to set software reverse limit for the motor." " motor motion will stop beyond this limit automatically." " default value is -2147483648. this value effectively " "disables the reverse limit.", )

can be used to set software reverse limit for the motor. motor motion will stop beyond this limit automatically. default value is -2147483648. this value effectively disables the reverse limit.

forward_sw_limit: Parameter = self.add_parameter( "forward_sw_limit", unit="quadrature counts", get_cmd=f"MG _FL{self._axis}", get_parser=lambda s: int(float(s)), set_cmd=self._set_forward_sw_limit, vals=Ints(-2147483648, 2147483647), docstring="can be used to set software forward limit for the motor." " motor motion will stop beyond this limit automatically." " default value is 2147483647. this value effectively " "disables the forward limit.", )

can be used to set software forward limit for the motor. motor motion will stop beyond this limit automatically. default value is 2147483647. this value effectively disables the forward limit.

off() → None

turns motor off

on_off_status() → str

tells motor on off status

servo_here() → None

servo at the motor

begin() → None

begins motion of the motor (returns immediately)

is_in_motion() → int

checks if the motor is in motion or not. return 1, if motor is in motion otherwise 0

wait_till_motor_motion_complete() → None

wait for motion on the motor to complete

error_magnitude() → float

gives the magnitude of error, in quadrature counts, for this motor a count is directly proportional to the micro-stepping resolution of the stepper drive.

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.Galil.GalilDMC4133VectorMode(parent: GalilDMC4133Controller, name: str, **kwargs: Unpack[InstrumentBaseKWArgs])

Bases: InstrumentChannel

Class to control motors in vector mode

Initializes the vector mode submodule for the controller

Parameters:

• parent – an instance of DMC4133Controller

• name – name of the vector mode plane

• **kwargs – kwargs are forwarded to base class.

Attributes:

coordinate_system	activates coordinate system for the motion.
vector_acceleration	sets and gets the defined vector's acceleration
vector_deceleration	sets and gets the defined vector's deceleration
vector_speed	sets and gets defined vector's speed

Methods:

activate()	activate plane of motion
vector_position(first_coord, second_coord)	sets the final vector position for the motion considering current position as the origin
vector_seq_end()	indicates to the controller that the end of the vector is coming up.
begin_seq()	begins motion of the motor
after_seq_motion()	wait till motion ends
clear_sequence(coord_sys)	clears vectors specified in the given coordinate system

coordinate_system: Parameter = self.add_parameter( "coordinate_system", get_cmd="CA ?", get_parser=self._parse_coordinate_system_active, set_cmd="CA {}", vals=Enum("S", "T"), docstring="activates coordinate system for the motion. Two " " coordinate systems are possible with values " "'S' and 'T'. All vector mode commands will apply to " "the active coordinate system.", )

activates coordinate system for the motion. Two coordinate systems are possible with values ‘S’ and ‘T’. All vector mode commands will apply to the active coordinate system.

vector_acceleration: Parameter = self.add_parameter( "vector_acceleration", get_cmd="VA ?", get_parser=lambda s: int(float(s)), set_cmd="VA {}", vals=Multiples(min_value=1024, max_value=1073740800, divisor=1024), unit="counts/sec2", docstring="sets and gets the defined vector's acceleration", )

sets and gets the defined vector’s acceleration

vector_deceleration: Parameter = self.add_parameter( "vector_deceleration", get_cmd="VD ?", get_parser=lambda s: int(float(s)), set_cmd="VD {}", vals=Multiples(min_value=1024, max_value=1073740800, divisor=1024), unit="counts/sec2", docstring="sets and gets the defined vector's deceleration", )

sets and gets the defined vector’s deceleration

vector_speed: Parameter = self.add_parameter( "vector_speed", get_cmd="VS ?", get_parser=lambda s: int(float(s)), set_cmd="VS {}", vals=Multiples(min_value=2, max_value=15000000, divisor=2), unit="counts/sec", docstring="sets and gets defined vector's speed", )

sets and gets defined vector’s speed

activate() → None

activate plane of motion

vector_position(first_coord: int, second_coord: int) → None

sets the final vector position for the motion considering current position as the origin

vector_seq_end() → None

indicates to the controller that the end of the vector is coming up. is required to exit the vector mode gracefully

begin_seq() → None

begins motion of the motor

after_seq_motion() → None

wait till motion ends

clear_sequence(coord_sys: str) → None

clears vectors specified in the given coordinate system

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}