APIs, concepts, guides, and more
See the following Concept pages for a detailed explanation of this sample: Math Blocks.
This is a sample program to assist in the integration of the RMP motion controller with your application. It may not contain all of the logic and safety features that your application requires. We recommend that you wire an external hardware emergency stop (e-stop) button for safety when using our code sample apps. Doing so will help ensure the safety of you and those around you and will prevent potential injury or damage.

The sample apps assume that the system (network, axes, I/O) are configured prior to running the code featured in the sample app. See the Configuration page for more information.
#include "SampleAppsHelper.h" // Import our helper functions.
#include "rsi.h" // Import our RapidCode Library.
using namespace RSI::RapidCode; // Import our RapidCode namespace
int main()
const std::string SAMPLE_APP_NAME = "Math Blocks: Calculate Acceleration from Velocity";
// Print a start message to indicate that the sample app has started
/* *NOTICE* The following constants must be configured before attempting to run with hardware. */
const double VELOCITY = 1.0; // the velocity to move the axis
const double ACCELERATION = 0.123; // something small so we can check the MathBlock is working
// Create the Controller
MotionController *controller = MotionController::Create(&params);
int exitCode = -1; // Set the exit code to an error value.
try // Ensure that the controller is deleted if an error occurs.
// Prepare the controller and axes as defined in SampleAppsHelper.h
/* Configure the controller object counts */
// Add the two MathBlocks needed for this sample
// Get the axis and make sure the axis is not moving and clear any faults
// Read the configuration of both MathBlocks
MotionController::MathBlockConfig subtractionConfig = controller->MathBlockConfigGet(SUBTRACTION_MATHBLOCK_INDEX);
// This index must be greater than the subtraction math block index, so the subtraction data is
// one sample old
MotionController::MathBlockConfig previousVelocityConfig = controller->MathBlockConfigGet(PREVIOUS_VELOCITY_MATHBLOCK_INDEX);
// Set the axis to use the command velocity as the input for the MathBlock
// Configure the first MathBlock to subtract the previous velocity from the current velocity
// Current velocity:
subtractionConfig.InputAddress0 = axis->AddressGet(INPUT_AXIS_ADDRESS_TYPE);
subtractionConfig.InputDataType0 = RSIDataType::RSIDataTypeDOUBLE;
// Previous velocity: (as was calculated by the second MathBlock, so we use its ProcessValue)
subtractionConfig.InputAddress1 =
controller->AddressGet(RSIControllerAddressType::RSIControllerAddressTypeMATHBLOCK_PROCESS_VALUE, PREVIOUS_VELOCITY_MATHBLOCK_INDEX);
subtractionConfig.InputDataType1 = RSIDataType::RSIDataTypeDOUBLE;
subtractionConfig.ProcessDataType = RSIDataType::RSIDataTypeDOUBLE;
subtractionConfig.Operation = RSIMathBlockOperation::RSIMathBlockOperationSUBTRACT;
// Write 1.0 to the first UserBuffer entry so the second MathBlock can use it for multiplication
uint64_t userBufferAddr0 = controller->AddressGet(RSIControllerAddressType::RSIControllerAddressTypeUSER_BUFFER, 0);
controller->MemoryDoubleSet(userBufferAddr0, 1.0);
// Configure the second MathBlock to multiply the current velocity by 1.0 (which we'll use for
// the previous sample's velocity)
previousVelocityConfig.InputAddress0 = axis->AddressGet(INPUT_AXIS_ADDRESS_TYPE);
previousVelocityConfig.InputDataType0 = RSIDataType::RSIDataTypeDOUBLE;
previousVelocityConfig.InputAddress1 = userBufferAddr0;
previousVelocityConfig.InputDataType1 = RSIDataType::RSIDataTypeDOUBLE;
previousVelocityConfig.ProcessDataType = RSIDataType::RSIDataTypeDOUBLE;
previousVelocityConfig.Operation = RSIMathBlockOperation::RSIMathBlockOperationMULTIPLY;
// Set the MathBlock configurations
controller->MathBlockConfigSet(SUBTRACTION_MATHBLOCK_INDEX, subtractionConfig);
controller->MathBlockConfigSet(PREVIOUS_VELOCITY_MATHBLOCK_INDEX, previousVelocityConfig);
// Wait a sample so we know the RMP is now processing the newly configured MathBlocks
// Set the axis to move with a very small acceleration so we can check the MathBlock is working
axis->AmpEnableSet(true); // Enable the motor.
// Wait several samples so we know the RMP is now processing the move command and accelerating
// Keep in mind firmware velocity is in counts per sample, so we need to convert to UserUnits
// per second squared
double calculatedVelocityDelta = controller->MathBlockProcessValueGet(SUBTRACTION_MATHBLOCK_INDEX).Double;
// Reduce the velocity back to 0
axis->MoveVelocity(0, ACCELERATION);
axis->MotionDoneWait(); // Wait for the axis to finish moving.
axis->AmpEnableSet(false); // Disable the motor.
// Convert to UserUnits per second squared
double calculatedAcceleration = calculatedVelocityDelta * controller->SampleRateGet() * controller->SampleRateGet() / axis->UserUnitsGet();
std::cout << "Calculated acceleration from MathBlock: " << calculatedAcceleration << std::endl;
// Check that the newly calculated acceleration is as expected
if (std::abs(calculatedAcceleration - ACCELERATION) <= 0.000001)
std::cout << "The MathBlock is calculating the Axis' acceleration by subtracting previous velocity from current velocity." << std::endl;
exitCode = 0;
std::cerr << "Error: The calculated acceleration does not match the expected value" << std::endl;
exitCode = -1;
catch (const std::exception &ex)
std::cerr << ex.what() << std::endl;
exitCode = -1;
// Delete the controller as the program exits to ensure memory is deallocated in the correct order
// Print a message to indicate the sample app has finished and if it was successful or not
SampleAppsHelper::PrintFooter(SAMPLE_APP_NAME, exitCode);
return exitCode;
uint64_t AddressGet(RSIAxisAddressType addressType)
Get the an address for some location on the Axis.
double UserUnitsGet()
Get the number of counts per User Unit.
void MoveVelocity(double velocity)
Represents a single axis of motion control. This class provides an interface for commanding motion,...
Definition rsi.h:5513
Axis * AxisGet(int32_t axisNumber)
AxisGet returns a pointer to an Axis object and initializes its internals.
void MathBlockCountSet(int32_t mathBlockCount)
Set the number of processed MathBlocks in the MotionController.
void MemoryDoubleSet(uint64_t address, double dataDouble)
Write a 64-bit double value to controller memory.
uint64_t AddressGet(RSIControllerAddressType type)
Get the an address for some location on the MotionController.
void SampleWait(uint32_t samples)
Wait for controller firmware to execute samples.
void Delete(void)
Delete the MotionController and all its objects.
Represents the RMP soft motion controller. This class provides an interface to general controller con...
Definition rsi.h:794
MathBlockConfig MathBlockConfigGet(int32_t mathBlockNumber)
Get a MathBlock configuration.
FirmwareValue MathBlockProcessValueGet(int32_t mathBlockNumber)
Get a MathBlock process value.
void MathBlockConfigSet(int32_t mathBlockNumber, MathBlockConfig &config)
Set a MathBlock configuration.
void ClearFaults()
Clear all faults for an Axis or MultiAxis.
void AmpEnableSet(bool enable)
Enable all amplifiers.
void Abort()
Abort an axis.
int32_t MotionDoneWait()
Waits for a move to complete.
Used to get firmware address used in User Limits, Recorders, etc.
Definition rsienums.h:433
static void PrintFooter(std::string sampleAppName, int exitCode)
Print a message to indicate the sample app has finished and if it was successful or not.
static void CheckErrors(RapidCodeObject *rsiObject)
Checks for errors in the given RapidCodeObject and throws an exception if any non-warning errors are ...
static void PrintHeader(std::string sampleAppName)
Print a start message to indicate that the sample app has started.
static void SetupController(MotionController *controller)
Setup the controller with user defined axis counts and configuration.
static MotionController::CreationParameters GetCreationParameters()
Returns a MotionController::CreationParameters object with user-defined parameters.
CreationParameters for MotionController::Create.
Definition rsi.h:855
RSIDataType ProcessDataType
Data type for processing.
Definition rsi.h:3642
MathBlock configuration structure.
Definition rsi.h:3635
uint64_t InputAddress0
Host memory address for Input0. Represents the left-hand side operand in math operations.
Definition rsi.h:3636
RSIDataType InputDataType0
Data type for Input0. This is the data type of the left-hand side operand in math operations.
Definition rsi.h:3637
uint64_t InputAddress1
Host memory address for Input1. Represents the right-hand side operand in math operations.
Definition rsi.h:3638
RSIDataType InputDataType1
Data type for Input1. This is the data type of the right-hand side operand in math operations.
Definition rsi.h:3639
RSIMathBlockOperation Operation
Math operation to be performed. (+, -, *, /, etc) use RSIMathBlockOperationNONE to disable a MathBloc...
Definition rsi.h:3643
static constexpr int AXIS_X_INDEX
Index of the first axis to use in the sample apps.
static constexpr int MATH_BLOCK_COUNT
Number of math block objects to configure on the controller.
double Double
Double precision (64-bit) floating-point.
Definition rsi.h:471