Api_V6

根目录结构

路径功能
/sdk_common/sdk本体的c++11源码
/sdk_c/sdk的c99接口导出
/sdk_csharp/sdk的c#接口导出, 基于clr类
/sdk_py/sdk的py接口导出
/sdk_node/sdk的node接口导出
/sdk_语言接口/待添加的其他接口支持
/CSharp_SDK原生 C# SDK

Sdk功能介绍

文件功能
/sdk_common/libmodbus依赖的modbus通讯库, lgplv2协议
/sdk_common/Config控制器寄存器地址配置等, 如需修改点位指令占用等修改此文件
/sdk_common/Exception通讯等异常抛出实现, 如需自定义异常可修改此文件
/sdk_common/ModbusModbus通讯库的简易封装
/sdk_common/RMAxisRM轴动作的封装

V6源码发布包的使用方法

  1. c++用户, 可以直接把sdk_common文件夹下的源码直接全部引入到工程文件中去, 然后包含RMAxis.h头文件即可使用.
  2. c用户可以用/sdk_c/文件夹下的cmake生成并编译一个动态库导出给c项目使用.
  3. c#用户, 打开/sdk_csharp/sdk_csharp.vcxproj工程文件, 右键项目属性配置所需要使用的x86/x64还有.net framework版本等, 确认后编译, 即可在生成文件夹获得编译出来的Sdk库dll文件。 在要使用的sdk的项目中右键添加引用并选中生成的dll即可.不希望使用 dll 的用户可提供原生态的 C# SDK 包.原生的 C# SDK 提供 AxisProxy.cs 源码文件, 将该文件导入项目工程中,并参考原生SDK中的 demo 使用. 如下图所示,下图为原生的 C# SDK 源码与 demo 源码示意图.
  4. python用户, 在sdk_py文件夹下执行 sudo python3 setup.py install , 即可触发setup_tool 的自动编译安装, 自动编译安装成功后在python3 repl环境下 直接键入 from pylibrm import RMAxis 即可导入sdk包.
from pylibrm import RMAxis
axis = RMAxis.Axis_V6.create_modbus_rtu("\\\\.\\COM9", 1, 115200)

C++用户需要注意编译器需要支持最低c++11标准。

Linux Python用户需要注意, 使用setup_tool, 需要确保build_essentials和cmake已经安装, windows用户同样需要确保msvc和cmake的安装。

RMAxis类功能实现简介

对RM控制器的控制主要依赖于

  1. 对IO线圈寄存器的操作(触发执行/停止等动作)
  2. 对保持寄存器的读写(位置/推力等数据)

以回原点的实现为例

void RMAxis::go_home()
{
    this->set_input_signal("go_home", false);
    std::this_thread::sleep_for(IO_GAP_TIME);
    this->set_input_signal("go_home", true);
}
  1. 设置输入io信号"go_home" 为低
  2. 等待IO_GAP_TIME, 约10ms 消抖时间
  3. 再次设置输入io信号"go_home" 为高, 以上升沿触发 执行回原点操作

以触发特定index的点位指令的实现为例

void RMAxis::trig_command(int index)
{
    this->set_parameter<int>("selected_command_index", index);
    this->set_input_signal("start", false);
    std::this_thread::sleep_for(IO_GAP_TIME);
    this->set_input_signal("start", true);
}
  1. 写入保持寄存器"selected_command_index" 为 要触发的指令序号
  2. 设置输入io信号"start" 为低
  3. 等待IO_GAP_TIME, 约10ms 消抖时间
  4. 再次设置输入io信号"start" 为高, 以上升沿触发 执行点位指令操作

Config.h的配置自定义

  1. IO消抖时间
#define IO_GAP_TIME 10ms

因RM控制器的IO寄存器存在和外部IO映射的关系, 一般情况下为10ms, 如遇到通讯无法触发IO或者在极高速通讯时IO读写无动作的情况可以适当改大该值范围在 10ms ~ 100ms之间。

  1. SDK指令占用的控制器点位指令槽
#define EXECUTE_COMMAND_INDEX 15
#define COMMAND_REACH_SIGNAL "reach_15"

