| optoICC

Loading...
Searching...
No Matches
optoICC.registers.icc_registers.SarynControl Class Reference

Parent class => FeedbackSystem
More...

Inheritance diagram for optoICC.registers.icc_registers.SarynControl:

## Public Member Functions
| __init__ (self, board=None)
| get_value (self, channel)
| get_value_id (self, channel)
| is_init_done (self)
| get_hall_voltage_x (self)
| get_hall_voltage_y (self)
| get_hall_voltage_z (self)
| get_x (self)
| get_y (self)
| get_z (self)
| get_move_rate_x (self)
| get_move_rate_y (self)
| set_x (self, value=0)
| set_y (self, value=0)
| set_z (self, value=0)
| set_update_freq (self, value=2000)
| set_max_output_current (self, value=0.1)
| enable_open_loop (self, enable=0)
| set_axis_in_limit_x (self, min_voltage, max_voltage)
| set_axis_in_limit_y (self, min_voltage, max_voltage)
| set_axis_in_limit_z (self, min_voltage, max_voltage)
| set_hall_in_limit_ch0 (self, min_voltage, max_voltage)
| set_hall_in_limit_ch1 (self, min_voltage, max_voltage)
| set_hall_in_limit_ch2 (self, min_voltage, max_voltage)
| init (self)
| start_controller (self)
| stop_controller (self)
| start_optical_stabilisation (self)
| stop_optical_stabilisation (self)
| enable_SG_debug (self)
| disable_SG_debug (self)
| set_poly_hall_to_current_x (self, vector)
| set_poly_hall_to_current_y (self, vector)
| set_poly_hall_to_current_z (self, vector)
| set_poly_hall_to_current_ch0 (self, vector)
| set_poly_hall_to_current_ch1 (self, vector)
| set_poly_hall_to_current_ch2 (self, vector)
| set_pid_coef_ch0 (self, kp, ki, kd)
| set_pid_coef_ch1 (self, kp, ki, kd)
| set_pid_coef_ch2 (self, kp, ki, kd)
| set_pid_coef_x (self, kp, ki, kd)
| set_pid_coef_y (self, kp, ki, kd)
| set_pid_coef_z (self, kp, ki, kd)
| set_pid_coef_os_x (self, kp, ki, kd)
| set_pid_coef_os_y (self, kp, ki, kd)
| set_poly_tf_feedback_hall_to_axis_x (self, poly)
| set_poly_tf_feedback_hall_to_axis_y (self, poly)
| set_poly_tf_feedback_hall_to_axis_z (self, poly)
| set_matrix_tf_hall_to_axis (self, vector)
| set_matrix_tf_axis_to_hall (self, vector)
| set_gyro_orientation_matrix (self, vector)
| get_gyro_orientation_matrix (self)

## Static Public Member Functions
| help ()

## Public Attributes
int | sys_id = 0x38
dict | run_controller
dict | run_os
dict | update_frequency
dict | setpoint_hall_ch0
dict | setpoint_hall_ch1
dict | setpoint_hall_ch2
dict | setpoint_tilt_x
dict | setpoint_tilt_y
dict | setpoint_shift_z
dict | hall_voltage_ch0
dict | hall_voltage_ch1
dict | hall_voltage_ch2
dict | hall_voltage_x
dict | hall_voltage_y
dict | hall_voltage_z
dict | output_current_ch0
dict | output_current_ch1
dict | output_current_ch2
dict | output_max_current
dict | axis_in_x_max
dict | axis_in_x_min
dict | axis_in_y_max
dict | axis_in_y_min
dict | axis_in_z_max
dict | axis_in_z_min
dict | hall_in_ch0_min
dict | hall_in_ch0_max
dict | hall_in_ch1_min
dict | hall_in_ch1_max
dict | hall_in_ch2_min
dict | hall_in_ch2_max
dict | move_rate_x
dict | move_rate_y
dict | fb_axis_x
dict | fb_axis_y
dict | init_sys
dict | xy_sg_debug
dict | run_open_loop
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_polly_hall_to_current_z = {'id': self.sys_id << 8 | 0x02, 'type': float}
dict | vec_polly_hall_to_current_ch0 = {'id': self.sys_id << 8 | 0x03, 'type': float}
dict | vec_polly_hall_to_current_ch1 = {'id': self.sys_id << 8 | 0x04, 'type': float}
dict | vec_polly_hall_to_current_ch2 = {'id': self.sys_id << 8 | 0x05, 'type': float}
dict | vec_pid_coef_ch0 = {'id': self.sys_id << 8 | 0x06, 'type': float}
dict | vec_pid_coef_ch1 = {'id': self.sys_id << 8 | 0x07, 'type': float}
dict | vec_pid_coef_ch2 = {'id': self.sys_id << 8 | 0x08, 'type': float}
dict | vec_pid_coef_x = {'id': self.sys_id << 8 | 0x09, 'type': float}
dict | vec_pid_coef_y = {'id': self.sys_id << 8 | 0x0A, 'type': float}
dict | vec_pid_coef_z = {'id': self.sys_id << 8 | 0x0B, 'type': float}
dict | vec_os_pid_coef_x = {'id': self.sys_id << 8 | 0x0C, 'type': float}
dict | vec_os_pid_coef_y = {'id': self.sys_id << 8 | 0x0D, 'type': float}
dict | vec_tf_hall_to_axis_x = {'id': self.sys_id << 8 | 0x0E, 'type': float}
dict | vec_tf_hall_to_axis_y = {'id': self.sys_id << 8 | 0x0F, 'type': float}
dict | vec_tf_hall_to_axis_z = {'id': self.sys_id << 8 | 0x10, 'type': float}
dict | vec_tf_hall_to_axis_matrix = {'id': self.sys_id << 8 | 0x11, 'type': float}
dict | vec_tf_axis_to_hall_matrix = {'id': self.sys_id << 8 | 0x12, 'type': float}
dict | vec_gyro_orientation_matrix = {'id': self.sys_id << 8 | 0x13, 'type': int}
| name = self.__class__.__name__

