## C/C++ API Reference
### <span style={{color: "#A7A7A7"}}>Driver.</span>Driver()
```cpp
Driver::Driver(uint32_t node_id, Interface *interface)
```
##### Description
Construct a new Driver object when Driver is connected via NLink / Native CAN. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint32_t``` | ```node_id``` | CAN Node ID of the driver  |
|```Interface *``` | ```interface``` | Initialised CAN Interface / USB Interface object for the interface to which the driver is connected  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>Driver()
```cpp
Driver::Driver(Interface *interface)
```
##### Description
Construct a new Driver object when Driver is directly connected via USB. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```Interface *``` | ```interface``` | CAN Interface / USB Interface object for the interface to which the Driver is connected  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>clearDriverErrors()
```cpp
ret_status_t Driver::clearDriverErrors()
```
##### Description
Clear driver errors. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>clearMAxxxOffAxisCalibration()
```cpp
uint8_t Driver::clearMAxxxOffAxisCalibration(bool encoder)
```
##### Description
Clear off-axis calibration for MAxxx series encoders. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to indicate if it's a motor encoder or output encoder. False for motor side encoder True for output side encoder'  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```uint8_t```| uint8_t Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>configureMotorEncoder()
```cpp
ret_status_t Driver::configureMotorEncoder(uint8_t encoder_type, int32_t resolution_param=4096, bool use_index=true)
```
##### Description
Configure motor side encoder. Set it to onboard absolute, external incremental or external absolute. Output side and motor side encoders can't be set to same. 

| `encoder_type` value | Encoder Type | Description |
|:----:|:----:|:-----|
| 0 | `TYPE_NONE` | Using no encoder |
| 1 | `TYPE_ONBOARD_ENCODER` | Using onboard absolute encoder (Tested) |
| 2 | `TYPE_INCREMENTAL` | Using External incremental Encoder (Tested) |
| 3 | `TYPE_SPI_ABS_AMS` | Using AS5047P absolute encoder from AMS (Tested) |
| 4 | `TYPE_SPI_ABS_MAXXX` | Using MA7xx series absolute encoders from Monolith Power Systems (Tested with MA732, MA702) |
| 5 | `TYPE_SPI_ABS_MUXXX` | Using MU series absolute encoders from iC-Haus (Tested with MU150, MU200) |
| 6 | `TYPE_SPI_ABS_CUI` | Using AMT 203 absolute encoder from CUI (Tested) |
| 7 | `TYPE_SPI_ABS_AEAT` | Using AEAT absolute encoders from Broadcomm (To be tested) |
| 8 | `TYPE_SPI_ABS_RLS` | Using RLS absolute encoders from Renishaw (To be tested) |
| 9 | `TYPE_SPI_ABS_MA600` | Using MA600 series absolute encoders from Monolith Power Systems (Tested) |
| 20 | `TYPE_HALL_SENSOR` | Using Hall Sensor Feedback (Tested) |

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t``` | ```encoder_type``` | type of encoder used  |
|```int32_t``` | ```resolution_param``` | CPR value of the encoder in case of an incremental encoder or resolution value in 2^bits in case of absolute encoder (this parameter is ignored in the case of using onboard absolute encoder) resolution_param is set to 4096 by default.  |
|```bool``` | ```use_index``` | flag to set whether to use the index pin for incremental encoder or not. Valid only when an incremental encoder is used. use_index is set to true by default.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>configureOutputEncoder()
```cpp
ret_status_t Driver::configureOutputEncoder(uint8_t encoder_type, int32_t resolution_param=4096, bool use_index=true)
```
##### Description
Configure Output side encoder. Set it to onboard absolute, external incremental or external absolute. Output side and motor side encoders can't be set to same. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t``` | ```encoder_type``` | - |
|```int32_t``` | ```resolution_param``` | - |
|```bool``` | ```use_index``` | - |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| - |