SDK执行绝对运动/相对运动/推压运动等时占用的控制器点位表位置, 默认情况为点位表最后一位第15条指令, 并以第15条指令到位为到位信号, 如有特殊需求可以修改该位置范围0~15。

  1. SDK所使用的参数
inline void init_parameters(std::map<std::string, param_t>& params)
{
    params["current_command_position"] =        { PARAM_FLOAT, PARAM_NORMAL, 4902 };
    // ...
}

该函数会在sdk被初始化的时候调用, 并初始化参数表的地址。 params["参数名字"] = { 参数数据类型, 参数编辑级别, 参数地址 } 一般情况下无需对其做出改动, 如有变更需要联系技术售服协助修改。

连接与配置

连接轴

// 函数原型
rm_handle_t rm_create_modbus_rtu(const char* device, int baudrate, uint8_t slave_id);
rm_handle_t rm_create_modbus_tcp(const char* address, int port, uint8_t slave_id);

// 使用示例
rm_handle_t handle = rm_create_modbus_rtu("\\\\.\\COM8", 115200, 1);
rm_handle_t handle = rm_create_modbus_tcp("192.168.0.233", 502, 1);
// 函数原型
static RMAxis* create_rmaxis_modbus_rtu(std::string device, int baudrate, uint8_t slave_id);
static RMAxis* create_rmaxis_modbus_tcp(std::string address, int port, uint8_t slave_id);

// 使用示例
auto axis = RMAxis::create_rmaxis_modbus_rtu("\\\\.\\COM8", 115200, 1);
auto axis = RMAxis::create_rmaxis_modbus_tcp("192.168.0.233", 502, 1);
// 函数原型
Axis^ Axis::CreateModbusRtu(String^ device, int baudrate, int slave_id);
Axis^ Axis::CreateModbusTcp(String^ address, int port, int slave_id);

// 使用示例
var axis = Axis.CreateModbusRtu("\\\\.\\COM8", 115200, 1);
var axis = Axis.CreateModbusTcp("192.168.50.9", 502, 1);
## 函数原型
def create_modbus_rtu(port, baudrate ,slave_id)
def create_modbus_tcp(host, port, slave_id)

## 使用示例
axis = RMAxis.Axis_V6.create_modbus_rtu('\\\\.\\COM8', 115200, 1)
axis = RMAxis.Axis_V6.create_modbus_tcp('192.168.0.233', 502, 1)
变量描述
device串口设备 \\.\COM8 或 /dev/ttyS0 等
baudrate波特率
slave_id站号
变量描述
addressip地址
port端口
slave_id站号

连接到指定设备上的控制器。

断开轴

// 函数原型
void rm_destroy(rm_handle_t handle);

// 使用示例
destroy_rmaxis((RMAxis*)handle);
// 函数原型
void RMAxis::destroy_rmaxis(RMAxis* axis);

// 使用示例
destroy_rmaxis(RMAxis* axis);
// 函数原型
void Axis::Destroy(Axis^ axis);

// 使用示例
Sdk.Destroy(Axis^ axis)
## 函数原型
def destroy(axis):

## 使用示例
destroy axis(axis)

断开连接的轴

IO功能控制

操作逻辑IO信号

// 函数原型
void rm_set_input_signal(rm_handle_t handle, const char* signal, bool level);
bool rm_get_output_signal(rm_handle_t handle, const char* signal);
// 函数原型
void RMAxis::set_input_signal(std::string signal, bool level);
bool RMAxis::get_output_signal(std::string signal);
// 函数原型
void Axis::SetInputSignal(String^ signal, bool level);
bool Axis::GetOutputSignal(String^ signal);
## 函数原型
.def("set_input_signal", &RMAxis::set_input_signal):
.def("get_output_signal", &RMAxis::get_output_signal):
变量描述
handle轴句柄
signal逻辑IO信号名称
返回值逻辑IO信号状态

读写当前控制器逻辑IO信号状态。

通用运动控制

常用运动控制指令，如不需要进行复杂指令执行，只需要使用以下api指令即可完成大部分操作。