## Static Protected Attributes
bool | _is_a_system = True

## Detailed Description

Parent class => FeedbackSystem

    Device Functionality - Saryn Control
    System ID: 0x38

    * Saryn Control system ID: <b>0x38</b>
    *
    * Control system for Saryn project,
    * this system provides optical stabilisation based on gyro data (from InertialMeasurementSystem).
    * Whole control compose from 3 stages:
    * - Optical Stabilisation   - 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: By feedforward polynome we mean 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     |
    *  |---------|---------------------|---------------|-------------------------------------------------------|--------|------------|
    *  | 0x3800  | RUN_CONTROLLER      | false         | Enable/Disable all control loops                   | boolean| read write |
    *  | 0x3801  | RUN_OS           | false         | Enable/Disable optical stabilisation                  | boolean| read write |
    *  | 0x3802  | UPDATE_FREQUENCY     | 2000          | Controllers update frequency [Hz]                     | uint8_t| read write |
    *  | 0x3803  | SETPOINT_HALL_CH0    | 0             | Required value for channel 0 [V]                      | float  | read only  |
    *  | 0x3804  | SETPOINT_HALL_CH1   | 0             | Required value for channel 1 [V]                       | float  | read only  |
    *  | 0x3805  | SETPOINT_HALL_CH2   | 0             | Required value for channel 2 [V]                   | boolean| read only  |
    *  | 0x3806  | SETPOINT_TILT_X     | 0             | Required value for X axis [deg]                    | float  | read write |
    *  | 0x3807  | SETPOINT_TILT_Y     | 0             | Required value for Y axis [deg]                    | float  | read write |
    *  | 0x3808  | SETPOINT_SHIFT_Z | 0             | Required value for Z axis [mm]                        | float  | read write |
    *  | 0x3809  | FB_HALL_CH0          | N/A           | Feedback value from hall sensor for channel 0 [V]     | uint16 | read write |
    *  | 0x380A  | FB_HALL_CH1      | N/A           | Feedback value from hall sensor for channel 1 [V]     | uint8_t| read write |
    *  | 0x380B  | FB_HALL_CH2      | N/A           | Feedback value from hall sensor for channel 2 [V]     | uint8_t| read write |
    *  | 0x380C  | FB_HALL_X            | N/A           | Transformed FB value from hall for X axis [deg]       | uint8_t| read only  |
    *  | 0x380D  | FB_HALL_Y            | N/A           | Transformed FB value from hall for Y axis [deg]       | uint8_t| read only  |
    *  | 0x380E  | FB_HALL_Z            | N/A           | Transformed FB value from hall for Z axis [dpt or mm] | float  | read only  |
    *  | 0x380F  | OUT_CURRENT_CH0      | 0             | Output of the controller for channel 0 [A]            | float  | read only  |
    *  | 0x3810  | OUT_CURRENT_CH1      | 0             | Output of the controller for channel 0 [A]            | float  | read only  |
    *  | 0x3811  | OUT_CURRENT_CH2      | 0             | Output of the controller for channel 0 [A]            | float  | read only  |
    *  | 0x3812  | OUT_MAX_CURRENT      | 0.1           | Maximal output current for individual channel [A]     | float  | write      |
    *  | 0x3813  | AXIS_IN_X_MAX        | 0             | Upper limit for input of X axis controller [deg]      | float  | write      |
    *  | 0x3814  | AXIS_IN_X_MIN        | 0             | Lower limit for input of X axis controller [deg]      | float  | write      |
    *  | 0x3815  | AXIS_IN_Y_MAX        | 0             | Upper limit for input of Y axis controller [deg]      | float  | write      |
    *  | 0x3816  | AXIS_IN_Y_MIN        | 0             | Lower limit for input of Y axis controller [deg]      | float  | write      |
    *  | 0x3817  | AXIS_IN_Z_MAX        | 0             | Upper limit for input of Z axis controller [dpt/mm]   | float  | write      |
    *  | 0x3818  | AXIS_IN_Z_MIN        | 0             | Lower limit for input of Z axis controller [dpt/mm]   | float  | write      |
    *  | 0x3819  | HALL_IN_CH0_MIN      | 0             | Lower limit for input of Channel 0 controller [V]     | float  | write      |
    *  | 0x381A  | HALL_IN_CH0_MAX      | 0             | Upper limit for input of Channel 0 controller [V]     | float  | write      |
    *  | 0x381B  | HALL_IN_CH1_MIN      | 0             | Lower limit for input of Channel 1 controller [V]     | float  | write      |
    *  | 0x381C  | HALL_IN_CH1_MAX      | 0             | Upper limit for input of Channel 1 controller [V]     | float  | write      |
    *  | 0x381D  | HALL_IN_CH2_MIN      | 0             | Lower limit for input of Channel 2 controller [V]     | float  | write      |
    *  | 0x381E  | HALL_IN_CH2_MAX      | 0             | Upper limit for input of Channel 2 controller [V]     | float  | write      |
    *  | 0x381F  | MOVE_RATE_X         | 0             | Gyro X feedback value (SG if XY_SG_DEBUG reg.enabled) | float  | read only  |
    *  | 0x3820  | MOVE_RATE_Y         | 0             | Gyro Y feedback value (SG if XY_SG_DEBUG reg.enabled) | float  | read only  |
    *  | 0x3821  | FB_AXIS_X           | 0             | X feedback value of the axis controller               | float  | read only  |
    *  | 0x3822  | FB_AXIS_Y           | 0             | Y feedback value of the axis controller               | float  | read only  |
    *  | 0x3823  | INIT                 | false         | Writes configuration from registers into IMU          | uint8  | write      |
    *  | 0x3824  | XY_SG_DEBUG          | false         | Connects signal generator instead of gyro (for debug) | uint8  | write      |
    *  | 0x3825  | RUN_OPEN_LOOP       | false         | Sets ch#1 cur.polarity according to magnet orientation| boolean| read write |
    *  |---------|---------------------|---------------|-------------------------------------------------------|--------|------------|
    *
    * ### Vector Map:
    *
    * | Address | Name                      | Default       | Description                                                       | Format and value          | Access     |
    * |---------|--------------------------|---------------|-------------------------------------------------------------------|---------------------------|------------|
    * | 0x3800  | 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 |
    * | 0x3801  | 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 |
    * | 0x3802  | HALL_TO_CURRENT_POLY_Z    | [0, 1, 0, 0 ] | {a0, a1, a2, a3}, feedforward polynome, outZ=pidZ.out+refZ*polyZ  | @polynom_order(=4) *float | read write |
    * | 0x3803  | HALL_TO_CURRENT_POLY_CH0  | [0, 0, 0, 0 ] | {a0, a1, a2, a3}, feedforward polynome, out0=pid0.out+ref0*poly0  | @polynom_order(=4) *float | read write |
    * | 0x3804  | HALL_TO_CURRENT_POLY_CH1  | [0, 0, 0, 0 ] | {a0, a1, a2, a3}, feedforward polynome, out1=pid1.out+ref1*poly1  | @polynom_order(=4) *float | read write |
    * | 0x3805  | HALL_TO_CURRENT_POLY_CH2  | [0, 0, 0, 0 ] | {a0, a1, a2, a3}, feedforward polynome, out2=pid2.out+ref2*poly2  | @polynom_order(=4) *float | read write |
    * | 0x3806  | HALL_PID_COEF_CH0     | [0, 0, 0 ]    | {Kp, Ki, Kd}, PID coefficients for channel 0 controller           | 3*float                   | write      |
    * | 0x3807  | HALL_PID_COEF_CH1     | [0, 0, 0 ]    | {Kp, Ki, Kd}, PID coefficients for channel 1 controller           | 3*float                   | write      |
    * | 0x3808  | HALL_PID_COEF_CH2     | [0, 0, 0 ]    | {Kp, Ki, Kd}, PID coefficients for channel 2 controller           | 3*float                   | write      |
    * | 0x3809  | HALL_PID_COEF_X           | [0, 0, 0 ]    | {Kp, Ki, Kd}, PID coefficients for X axis controller              | 3*float                   | write      |
    * | 0x380A  | HALL_PID_COEF_Y           | [0, 0, 0 ]    | {Kp, Ki, Kd}, PID coefficients for Y axis controller              | 3*float                   | write      |
    * | 0x380B  | HALL_PID_COEF_Z           | [0, 0, 0 ]    | {Kp, Ki, Kd}, PID coefficients for Z axis controller              | 3*float                   | write      |
    * | 0x380C  | OS_PID_CEF_X              | [0, 0, 0 ]    | {Kp, Ki, Kd}, PID coefficients for optical stabilisation in X dir | 3*float                   | write      |
    * | 0x380D  | OS_PID_CEF_Y              | [0, 0, 0 ]    | {Kp, Ki, Kd}, PID coefficients for optical stabilisation in X dir | 3*float                   | write      |
    * | 0x380E  | TF_HALL_TO_AXIS_X     | [0, 0, 0, 0 ] | {a0, a1, a2, a3}, conversion from hall voltage to X axis          | @polynom_order(=4) *float | write      |
    * | 0x380F  | TF_HALL_TO_AXIS_Y     | [0, 0, 0, 0 ] | {a0, a1, a2, a3}, conversion from hall voltage to Y axis          | @polynom_order(=4) *float | write      |
    * | 0x3810  | TF_HALL_TO_AXIS_Z     | [0, 0, 0, 0 ] | {a0, a1, a2, a3}, conversion from hall voltage to Z axis          | @polynom_order(=4) *float | write      |
    * | 0x3811  | TF_HALL_TO_AXIS_MATRIX    | [0, .., 0] (1)| Hall to Axis transformation matrix coefficients, size depends on CCM project (1)| @size *float | write     |
    * | 0x3812  | TF_AXIS_TO_CHANNEL_MATRIX| [0, .., 0] (2)| Axis to Channel transformation matrix coefficients, size depends on CCM project (2)| @size *float | write  |
    * | 0x3813  | GYRO_ORIENTATION_MATRIX  | [-1, .., 1] (3)| Matrix represents the setup of sensor acceleration Ax, Ay, Az values versus X, Y axes| 6*int32 | read write|
    *
    *
    * \note Transformation matrix coefficients are represented as rows following each other:
    *           <br/>(1) Frey = 13*3; Saiph = 10*2 coefficients
    *           <br/>(2) Frey =  4*3; Saiph =  3*2 coefficients
    *
    * Gyro orientation matrix represents the setup 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  |
    * | Y   |  0  |  0  |  1  |
    *
    * \note Matrix values can have only integer values, every row should have 2 matrix elements = 0 and one having absolute value = 1.
    *           <br/>(3) Default vector values are [-1, 0, 0, 0, 0, 1]