### <span style={{color: "#A7A7A7"}}>Driver.</span>disableBrakeResistor()
```cpp
ret_status_t Driver::disableBrakeResistor()
```
##### Description
Disable brake resistor and configure it. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>disableMotorThermalLimit()
```cpp
ret_status_t Driver::disableMotorThermalLimit()
```
##### Description
Disable Motor based Thermal limit. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>disableOutputEncoder()
```cpp
ret_status_t Driver::disableOutputEncoder()
```
##### Description
Disable Output Encoder. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>emergencyStop()
```cpp
ret_status_t Driver::emergencyStop()
```
##### Description
Function to issue an emergency stop to the device which halts the driver and sets the error flag; Since the error flag is set the driver doesn't respond to any other commands, until the driver is rebooted. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>enableBrakeResistor()
```cpp
ret_status_t Driver::enableBrakeResistor(float brake_resistance_value)
```
##### Description
Enable brake resistor and configure it. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```brake_resistance_value``` | brake resistance value  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>enableMotorThermalLimit()
```cpp
ret_status_t Driver::enableMotorThermalLimit(uint16_t upper_limit)
```
##### Description
Enable Motor based Thermal limit. A thermistor is used to measure motor temperature and start limiting the motor current once the temperature starts to approach the upper limit. The current limiting starts when the difference between the current temperature & the upper limit reaches 10 degrees celsius. The actuators will shut themselves off in case the temperature reaches the upper limit. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint16_t``` | ```upper_limit``` | Shutdown temperature at which the driver will stop.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>enterDFUMode()
```cpp
ret_status_t Driver::enterDFUMode()
```
##### Description
Enter in DFU Mode. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| ret_status_t  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>eraseConfigurations()
```cpp
ret_status_t Driver::eraseConfigurations()
```
##### Description
Erase Configuration of the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>flash()
```cpp
ret_status_t Driver::flash(std::string firmware_path, bool is_in_dfu_mode=false)
```
##### Description
Function to flash a firmware onto the device. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```std::string``` | ```firmware_path``` | path to firmware file  |
|```bool``` | ```is_in_dfu_mode``` | flag to set if the driver is already in dfu mode  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| ret_status_t  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getBrakeCurrent()
```cpp
ret_status_t Driver::getBrakeCurrent(float *brake_current)
```
##### Description
Function to get the brake current of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```brake_current``` | variable to store the brake current  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getBrakeResistorState()
```cpp
ret_status_t Driver::getBrakeResistorState(bool *enable, float *brake_resistance_value, bool *brake_resistor_armed, bool *brake_resistor_saturated)
```
##### Description
Get current state of brake resistor. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool *``` | ```enable``` | Pointer to variable to which the enable status of the brake resistor is to be saved (true means that the brake resistor is enabled).  |
|```float *``` | ```brake_resistance_value``` | Pointer to the variable to which the value of brake resistance is to be saved.  |
|```bool *``` | ```brake_resistor_armed``` | Pointer to the variable to which the value of the arm status of the brake resistor is to be saved (true means that the brake resistor is armed).  |
|```bool *``` | ```brake_resistor_saturated``` | Pointer to the variable to which the value of saturation status of the brake resistor is to be saved (true means that the brake resistor is saturated).  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getBusCurrent()
```cpp
ret_status_t Driver::getBusCurrent(float *ibus)
```
##### Description
Get the Bus Current of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```ibus``` | Pointer to the variable to which the bus current value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getBusVoltage()
```cpp
ret_status_t Driver::getBusVoltage(float *vbus_voltage)
```
##### Description
Get the Bus Voltage of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```vbus_voltage``` | Pointer to the variable to which the current bus voltage value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCANBaudRate()
```cpp
ret_status_t Driver::getCANBaudRate(CANBaudRate *baud_rate)
```
##### Description
Get the CAN Baud Rate of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```CANBaudRate *``` | ```baud_rate``` | Pointer to the variable to which the CAN Baud Rate is to be saved  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| ret_status_t  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCANCommunicationStatus()
```cpp
ret_status_t Driver::getCANCommunicationStatus(bool *is_connected_to_master, bool *is_receiving_heartbeat)
```
##### Description
Get CAN communication status. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool *``` | ```is_connected_to_master``` | Pointer to the variable to which the status of connection to master node is to be saved.  |
|```bool *``` | ```is_receiving_heartbeat``` | Pointer to the variable to which the heartbeat receive status is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getControllerMode()
```cpp
ret_status_t Driver::getControllerMode(uint16_t *control_mode)
```
##### Description
Get controller mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint16_t *``` | ```control_mode``` | Pointer to the variable to which the value of control mode is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getControllerState()
```cpp
ret_status_t Driver::getControllerState(uint8_t *controller_state)
```
##### Description
Get the controller state of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t *``` | ```controller_state``` | Pointer to the variable to which the controller state value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCurrentControllerBandwidth()
```cpp
ret_status_t Driver::getCurrentControllerBandwidth(float *bandwidth)
```
##### Description
Get current bandwidth of the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```bandwidth``` | Pointer to the variable to which the current controller bandwidth is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCurrentControllerGains()
```cpp
ret_status_t Driver::getCurrentControllerGains(float *p_gain, float *i_gain)
```
##### Description
Get current controller gains. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```p_gain``` | Pointer to the variable to which the current controller gain value of the controller is to be saved.  |
|```float *``` | ```i_gain``` | Pointer to the variable to which the current controller integrator gain value of the controller is to be saved. controller  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCurrentFilter()
```cpp
ret_status_t Driver::getCurrentFilter(float *current_filter)
```
##### Description
Get the current data filter value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```current_filter``` | Value of current filter.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDCBusTripLevels()
```cpp
ret_status_t Driver::getDCBusTripLevels(float *undervoltage_level, float *overvoltage_level)
```
##### Description
Get the driver's current under-voltage and over-voltage levels. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```undervoltage_level``` | Pointer to the variable where the under-voltage trip level is to be saved.  |
|```float *``` | ```overvoltage_level``` | Pointer to the variable where the over-voltage trip level is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDCCalibPhaseCurrents()
```cpp
ret_status_t Driver::getDCCalibPhaseCurrents(float *dc_calib_phA, float *dc_calib_phB, float *dc_calib_phC)
```
##### Description
Get motor phase dc calib currents in Ampere. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```dc_calib_phA``` | Pointer to the variable to which the current in phase A value is to be saved.  |
|```float *``` | ```dc_calib_phB``` | Pointer to the variable to which the current in phase B value is to be saved.  |
|```float *``` | ```dc_calib_phC``` | Pointer to the variable to which the current in phase C value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDebugErrorCode()
```cpp
ret_status_t Driver::getDebugErrorCode(uint64_t *system_error, uint64_t *axis_error, uint64_t *motor_error, uint64_t *encoder_error, uint64_t *controller_error, uint64_t *driver_error)
```
##### Description
Get the debug error codes from the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint64_t *``` | ```system_error``` | Pointer to the variable to which the value of system error code is saved  |
|```uint64_t *``` | ```axis_error``` | Pointer to the variable to which the value of axis error code is saved  |
|```uint64_t *``` | ```motor_error``` | Pointer to the variable to which the value of motor error code is saved  |
|```uint64_t *``` | ```encoder_error``` | Pointer to the variable to which the value of encoder error code is saved  |
|```uint64_t *``` | ```controller_error``` | Pointer to the variable to which the value of controller error code is saved  |
|```uint64_t *``` | ```driver_error``` | Pointer to the variable to which the value of driver error code is saved  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDriverFault()
```cpp
ret_status_t Driver::getDriverFault(uint32_t *driver_error)
```
##### Description
Get the Driver error status from the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint32_t *``` | ```driver_error``` | Pointer to the variable to which the value of driver error is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDriverTemperature()
```cpp
ret_status_t Driver::getDriverTemperature(float *driver_temperature)
```
##### Description
Get driver temperature in degree Celsius. It uses a thermistor near the FETs to measure the temperature. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```driver_temperature``` | Pointer to the variable to which the current driver temperature value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getEncoderDataFilter()
```cpp
ret_status_t Driver::getEncoderDataFilter(float *encoder_data_filter)
```
##### Description
Get the current value of encoder data filter in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```encoder_data_filter``` | Pointer to the variable to which the current encoder data filter value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getErrorCode()
```cpp
ret_status_t Driver::getErrorCode(driver_error_t *error_code)
```
##### Description
Get the error code from the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```driver_error_t *``` | ```error_code``` | Pointer to the variable to which the value of error code is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getFirmwareCommit()
```cpp
ret_status_t Driver::getFirmwareCommit(std::string *commit)
```
##### Description
Get Driver's Firmware commit. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```std::string *``` | ```commit``` | Pointer to the variable where the commit value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getFirmwareVersion()
```cpp
ret_status_t Driver::getFirmwareVersion(uint8_t *major, uint8_t *minor, uint16_t *revision)
```
##### Description
Get Driver's Firmware version. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t *``` | ```major``` | Pointer to the variable where the major version value is to be saved.  |
|```uint8_t *``` | ```minor``` | Pointer to the variable where the minor version value is to be saved.  |
|```uint16_t *``` | ```revision``` | Pointer to the variable where the revision value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getGearBoxParameters()
```cpp
ret_status_t Driver::getGearBoxParameters(float *gear_ratio)
```
##### Description
Get Gear ratio of the Gearbox. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```gear_ratio``` | Pointer to the variable to which the gear ratio value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getHallEncoderState()
```cpp
ret_status_t Driver::getHallEncoderState(uint8_t *hall_state)
```
##### Description
Get Hall encoder state. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t *``` | ```hall_state``` | Pointer to variable to which the value of hall state is to be saved  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getHallEncoderStateCounts()
```cpp
ret_status_t Driver::getHallEncoderStateCounts(uint16_t *hall0_count, uint16_t *hall1_count, uint16_t *hall2_count, uint16_t *hall3_count, uint16_t *hall4_count, uint16_t *hall5_count, uint16_t *hall6_count, uint16_t *hall7_count)
```
##### Description
Get Hall encoder state count. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint16_t *``` | ```hall0_count``` | Pointer to variable to which the value of hall state 0 count is to be saved.  |
|```uint16_t *``` | ```hall1_count``` | Pointer to variable to which the value of hall state 1 count is to be saved.  |
|```uint16_t *``` | ```hall2_count``` | Pointer to variable to which the value of hall state 2 count is to be saved.  |
|```uint16_t *``` | ```hall3_count``` | Pointer to variable to which the value of hall state 3 count is to be saved.  |
|```uint16_t *``` | ```hall4_count``` | Pointer to variable to which the value of hall state 4 count is to be saved.  |
|```uint16_t *``` | ```hall5_count``` | Pointer to variable to which the value of hall state 5 count is to be saved.  |
|```uint16_t *``` | ```hall6_count``` | Pointer to variable to which the value of hall state 6 count is to be saved.  |
|```uint16_t *``` | ```hall7_count``` | Pointer to variable to which the value of hall state 7 count is to be saved. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getHardwareVersion()
```cpp
ret_status_t Driver::getHardwareVersion(uint8_t *tag, uint8_t *major, uint8_t *minor, uint8_t *variant)
```
##### Description
Get Driver's Hardware version. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t *``` | ```tag``` | Pointer to the variable where the hardware tag value is to be saved.  |
|```uint8_t *``` | ```major``` | Pointer to the variable where the major version value is to be saved.  |
|```uint8_t *``` | ```minor``` | Pointer to the variable where the minor version value is to be saved.  |
|```uint8_t *``` | ```variant``` | Pointer to the variable where the variant value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getIdqCurrents()
```cpp
ret_status_t Driver::getIdqCurrents(float *id_current, float *iq_current)
```
##### Description
Get the Id and Iq currents of the motor. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```id_current``` | Pointer to the variable to which the Id current value is to be saved.  |
|```float *``` | ```iq_current``` | Pointer to the variable to which the Iq current value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMAxxxBCTValue()
```cpp
ret_status_t Driver::getMAxxxBCTValue(bool encoder, uint8_t *bct_value, bool *status)
```
##### Description
Get the encoder bct value of the MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```uint8_t *``` | ```bct_value``` | Pointer to the variable to which the current encoder bct value is to be saved.  |
|```bool *``` | ```status``` | - |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMAxxxFilterWindow()
```cpp
ret_status_t Driver::getMAxxxFilterWindow(bool encoder, uint8_t *filter_window, bool *status)
```
##### Description
Get the encoder filter window of MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```uint8_t *``` | ```filter_window``` | Pointer to the variable to which the current encoder filter window is to be saved.  |
|```bool *``` | ```status``` | - |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMAxxxSPIRegister()
```cpp
ret_status_t Driver::getMAxxxSPIRegister(bool encoder, uint8_t register_address, uint8_t *data, bool *status)
```
##### Description
Get the register for MAxxx series encoders. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to indicate if it's a motor encoder or output encoder. False for motor side encoder True for output side encoder'  |
|```uint8_t``` | ```register_address``` | Address of the register to read  |
|```uint8_t *``` | ```data``` | Pointer to the variable to which the read value is saved  |
|```bool *``` | ```status``` | Pointer to the variable to which the status is saved  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| ret_status_t Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMAxxxTrimmingSettings()
```cpp
ret_status_t Driver::getMAxxxTrimmingSettings(bool encoder, bool *etx, bool *ety, bool *status)
```
##### Description
Get the trimming setting of MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```bool *``` | ```etx``` | Value of the encoder etx settings.  |
|```bool *``` | ```ety``` | Value of the encoder ety settings.  |
|```bool *``` | ```status``` | - |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorAcceleration()
```cpp
ret_status_t Driver::getMotorAcceleration(float *motor_acceleration)
```
##### Description
Get current acceleration of the motor rotor in rotations per second^2. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```motor_acceleration``` | Pointer to the variable to which the current acceleration value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorCalibrationParameters()
```cpp
ret_status_t Driver::getMotorCalibrationParameters(float *motor_calib_voltage, float *motor_calib_current)
```
##### Description
Get current Motor Calibration Parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```motor_calib_voltage``` | Pointer to the variable to which the current calibration voltage to calibrate motor is to be saved.  |
|```float *``` | ```motor_calib_current``` | Pointer to the variable to which the current calibration current to calibrate motor is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorEncoderBandwidth()
```cpp
ret_status_t Driver::getMotorEncoderBandwidth(float *bandwidth)
```
##### Description
Get motor encoder bandwidth of the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```bandwidth``` | Pointer to the variable to which the encoder bandwidth is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorEncoderConfiguration()
```cpp
ret_status_t Driver::getMotorEncoderConfiguration(uint8_t *encoder_type, int32_t *resolution_param, bool *use_index)
```
##### Description
Get motor encoder configuration. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t *``` | ```encoder_type``` | Pointer to the variable to which the current encoder type value is to be saved. If the value is 0, it means the output encoder is not enabled.  |
|```int32_t *``` | ```resolution_param``` | Pointer to the variable to which the value of encoder CPR (in case of incremental encoder) or value of encoder resolution bits (in case of absolute encoder) is to be saved.  |
|```bool *``` | ```use_index``` | Pointer to the variable to which the status of using index pin for incremental encoder is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorEncoderRawData()
```cpp
ret_status_t Driver::getMotorEncoderRawData(int32_t *encoder_data)
```
##### Description
Get raw encoder data from the encoder on the motor side. Returns the counts in case its an incremental encoder or it returns the raw bit data in case its an absolute encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int32_t *``` | ```encoder_data``` | Pointer to the variable to which the raw encoder value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorEncoderState()
```cpp
ret_status_t Driver::getMotorEncoderState(bool *index_found, bool *is_ready, bool *is_hall_calibrated)
```
##### Description
Get the state of encoder on the motor side. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool *``` | ```index_found``` | Pointer to the variable to which the index_found state of the motor encoder is to be saved. This value is only valid if the motor side encoder is incremental.  |
|```bool *``` | ```is_ready``` | Pointer to the variable to which the is_ready state of the motor encoder is to be saved (true means that the motor side encoder is ready)  |
|```bool *``` | ```is_hall_calibrated``` | Pointer to the variable to which the is_hall_calibrated state of the motor encoder is to be saved (true means that the motor side hall encoder is calibrated)  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorParameters()
```cpp
ret_status_t Driver::getMotorParameters(uint8_t *pole_pairs, uint16_t *kV_rating, float *current_limit)
```
##### Description
Get current motor parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t *``` | ```pole_pairs``` | Pointer to the variable to which the pole-pair value of the motor is to be saved.  |
|```uint16_t *``` | ```kV_rating``` | Pointer to the variable to which the kV rating value of the motor is to be saved.  |
|```float *``` | ```current_limit``` | Pointer to the variable to which the current limit value for the motor is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorPhaseCurrents()
```cpp
ret_status_t Driver::getMotorPhaseCurrents(float *phA, float *phB, float *phC)
```
##### Description
Get motor phase currents in Ampere. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```phA``` | Pointer to the variable to which the current in phase A value is to be saved.  |
|```float *``` | ```phB``` | Pointer to the variable to which the current in phase B value is to be saved.  |
|```float *``` | ```phC``` | Pointer to the variable to which the current in phase C value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorPhaseParameters()
```cpp
ret_status_t Driver::getMotorPhaseParameters(float *phase_resistance, float *phase_inductance)
```
##### Description
Get the Motor Phase Parameters (Phase Resistance and Phase Inductance of the motor windings) 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```phase_resistance``` | Pointer to the variable to which the phase resistance of the motor is to be saved.  |
|```float *``` | ```phase_inductance``` | Pointer to the variable to which the phase inductance of the motor is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorPosition()
```cpp
ret_status_t Driver::getMotorPosition(float *motor_position)
```
##### Description
Get current angle of the motor rotor in number of rotations. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```motor_position``` | Pointer to the variable to which the current rotation value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorState()
```cpp
ret_status_t Driver::getMotorState(bool *is_calibrated, bool *is_armed)
```
##### Description
Get the motor state of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool *``` | ```is_calibrated``` | Pointer to the variable to which the is_calibrated state of motor is to be saved.  |
|```bool *``` | ```is_armed``` | Pointer to the variable to which the is_armed state of motor is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorTemperature()
```cpp
ret_status_t Driver::getMotorTemperature(float *motor_temperature)
```
##### Description
Get motor temperature in degree Celsius. Valid only if a motor thermistor is connected to the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```motor_temperature``` | Pointer to the variable to which the current motor temperature value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorThermistorConfiguration()
```cpp
ret_status_t Driver::getMotorThermistorConfiguration(bool *enable, float *r_ref, uint16_t *beta, uint8_t *upper_limit, uint8_t *lower_limit)
```
##### Description
Get the Motor thermistor configuration. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool *``` | ```enable``` | Pointer to the variable where the enabled/disabled status of the motor thermal limit is to be saved.  |
|```float *``` | ```r_ref``` | Pointer to the variable to which the Reference Resistance value is to be saved.  |
|```uint16_t *``` | ```beta``` | Pointer to the variable to which the beta value of thermistor is to be saved.  |
|```uint8_t *``` | ```upper_limit``` | Pointer to the variable where the upper limit of the thermal limit is to be saved.  |
|```uint8_t *``` | ```lower_limit``` | Pointer to the variable where the lower limit of the thermal limit is to be saved. This is the limit from which the current limiting of the driver will start.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorTorque()
```cpp
ret_status_t Driver::getMotorTorque(float *rotor_torque)
```
##### Description
Get torque of the motor rotor in Nm. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```rotor_torque``` | Pointer to the variable to which the current torque value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorTorqueLimit()
```cpp
ret_status_t Driver::getMotorTorqueLimit(float *torque_limit)
```
##### Description
Get the torque limit for the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```torque_limit``` | Pointer to the variable to which the torque limit value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorType()
```cpp
ret_status_t Driver::getMotorType(uint8_t *motor_type)
```
##### Description
Get the motor type connected to the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t *``` | ```motor_type``` | Pointer to the variable to which the motor type value is to be saved. (0: HIGH_CURRENT_BLDC, 1: GIMBAL)  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorVelocity()
```cpp
ret_status_t Driver::getMotorVelocity(float *motor_velocity)
```
##### Description
Get current velocity of the motor rotor in rotations per second[rps]. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```motor_velocity``` | Pointer to the variable to which the current velocity value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getNodeId()
```cpp
ret_status_t Driver::getNodeId(uint32_t *node_id)
```
##### Description
Get current CAN Node ID of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint32_t *``` | ```node_id``` | Pointer to the variable to which the current CAN Node ID of the driver is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputAcceleration()
```cpp
ret_status_t Driver::getOutputAcceleration(float *output_acceleration)
```
##### Description
Get current acceleration of the output in degrees per second^2. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```output_acceleration``` | Pointer to the variable to which the current output acceleration value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputEncoderConfiguration()
```cpp
ret_status_t Driver::getOutputEncoderConfiguration(uint8_t *encoder_type, int32_t *resolution_param, bool *use_index)
```
##### Description
Get output encoder configuration. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t *``` | ```encoder_type``` | Pointer to the variable to which the current encoder type value is to be saved. If the value is 0, it means the output encoder is not enabled.  |
|```int32_t *``` | ```resolution_param``` | Pointer to the variable to which the value of encoder CPR (in case of incremental encoder) or value of encoder resolution bits (in case of absolute encoder) is to be saved.  |
|```bool *``` | ```use_index``` | Pointer to the variable to which the status of using index pin for incremental encoder is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputEncoderRawData()
```cpp
ret_status_t Driver::getOutputEncoderRawData(int32_t *encoder_data)
```
##### Description
Get raw encoder data from the encoder on the Output side. Returns the counts in case its an incremental encoder or it returns the raw bit data in case its an absolute encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int32_t *``` | ```encoder_data``` | Pointer to the variable to which the raw encoder value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputEncoderState()
```cpp
ret_status_t Driver::getOutputEncoderState(bool *index_found, bool *is_ready)
```
##### Description
Get the state of encoder on the output side. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool *``` | ```index_found``` | Pointer to the variable to which the index_found state of the motor encoder is to be saved. This value is only valid if the motor side encoder is incremental.  |
|```bool *``` | ```is_ready``` | Pointer to the variable to which the is_ready state of the motor encoder is to be saved (true means that the output side encoder is ready)  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputPosition()
```cpp
ret_status_t Driver::getOutputPosition(float *output_position)
```
##### Description
Get current angle of the output in degrees. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```output_position``` | Pointer to the variable to which the current output angle value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputTorque()
```cpp
ret_status_t Driver::getOutputTorque(float *output_torque)
```
##### Description
Get current torque at the output in Nm. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```output_torque``` | Pointer to the variable to which the current output torque value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputVelocity()
```cpp
ret_status_t Driver::getOutputVelocity(float *output_velocity)
```
##### Description
Get current velocity of the output in degrees per second. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```output_velocity``` | Pointer to the variable to which the current velocity value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getPositionControllerGain()
```cpp
ret_status_t Driver::getPositionControllerGain(float *position_gain)
```
##### Description
Get position controller gain value. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```position_gain``` | Pointer to the variable to which the current position controller gain value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getRegenCurrentTripLevel()
```cpp
ret_status_t Driver::getRegenCurrentTripLevel(float *regen_current_trip_level)
```
##### Description
Get the maximum regenerative current the power supply/battery can take. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```regen_current_trip_level``` | Pointer to the variable to which the value of the maximum regeneration current that battery/supply is to be saved  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getStartupConfigs()
```cpp
ret_status_t Driver::getStartupConfigs(bool *index_search, bool *encoder_matching, bool *closed_loop)
```
##### Description
Get startup configuration of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool *``` | ```index_search``` | Pointer to the variable to which the enable/disable status of index searching on startup is to be saved.  |
|```bool *``` | ```encoder_matching``` | Pointer to the variable to which the enable/disable status of output encoder matching sequence on startup is to be saved.  |
|```bool *``` | ```closed_loop``` | Pointer to the variable to which the enable/disable status of setting the driver to closed loop on startup value is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getTrajectoryDoneStatus()
```cpp
ret_status_t Driver::getTrajectoryDoneStatus(bool *is_done)
```
##### Description
Get the trajectory done status. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool *``` | ```is_done``` | Pointer to the variable to which the status of reaching the trajectory end point is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getVelocityControllerGains()
```cpp
ret_status_t Driver::getVelocityControllerGains(float *vel_gain, float *vel_integrator_gain)
```
##### Description
Get controller velocity controller gains. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```vel_gain``` | Pointer to the variable to which the velocity gain value of the controller is to be saved.  |
|```float *``` | ```vel_integrator_gain``` | Pointer to the variable to which the velocity integrator gain value of the controller is to be saved. controller  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getZeroPosition()
```cpp
ret_status_t Driver::getZeroPosition(float *zero_position)
```
##### Description
Get zero offset position in degrees. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float *``` | ```zero_position``` | Pointer to the variable to which the zero position of the driver is to be saved.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>importConfiguration()
```cpp
uint8_t Driver::importConfiguration(std::string config)
```
##### Description
Function to write current configuration from json file to device. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```std::string``` | ```config``` | Configuration in JSON string format  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```uint8_t```| - |

