optoOIS
Loading...
Searching...
No Matches
optoOIS.registers.mre3ois_registers.OIScontrol Class Reference

Parent class => FeedbackSystem
. More...

Inheritance diagram for optoOIS.registers.mre3ois_registers.OIScontrol:

Public Member Functions

 __init__ (self, board=None)
 get_value (self, channel)
 get_value_id (self, channel)
 init (self)
 is_init_done (self)
 get_feedback_x (self)
 get_feedback_y (self)
 get_x (self)
 get_y (self)
 get_move_rate_x (self)
 get_move_rate_y (self)
 get_ff_kv_x (self)
 get_ff_kv_y (self)
 get_setpoint_x_filter (self)
 get_setpoint_y_filter (self)
 get_enable_FF_X (self)
 get_enable_FF_Y (self, enable=0)
 get_FF_K_X (self)
 get_FF_K_Y (self)
 get_FF_T_X (self)
 get_FF_T_Y (self)
 get_FC_Gyro (self)
 get_gyro_x_correction (self)
 get_gyro_y_correction (self)
 get_optical_amplification (self)
 get_kalman_position_x (self)
 get_kalman_velocity_x (self)
 get_kalman_position_y (self)
 get_kalman_velocity_y (self)
 set_x (self, value=0)
 set_y (self, value=0)
 set_kalman_q_pos (self, value)
 set_kalman_q_vel (self, value)
 set_kalman_r_meas_x (self, value)
 set_kalman_r_meas_y (self, value)
 set_kalman_r_vel (self, value)
 set_static_setpoint_x (self, float value)
 set_static_setpoint_y (self, float value)
 set_damping_hp_gyro (self, value)
 enable_gyro_filter (self, enable=0)
 set_enable_FF_X (self, enable=0)
 set_enable_FF_Y (self, enable=0)
 set_FF_K_X (self, value)
 set_FF_K_Y (self, value)
 set_FF_T_X (self, value)
 set_FF_T_Y (self, value)
 set_FC_Gyro (self, value)
 set_gyro_x_correction (self, value)
 set_gyro_y_correction (self, value)
 set_optical_amplification (self, value)
 enable_VPU_debug (self, value)
 reset (self)
 start_control (self)
 stop_control (self)
 start_optical_stabilisation (self)
 stop_optical_stabilisation (self)
 enable_SG_debug (self, value)
 enable_static_setpoints (self, value)
 set_poly_hall_to_current_x (self, vector)
 set_poly_hall_to_current_y (self, vector)
 set_pid_coef_x (self, kp, ki, kd)
 set_pid_coef_y (self, kp, ki, kd)
 set_matrix_tf_hall_to_axis (self, vector)
 set_matrix_tf_axis_to_hall (self, vector)
 set_gyro_correction_matrix (self, vector)
 get_gyro_correction_matrix (self)
 set_gyro_offsets (self, vector)
 get_gyro_offsets (self)

Static Public Member Functions

 help ()

Public Attributes