## Constructor & Destructor Documentation

## ◆ __init__()

optoICC.registers.icc_registers.SarynControl.__init__ | ( |  | self,
|  |  | board = None )

## Member Function Documentation

## ◆ help()

optoICC.registers.icc_registers.SarynControl.help | ( |  | ) |
| static

## ◆ get_value()

optoICC.registers.icc_registers.SarynControl.get_value | ( |  | self,
|  |  | channel )

## ◆ get_value_id()

optoICC.registers.icc_registers.SarynControl.get_value_id | ( |  | self,
|  |  | channel )

## ◆ is_init_done()

optoICC.registers.icc_registers.SarynControl.is_init_done | ( |  | self | ) |

## ◆ get_hall_voltage_x()

optoICC.registers.icc_registers.SarynControl.get_hall_voltage_x | ( |  | self | ) |

## ◆ get_hall_voltage_y()

optoICC.registers.icc_registers.SarynControl.get_hall_voltage_y | ( |  | self | ) |

## ◆ get_hall_voltage_z()

optoICC.registers.icc_registers.SarynControl.get_hall_voltage_z | ( |  | self | ) |

## ◆ get_x()

optoICC.registers.icc_registers.SarynControl.get_x | ( |  | self | ) |

## ◆ get_y()

optoICC.registers.icc_registers.SarynControl.get_y | ( |  | self | ) |