设置直接运动规划器参数

// 函数原型
void rm_config_motion(rm_handle_t handle, float velocity, float acceleration);

// 使用示例
rm_config_motion(axis, 100.f, 500.f);
// 函数原型
void RMAxis::config_motion(float velocity, float acceleration);

// 使用示例
axis.config_motion(100.f, 500.f);
// 函数原型
void Axis::ConfigMotion(float velocity, float acceleration);

// 使用示例
axis.ConfigMotion(100, 500);
## 函数原型
def config_motion(self, velocity, acceleration):

## 使用示例
axis.config_motion(100, 3000);
变量描述
handle轴句柄
velocity速度 mm/s
acceleration加速度 mm/s^2

设置直接运动时规划器的速度，加速度和移动到位置配合使用。

移动到位置

// 函数原型
void rm_move_to(rm_handle_t handle, float position);

// 使用示例
rm_move_to(axis, 10.f);
// 函数原型
void RMAxis::move_to(float position);

// 使用示例
axis.move_to(10.f);
// 函数原型
void Axis::MoveTo(float position);

// 使用示例
axis.MoveTo(10)
## 函数原型
def move_to(self, position):

## 使用示例
axis.move_to(10)
变量描述
handle轴句柄
position位置 mm

设置直接运动时规划器的目标位置和设置直接运动规划器参数配合使用。

回原点

// 函数原型
void rm_go_home(rm_handle_t handle);

// 使用示例
rm_go_home(axis);
// 函数原型
void RMAxis::go_home();

// 使用示例
axis.go_home();
// 函数原型
void Axis::GoHome();

// 使用示例
axis.GoHome();
## 函数原型
def go_home(self):

## 使用示例
axis.go_home()
变量描述
handle轴句柄

触发轴回原点, 如果没有设置 自动回原点 的话 每次上电后只需要触发执行一次就行 可以通过读取逻辑信号 "is_go_Home_Down" 来判断是否执行完成

绝对运动

// 函数原型
void rm_move_absolute(rm_handle_t handle,float position, float velocity,float acceleration, float decceleration, float band);

// 使用示例
rm_move_absolute(axis, 10.f, 100.f, 3000.f, 3000.f, 0.1f);
// 函数原型
void RMAxis::move_absolute(float position, float velocity, float acceleration, float decceleration, float band);

// 使用示例
axis.move_absolute(10.f, 100.f, 3000.f, 3000.f, 0.1f);
// 函数原型
void Axis::MoveAbsolute(float position, float velocity,float acceleration, float decceleration, float band);

// 使用示例
axis.MoveAbsolute(10, 100, 3000, 3000, 0.1)
## 函数原型
def move_absolute(self, position, velocity, acceleration, deacceleration, band):

## 使用示例
axis.move_absolute(10, 100, 3000, 3000, 0.1)
变量描述
handle轴句柄
position位置 mm
velocity速度 mm/s
acceleration加速度 mm/s^2
deacceleration减速度 mm/s^2
band定位范围 mm

以设定速度加速度绝对运动到给定位置。

相对运动

// 函数原型
void rm_move_relative(rm_handle_t handle,float position, float velocity,float acceleration, float decceleration, float band);

// 使用示例
rm_move_relative(axis, 10.f, 100.f, 3000.f, 3000.f, 0.1f);
// 函数原型
void RMAxis::move_relative(
    float distance, float velocity,
    float acceleration, float decceleration, float band);

// 使用示例
axis.move_relative(10.f, 100.f, 3000.f, 3000.f, 0.1f);
// 函数原型
void Axis::MoveRelative(float position, float velocity,float acceleration, float decceleration, float band);

// 使用示例
axis.MoveRelative(10, 100, 3000, 3000, 0.1)
## 函数原型
def move_relative(self, position, velocity, acceleration, deacceleration, band):

## 使用示例
axis.move_relative(10, 100, 3000, 3000, 0.1)
变量描述
handle轴句柄
position位置 mm
velocity速度 mm/s
acceleration加速度 mm/s^2
deacceleration减速度 mm/s^2
band定位范围 mm