int sys_id = 0x36
dict RUN_CONTROL
dict RESET_SYSTEM
dict INPUT_SOURCE
dict SETPOINT_TILT_X
dict SETPOINT_TILT_Y
dict MOVE_RATE_X
dict MOVE_RATE_Y
dict FB_AXIS_X
dict FB_AXIS_Y
dict GYRO_INPUT_X
dict GYRO_INPUT_Y
dict GYRO_FILTER_ENABLE
dict ENABLE_FF_X
dict ENABLE_FF_Y
dict FF_K_X
dict FF_K_Y
dict FF_T_X
dict FF_T_Y
dict FC_HP_GYRO
dict DAMPING_HP_GYRO
dict SETPOINT_X_FILTER
dict SETPOINT_Y_FILTER
dict GYRO_CORRECTION_X
dict GYRO_CORRECTION_Y
dict OPT_AMPLIFICATION
dict KALMAN_POSITION_X
dict KALMAN_VELOCITY_X
dict KALMAN_POSITION_Y
dict KALMAN_VELOCITY_Y
dict KALMAN_Q_POS
dict KALMAN_Q_VEL
dict KALMAN_R_MEAS_X
dict KALMAN_R_MEAS_Y
dict KALMAN_R_VEL
dict STATIC_SETPOINT_X
dict STATIC_SETPOINT_Y
dict vec_polly_hall_to_current_x = {'id': self.sys_id << 8 | 0x00, 'type': float}
dict vec_polly_hall_to_current_y = {'id': self.sys_id << 8 | 0x01, 'type': float}
dict vec_pid_coef_x = {'id': self.sys_id << 8 | 0x02, 'type': float}
dict vec_pid_coef_y = {'id': self.sys_id << 8 | 0x03, 'type': float}
dict vec_tf_hall_to_axis_matrix = {'id': self.sys_id << 8 | 0x04, 'type': float}
dict vec_tf_axis_to_hall_matrix = {'id': self.sys_id << 8 | 0x05, 'type': float}
dict vec_gyro_correction_matrix = {'id': self.sys_id << 8 | 0x06, 'type': float}
dict vec_gyro_offsets = {'id': self.sys_id << 8 | 0x07, 'type': float}
 name = self.__class__.__name__

Static Protected Attributes

bool _is_a_system = True

Detailed Description

Parent class => FeedbackSystem
. 