## ◆ get_z()

optoICC.registers.icc_registers.SarynControl.get_z | ( |  | self | ) |

## ◆ get_move_rate_x()

optoICC.registers.icc_registers.SarynControl.get_move_rate_x | ( |  | self | ) |

## ◆ get_move_rate_y()

optoICC.registers.icc_registers.SarynControl.get_move_rate_y | ( |  | self | ) |

## ◆ set_x()

optoICC.registers.icc_registers.SarynControl.set_x | ( |  | self,
|  |  | value = 0 )

## ◆ set_y()

optoICC.registers.icc_registers.SarynControl.set_y | ( |  | self,
|  |  | value = 0 )

## ◆ set_z()

optoICC.registers.icc_registers.SarynControl.set_z | ( |  | self,
|  |  | value = 0 )

## ◆ set_update_freq()

optoICC.registers.icc_registers.SarynControl.set_update_freq | ( |  | self,
|  |  | value = 2000 )

## ◆ set_max_output_current()

optoICC.registers.icc_registers.SarynControl.set_max_output_current | ( |  | self,
|  |  | value = 0.1 )

## ◆ enable_open_loop()

optoICC.registers.icc_registers.SarynControl.enable_open_loop | ( |  | self,
|  |  | enable = 0 )

## ◆ set_axis_in_limit_x()