以设定速度加速度相对运动到给定位置。

推压运动

// 函数原型
void rm_push(rm_handle_t handle,float distance, float velocity, float acceleration, float force_limit, float pos_band_mm, float time_band_ms);

// 使用示例
rm_push(axis, 50.f, 5.f, 500.f, 0.5f, 0.1f, 500.f);
// 函数原型
void RMAxis::push( float distance, float velocity,float acceleration,float force_limit,float pos_band_mm, float time_band_ms);

// 使用示例
axis.push(50.f, 5.f, 500.f, 0.5f, 0.1f, 500.f);
// 函数原型
void Axis::Push(float distance,float velocity, float acceleration,float force_limit,float pos_band_mm,float time_band_ms);

// 使用示例
axis.Push(50, 5, 500, 0.5, 0.1, 500)
## 函数原型
def push(float distance,float velocity, float acceleration,float force_limit,float pos_band_mm,float time_band_ms):

## 使用示例
axis.push(50, 5, 500, 0.5, 0.1, 500)
变量描述
handle轴句柄
distance距离 mm
velocity速度 mm/s
acceleration加速度 mm/s^2
force_limit最大出力限制 %
pos_band位置范围 mm
time_band时间范围 ms

以设定速度mm/s和最大出力%推压到指定距离,推压距离设定需要大于实际推压到工件的位置(如推压到工件位置为5mm，推压距离设定需要大于5mm) 最大出力限制范围推荐0.3 ~ 1.0(代表30% ~ 100%)

精密推压运动

// 函数原型
void rm_precise_push(rm_handle_t handle,float distance, float force, float velocity_factor, float impact_factor, float band_n, float band_ms);

// 使用示例
rm_precise_push(axis, 10.f, 10.f, 1.f, 0.f, 0.1f, 500.f);
// 函数原型
void RMAxis::precise_push(float distance, float force, float velocity_factor, float impact_factor, float band_n, float band_ms);

// 使用示例
axis.precise_push(10.f, 10.f, 1.f, 0.f, 0.1f, 500.f);
// 函数原型
void Axis::PrecisePush(float distance, float force, float velocity_factor, float impact_factor, float band_n, float band_ms);

// 使用示例
axis.PrecisePush(10, 10, 1, 0, 0.1, 500);
## 函数原型
def precise_push(float distance, float force, float velocity_factor, float impact_factor, float band_n, float band_ms):

## 使用示例
axis.precise_push(10, 10, 1, 0, 0.1, 500)
变量描述
handle轴句柄
distance距离 mm
force受力 N
velocity_factor加速度
impact_factor冲击系数
band_n力定位范围 N
band_ms稳压时间 ms

闭环推压距离:闭环推压执行的最大相对距离。如:设定10mm，即执行相对当前位置最多10mm闭环推压，在相对当前位置10mm内达设定力度时输出到位信号，若运动至相对当前位置10mm处将停止向前运动但一直保持出力。 示例：到位范围设定为0.5N，力度设定为30N，延时设定为100ms，即闭环推压 接近物体推力达到30N±0.5N范围内并稳定持续100ms后输出到位信号;当电缸受到大于设定力度(30N)时往反方向运动。若要中断闭环推压需要触发其他绝对运动指令;

Z相回原

// 函数原型
void rm_go_home_z(rm_handle_t handle,float distance, float velocity, float acceleration, float force_limit, float band_mm);

// 使用示例
rm_go_home_z(axis, 10.f, 10.f, 500.f, 0.1f, 0.1f);
// 函数原型
void RMAxis::go_home_z(float distance, float velocity, float acceleration, float force_limit, float band_mm);

// 使用示例
axis.go_home_z(10.f, 10.f, 500.f, 0.1f, 0.1f);
// 函数原型
void Axis::GoHomeZ(float distance, float velocity, float acceleration, float force_limit, float band_mm);

// 使用示例
Axis.GoHomeZ(10.0, 10.0, 500.0, 0.1, 0.1)
## 函数原型
def go_home_z(self,distance,velocity,acceleration,force_limit,band_mm):