### <span style={{color: "#A7A7A7"}}>Driver.</span>isConnected()
```cpp
bool Driver::isConnected()
```
##### Description
Check if the device is still connected or not. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```bool```| true  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>rebootDriver()
```cpp
ret_status_t Driver::rebootDriver()
```
##### Description
Reboot the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runCalibrationSequence()
```cpp
ret_status_t Driver::runCalibrationSequence()
```
##### Description
Run calibration sequence on the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runEncoderCalibration()
```cpp
ret_status_t Driver::runEncoderCalibration()
```
##### Description
Run encoder calibration on the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runEncoderIndexSearch()
```cpp
ret_status_t Driver::runEncoderIndexSearch()
```
##### Description
Function to run incremental encoder index search. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runEncoderMatching()
```cpp
ret_status_t Driver::runEncoderMatching()
```
##### Description
Function to run matches the motor encoder with output encoder. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runMAxxxOffAxisCalibration()
```cpp
uint8_t Driver::runMAxxxOffAxisCalibration(bool encoder, float constant_speed_dps)
```
##### Description
Run off-axis calibration for MAxxx series encoders. For MA702 and MA732 encoders, only BCT calibration will be performed, while for MA600 encoders, both BCT calibration and Harmonic Compensation calibration will be performed. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to indicate if it's a motor encoder or output encoder. False for motor side encoder True for output side encoder'  |
|```float``` | ```constant_speed_dps``` | Constant speed in degrees per second  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```uint8_t```| uint8_t Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>saveConfigurations()
```cpp
ret_status_t Driver::saveConfigurations()
```
##### Description
Save the configuration to the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCANBaudRate()
```cpp
ret_status_t Driver::setCANBaudRate(CANBaudRate baud_rate)
```
##### Description
Set the CAN Baud Rate of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```CANBaudRate``` | ```baud_rate``` | CAN Baud Rate to be set  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| ret_status_t  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCurrentControllerBandwidth()
```cpp
ret_status_t Driver::setCurrentControllerBandwidth(float bandwidth)
```
##### Description
Set current controller bandwidth. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```bandwidth``` | bandwidth value of the current controller |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCurrentFilter()
```cpp
ret_status_t Driver::setCurrentFilter(float current_filter)
```
##### Description
Set the current data filter value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```current_filter``` | Value of current filter.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCurrentPositionAs()
```cpp
ret_status_t Driver::setCurrentPositionAs(float angle)
```
##### Description
Set current position of the motor to a particular angle in degrees. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCurrentPositionToZero()
```cpp
ret_status_t Driver::setCurrentPositionToZero()
```
##### Description
Set current position of the driver as zero. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setDCBusTripLevels()
```cpp
ret_status_t Driver::setDCBusTripLevels(float undervoltage_level, float overvoltage_level)
```
##### Description
Set the driver's undervoltage and overvoltage trip levels. The device will throw an error when the bus voltage will drop below under-voltage level or goes higher than the over-voltage level. Used to keep the driver safe from high transient currents and voltage fluctuations. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```undervoltage_level``` | under-voltage trip level  |
|```float``` | ```overvoltage_level``` | over-voltage trip level  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setDeviceToActive()
```cpp
ret_status_t Driver::setDeviceToActive()
```
##### Description
Set the driver to active state. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setDeviceToIdle()
```cpp
ret_status_t Driver::setDeviceToIdle()
```
##### Description
Set the driver to idle state. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setEncoderDataFilter()
```cpp
ret_status_t Driver::setEncoderDataFilter(float encoder_data_filter)
```
##### Description
Set the encoder data filter value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```encoder_data_filter``` | Value of the encoder data filter.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setGearBoxParameters()
```cpp
ret_status_t Driver::setGearBoxParameters(float gear_ratio)
```
##### Description
Set gear ratio (Output / Input) of the Gearbox. By default the value is 1 in the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```gear_ratio``` | gear ratio of the gearbox  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMAxxxBCTValue()
```cpp
ret_status_t Driver::setMAxxxBCTValue(bool encoder, uint8_t bct_value)
```
##### Description
Set the encoder bct value of MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```uint8_t``` | ```bct_value``` | Value of the encoder BCT Settings.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMAxxxFilterWindow()
```cpp
ret_status_t Driver::setMAxxxFilterWindow(bool encoder, uint8_t filter_window)
```
##### Description
Set the encoder filter window of the MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```uint8_t``` | ```filter_window``` | Value of the encoder etx settings.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMAxxxSPIRegister()
```cpp
ret_status_t Driver::setMAxxxSPIRegister(bool encoder, uint8_t register_address, uint8_t data)
```
##### Description
Set the SPI register for MAxxx series encoders. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to indicate if it's a motor encoder or output encoder. False for motor side encoder True for output side encoder'  |
|```uint8_t``` | ```register_address``` | Address of the register to set  |
|```uint8_t``` | ```data``` | Data to write to the register  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| ret_status_t Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMAxxxTrimmingSettings()
```cpp
ret_status_t Driver::setMAxxxTrimmingSettings(bool encoder, bool etx, bool ety)
```
##### Description
Set the encoder trimming settings of MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```bool``` | ```etx``` | Value of the encoder etx settings.  |
|```bool``` | ```ety``` | Value of the encoder ety settings.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorCalibrationParameters()
```cpp
ret_status_t Driver::setMotorCalibrationParameters(float motor_calib_voltage, float motor_calib_current)
```
##### Description
Set Motor Calibration Parameters. These values are used to calculate the phase resistance & inductance values. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```motor_calib_voltage``` | calibration voltage used to calibrate motor  |
|```float``` | ```motor_calib_current``` | calibration current used to calibrate motor  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorEncoderBandwidth()
```cpp
ret_status_t Driver::setMotorEncoderBandwidth(float bandwidth)
```
##### Description
Set motor encoder bandwidth. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```bandwidth``` | bandwidth value of the encoder |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorParameters()
```cpp
ret_status_t Driver::setMotorParameters(uint8_t pole_pairs, uint16_t kV_rating, float current_limit)
```
##### Description
Set parameters of the motor which is connected to the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t``` | ```pole_pairs``` | pole-pair value of the motor  |
|```uint16_t``` | ```kV_rating``` | kV rating value of the motor  |
|```float``` | ```current_limit``` | current limit value for the motor  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorPhaseParameters()
```cpp
ret_status_t Driver::setMotorPhaseParameters(float phase_resistance, float phase_inductance)
```
##### Description
Set motor phase parameters of the motor in the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```phase_resistance``` | phase resistance value of the motor  |
|```float``` | ```phase_inductance``` | phase inductance value of the motor  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorThermistorParameters()
```cpp
ret_status_t Driver::setMotorThermistorParameters(float r_ref, uint16_t beta)
```
##### Description
Function to set Motor Thermistor Parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```r_ref``` | Reference Resistance at 25 degrees celsius of the NTC thermistor  |
|```uint16_t``` | ```beta``` | beta value of the thermistor  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorTorqueLimit()
```cpp
ret_status_t Driver::setMotorTorqueLimit(float torque_limit)
```
##### Description
Set the torque limit for the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```torque_limit``` | torque limit for controller (value in Nm)  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorType()
```cpp
ret_status_t Driver::setMotorType(uint8_t motor_type)
```
##### Description
Set the motor type connected to the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint8_t``` | ```motor_type``` | motor type (0: HIGH_CURRENT_BLDC, 1: GIMBAL)  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| - |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setNodeId()
```cpp
ret_status_t Driver::setNodeId(uint32_t id)
```
##### Description
Set the node id for the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```uint32_t``` | ```id``` | CAN Node ID of the driver  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setOpenLoopPositionControl()
```cpp
ret_status_t Driver::setOpenLoopPositionControl(int16_t pos, int16_t vel, int16_t accel, float current)
```
##### Description
Set the driver in Open Loop Position Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int16_t``` | ```pos``` | relative position based on the pole pair. pos = 8 and if pole-pair is 8, then driver rotates 1 rotation  |
|```int16_t``` | ```vel``` | velocity in terms of pole-pairs. If vel = 8 and if the pole-pair is 8, then driver rotates in 1 rps Note: to reverse direction, need to set position and velocity in negative.  |
|```int16_t``` | ```accel``` | acceleration in terms of pole-pairs. If accel = 8 and if pole-pairs is 8, the acceleration is 1 rps per second.  |
|```float``` | ```current``` | open-loop controller requires minimum current to maintain lock-in.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setOpenLoopVelocityControl()
```cpp
ret_status_t Driver::setOpenLoopVelocityControl(int16_t vel, int16_t accel, float current)
```
##### Description
Set the driver in Open Loop Velocity Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int16_t``` | ```vel``` | velocity in terms of pole-pairs. If vel = 8 and if the pole-pair is 8, then driver rotates in 1 rps. for reverse direction only set velocity as negative  |
|```int16_t``` | ```accel``` | acceleration in terms of pole-pairs. If accel = 8 and if pole-pairs is 8, the acceleration is 1 rps per second.  |
|```float``` | ```current``` | open-loop controller requires minimum current to maintain lock-in.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setOutputLogStream()
```cpp
void Driver::setOutputLogStream(std::ostream *out)
```
##### Description
Set an output log stream object to which the low-level logs can be written. To be used for debugging purposes. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```std::ostream *``` | ```out``` | Output log stream object  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setPositionControl()
```cpp
ret_status_t Driver::setPositionControl(float angle, float degrees_per_seconds)
```
##### Description
Set the driver in Position Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees to where the motor should move  |
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the motor should move  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setPositionControlWithFeedForward()
```cpp
ret_status_t Driver::setPositionControlWithFeedForward(float angle, float velocity_ff, float torque_ff)
```
##### Description
Set the Driver in Position Control mode with Feedforward parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees to where the actuator should move.  |
|```float``` | ```velocity_ff``` | feedForward velocity in degrees per second.  |
|```float``` | ```torque_ff``` | feedForward torque in Nm.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setPositionControllerGain()
```cpp
ret_status_t Driver::setPositionControllerGain(float position_gain)
```
##### Description
Set position controller gain value. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```position_gain``` | pos gain value of the position controller  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setRegenCurrentTripLevel()
```cpp
ret_status_t Driver::setRegenCurrentTripLevel(float regen_current_trip_level)
```
##### Description
Set the maximum regenerative current the power supply/battery can take. The device will throw DC_BUS_OVERREGEN Error if the current sink is more than this value. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```regen_current_trip_level``` | maximum regeneration current that battery/supply can take in  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setScurveTrajectoryControl()
```cpp
ret_status_t Driver::setScurveTrajectoryControl(float angle, float degrees_per_seconds, float accel_rate, float jerk_rate)
```
##### Description
Set the Driver in S-Curve Trajectory Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees to where the actuator should move  |
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move  |
|```float``` | ```accel_rate``` | acceleration rate  |
|```float``` | ```jerk_rate``` | jerk rate  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setSensorlessVelocityControl()
```cpp
ret_status_t Driver::setSensorlessVelocityControl(float degrees_per_seconds, float ramp_rate_degrees_per_seconds, float current)
```
##### Description
Set the Driver in Sensorless Velocity Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move  |
|```float``` | ```ramp_rate_degrees_per_seconds``` | velocity ramp rate in degrees per seconds  |
|```float``` | ```current``` | current for the sensorless control  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setStartupConfigs()
```cpp
ret_status_t Driver::setStartupConfigs(bool index_search, bool encoder_matching, bool closed_loop)
```
##### Description
Set startup configuration for the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```index_search``` | enable/disable index searching on startup  |
|```bool``` | ```encoder_matching``` | enable/disable output encoder matching sequence on startup  |
|```bool``` | ```closed_loop``` | enable/disable setting driver to closed loop on startup  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setTorqueControl()
```cpp
ret_status_t Driver::setTorqueControl(float torque, float degrees_per_seconds)
```
##### Description
Set the driver in Torque Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```torque``` | motor torque in Nm  |
|```float``` | ```degrees_per_seconds``` | velocity limit in degrees per seconds  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setTorqueRampControl()
```cpp
ret_status_t Driver::setTorqueRampControl(float torque, float torque_ramp_rate, float degrees_per_seconds)
```
##### Description
Set the driver in Torque Ramp Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```torque``` | motor torque in Nm  |
|```float``` | ```torque_ramp_rate``` | motor torque ramp in Nm  |
|```float``` | ```degrees_per_seconds``` | velocity limit in degrees per seconds  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setTrapezoidalTrajectoryControl()
```cpp
ret_status_t Driver::setTrapezoidalTrajectoryControl(float angle, float degrees_per_seconds, float accel_rate, float decel_rate)
```
##### Description
Set the Driver in Trapezoidal Trajectory Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees to where the actuator should move  |
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move  |
|```float``` | ```accel_rate``` | acceleration rate  |
|```float``` | ```decel_rate``` | deceleration rate  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setVelocityControl()
```cpp
ret_status_t Driver::setVelocityControl(float degrees_per_seconds)
```
##### Description
Set the driver in Velocity Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the motor should move.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setVelocityControlWithFeedForward()
```cpp
ret_status_t Driver::setVelocityControlWithFeedForward(float degrees_per_seconds, float torque_ff)
```
##### Description
Set the Driver in Velocity Control mode with FeedForward parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move.  |
|```float``` | ```torque_ff``` | feedForward torque in Nm.  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setVelocityControllerGains()
```cpp
ret_status_t Driver::setVelocityControllerGains(float vel_gain, float vel_integrator_gain)
```
##### Description
Set velocity controller gains. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```vel_gain``` | velocity gain value of the velocity controller  |
|```float``` | ```vel_integrator_gain``` | velocity integrator gain value of the velocity controller |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setVelocityRampControl()
```cpp
ret_status_t Driver::setVelocityRampControl(float degrees_per_seconds, float ramp_rate_degrees_per_seconds)
```
##### Description
Set the Driver in Velocity Ramp Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move  |
|```float``` | ```ramp_rate_degrees_per_seconds``` | velocity ramp rate in degrees per seconds  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```ret_status_t```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>string Driver()
```cpp
std::string Driver::exportConfiguration()
```
##### Description
Function to export current configuration into a json string format. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```std::string```| std::string Configuration in JSON string format  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>~Driver()
```cpp
Driver::~Driver()
```
##### Description
Destroy the Driver object. 