Device Functionality - OIS control
* \page OIScontrol OIS control
* OIS control system ID: <b>0x36</b>
*
* Control system for CCM projects,
* this system provides optical stabilization based on gyro data (from InertialMeasurementSystem).
* Whole control compose from 3 stages:
* - Optical Stabilization   - PID for X and Y movement
*                           - setpoint=0, feedback=gyro, output=axis_controller
* - Axis controller     - 3x(PID+Feedforward polynome) for X, Y, Z axis
*                       - setpoint=optical_stabilization, feedback=transformed_hall_voltage, output=channel_controller
* - Channel controller - 3x(PID+Feedforward polynome) for hall channels 0, 1, 2
*                       - setpoint=axis_controller, feedback=hall_voltage, output=current_for_given_channel
*
* \note Newer control implementation with transformations skips Channel controller PIDs; registers are kept for compatibility
*
* \note Feedforward polynome means feedforward_output = setpoint^0*poly[0] + setpoint^1*poly[1] + ... + setpoint^(n-1)*poly[n-1]
*           where n = @polynom_order = 4
*           controller_output = feedforward_output + pid_output
*
* ### Register Map:
*
*  | Address | Name             | Default Value | Description                                           |  Type  | Access     |
*  |---------|---------------------|---------------|-------------------------------------------------------|--------|------------|
*  | 0x3600  | RUN_CONTROL         | false         | Enable/Disable all control loops                   | boolean| read write |
*  | 0x3601  | RESET_SYSTEM     | false         | Resets all internal variables of the system           | boolean| read write |
*  | 0x3602  | INPUT_SOURCE         | 0             | 0=NONE, 1=IMU, 2=STATIC, 3=SG, 4=VPU                  | uint8  | read write |
*  | 0x3603  | SETPOINT_TILT_X     | 0             | Required value for X axis [deg]                    | float  | read write |
*  | 0x3604  | SETPOINT_TILT_Y     | 0             | Required value for Y axis [deg]                    | float  | read write |
*  | 0x3605  | MOVE_RATE_X         | 0             | Gyro X feedback value                                 | float  | read only  |
*  | 0x3606  | MOVE_RATE_Y         | 0             | Gyro Y feedback value                                 | float  | read only  |
*  | 0x3607  | FB_AXIS_X           | 0             | X feedback value of the axis controller               | float  | read only  |
*  | 0x3608  | FB_AXIS_Y           | 0             | Y feedback value of the axis controller               | float  | read only  |
*  | 0x3609  | GYRO_INPUT_X         | 0             | Gyro X value corrected through correction matrix and offset| float | read only |
*  | 0x360A  | GYRO_INPUT_Y     | 0             | Gyro Y value corrected through correction matrix and offset| float | read only |
*  | 0x360B  | GYRO_FILTER_ENABLE  | true          | Enables/disables gyro band-pass filter                | boolean| write       |
*  | 0x360C  | ENABLE_FF_X         | true (1)      | Enables/disables feed-forward control path for X axis | boolean| write       |
*  | 0x360D  | ENABLE_FF_Y         | true (1)      | Enables/disables feed-forward control path for Y axis | boolean| write       |
*  | 0x360E  | FF_K_X              | 1.0 (2)       | Feed-forward K parameter for X axis                   | float  | read write |
*  | 0x360F  | FF_K_Y              | 1.0 (2)       | Feed-forward K parameter for Y axis                   | float  | read write |
*  | 0x3610  |  FF_T_X              | 0.1 (2)       | Feed-forward T parameter for X axis                   | float  | read write |
*  | 0x3611  | FF_T_Y              | 0.1 (2)       | Feed-forward T parameter for Y axis                   | float  | read write |
*  | 0x3612  | FC_HP_GYRO          | 2.0           | Cut off frequency for the HP part of the gyro filter  | float  | read write |
*  | 0x3613  | SETPOINT_X_FILTER   | 0.0           | Filtered integral set-point value for X axis PID      | float  | read write |
*  | 0x3614  | SETPOINT_Y_FILTER   | 0.0           | Filtered integral set-point value for Y axis PID      | float  | read write |
*  | 0x3615  | GYRO_CORRECTION_X   | 1.0 (2)       | Gyro correction parameter for X axis                  | float  | read write |
*  | 0x3616  | GYRO_CORRECTION_Y   | 1.0 (2)       | Gyro correction parameter for Y axis                  | float  | read write |
*  | 0x3617  | OPT_AMPLIFICATION   | 1.0 (2)       | Optical amplification parameter describing the optical path | float  | read write |
*  | 0x3618  | VPU_DEBUG           | false         | Connects VPU generator instead of gyro (for debug)    | boolean| read write |
*  | 0x3619  | KALMAN_POSITION_X   |               | Kalman filter estimated position output for the X axis| float  | read write |
*  | 0x361A  | KALMAN_VELOCITY_X   |               | Kalman filter estimated velocity output for the X axis| float  | read write |
*  | 0x361B  | KALMAN_POSITION_Y   |               | Kalman filter estimated position output for the Y axis| float  | read write |
*  | 0x361C  | KALMAN_VELOCITY_Y   |               | Kalman filter estimated velocity output for the X axis| float  | read write |
*  | 0x361D  | KALMAN_Q_POS        |               | Kalman process noise parameter for the position state | float  | read write |
*  | 0x361E  | KALMAN_Q_VEL        |               | Kalman process noise parameter for the velocity state | float  | read write |
*  | 0x361F  | KALMAN_R_MEAS_X     |               | Measurement noise parameter for X axis position feedback| float | read write |
*  | 0x3620  | KALMAN_R_MEAS_Y     |               | Measurement noise parameter for Y axis position feedback| float | read write |
*  | 0x3621  | KALMAN_R_VEL        |               | Measurement noise parameter for velocity (gyro-derived) input | float | read write |
*  | 0x3622  | STATIC_SETPOINT_X   |               | External closed-loop setpoint value for the X axis    | boolean| read write |
*  | 0x3623  | STATIC_SETPOINT_Y   |               | External closed-loop setpoint value for the Y axis    | boolean| read write |
*
* \note <br/>(1) Enabled automatically if module EEPROM was correctly parsed, otherwise false
*           <br/>(2) Values are taken from EEPROM if successfully parsed
*
* ### Vector Map:
*
* | Address | Name                      | Default       | Description                                                       | Format and value          | Access     |
* |---------|--------------------------|---------------|-------------------------------------------------------------------|---------------------------|------------|
* | 0x3600  | HALL_TO_CURRENT_POLY_X    | [0, 1, 0, 0]  | {a0, a1, a2, a3}, feedforward polynome, outX=pidX.out+refX*polyX  | @polynom_order(=4) *float | read write |
* | 0x3601  | HALL_TO_CURRENT_POLY_Y    | [0, 1, 0, 0]  | {a0, a1, a2, a3}, feedforward polynome, outY=pidY.out+refY*polyY  | @polynom_order(=4) *float | read write |
* | 0x3609  | AXIS_PID_COEF_X           | [0, 0, 0] (3) | {Kp, Ki, Kd}, PID coefficients for X axis controller              | 3*float                   | write      |
* | 0x360A  | AXIS_PID_COEF_Y           | [0, 0, 0] (3) | {Kp, Ki, Kd}, PID coefficients for Y axis controller              | 3*float                   | write      |
* | 0x360B  | HALL_PID_COEF_Z           | [0, 0, 0] (3) | {Kp, Ki, Kd}, PID coefficients for Z axis controller              | 3*float                   | write      |
* | 0x3611  | TF_HALL_TO_AXIS_MATRIX    | [0, .., 0] (3)(4)| Hall to Axis transformation matrix coefficients, size depends on CCM project (1)| @size *float | write      |
* | 0x3612  | TF_AXIS_TO_CHANNEL_MATRIX| [0, .., 0] (3)(5)| Axis to Channel transformation matrix coefficients, size depends on CCM project (2)| @size *float | write  |
* | 0x3613  | GYRO_CORRECTION_MATRIX   |[-1, .., 0] (3)(6)| Matrix represents correction of sensor acceleration Ax, Ay, Az values versus X, Y axes| 6*float | read write|
* | 0x3614  | GYRO_OFFSETS             | [0, 0, 0] (3)    | Vector describes offsets of the gyro sensor; offset value is subtracted in the system| 3*float | read write|
*
* \note <br/>(3) Values are taken from EEPROM if successfully parsed
*           <br/> Transformation matrix coefficients are represented as rows following each other:
*           <br/>(4) Frey = 13*3; Saiph = 13*2 coefficients
*           <br/>(5) Frey =  4*3; Saiph =  3*2 coefficients
*
* Gyro correction matrix represents correction of sensor acceleration Ax, Ay, Az values versus X, Y axes of the module. Default matrix connects negative Ax data with X and Az data with Y axis as shown in table:
*
* |Axis\Accel| Ax | Ay | Az |
* |:---:|:---:|:---:|:---:|
* | X   |-1.0 | 0.0 | 0.0 |
* | Y   | 0.0 |-1.0 | 0.0 |
*
* \note <br/>(6) Default vector values are [-1.0, 0.0, 0.0, 0.0, -1.0, 0.0]
*/