## 使用示例
axis.go_home_z(10.0, 10.0, 500.0, 0.1, 0.1)
变量描述
handle轴句柄
distance距离 mm
velocity速度
acceleration加速度
force_limit力限幅 %
band_mm定位范围 mm

触发Z轴回原点, 如果没有设置 自动回原点 的话 每次上电后只需要触发执行一次就行

读取初始化回原点完成信号

// 函数原型
float rm_is_home_down(rm_handle_t handle);

// 使用示例
float _home_down = rm_is_home_down(axis);
// 函数原型
float RMAxis::is_home_down();

// 使用示例
float home_down = axis.is_home_down();
// 函数原型
float Axis::IsHomeDown();

// 使用示例
var HomeDown = axis.IsHomeDown();
## 函数原型
def is_home_down(self):

## 使用示例
HomeDown = axis.is_home_down()
变量描述
handle轴句柄
返回值初始化回原是否完成

检查是否已初始化回原点完成

是否在运动中

// 函数原型
bool rm_is_moving(rm_handle_t handle);

// 使用示例
bool moving = rm_is_moving(axis);
// 函数原型
bool RMAxis::is_moving()//只能用于判断指令15是否完成,判断是否在moving;

// 使用示例
bool moving = axis.is_moving();
// 函数原型
bool Axis::IsMoving();

// 使用示例
bool moving = axis.IsMoving();
## 函数原型
def is_moving(self):

## 使用示例
moving = axis.is_moving()
变量描述
handle轴句柄
返回值是否在运动

检查轴是否在运动

是否运动到达

// 函数原型
bool rm_is_reached(rm_handle_t handle);

// 使用示例
bool reached = rm_is_reached(axis);
// 函数原型
bool RMAxis::is_reached()//只能判断 绝对运动，精密推压;

// 使用示例
bool reached = axis.is_reached();
// 函数原型
bool Axis::IsReached();

// 使用示例
bool reached = axis.IsReached();
## 函数原型
def is_reached(self):

## 使用示例
reached = axis.is_reached()
变量描述
handle轴句柄
返回值是否运动到达

检查轴是否到达运动目标

是否推空

// 函数原型
bool rm_is_push_empty(rm_handle_t handle);

// 使用示例
bool empty = rm_is_push_empty(axis);
// 函数原型
bool RMAxis::is_push_empty();

// 使用示例
bool empty = axis.is_push_empty();
// 函数原型
bool Axis::IsPushEmpty();

// 使用示例
bool empty = axis.IsPushEmpty();
## 函数原型
def is_push_empty(self):

## 使用示例
empty = axis.is_push_empty()
变量描述
handle轴句柄
返回值是否推空

检查轴推压运动是否推空， 可以在推压运动完成后用这来检测是否推压/夹持空，夹持到返回fasle，夹空返回true。

0~15到位信号

// 函数原型
bool rm_get_output_signal(rm_handle_t handle, const char* signal);

// 使用示例
bool command_finished = rm_get_output_signal("virtual_io.command_finished_15");
// 函数原型
bool RMAxis::get_output_signal(std::string signal);

// 使用示例
bool command_finished = axis->get_output_signal("virtual_io.command_finished_15");
// 函数原型
bool Axis::ReadInput(ushort inputAddress)

// 使用示例
bool command_finished_15 = axis.Readinput(1015);
## 函数原型
def get_output_signal(self):

## 使用示例
empty = axis.get_output_signal("virtual_io.command_finished_15");
变量描述
handle轴句柄
signal指令序号 "virtual_io.command_finished_0"，"virtual_io.command_finished_1"...
返回值是否到位

检查轴点位0~15是否到位， 可以在触发点位后用这来检测是执行完该点位。 Csharp用户使用Readinput()函数，地址与Modbus通讯文档相同如：读取点位0到位地址：1000，点位15:1015。其他点位序号地址1000+n；

离线采集

触发离线采集

// 函数原型
void rm_start_monitor(rm_handle_t handle,int32_t next,uint32_t freq_hz, uint32_t length, uint32_t count, uint32_t var_0, uint32_t var_1, uint32_t var_2);