## Python API Reference
### <span style={{color: "#A7A7A7"}}>Driver.</span>Driver()
```python
Driver(id: int = -1, Union[USBInterface, CANInterface, interface: None] = None)
```
##### Description
Driver class constructor. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```id``` | CAN Node ID of the Driver  |
|```Union``` | ```interface``` | Initialised CANInterface or USBInterface object  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>clearDriverErrors()
```python
clearDriverErrors() -> int
```
##### Description
Clear driver errors. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>clearMAxxxOffAxisCalibration()
```python
clearMAxxxOffAxisCalibration(encoder: bool) -> int
```
##### Description
Clears off-axis calibration sequence for MA600 series actuators in the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>configureMotorEncoder()
```python
configureMotorEncoder(encoder_type: int, resolution_param: int = 4096, use_index: bool = True) -> int
```
##### Description
Configure motor side encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```encoder_type``` | Type of encoder used  |
|```int``` | ```resolution_param``` | value of the encoder in case of an incremental encoder or resolution value in 2^bits in case of absolute encoder (this parameter is ignored in the case of using onboard absolute encoder) resolution_param is set to 4096 by default.  |
|```bool``` | ```use_index``` | Flag to set whether to use the index pin for incremental encoder or not. Valid only when an incremental encoder is used. use_index is set to true by default. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>configureOutputEncoder()
```python
configureOutputEncoder(encoder_type: int, resolution_param: int = 4096, use_index: bool = True) -> int
```
##### Description
Configure Output side encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```encoder_type``` | Type of encoder used  |
|```int``` | ```resolution_param``` | CPR value of the encoder in case of an incremental encoder or resolution value in 2^bits in case of absolute encoder (this parameter is ignored in the case of using onboard absolute encoder) resolution_param is set to 4096 by default.  |
|```bool``` | ```use_index``` | Flag to set whether to use the index pin for incremental encoder or not. Valid only when an incremental encoder is used. use_index is set to true by default. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>disableBrakeResistor()
```python
disableBrakeResistor() -> int
```
##### Description
Disable brake resistor and configure it. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>disableMotorThermalLimit()
```python
disableMotorThermalLimit() -> int
```
##### Description
Disable Motor based thermal limit. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>disableOutputEncoder()
```python
disableOutputEncoder() -> int
```
##### Description
Disable Output Encoder. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>emergencyStop()
```python
emergencyStop() -> int
```
##### Description
Function to issue an emergency stop to the device which stops the actuator and sets the error flag; Since the error flag is set the actuator doesn't respond to any other commands, until the actuator is rebooted. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>enableBrakeResistor()
```python
enableBrakeResistor(brake_resistance_value: float) -> int
```
##### Description
Enable the brake resistor in the driver and configure it. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```brake_resistance_value``` | brake resistance value |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>enableMotorThermalLimit()
```python
enableMotorThermalLimit(upper_limit: int) -> int
```
##### Description
Enable Motor based Thermal limit. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```upper_limit``` | Shutdown temperature at which the actuator will stop. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>enterDFUMode()
```python
enterDFUMode() -> int
```
##### Description
Set driver to DFU mode. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>eraseConfigurations()
```python
eraseConfigurations() -> int
```
##### Description
Erase configuration of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>exportConfiguration()
```python
exportConfiguration() -> str
```
##### Description
Export current device configuration as a JSON string. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```str```| JSON string containing configuration parameters  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>flash()
```python
flash(firmware_path: str, is_in_dfu_mode: bool = False) -> 'bool'
```
##### Description
flash the firmware to the driver 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```str``` | ```firmware_path``` | path to which the firmware file is located |
|```bool``` | ```is_in_dfu_mode``` | - |
##### Returns
|Datatype|Description|
|:---:|:----|
|```'bool'```| Connection Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getBrakeCurrent()
```python
getBrakeCurrent() -> 'tuple[int, float]'
```
##### Description
Get the value of current passing through the brake. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and brake current.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getBrakeResistorState()
```python
getBrakeResistorState() -> 'tuple[int, bool, float, bool, bool]'
```
##### Description
Get current state of brake resistor. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool, float, bool, bool]'```| Tuple containing return status, enable status of brake, value of the brake resistor, arm status of brake and the saturation status of the brake.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getBusCurrent()
```python
getBusCurrent() -> 'tuple[int, float]'
```
##### Description
Get the bus current of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and bus current.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getBusVoltage()
```python
getBusVoltage() -> 'tuple[int, float]'
```
##### Description
Get the bus voltage of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and bus voltage.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCANBaudRate()
```python
getCANBaudRate() -> 'tuple[int, nmotion_transport.CANBaudRate]'
```
##### Description
Get the CAN baud rate of the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, nmotion_transport.CANBaudRate]'```| Tuple containing return status and the current CAN baud rate in bps.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCANCommunicationStatus()
```python
getCANCommunicationStatus() -> 'tuple[int, bool, bool]'
```
##### Description
Get CAN communication status. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool, bool]'```| Tuple containing the return status, master connection status (true means master connection is OK) and heartbeat receive status (true means the device is still receiving heartbeat from master).  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getControllerMode()
```python
getControllerMode() -> 'tuple[int, int]'
```
##### Description
Get controller mode. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing the return status and the control mode value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getControllerState()
```python
getControllerState() -> 'tuple[int, int]'
```
##### Description
Get the controller state of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing the return status and the controller state value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCurrentControllerBandwidth()
```python
getCurrentControllerBandwidth() -> 'tuple[int, float]'
```
##### Description
Get current controller bandwidth. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the current controller bandwidth value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCurrentControllerGains()
```python
getCurrentControllerGains() -> 'tuple[int, float, float]'
```
##### Description
Get current controller gains. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float, float]'```| Tuple containing return status, current controller gain value and current controller integrator gain value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getCurrentFilter()
```python
getCurrentFilter() -> 'tuple[int, float]'
```
##### Description
Get the current data filter value of the controller. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the current data filter value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDCBusTripLevels()
```python
getDCBusTripLevels() -> 'tuple[int, float, float]'
```
##### Description
Get the actuator's current under-voltage and over-voltage levels. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float, float]'```| Tuple containing return status, undervoltage level & overvoltage level  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDCCalibPhaseCurrents()
```python
getDCCalibPhaseCurrents() -> 'tuple[int, float, float, float]'
```
##### Description
Get DC Calib Phase Currents in Ampere. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float, float, float]'```| Tuple containing return status and currents in phase A, B and C  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDebugErrorCode()
```python
getDebugErrorCode() -> 'tuple[int, int, int, int, int, int, int]'
```
##### Description
Get the debug error codes for errors from the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, int, int, int, int, int]'```| Tuple containing the return status and the error code value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDriverFault()
```python
getDriverFault() -> 'tuple[int, int]'
```
##### Description
Get the Driver error status from the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing the return status and the driver error value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getDriverTemperature()
```python
getDriverTemperature() -> 'tuple[int, float]'
```
##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| - |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getEncoderDataFilter()
```python
getEncoderDataFilter() -> 'tuple[int, float]'
```
##### Description
Get the current value of encoder data filter in the controller. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the current encoder data filter value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getErrorCode()
```python
getErrorCode() -> 'tuple[int, int]'
```
##### Description
Get the error code from the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing the return status and the error code value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getFirmwareCommit()
```python
getFirmwareCommit() -> 'tuple[int, str]'
```
##### Description
Get the driver firmware's commit information. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, str]'```| Tuple containing return status, and commit information.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getFirmwareVersion()
```python
getFirmwareVersion() -> 'tuple[int, int, int, int]'
```
##### Description
Get the driver firmware's major, minor and revision information. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, int, int]'```| Tuple containing return status, major, minor and revision information.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getGearBoxParameters()
```python
getGearBoxParameters() -> 'tuple[int, float]'
```
##### Description
Get Gear ratio of the Gearbox. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and current gearbox ratio.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getHallEncoderState()
```python
getHallEncoderState() -> 'tuple[int, int]'
```
##### Description
Get hall encoder state. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing the return status and the hall encoder state value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getHallEncoderStateCounts()
```python
getHallEncoderStateCounts() -> 'tuple[int, int, int, int, int, int, int, int, int]'
```
##### Description
Get hall encoder state counts. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, int, int, int, int, int, int, int]'```| Tuple containing the return status and the hall encoder state value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getHardwareVersion()
```python
getHardwareVersion() -> 'tuple[int, int, int, int, int]'
```
##### Description
Get the driver hardware's current tag, major, minor and variant information. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, int, int, int]'```| Tuple containing return status, tag, major, minor and variant information.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getIdqCurrents()
```python
getIdqCurrents() -> 'tuple[int, float, float]'
```
##### Description
Get the Id and Iq currents of the motor. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float, float]'```| Tuple containing return status, Id current and Iq current values.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMAxxxBCTValue()
```python
getMAxxxBCTValue(encoder: bool) -> 'tuple[int, int, bool]'
```
##### Description
Get the encoder bct value of the MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | - |
##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, bool]'```| Tuple containing return status and the current encoder bct value and the spi read status.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMAxxxFilterWindow()
```python
getMAxxxFilterWindow(encoder: bool) -> 'tuple[int, int, bool]'
```
##### Description
Get the current value of encoder bct value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, bool]'```| Tuple containing return status and the current encoder bct value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMAxxxSPIRegister()
```python
getMAxxxSPIRegister(encoder: bool, register_address: int) -> 'tuple[int, int, bool]'
```
##### Description
Get the value of a specific SPI register of the MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```int``` | ```register_address``` | Address of the SPI register to be read |
##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, bool]'```| Tuple containing return status, value of the specified SPI register and the spi read status.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMAxxxTrimmingSettings()
```python
getMAxxxTrimmingSettings(encoder: bool) -> 'tuple[int, bool, bool, bool]'
```
##### Description
Get the current value of encoder bct value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool, bool, bool]'```| Tuple containing return status and the current encoder bct value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorAcceleration()
```python
getMotorAcceleration() -> 'tuple[int, float]'
```
##### Description
Get current acceleration of the motor rotor in rotations per second^2. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the current acceleration value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorCalibrationParameters()
```python
getMotorCalibrationParameters() -> 'tuple[int, float, float]'
```
##### Description
Get current Motor Calibration Parameters. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float, float]'```| Tuple containing return status, motor calibration voltage and motor calibration current.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorEncoderBandwidth()
```python
getMotorEncoderBandwidth() -> 'tuple[int, float]'
```
##### Description
Get current motor bandwidth value. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and current motor bandwidth value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorEncoderConfiguration()
```python
getMotorEncoderConfiguration() -> 'tuple[int, int, int, bool]'
```
##### Description
Get motor encoder configuration. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, int, bool]'```| Tuple containing return status, encoder type, resolution parameter (CPR in case of incremental encoder or resolution in bits in case of absolute encoder) and use_index flag value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorEncoderRawData()
```python
getMotorEncoderRawData() -> 'tuple[int, int]'
```
##### Description
Get the raw data from motor encoder. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing the return status and raw data value of the motor encoder.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorEncoderState()
```python
getMotorEncoderState() -> 'tuple[int, bool, bool, bool]'
```
##### Description
Get the motor encoder state of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool, bool, bool]'```| Tuple containing the return status, index state (true means encoder found the index), ready state (true means the encoder is ready) of the motor encoder and hall calibration state (true means the hall encoder is calibrated) of the motor encoder  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorParameters()
```python
getMotorParameters() -> 'tuple[int, int, int, float]'
```
##### Description
Get current motor parameters. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, int, float]'```| Tuple containing the return status, pole pairs, kV rating and current limit value of the motor.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorPhaseCurrents()
```python
getMotorPhaseCurrents() -> 'tuple[int, float, float, float]'
```
##### Description
Get motor phase currents in Ampere. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float, float, float]'```| Tuple containing return status and currents in phase A, B and C  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorPhaseParameters()
```python
getMotorPhaseParameters() -> 'tuple[int, float, float]'
```
##### Description
Get motor phase parameters (phase resistance and inductance). 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float, float]'```| Tuple containing return status, phase resistance and phase inductance  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorPosition()
```python
getMotorPosition() -> 'tuple[int, float]'
```
##### Description
Get current angle of the motor rotor in number of rotations. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the current rotation value  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorState()
```python
getMotorState() -> 'tuple[int, bool, bool]'
```
##### Description
Get the motor state of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool, bool]'```| Tuple containing the return status, calibration state status (true means motor is calibrated) and the armed state (true means motor is currently armed) status of the motor.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorTemperature()
```python
getMotorTemperature() -> 'tuple[int, float]'
```
##### Description
Get motor temperature in degree Celsius. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and driver temperature.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorThermistorConfiguration()
```python
getMotorThermistorConfiguration() -> 'tuple[int, bool, float, int, int, int]'
```
##### Description
Get the motor thermistor configuration. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool, float, int, int, int]'```| Tuple containing return status, thermal limit enable status, upper limit and lower limit  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorTorque()
```python
getMotorTorque() -> 'tuple[int, float]'
```
##### Description
Get torque of the motor rotor in Nm. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and torque value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorTorqueLimit()
```python
getMotorTorqueLimit() -> 'tuple[int, float]'
```
##### Description
Get the controller torque limit. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the torque limit of the controller  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorType()
```python
getMotorType() -> 'tuple[int, int]'
```
##### Description
Get the controller Motor Type. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing return status and the Motor Type of the controller  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getMotorVelocity()
```python
getMotorVelocity() -> 'tuple[int, float]'
```
##### Description
Get current velocity of the motor rotor in rotations per second. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the current velocity value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getNodeId()
```python
getNodeId() -> 'tuple[int, int]'
```
##### Description
Get current CAN Node ID of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing return status and the current CAN Node ID.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputAcceleration()
```python
getOutputAcceleration() -> 'tuple[int, float]'
```
##### Description
Get current acceleration of the output in degrees per second^2. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and current output acceleration.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputEncoderConfiguration()
```python
getOutputEncoderConfiguration() -> 'tuple[int, int, int, bool]'
```
##### Description
Get Output encoder configuration. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int, int, bool]'```| Tuple containing return status, encoder type, resolution parameter (CPR in case of incremental encoder or resolution in bits in case of absolute encoder) and use_index flag value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputEncoderRawData()
```python
getOutputEncoderRawData() -> 'tuple[int, int]'
```
##### Description
Get the raw data from output encoder. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, int]'```| Tuple containing the return status and raw data value of the absolute encoder.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputEncoderState()
```python
getOutputEncoderState() -> 'tuple[int, bool, bool]'
```
##### Description
Get the output encoder state of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool, bool]'```| Tuple containing return status, index state (true means encoder found the index) and ready state (true means the encoder is ready) of the output encoder.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputPosition()
```python
getOutputPosition() -> 'tuple[int, float]'
```
##### Description
Get current angle of the output in degrees. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and current output angle.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputTorque()
```python
getOutputTorque() -> 'tuple[int, float]'
```
##### Description
Get current torque at the output in Nm. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and output torque.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getOutputVelocity()
```python
getOutputVelocity() -> 'tuple[int, float]'
```
##### Description
Get current velocity of output in degrees per second. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and current output velocity.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getPositionControllerGain()
```python
getPositionControllerGain() -> 'tuple[int, float]'
```
##### Description
Get position controller gain value. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the current position controller gain value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getRegenCurrentTripLevel()
```python
getRegenCurrentTripLevel() -> 'tuple[int, float]'
```
##### Description
Get the maximum regenerative current the power supply/battery can take. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing the return status and value of maximum regenerative current which is set.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getStartupConfigs()
```python
getStartupConfigs() -> 'tuple[int, bool, bool, bool]'
```
##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool, bool, bool]'```| - |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getTrajectoryDoneStatus()
```python
getTrajectoryDoneStatus() -> 'tuple[int, bool]'
```
##### Description
Get the trajectory status of the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, bool]'```| Tuple containing return status and the trajectory done status (true means the motion along the trajectory is complete)  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getVelocityControllerGains()
```python
getVelocityControllerGains() -> 'tuple[int, float, float]'
```
##### Description
Get controller velocity controller gains. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float, float]'```| Tuple containing return status, velocity controller gain value and velocity controller integrator gain value.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>getZeroPosition()
```python
getZeroPosition() -> 'tuple[int, float]'
```
##### Description
Get zero offset position in degrees. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'tuple[int, float]'```| Tuple containing return status and the current zero offset position.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>importConfiguration()
```python
importConfiguration(config: str) -> int
```
##### Description
Import device configuration from a JSON string. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```str``` | ```config``` | JSON string containing configuration parameters |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>isConnected()
```python
isConnected() -> 'bool'
```
##### Description
Check if the driver is still connected. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```'bool'```| Connection Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>rebootDriver()
```python
rebootDriver() -> int
```
##### Description
Reboot the Driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runCalibrationSequence()
```python
runCalibrationSequence() -> int
```
##### Description
Run calibration sequence in the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runEncoderCalibration()
```python
runEncoderCalibration() -> int
```
##### Description
Run encoder calibration in the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runEncoderIndexSearch()
```python
runEncoderIndexSearch() -> int
```
##### Description
Run encoder index search sequence in the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runEncoderMatching()
```python
runEncoderMatching() -> int
```
##### Description
Run matching motor encoder with output encoder in the driver. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>runMAxxxOffAxisCalibration()
```python
runMAxxxOffAxisCalibration(encoder: bool, constant_speed_dps: float) -> int
```
##### Description
Run off-axis calibration sequence for MA600 series actuators in the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```float``` | ```constant_speed_dps``` | Constant speed in degrees per second at which the motor will be rotated during the calibration sequence. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>saveConfigurations()
```python
saveConfigurations() -> int
```
##### Description
Save the configuration to the actuator. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCANBaudRate()
```python
setCANBaudRate(baud_rate: nmotion_transport.CANBaudRate) -> int
```
##### Description
Set the CAN baud rate of the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```nmotion_transport.CANBaudRate``` | ```baud_rate``` | CAN baud rate in bps to be set |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCurrentControllerBandwidth()
```python
setCurrentControllerBandwidth(bandwidth: float) -> int
```
##### Description
Set current controller bandwidth. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```bandwidth``` | Bandwidth value for the current controller. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCurrentFilter()
```python
setCurrentFilter(current_filter: float) -> int
```
##### Description
Set the current data filter value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```current_filter``` | Value of current filter. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCurrentPositionAs()
```python
setCurrentPositionAs(angle: float) -> int
```
##### Description
Set current position of the motor to a particular angle in degrees. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | - |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setCurrentPositionToZero()
```python
setCurrentPositionToZero() -> int
```
##### Description
Set current position of the actuator as zero. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setDCBusTripLevels()
```python
setDCBusTripLevels(undervoltage_level: float, overvoltage_level: float) -> int
```
##### Description
Set the actuator's undervoltage and overvoltage trip levels. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```undervoltage_level``` | under-voltage trip level  |
|```float``` | ```overvoltage_level``` | over-voltage trip level |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setDeviceToActive()
```python
setDeviceToActive() -> int
```
##### Description
Set the actuator to active state. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setDeviceToIdle()
```python
setDeviceToIdle() -> int
```
##### Description
Set the actuator to idle state. 

##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setEncoderDataFilter()
```python
setEncoderDataFilter(encoder_data_filter: float) -> int
```
##### Description
Set the encoder data filter value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```encoder_data_filter``` | value of encoder data filter. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setGearBoxParameters()
```python
setGearBoxParameters(gear_ratio: float) -> int
```
##### Description
Set gear ratio (Output / Input) of the Gearbox. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```gear_ratio``` | Gear ratio of the gearbox |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMAxxxBCTValue()
```python
setMAxxxBCTValue(encoder: bool, bct_value: int) -> int
```
##### Description
Set the encoder bct value of MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```int``` | ```bct_value``` | BCT value to be set in the controller |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMAxxxFilterWindow()
```python
setMAxxxFilterWindow(encoder: bool, filter_window: int) -> int
```
##### Description
Set the encoder data filter value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```int``` | ```filter_window``` | Filter window value to be set in the controller |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMAxxxSPIRegister()
```python
setMAxxxSPIRegister(encoder: bool, register_address: int, register_value: int) -> int
```
##### Description
Set the value of a specific SPI register of the MAxxx encoder. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```int``` | ```register_address``` | Address of the SPI register to be set  |
|```int``` | ```register_value``` | Value to be set in the specified SPI register |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMAxxxTrimmingSettings()
```python
setMAxxxTrimmingSettings(encoder: bool, etx: bool, ety: bool) -> int
```
##### Description
Set the encoder data filter value in the controller. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```encoder``` | Flag to set the encoder type. False for motor side encoder True for output side encoder  |
|```bool``` | ```etx``` | set the encoder trimming value for x axis  |
|```bool``` | ```ety``` | set the encoder trimming value for y axis |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorCalibrationParameters()
```python
setMotorCalibrationParameters(motor_calib_voltage: float, motor_calib_current: float) -> int
```
##### Description
Set Motor Calibration Parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```motor_calib_voltage``` | calibration voltage used to calibrate motor  |
|```float``` | ```motor_calib_current``` | calibration current used to calibrate motor |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorEncoderBandwidth()
```python
setMotorEncoderBandwidth(bandwidth: float) -> int
```
##### Description
Set motor encoder bandwidth value. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```bandwidth``` | Bandwidth value |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorParameters()
```python
setMotorParameters(pole_pairs: int, kV_rating: int, current_limit: float) -> int
```
##### Description
Set parameters of the motor which is connected to the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```pole_pairs``` | pole-pair value of the motor  |
|```int``` | ```kV_rating``` | kV rating value of the motor  |
|```float``` | ```current_limit``` | current limit value for the motor |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorPhaseParameters()
```python
setMotorPhaseParameters(phase_resistance: float, phase_inductance: float) -> int
```
##### Description
Set motor phase parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```phase_resistance``` | Phase resistance of the motor  |
|```float``` | ```phase_inductance``` | Phase inductance of the motor |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorThermistorParameters()
```python
setMotorThermistorParameters(r_ref: float, beta: int) -> int
```
##### Description
Set Motor thermistor parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```r_ref``` | Reference Resistance at 25 degrees celsius of the NTC thermistor  |
|```int``` | ```beta``` | Beta value of the thermistor |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status.  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorTorqueLimit()
```python
setMotorTorqueLimit(torque_limit: float) -> int
```
##### Description
Set Torque Limit for the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```torque_limit``` | Torque limit value in Nm. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setMotorType()
```python
setMotorType(motor_type: int) -> int
```
##### Description
Set Motor Type for the driver. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```motor_type``` | Motor Type for controller. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setNodeId()
```python
setNodeId(id: int) -> int
```
##### Description
Set the node id for the actuator. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```id``` | CAN Device ID of the actuator |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setOpenLoopPositionControl()
```python
setOpenLoopPositionControl(pos: int, vel: int, accel: int, current: float) -> int
```
##### Description
Set the driver in open loop position control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```pos``` | relative position based on the pole pair. pos = 8 and if pole-pair is 8, then driver rotates 1 rotation  |
|```int``` | ```vel``` | velocity in terms of pole-pairs. If vel = 8 and if the pole-pair is 8, then driver rotates in 1 rps. for reverse direction only set velocity as negative  |
|```int``` | ```accel``` | acceleration in terms of pole-pairs. If accel = 8 and if pole-pairs is 8, the acceleration is 1 rps per second.  |
|```float``` | ```current``` | open-loop controller requires minimum current to maintain lock-in. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setOpenLoopVelocityControl()
```python
setOpenLoopVelocityControl(vel: int, accel: int, current: float) -> int
```
##### Description
Set the driver in Velocity Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```int``` | ```vel``` | velocity in terms of pole-pairs. If vel = 8 and if the pole-pair is 8, then driver rotates in 1 rps. for reverse direction only set velocity as negative  |
|```int``` | ```accel``` | acceleration in terms of pole-pairs. If accel = 8 and if pole-pairs is 8, the acceleration is 1 rps per second.  |
|```float``` | ```current``` | open-loop controller requires minimum current to maintain lock-in. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setPositionControl()
```python
setPositionControl(angle: float, degrees_per_seconds: float) -> int
```
##### Description
Set the driver in position control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees to where the actuator should move.  |
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setPositionControlWithFeedForward()
```python
setPositionControlWithFeedForward(angle: float, velocity_ff: float, torque_ff: float) -> int
```
##### Description
Set the actuator in position control mode with feedforward parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees to where the actuator should move.  |
|```float``` | ```velocity_ff``` | feedForward velocity in degrees per second.  |
|```float``` | ```torque_ff``` | feedForward torque in Nm. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setPositionControllerGain()
```python
setPositionControllerGain(pos_gain: float) -> int
```
##### Description
Set position controller gain value. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```pos_gain``` | position gain value of the position controller |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setRegenCurrentTripLevel()
```python
setRegenCurrentTripLevel(regen_current_trip_level: float) -> int
```
##### Description
Set the maximum regenerative current the power supply/battery can take. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```regen_current_trip_level``` | maximum regeneration current that battery/supply can take in |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setScurveTrajectoryControl()
```python
setScurveTrajectoryControl(angle: float, degrees_per_seconds: float, accel_rate: float, jerk_rate: float) -> int
```
##### Description
Set the actuator in S-Curve trajectory control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees to where the actuator should move  |
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move  |
|```float``` | ```accel_rate``` | acceleration rate as a factor of velocity in degrees per second^2.  |
|```float``` | ```jerk_rate``` | jerk rate as a factor of acceleration in degrees per second^3. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setSensorlessVelocityControl()
```python
setSensorlessVelocityControl(degrees_per_seconds: float, ramp_rate_degrees_per_second: float, current: float) -> int
```
##### Description
Set the actuator in Sensorless Velocity Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move.  |
|```float``` | ```ramp_rate_degrees_per_second``` | velocity ramp rate.  |
|```float``` | ```current``` | current for sensorless control |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setStartupConfigs()
```python
setStartupConfigs(index_search: bool = False, encoder_matching: bool = False, closed_loop: bool = False) -> int
```
##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```bool``` | ```index_search``` | - |
|```bool``` | ```encoder_matching``` | - |
|```bool``` | ```closed_loop``` | - |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| - |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setTorqueControl()
```python
setTorqueControl(torque: float, degrees_per_second: float) -> int
```
##### Description
Set the Driver in torque control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```torque``` | Motor Torque in Nm  |
|```float``` | ```degrees_per_second``` | Velocity limit in degrees per second when the actuator is moving. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setTorqueRampControl()
```python
setTorqueRampControl(torque: float, torque_ramp_rate: float, degrees_per_second: float) -> int
```
##### Description
Set the Driver in torque ramp control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```torque``` | Motor Torque in Nm  |
|```float``` | ```torque_ramp_rate``` | Motor Torque Ramp in Nm  |
|```float``` | ```degrees_per_second``` | Velocity limit in degrees per second when the actuator is moving. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setTrapezoidalTrajectoryControl()
```python
setTrapezoidalTrajectoryControl(angle: float, degrees_per_seconds: float, accel_rate: float, decel_rate: float) -> int
```
##### Description
Set the actuator in Trapezoidal trajectory control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```angle``` | angle in degrees to where the actuator should move  |
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move  |
|```float``` | ```accel_rate``` | acceleration rate as a factor of velocity in degrees per second^2.  |
|```float``` | ```decel_rate``` | deceleration rate as a factor of velocity in degrees per second^2. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setVelocityControl()
```python
setVelocityControl(degrees_per_seconds: float) -> int
```
##### Description
Set the driver in Velocity Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setVelocityControlWithFeedForward()
```python
setVelocityControlWithFeedForward(degrees_per_seconds: float, torque_ff: float) -> int
```
##### Description
Set the actuator in velocity control mode with feedForward parameters. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move.  |
|```float``` | ```torque_ff``` | feedForward torque in Nm. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setVelocityControllerGains()
```python
setVelocityControllerGains(vel_gain: float, vel_integrator_gain: float) -> int
```
##### Description
Set velocity controller gains. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```vel_gain``` | velocity gain value of the velocity controller  |
|```float``` | ```vel_integrator_gain``` | velocity integrator gain value of the velocity controller |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return status  |

### <span style={{color: "#A7A7A7"}}>Driver.</span>setVelocityRampControl()
```python
setVelocityRampControl(degrees_per_seconds: float, ramp_rate_degrees_per_second: float) -> int
```
##### Description
Set the actuator in Velocity Ramp Control mode. 

##### Parameters
|Datatype|Variable|Description|
|:---:|:---:|:----|
|```float``` | ```degrees_per_seconds``` | velocity in degrees per second at which the actuator should move.  |
|```float``` | ```ramp_rate_degrees_per_second``` | velocity ramp rate. |
##### Returns
|Datatype|Description|
|:---:|:----|
|```int```| Return Status  |