Constructor & Destructor Documentation

◆ __init__()

optoOIS.registers.mre3ois_registers.OIScontrol.__init__ ( self,
board = None )

Member Function Documentation

◆ enable_gyro_filter()

optoOIS.registers.mre3ois_registers.OIScontrol.enable_gyro_filter ( self,
enable = 0 )

◆ enable_SG_debug()

optoOIS.registers.mre3ois_registers.OIScontrol.enable_SG_debug ( self,
value )

◆ enable_static_setpoints()

optoOIS.registers.mre3ois_registers.OIScontrol.enable_static_setpoints ( self,
value )

◆ enable_VPU_debug()

optoOIS.registers.mre3ois_registers.OIScontrol.enable_VPU_debug ( self,
value )

◆ get_enable_FF_X()

optoOIS.registers.mre3ois_registers.OIScontrol.get_enable_FF_X ( self)

◆ get_enable_FF_Y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_enable_FF_Y ( self,
enable = 0 )

◆ get_FC_Gyro()

optoOIS.registers.mre3ois_registers.OIScontrol.get_FC_Gyro ( self)

◆ get_feedback_x()

optoOIS.registers.mre3ois_registers.OIScontrol.get_feedback_x ( self)

◆ get_feedback_y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_feedback_y ( self)

◆ get_FF_K_X()