// 使用示例
rm_start_monitor(axis,1,1000,1,1000,1,0,0);
// 函数原型
void RMAxis::start_monitor(int32_t next,uint32_t freq_hz, uint32_t length, uint32_t count, uint32_t var_0, uint32_t var_1, uint32_t var_2);

// 使用示例
axis.start_monitor(1,1000,1,1000,1,0,0);
// 函数原型
void Axis::StartMonitor(int32_t next,uint32_t freq_hz, uint32_t length, uint32_t count, uint32_t var_0, uint32_t var_1, uint32_t var_2);

// 使用示例
axis.StartMonitor(1,1000,1,1000,1,0,0);
## 函数原型
def start_monitor(self):

## 使用示例
axis.start_monitor(1,1000,1,1000,1,0,0);
变量描述
handle轴句柄
next指令序号
freq_hz采集频率
length采集频道数 （最大值为3，对应下发三个参数是否生效）
count采集数量
var_0指令0
var_1指令1
var_2指令2
以上三个参数可以填入一下index0 当前位置 1 当前速度 2 当前出力 3 目标位置 4 当前受力

设置离线采集，并设置需要采集的下一步指令next

获取离线采集结果

// 函数原型
void rm_sample_result(rm_handle_t handle,float** buffer, size_t* buffer_size);

// 使用示例
float* result_buffer = NULL;
size_t result_size = 0;
rm_sample_result(&result_buffer, &result_size);
// 使用结果...
if (result_buffer != NULL) {
    for (size_t i = 0; i < result_size; i++) {
        printf("%f\n", result_buffer[i]);
    }
}
// 使用完后释放通过 malloc 分配的内存
free(result_buffer);
result_buffer = NULL;
// 函数原型
std::vector<float> RMAxis::sample_result()
// 使用示例
axis.sample_result();
// 函数原型
void Axis::SampleResult()

// 使用示例
IList<float> samples = axisProxy.ReadSampleResult();
## 函数原型
def sample_result(self)

## 使用示例
axis.sample_result();

采集的数据长度与控制器版本的内存有关系 具体详情咨询技术支持

指令

typedef enum {
    command.none = 0,
    command.go_home = 1,
    command.delay = 2,
    command.absolute_move = 3,
    command.relative_move = 4,
    command.push = 5,
    command.precise_push = 6,
    command.go_home_z= 7,
    command.precise_touch= 8,
    command.start_monitor= 9
} command_type_t;

typedef struct {
    command_type_t type;
    float position;
    float velocity;
    float acceleration;
    float deacceleration;
    float band;
    float push_force;
    float push_distance;
    int32_t delay;
    int32_t next_command_index;
} command_t;
public enum MOTION_COMMAND : uint
{
   none = 0,
    go_home = 1,
    delay = 2,
    absolute_move = 3,
    relative_move = 4,
    push = 5,
    precise_push = 6,
    go_home_z= 7,
    precise_touch= 8,
    start_monitor= 9
};
            
[StructLayout(LayoutKind.Sequential)]
public struct motion_command_t
{
    public MOTION_COMMAND type;
    public float position;
    public float velocity;
    public float acceleration;
    public float deacceleration;
    public float tolerance;
    public float push_force;
    public float push_distance;
    public int delay;
    public int next_command_index;
}

class Command(ctypes.Structure):
    _fields_ = [('type', ctypes.c_int),
                ('position', ctypes.c_float),
                ('velocity', ctypes.c_float),
                ('acceleration', ctypes.c_float),
                ('deacceleration', ctypes.c_float),
                ('tolerance', ctypes.c_float),
                ('push_force', ctypes.c_float),
                ('push_distance', ctypes.c_float),
                ('delay', ctypes.c_float),
                ('next_command_index', ctypes.c_int)]
指令结构体

设置指令

// 函数原型
void rm_set_command(rm_handle_t handle, int index, command_t command);

// 使用示例
rm_set_command(asix,0, command);
// 函数原型
void RMAxis::set_command(int index, command_t command);