optoICC.registers.icc_registers.SarynControl.set_axis_in_limit_x | ( |  | self,
|  |  | min_voltage,
|  |  | max_voltage )

## ◆ set_axis_in_limit_y()

optoICC.registers.icc_registers.SarynControl.set_axis_in_limit_y | ( |  | self,
|  |  | min_voltage,
|  |  | max_voltage )

## ◆ set_axis_in_limit_z()

optoICC.registers.icc_registers.SarynControl.set_axis_in_limit_z | ( |  | self,
|  |  | min_voltage,
|  |  | max_voltage )

## ◆ set_hall_in_limit_ch0()

optoICC.registers.icc_registers.SarynControl.set_hall_in_limit_ch0 | ( |  | self,
|  |  | min_voltage,
|  |  | max_voltage )

## ◆ set_hall_in_limit_ch1()

optoICC.registers.icc_registers.SarynControl.set_hall_in_limit_ch1 | ( |  | self,
|  |  | min_voltage,
|  |  | max_voltage )

## ◆ set_hall_in_limit_ch2()

optoICC.registers.icc_registers.SarynControl.set_hall_in_limit_ch2 | ( |  | self,
|  |  | min_voltage,
|  |  | max_voltage )

## ◆ init()

optoICC.registers.icc_registers.SarynControl.init | ( |  | self | ) |

## ◆ start_controller()

optoICC.registers.icc_registers.SarynControl.start_controller | ( |  | self | ) |

## ◆ stop_controller()

optoICC.registers.icc_registers.SarynControl.stop_controller | ( |  | self | ) |

## ◆ start_optical_stabilisation()

optoICC.registers.icc_registers.SarynControl.start_optical_stabilisation | ( |  | self | ) |

## ◆ stop_optical_stabilisation()

optoICC.registers.icc_registers.SarynControl.stop_optical_stabilisation | ( |  | self | ) |

## ◆ enable_SG_debug()

optoICC.registers.icc_registers.SarynControl.enable_SG_debug | ( |  | self | ) |

## ◆ disable_SG_debug()

optoICC.registers.icc_registers.SarynControl.disable_SG_debug | ( |  | self | ) |

## ◆ set_poly_hall_to_current_x()

optoICC.registers.icc_registers.SarynControl.set_poly_hall_to_current_x | ( |  | self,
|  |  | vector )

## ◆ set_poly_hall_to_current_y()

optoICC.registers.icc_registers.SarynControl.set_poly_hall_to_current_y | ( |  | self,
|  |  | vector )

## ◆ set_poly_hall_to_current_z()

optoICC.registers.icc_registers.SarynControl.set_poly_hall_to_current_z | ( |  | self,
|  |  | vector )

## ◆ set_poly_hall_to_current_ch0()

optoICC.registers.icc_registers.SarynControl.set_poly_hall_to_current_ch0 | ( |  | self,
|  |  | vector )

## ◆ set_poly_hall_to_current_ch1()

optoICC.registers.icc_registers.SarynControl.set_poly_hall_to_current_ch1 | ( |  | self,
|  |  | vector )

## ◆ set_poly_hall_to_current_ch2()

optoICC.registers.icc_registers.SarynControl.set_poly_hall_to_current_ch2 | ( |  | self,
|  |  | vector )

## ◆ set_pid_coef_ch0()

optoICC.registers.icc_registers.SarynControl.set_pid_coef_ch0 | ( |  | self,
|  |  | kp,
|  |  | ki,
|  |  | kd )

## ◆ set_pid_coef_ch1()