optoOIS.registers.mre3ois_registers.OIScontrol.get_FF_K_X ( self)

◆ get_FF_K_Y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_FF_K_Y ( self)

◆ get_ff_kv_x()

optoOIS.registers.mre3ois_registers.OIScontrol.get_ff_kv_x ( self)

◆ get_ff_kv_y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_ff_kv_y ( self)

◆ get_FF_T_X()

optoOIS.registers.mre3ois_registers.OIScontrol.get_FF_T_X ( self)

◆ get_FF_T_Y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_FF_T_Y ( self)

◆ get_gyro_correction_matrix()

optoOIS.registers.mre3ois_registers.OIScontrol.get_gyro_correction_matrix ( self)

◆ get_gyro_offsets()

optoOIS.registers.mre3ois_registers.OIScontrol.get_gyro_offsets ( self)

◆ get_gyro_x_correction()

optoOIS.registers.mre3ois_registers.OIScontrol.get_gyro_x_correction ( self)

◆ get_gyro_y_correction()

optoOIS.registers.mre3ois_registers.OIScontrol.get_gyro_y_correction ( self)

◆ get_kalman_position_x()

optoOIS.registers.mre3ois_registers.OIScontrol.get_kalman_position_x ( self)

◆ get_kalman_position_y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_kalman_position_y ( self)

◆ get_kalman_velocity_x()

optoOIS.registers.mre3ois_registers.OIScontrol.get_kalman_velocity_x ( self)

◆ get_kalman_velocity_y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_kalman_velocity_y ( self)

◆ get_move_rate_x()

optoOIS.registers.mre3ois_registers.OIScontrol.get_move_rate_x ( self)

◆ get_move_rate_y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_move_rate_y ( self)

◆ get_optical_amplification()

optoOIS.registers.mre3ois_registers.OIScontrol.get_optical_amplification ( self)

◆ get_setpoint_x_filter()

optoOIS.registers.mre3ois_registers.OIScontrol.get_setpoint_x_filter ( self)

◆ get_setpoint_y_filter()

optoOIS.registers.mre3ois_registers.OIScontrol.get_setpoint_y_filter ( self)

◆ get_value()

optoOIS.registers.mre3ois_registers.OIScontrol.get_value ( self,
channel )

◆ get_value_id()

optoOIS.registers.mre3ois_registers.OIScontrol.get_value_id ( self,
channel )

◆ get_x()

optoOIS.registers.mre3ois_registers.OIScontrol.get_x ( self)

◆ get_y()

optoOIS.registers.mre3ois_registers.OIScontrol.get_y ( self)

◆ help()

optoOIS.registers.mre3ois_registers.OIScontrol.help ( )
static

◆ init()

optoOIS.registers.mre3ois_registers.OIScontrol.init ( self)

◆ is_init_done()

optoOIS.registers.mre3ois_registers.OIScontrol.is_init_done ( self)

◆ reset()

optoOIS.registers.mre3ois_registers.OIScontrol.reset ( self)

◆ set_damping_hp_gyro()

optoOIS.registers.mre3ois_registers.OIScontrol.set_damping_hp_gyro ( self,
value )

◆ set_enable_FF_X()

optoOIS.registers.mre3ois_registers.OIScontrol.set_enable_FF_X ( self,
enable = 0 )

◆ set_enable_FF_Y()

optoOIS.registers.mre3ois_registers.OIScontrol.set_enable_FF_Y ( self,
enable = 0 )

◆ set_FC_Gyro()