// 使用示例
axis.set_command(axis,0, command);
// 函数原型
vvoid Axis::SetCommand(int index, Command command);

// 使用示例
axis.SetCommand(0, command);
## 函数原型
def set_command(self, index, command):

## 使用示例
axis.set_command(0, command)
变量描述
handle轴句柄
index指令序号
command指令

设置指定序号的指令

读取指令

// 函数原型
command_t rm_get_command(rm_handle_t handle, int index);

// 使用示例
command_t command = rm_get_command(axis, 0);
// 函数原型
command_t RMAxis::get_command(int index);

// 使用示例
auto command = axis.get_command(0);
// 函数原型
Command Axis::GetCommand(int index);

// 使用示例
var command = axis.GetCommand(0);
## 函数原型
def get_command(self, index):

## 使用示例
command = axis.get_command(0)
变量描述
handle轴句柄
index指令序号

读取指定序号的指令

执行指令

// 函数原型
void rm_execute_command(rm_handle_t handle, command_t command);

// 使用示例
rm_execute_command(axis, command);
// 函数原型
void RMAxis::execute_command(command_t command);

// 使用示例
axis.execute_command(command);
// 函数原型
void Axis::ExecuteCommand(Command command);

// 使用示例
axis.ExecuteCommand(command);
## 函数原型
def execute_command(self, command):

## 使用示例
axis.execute_command(command)
变量描述
handle轴句柄
command指令

触发执行指定指令

触发指令

// 函数原型
void rm_trig_command(rm_handle_t handle, int index);

// 使用示例
rm_trig_command(axis, 0);
// 函数原型
void RMAxis::trig_command(int index);

// 使用示例
axis.trig_command(0);
// 函数原型
void Axis::TrigCommand(int index);

// 使用示例
axis.TrigCommand(0);
## 函数原型
def trig_command(self, index):

## 使用示例
axis.trig_command(0)
变量描述
handle轴句柄
index指令序号

触发执行指定序号的指令

读取指令

// 函数原型
void rm_load_commands(rm_handle_t handle);

// 使用示例
rm_load_commands(axis);
// 函数原型
void RMAxis::load_commands();

// 使用示例
axis.load_commands();
// 函数原型
void Axis::LoadCommands()

// 使用示例
axis.LoadCommands();
## 函数原型
def load_commands(self):

## 使用示例
axis.load_commands()
变量描述
handle轴句柄

读取指令表

保存指令

// 函数原型
void rm_save_commands(rm_handle_t handle);

// 使用示例
rm_save_commands(axis);
// 函数原型
void RMAxis::save_commands();

// 使用示例
axis.save_commands();
// 函数原型
void Axis::SaveCommands();

// 使用示例
axis.SaveCommands();
## 函数原型
def save_commands(self):

## 使用示例
axis.save_commands()
变量描述
handle轴句柄

保存指令表

状态

读取当前位置

// 函数原型
float rm_position(rm_handle_t handle);

// 使用示例
float position = rm_position(axis);
// 函数原型
float RMAxis::position();

// 使用示例
float position = axis.position();
// 函数原型
float Axis::Position();

// 使用示例
var position = axis.Position();
## 函数原型
def position(self):

## 使用示例
position = axis.position()
变量描述
handle轴句柄
返回值位置 mm

读取当前位置mm

读取当前速度

// 函数原型
float rm_velocity(rm_handle_t handle);

// 使用示例
float velocity = rm_velocity(axis);
// 函数原型
float RMAxis::velocity();

// 使用示例
float velocity = axis.velocity();
// 函数原型
float Axis::Velocity();

// 使用示例
var velocity = axis.Velocity();
## 函数原型
def velocity(self):

## 使用示例
velocity = axis.velocity()
变量描述
handle轴句柄
返回值速度 mm/s

读取当前速度mm/s

读取当前电机出力

// 函数原型
float rm_torque(rm_handle_t handle);

// 使用示例
float torque = rm_torque(axis);
// 函数原型
float RMAxis::torque();

// 使用示例
float torque = axis.torque();
// 函数原型
float Axis::Torque();

// 使用示例
var torque = axis.Torque();
## 函数原型
def torque(self):