optoICC.registers.icc_registers.SarynControl.set_pid_coef_ch1 | ( |  | self,
|  |  | kp,
|  |  | ki,
|  |  | kd )

## ◆ set_pid_coef_ch2()

optoICC.registers.icc_registers.SarynControl.set_pid_coef_ch2 | ( |  | self,
|  |  | kp,
|  |  | ki,
|  |  | kd )

## ◆ set_pid_coef_x()

optoICC.registers.icc_registers.SarynControl.set_pid_coef_x | ( |  | self,
|  |  | kp,
|  |  | ki,
|  |  | kd )

## ◆ set_pid_coef_y()

optoICC.registers.icc_registers.SarynControl.set_pid_coef_y | ( |  | self,
|  |  | kp,
|  |  | ki,
|  |  | kd )

## ◆ set_pid_coef_z()

optoICC.registers.icc_registers.SarynControl.set_pid_coef_z | ( |  | self,
|  |  | kp,
|  |  | ki,
|  |  | kd )

## ◆ set_pid_coef_os_x()

optoICC.registers.icc_registers.SarynControl.set_pid_coef_os_x | ( |  | self,
|  |  | kp,
|  |  | ki,
|  |  | kd )

## ◆ set_pid_coef_os_y()

optoICC.registers.icc_registers.SarynControl.set_pid_coef_os_y | ( |  | self,
|  |  | kp,
|  |  | ki,
|  |  | kd )

## ◆ set_poly_tf_feedback_hall_to_axis_x()

optoICC.registers.icc_registers.SarynControl.set_poly_tf_feedback_hall_to_axis_x | ( |  | self,
|  |  | poly )

## ◆ set_poly_tf_feedback_hall_to_axis_y()

optoICC.registers.icc_registers.SarynControl.set_poly_tf_feedback_hall_to_axis_y | ( |  | self,
|  |  | poly )

## ◆ set_poly_tf_feedback_hall_to_axis_z()

optoICC.registers.icc_registers.SarynControl.set_poly_tf_feedback_hall_to_axis_z | ( |  | self,
|  |  | poly )

## ◆ set_matrix_tf_hall_to_axis()

optoICC.registers.icc_registers.SarynControl.set_matrix_tf_hall_to_axis | ( |  | self,
|  |  | vector )

## ◆ set_matrix_tf_axis_to_hall()

optoICC.registers.icc_registers.SarynControl.set_matrix_tf_axis_to_hall | ( |  | self,
|  |  | vector )

## ◆ set_gyro_orientation_matrix()

optoICC.registers.icc_registers.SarynControl.set_gyro_orientation_matrix | ( |  | self,
|  |  | vector )

## ◆ get_gyro_orientation_matrix()

optoICC.registers.icc_registers.SarynControl.get_gyro_orientation_matrix | ( |  | self | ) |

## Member Data Documentation

## ◆ _is_a_system

bool optoICC.registers.icc_registers.SarynControl._is_a_system = True
| static protected

## ◆ sys_id

int optoICC.registers.icc_registers.SarynControl.sys_id = 0x38

## ◆ run_controller

dict optoICC.registers.icc_registers.SarynControl.run_controller