optoOIS.registers.mre3ois_registers.OIScontrol.set_FC_Gyro ( self,
value )

◆ set_FF_K_X()

optoOIS.registers.mre3ois_registers.OIScontrol.set_FF_K_X ( self,
value )

◆ set_FF_K_Y()

optoOIS.registers.mre3ois_registers.OIScontrol.set_FF_K_Y ( self,
value )

◆ set_FF_T_X()

optoOIS.registers.mre3ois_registers.OIScontrol.set_FF_T_X ( self,
value )

◆ set_FF_T_Y()

optoOIS.registers.mre3ois_registers.OIScontrol.set_FF_T_Y ( self,
value )

◆ set_gyro_correction_matrix()

optoOIS.registers.mre3ois_registers.OIScontrol.set_gyro_correction_matrix ( self,
vector )

◆ set_gyro_offsets()

optoOIS.registers.mre3ois_registers.OIScontrol.set_gyro_offsets ( self,
vector )

◆ set_gyro_x_correction()

optoOIS.registers.mre3ois_registers.OIScontrol.set_gyro_x_correction ( self,
value )

◆ set_gyro_y_correction()

optoOIS.registers.mre3ois_registers.OIScontrol.set_gyro_y_correction ( self,
value )

◆ set_kalman_q_pos()

optoOIS.registers.mre3ois_registers.OIScontrol.set_kalman_q_pos ( self,
value )

◆ set_kalman_q_vel()

optoOIS.registers.mre3ois_registers.OIScontrol.set_kalman_q_vel ( self,
value )

◆ set_kalman_r_meas_x()

optoOIS.registers.mre3ois_registers.OIScontrol.set_kalman_r_meas_x ( self,
value )

◆ set_kalman_r_meas_y()

optoOIS.registers.mre3ois_registers.OIScontrol.set_kalman_r_meas_y ( self,
value )

◆ set_kalman_r_vel()

optoOIS.registers.mre3ois_registers.OIScontrol.set_kalman_r_vel ( self,
value )

◆ set_matrix_tf_axis_to_hall()

optoOIS.registers.mre3ois_registers.OIScontrol.set_matrix_tf_axis_to_hall ( self,
vector )

◆ set_matrix_tf_hall_to_axis()

optoOIS.registers.mre3ois_registers.OIScontrol.set_matrix_tf_hall_to_axis ( self,
vector )

◆ set_optical_amplification()

optoOIS.registers.mre3ois_registers.OIScontrol.set_optical_amplification ( self,
value )

◆ set_pid_coef_x()

optoOIS.registers.mre3ois_registers.OIScontrol.set_pid_coef_x ( self,
kp,
ki,
kd )

◆ set_pid_coef_y()

optoOIS.registers.mre3ois_registers.OIScontrol.set_pid_coef_y ( self,
kp,
ki,
kd )

◆ set_poly_hall_to_current_x()

optoOIS.registers.mre3ois_registers.OIScontrol.set_poly_hall_to_current_x ( self,
vector )

◆ set_poly_hall_to_current_y()

optoOIS.registers.mre3ois_registers.OIScontrol.set_poly_hall_to_current_y ( self,
vector )

◆ set_static_setpoint_x()

optoOIS.registers.mre3ois_registers.OIScontrol.set_static_setpoint_x ( self,
float value )

◆ set_static_setpoint_y()

optoOIS.registers.mre3ois_registers.OIScontrol.set_static_setpoint_y ( self,
float value )

◆ set_x()

optoOIS.registers.mre3ois_registers.OIScontrol.set_x ( self,
value = 0 )

◆ set_y()

optoOIS.registers.mre3ois_registers.OIScontrol.set_y ( self,
value = 0 )

◆ start_control()

optoOIS.registers.mre3ois_registers.OIScontrol.start_control ( self)

◆ start_optical_stabilisation()

optoOIS.registers.mre3ois_registers.OIScontrol.start_optical_stabilisation ( self)