## 使用示例
torque = axis.torque()
变量描述
handle轴句柄
返回值出力%

读取当前电机出力%

读取当前力传感器读数

// 函数原型
float rm_force_sensor(rm_handle_t handle);

// 使用示例
float force = rm_force_sensor(axis);
// 函数原型
float RMAxis::force_sensor();

// 使用示例
float force = axis.force_sensor();
// 函数原型
float Axis::ForceSensor();

// 使用示例
var force = axis.ForceSensor();
## 函数原型
def force_sensor(self):

## 使用示例
force = axis.force_sensor()
变量描述
handle轴句柄
返回值当前力传感器值N

读取当前力传感器值N

读取错误状态代码

// 函数原型
uint32_t rm_error_code(rm_axis_t handle);

// 使用示例
uint32_t error = rm_error_code(axis);
// 函数原型
virtual uint32_t error_code() = 0;

// 使用示例
uint32_t error = axis.error_code(axis);
// 函数原型
public uint ErrorCode{get;}

// 使用示例
var error = axis.ErrorCode;
## 函数原型
def error_code(self):

## 使用示例
error = axis.error_code()
// 函数原型
error_code : () => number;

// 使用示例
error = axis.error_code()
变量描述
handle轴句柄
返回值当前错误状态代码

读取当前错误状态代码

错误代码描述
0正常
-10位置超差
-20速度超差
-30位置超差 + 速度超差
-40电机堵转
-50位置超差 + 电机堵转
-60速度超差 + 电机堵转
-70位置超差 + 速度超差 + 电机堵转

重置错误

// 函数原型
uint32_t rm_reset_error(rm_handle_t handle);

// 使用示例
rm_reset_error(axis);
// 函数原型
void RMAxis::reset_error();

// 使用示例
axis.reset_error();
// 函数原型
void Axis::ResetError()

// 使用示例
axis.ResetError();
## 函数原型
def reset_error(self):

## 使用示例
axis.reset_error()
变量描述
handle轴句柄

重置控制器错误状态

开关伺服

// 函数原型
void rm_set_servo_on_off(rm_handle_t handle, bool on_off);

// 使用示例
rm_set_servo_on_off(axis, false);
// 函数原型
void RMAxis::set_servo_on_off(bool on_off);

// 使用示例
axis.set_servo_on_off(false);
// 函数原型
void Axis::SetServoOnOff(bool on_off);

// 使用示例
axis.ServoOnOff = false;
## 函数原型
def set_servo_on_off(self,on_off):

## 使用示例
axis.set_servo_on_off(False)
变量描述
handle轴句柄
on_off伺服开关信号

设置伺服开关信号 false：下伺服使能; true：上伺服使能;

停止

// 函数原型
void rm_stop(rm_handle_t handle);

// 使用示例
rm_stop(axis);
// 函数原型
void RMAxis::stop();    

// 使用示例
axis.stop();
// 函数原型
void Axis::Stop()

// 使用示例
axis.Stop();
## 函数原型
def stop(self):

## 使用示例
axis.stop()
变量描述
handle轴句柄

停止轴运动

加载参数

// 函数原型
void rm_load_parameters(rm_handle_t handle);

// 使用示例
rm_load_parameters(axis);
// 函数原型
void RMAxis::load_parameters(); 

// 使用示例
axis.load_parameters();
// 函数原型
void Axis::LoadParameters()

// 使用示例
axis.LoadParameters();
## 函数原型
def load_parameters(self):

## 使用示例
axis.load_parameters()
变量描述
handle轴句柄

加载参数表

保存参数

// 函数原型
void rm_save_parameters(rm_handle_t handle);

// 使用示例
rm_save_parameters(axis);
// 函数原型
void RMAxis::save_parameters(); 

// 使用示例
axis.save_parameters();
// 函数原型
void Axis::SaveParameters()

// 使用示例
axis.SaveParameters();
## 函数原型
def save_parameters(self):

## 使用示例
axis.save_parameters()
变量描述
handle轴句柄

保存参数表

Last updated on 2025/2/21
← Api_V4