Initial value:
= {'id': self.sys_id << 8 | 0x00, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ run_os

dict optoICC.registers.icc_registers.SarynControl.run_os

Initial value:
= {'id': self.sys_id << 8 | 0x01, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ update_frequency

dict optoICC.registers.icc_registers.SarynControl.update_frequency

Initial value:
= {'id': self.sys_id << 8 | 0x02, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ setpoint_hall_ch0

dict optoICC.registers.icc_registers.SarynControl.setpoint_hall_ch0

Initial value:
= {'id': self.sys_id << 8 | 0x03, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ setpoint_hall_ch1

dict optoICC.registers.icc_registers.SarynControl.setpoint_hall_ch1

Initial value:
= {'id': self.sys_id << 8 | 0x04, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ setpoint_hall_ch2

dict optoICC.registers.icc_registers.SarynControl.setpoint_hall_ch2

Initial value:
= {'id': self.sys_id << 8 | 0x05, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ setpoint_tilt_x

dict optoICC.registers.icc_registers.SarynControl.setpoint_tilt_x

Initial value:
= {'id': self.sys_id << 8 | 0x06, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ setpoint_tilt_y

dict optoICC.registers.icc_registers.SarynControl.setpoint_tilt_y

Initial value:
= {'id': self.sys_id << 8 | 0x07, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ setpoint_shift_z

dict optoICC.registers.icc_registers.SarynControl.setpoint_shift_z

Initial value:
= {'id': self.sys_id << 8 | 0x08, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_voltage_ch0

dict optoICC.registers.icc_registers.SarynControl.hall_voltage_ch0

Initial value:
= {'id': self.sys_id << 8 | 0x09, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_voltage_ch1

dict optoICC.registers.icc_registers.SarynControl.hall_voltage_ch1

Initial value:
= {'id': self.sys_id << 8 | 0x0A, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_voltage_ch2

dict optoICC.registers.icc_registers.SarynControl.hall_voltage_ch2

Initial value:
= {'id': self.sys_id << 8 | 0x0B, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_voltage_x

dict optoICC.registers.icc_registers.SarynControl.hall_voltage_x

Initial value:
= {'id': self.sys_id << 8 | 0x0C, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_voltage_y

dict optoICC.registers.icc_registers.SarynControl.hall_voltage_y

Initial value:
= {'id': self.sys_id << 8 | 0x0D, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_voltage_z

dict optoICC.registers.icc_registers.SarynControl.hall_voltage_z

Initial value:
= {'id': self.sys_id << 8 | 0x0E, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ output_current_ch0

dict optoICC.registers.icc_registers.SarynControl.output_current_ch0

Initial value:
= {'id': self.sys_id << 8 | 0x0F, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ output_current_ch1

dict optoICC.registers.icc_registers.SarynControl.output_current_ch1

Initial value:
= {'id': self.sys_id << 8 | 0x10, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ output_current_ch2

dict optoICC.registers.icc_registers.SarynControl.output_current_ch2

Initial value:
= {'id': self.sys_id << 8 | 0x11, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ output_max_current

dict optoICC.registers.icc_registers.SarynControl.output_max_current

Initial value:
= {'id': self.sys_id << 8 | 0x12, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ axis_in_x_max

dict optoICC.registers.icc_registers.SarynControl.axis_in_x_max

Initial value:
= {'id': self.sys_id << 8 | 0x13, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ axis_in_x_min

dict optoICC.registers.icc_registers.SarynControl.axis_in_x_min

Initial value:
= {'id': self.sys_id << 8 | 0x14, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ axis_in_y_max

dict optoICC.registers.icc_registers.SarynControl.axis_in_y_max

Initial value:
= {'id': self.sys_id << 8 | 0x15, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ axis_in_y_min

dict optoICC.registers.icc_registers.SarynControl.axis_in_y_min

Initial value:
= {'id': self.sys_id << 8 | 0x16, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ axis_in_z_max

dict optoICC.registers.icc_registers.SarynControl.axis_in_z_max

Initial value:
= {'id': self.sys_id << 8 | 0x17, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ axis_in_z_min

dict optoICC.registers.icc_registers.SarynControl.axis_in_z_min

Initial value:
= {'id': self.sys_id << 8 | 0x18, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_in_ch0_min

dict optoICC.registers.icc_registers.SarynControl.hall_in_ch0_min

Initial value:
= {'id': self.sys_id << 8 | 0x19, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_in_ch0_max

dict optoICC.registers.icc_registers.SarynControl.hall_in_ch0_max

Initial value:
= {'id': self.sys_id << 8 | 0x1A, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_in_ch1_min

dict optoICC.registers.icc_registers.SarynControl.hall_in_ch1_min

Initial value:
= {'id': self.sys_id << 8 | 0x1B, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_in_ch1_max

dict optoICC.registers.icc_registers.SarynControl.hall_in_ch1_max

Initial value:
= {'id': self.sys_id << 8 | 0x1C, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_in_ch2_min

dict optoICC.registers.icc_registers.SarynControl.hall_in_ch2_min

Initial value:
= {'id': self.sys_id << 8 | 0x1D, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ hall_in_ch2_max

dict optoICC.registers.icc_registers.SarynControl.hall_in_ch2_max

Initial value:
= {'id': self.sys_id << 8 | 0x1E, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ move_rate_x

dict optoICC.registers.icc_registers.SarynControl.move_rate_x

Initial value:
= {'id': self.sys_id << 8 | 0x1F, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ move_rate_y

dict optoICC.registers.icc_registers.SarynControl.move_rate_y

Initial value:
= {'id': self.sys_id << 8 | 0x20, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ fb_axis_x

dict optoICC.registers.icc_registers.SarynControl.fb_axis_x

Initial value:
= {'id': self.sys_id << 8 | 0x21, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ fb_axis_y

dict optoICC.registers.icc_registers.SarynControl.fb_axis_y

Initial value:
= {'id': self.sys_id << 8 | 0x22, 'type': float, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ init_sys

dict optoICC.registers.icc_registers.SarynControl.init_sys

Initial value:
= {'id': self.sys_id << 8 | 0x23, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ xy_sg_debug

dict optoICC.registers.icc_registers.SarynControl.xy_sg_debug

Initial value:
= {'id': self.sys_id << 8 | 0x24, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ run_open_loop

dict optoICC.registers.icc_registers.SarynControl.run_open_loop

Initial value:
= {'id': self.sys_id << 8 | 0x25, 'type': int, 'unit': None,
'range': None, 'default': None, 'value': None}

## ◆ vec_polly_hall_to_current_x

optoICC.registers.icc_registers.SarynControl.vec_polly_hall_to_current_x = {'id': self.sys_id << 8 | 0x00, 'type': float}

## ◆ vec_polly_hall_to_current_y

optoICC.registers.icc_registers.SarynControl.vec_polly_hall_to_current_y = {'id': self.sys_id << 8 | 0x01, 'type': float}

## ◆ vec_polly_hall_to_current_z

optoICC.registers.icc_registers.SarynControl.vec_polly_hall_to_current_z = {'id': self.sys_id << 8 | 0x02, 'type': float}

## ◆ vec_polly_hall_to_current_ch0

optoICC.registers.icc_registers.SarynControl.vec_polly_hall_to_current_ch0 = {'id': self.sys_id << 8 | 0x03, 'type': float}

## ◆ vec_polly_hall_to_current_ch1

optoICC.registers.icc_registers.SarynControl.vec_polly_hall_to_current_ch1 = {'id': self.sys_id << 8 | 0x04, 'type': float}

## ◆ vec_polly_hall_to_current_ch2

optoICC.registers.icc_registers.SarynControl.vec_polly_hall_to_current_ch2 = {'id': self.sys_id << 8 | 0x05, 'type': float}

## ◆ vec_pid_coef_ch0

optoICC.registers.icc_registers.SarynControl.vec_pid_coef_ch0 = {'id': self.sys_id << 8 | 0x06, 'type': float}

## ◆ vec_pid_coef_ch1

optoICC.registers.icc_registers.SarynControl.vec_pid_coef_ch1 = {'id': self.sys_id << 8 | 0x07, 'type': float}

## ◆ vec_pid_coef_ch2

optoICC.registers.icc_registers.SarynControl.vec_pid_coef_ch2 = {'id': self.sys_id << 8 | 0x08, 'type': float}

## ◆ vec_pid_coef_x

optoICC.registers.icc_registers.SarynControl.vec_pid_coef_x = {'id': self.sys_id << 8 | 0x09, 'type': float}

## ◆ vec_pid_coef_y

optoICC.registers.icc_registers.SarynControl.vec_pid_coef_y = {'id': self.sys_id << 8 | 0x0A, 'type': float}

## ◆ vec_pid_coef_z

optoICC.registers.icc_registers.SarynControl.vec_pid_coef_z = {'id': self.sys_id << 8 | 0x0B, 'type': float}

## ◆ vec_os_pid_coef_x

optoICC.registers.icc_registers.SarynControl.vec_os_pid_coef_x = {'id': self.sys_id << 8 | 0x0C, 'type': float}

## ◆ vec_os_pid_coef_y

optoICC.registers.icc_registers.SarynControl.vec_os_pid_coef_y = {'id': self.sys_id << 8 | 0x0D, 'type': float}

## ◆ vec_tf_hall_to_axis_x

optoICC.registers.icc_registers.SarynControl.vec_tf_hall_to_axis_x = {'id': self.sys_id << 8 | 0x0E, 'type': float}

## ◆ vec_tf_hall_to_axis_y

optoICC.registers.icc_registers.SarynControl.vec_tf_hall_to_axis_y = {'id': self.sys_id << 8 | 0x0F, 'type': float}

## ◆ vec_tf_hall_to_axis_z

optoICC.registers.icc_registers.SarynControl.vec_tf_hall_to_axis_z = {'id': self.sys_id << 8 | 0x10, 'type': float}

## ◆ vec_tf_hall_to_axis_matrix

optoICC.registers.icc_registers.SarynControl.vec_tf_hall_to_axis_matrix = {'id': self.sys_id << 8 | 0x11, 'type': float}

## ◆ vec_tf_axis_to_hall_matrix

optoICC.registers.icc_registers.SarynControl.vec_tf_axis_to_hall_matrix = {'id': self.sys_id << 8 | 0x12, 'type': float}

## ◆ vec_gyro_orientation_matrix

optoICC.registers.icc_registers.SarynControl.vec_gyro_orientation_matrix = {'id': self.sys_id << 8 | 0x13, 'type': int}

## ◆ name

optoICC.registers.icc_registers.SarynControl.name = self.__class__.__name__