◆ stop_control()

optoOIS.registers.mre3ois_registers.OIScontrol.stop_control ( self)

◆ stop_optical_stabilisation()

optoOIS.registers.mre3ois_registers.OIScontrol.stop_optical_stabilisation ( self)

Member Data Documentation

◆ _is_a_system

bool optoOIS.registers.mre3ois_registers.OIScontrol._is_a_system = True
staticprotected

◆ DAMPING_HP_GYRO

dict optoOIS.registers.mre3ois_registers.OIScontrol.DAMPING_HP_GYRO
Initial value:
= {'id': self.sys_id << 8 | 0x13, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ ENABLE_FF_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.ENABLE_FF_X
Initial value:
= {'id': self.sys_id << 8 | 0x0C, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ ENABLE_FF_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.ENABLE_FF_Y
Initial value:
= {'id': self.sys_id << 8 | 0x0D, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ FB_AXIS_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.FB_AXIS_X
Initial value:
= {'id': self.sys_id << 8 | 0x07, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ FB_AXIS_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.FB_AXIS_Y
Initial value:
= {'id': self.sys_id << 8 | 0x08, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ FC_HP_GYRO

dict optoOIS.registers.mre3ois_registers.OIScontrol.FC_HP_GYRO
Initial value:
= {'id': self.sys_id << 8 | 0x12, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ FF_K_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.FF_K_X
Initial value:
= {'id': self.sys_id << 8 | 0x0E, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ FF_K_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.FF_K_Y
Initial value:
= {'id': self.sys_id << 8 | 0x0F, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ FF_T_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.FF_T_X
Initial value:
= {'id': self.sys_id << 8 | 0x10, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ FF_T_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.FF_T_Y
Initial value:
= {'id': self.sys_id << 8 | 0x11, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ GYRO_CORRECTION_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.GYRO_CORRECTION_X
Initial value:
= {'id': self.sys_id << 8 | 0x16, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ GYRO_CORRECTION_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.GYRO_CORRECTION_Y
Initial value:
= {'id': self.sys_id << 8 | 0x17, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ GYRO_FILTER_ENABLE

dict optoOIS.registers.mre3ois_registers.OIScontrol.GYRO_FILTER_ENABLE
Initial value:
= {'id': self.sys_id << 8 | 0x0B, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ GYRO_INPUT_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.GYRO_INPUT_X
Initial value:
= {'id': self.sys_id << 8 | 0x09, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ GYRO_INPUT_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.GYRO_INPUT_Y
Initial value:
= {'id': self.sys_id << 8 | 0x0A, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ INPUT_SOURCE

dict optoOIS.registers.mre3ois_registers.OIScontrol.INPUT_SOURCE
Initial value:
= {'id': self.sys_id << 8 | 0x02, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_POSITION_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_POSITION_X
Initial value:
= {'id': self.sys_id << 8 | 0x19, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_POSITION_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_POSITION_Y
Initial value:
= {'id': self.sys_id << 8 | 0x1B, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_Q_POS

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_Q_POS
Initial value:
= {'id': self.sys_id << 8 | 0x1D, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_Q_VEL

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_Q_VEL
Initial value:
= {'id': self.sys_id << 8 | 0x1E, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_R_MEAS_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_R_MEAS_X
Initial value:
= {'id': self.sys_id << 8 | 0x1F, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_R_MEAS_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_R_MEAS_Y
Initial value:
= {'id': self.sys_id << 8 | 0x20, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_R_VEL

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_R_VEL
Initial value:
= {'id': self.sys_id << 8 | 0x21, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_VELOCITY_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_VELOCITY_X
Initial value:
= {'id': self.sys_id << 8 | 0x1A, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ KALMAN_VELOCITY_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.KALMAN_VELOCITY_Y
Initial value:
= {'id': self.sys_id << 8 | 0x1C, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ MOVE_RATE_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.MOVE_RATE_X
Initial value:
= {'id': self.sys_id << 8 | 0x05, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ MOVE_RATE_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.MOVE_RATE_Y
Initial value:
= {'id': self.sys_id << 8 | 0x06, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ name

optoOIS.registers.mre3ois_registers.OIScontrol.name = self.__class__.__name__

◆ OPT_AMPLIFICATION

dict optoOIS.registers.mre3ois_registers.OIScontrol.OPT_AMPLIFICATION
Initial value:
= {'id': self.sys_id << 8 | 0x18, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ RESET_SYSTEM

dict optoOIS.registers.mre3ois_registers.OIScontrol.RESET_SYSTEM
Initial value:
= {'id': self.sys_id << 8 | 0x01, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ RUN_CONTROL

dict optoOIS.registers.mre3ois_registers.OIScontrol.RUN_CONTROL
Initial value:
= {'id': self.sys_id << 8 | 0x00, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ SETPOINT_TILT_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.SETPOINT_TILT_X
Initial value:
= {'id': self.sys_id << 8 | 0x03, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ SETPOINT_TILT_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.SETPOINT_TILT_Y
Initial value:
= {'id': self.sys_id << 8 | 0x04, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ SETPOINT_X_FILTER

dict optoOIS.registers.mre3ois_registers.OIScontrol.SETPOINT_X_FILTER
Initial value:
= {'id': self.sys_id << 8 | 0x14, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ SETPOINT_Y_FILTER

dict optoOIS.registers.mre3ois_registers.OIScontrol.SETPOINT_Y_FILTER
Initial value:
= {'id': self.sys_id << 8 | 0x15, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ STATIC_SETPOINT_X

dict optoOIS.registers.mre3ois_registers.OIScontrol.STATIC_SETPOINT_X
Initial value:
= {'id': self.sys_id << 8 | 0x22, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ STATIC_SETPOINT_Y

dict optoOIS.registers.mre3ois_registers.OIScontrol.STATIC_SETPOINT_Y
Initial value:
= {'id': self.sys_id << 8 | 0x23, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

◆ sys_id

int optoOIS.registers.mre3ois_registers.OIScontrol.sys_id = 0x36

◆ vec_gyro_correction_matrix

optoOIS.registers.mre3ois_registers.OIScontrol.vec_gyro_correction_matrix = {'id': self.sys_id << 8 | 0x06, 'type': float}

◆ vec_gyro_offsets

optoOIS.registers.mre3ois_registers.OIScontrol.vec_gyro_offsets = {'id': self.sys_id << 8 | 0x07, 'type': float}

◆ vec_pid_coef_x

optoOIS.registers.mre3ois_registers.OIScontrol.vec_pid_coef_x = {'id': self.sys_id << 8 | 0x02, 'type': float}

◆ vec_pid_coef_y

optoOIS.registers.mre3ois_registers.OIScontrol.vec_pid_coef_y = {'id': self.sys_id << 8 | 0x03, 'type': float}

◆ vec_polly_hall_to_current_x

optoOIS.registers.mre3ois_registers.OIScontrol.vec_polly_hall_to_current_x = {'id': self.sys_id << 8 | 0x00, 'type': float}

◆ vec_polly_hall_to_current_y

optoOIS.registers.mre3ois_registers.OIScontrol.vec_polly_hall_to_current_y = {'id': self.sys_id << 8 | 0x01, 'type': float}

◆ vec_tf_axis_to_hall_matrix

optoOIS.registers.mre3ois_registers.OIScontrol.vec_tf_axis_to_hall_matrix = {'id': self.sys_id << 8 | 0x05, 'type': float}

◆ vec_tf_hall_to_axis_matrix

optoOIS.registers.mre3ois_registers.OIScontrol.vec_tf_hall_to_axis_matrix = {'id': self.sys_id << 8 | 0x04, 'type': float}
The documentation for this class was generated from the following file: