Skip to content

张东亮 / SO1049-CarriageClient

转到一个项目
切换导航栏
切换导航栏固定状态
Commit 959e9b94 由 张东亮
选项

关闭加载监控相机

1 个父辈 52a58a0b
内嵌 并排
正在显示 3 个修改的文件 包含 372 行增加 和 353 行删除
source/DeviceLibrary/clientEquip/ClientBean.cs
......@@ -55,11 +55,15 @@ namespace OnlineStore.DeviceLibrary
equipsMap.Add(3, robotEquip);
//先初始化设备
// RFIDManager.Open();
//LogUtil.info("准备加载板卡配置");
HCBoardManager.InitConfig();
// LogUtil.info("准备加载IO");
IOManager.Init();
// LogUtil.info("准备加载轴");
AxisManager.Init();
//LogUtil.info("准备开卡");
AxisManager.instance.OpenCard();
// LogUtil.info("准备加载相机配置");
//初始化摄像机配置
CodeManager.LoadConfig();
......
source/DeviceLibrary/clientEquip/robotEquip/RobotEquip_Camera.cs
......@@ -24,16 +24,16 @@ namespace OnlineStore.DeviceLibrary
{
if (loadCameraState)
return;
string path = @".\Config\Camera.json";
if (!File.Exists(path))
{
LogUtil.error(Name + "找不到监控相机配置文件" + path);
}
//string path = @".\Config\Camera.json";
//if (!File.Exists(path))
//{
// LogUtil.error(Name + "找不到监控相机配置文件" + path);
//}
camera = new Asa.Camera.VisionLib(path);
camerathread = new Thread[2];
//pictureBox1.Image = bmp;
StartCamera();
//camera = new Asa.Camera.VisionLib(path);
//camerathread = new Thread[2];
////pictureBox1.Image = bmp;
//StartCamera();
loadCameraState = true;
}
void StartCamera()
......@@ -51,36 +51,36 @@ namespace OnlineStore.DeviceLibrary
void startMonitor(object obj)
{
if (!loadCameraState)
{
LogUtil.error(Name + "监控相机初始化失败,无法开启");
return;
}
string name = (string)obj;
while (IsOpen)
{
Bitmap bmp = AcqImage(name);
if (bmp != null)
{
camera_event?.Invoke(new CameraArgs(name, bmp));
}
//if (MoveInfo != null)
//{
// if (MoveInfo.MoveType.Equals(MoveType.InStore) || MoveInfo.MoveType.Equals(MoveType.OutStore))
// {
// if (CheckASide() && name.Equals("box_A"))
// {
// SaveImage(name);
// }
// else
// {
// SaveImage("box_B");
// }
//if (!loadCameraState)
//{
// LogUtil.error(Name + "监控相机初始化失败,无法开启");
// return;
//}
//string name = (string)obj;
//while (IsOpen)
//{
// Bitmap bmp = AcqImage(name);
// if (bmp != null)
// {
// camera_event?.Invoke(new CameraArgs(name, bmp));
// }
// //if (MoveInfo != null)
// //{
// // if (MoveInfo.MoveType.Equals(MoveType.InStore) || MoveInfo.MoveType.Equals(MoveType.OutStore))
// // {
// // if (CheckASide() && name.Equals("box_A"))
// // {
// // SaveImage(name);
// // }
// // else
// // {
// // SaveImage("box_B");
// // }
// }
//}
Thread.Sleep(300);
}
// // }
// //}
// Thread.Sleep(300);
//}
}
void StopCamera()
{
......
source/JAKA/JAKABean-Functions.cs
......@@ -26,24 +26,7 @@ namespace JAKA
}
return false;
}
/// <summary>
/// 注册机器人出错时的回调函数
/// </summary>
/// <returns></returns>
bool SetErrorHandler()
{
int rtn = jakaAPI.set_error_handler(ref _handle, user_error_handle);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"SetErrorHandler OK");
return true;
}
else
{
ErrorLog($"SetErrorHandler Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 销毁机器人控制句柄
/// </summary>
......@@ -97,23 +80,7 @@ namespace JAKA
}
return false;
}
/// <summary>
/// 机器人关机
/// </summary>
public bool ShutDown()
{
int rtn = jakaAPI.shut_down(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"ShutDown OK");
return true;
}
else
{
ErrorLog($"ShutDown Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人上使能
/// </summary>
......@@ -149,407 +116,305 @@ namespace JAKA
return false;
}
/// <summary>
/// 机器人手动模式下运动
/// </summary>
/// <param name="aj_num">关节空间下代表关节号[0-5]，笛卡尔下依次为轴 x，y，z，rx，ry，rz</param>
/// <param name="move_mode">机器人运动模式，增量运动或者绝对运动(即持续 jog 运动)</param>
/// <param name="coordType">机器人运动坐标系，工具坐标系，基坐标系（当前的世界/用户坐标系）或关节空间</param>
/// <param name="vel_cmd">指令速度，旋转轴或关节运动单位为 rad/s，移动轴单位为 mm/</param>
/// <param name="pos_cmd">指令位置，旋转轴或关节运动单位为 rad，移动轴单位为 m</param>
/// <returns></returns>
bool Jog(int aj_num,JKTYPE.MoveMode move_mode,JKTYPE.CoordType coordType,double vel_cmd,double pos_cmd)
{
int rtn = jakaAPI.jog(ref _handle,aj_num,move_mode,coordType,vel_cmd,pos_cmd);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"Jog OK");
return true;
}
else
{
ErrorLog($"Jog Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人手动模式下运动停止
/// 查询数字输出状态
/// </summary>
/// <param name="num">机械臂轴号 0-5，num为-1时，停止所有轴 </param>
/// <param name="iOType"> DO 类型</param>
/// <param name="index">DO 索引（从 0 开始）</param>
/// <param name="value">DO 状态查询结果</param>
/// <returns></returns>
public bool JogStop(int num=-1)
public bool GetDigitalOutput(JKTYPE.IOType iOType, int index, out bool result)
{
int rtn = jakaAPI.jog_stop(ref _handle,ref num);
result = false;
int rtn = jakaAPI.get_digital_output(ref _handle, iOType, index, ref result);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"JogStop OK");
DebugLog($"GetDigitalOutput [{iOType}][{index}={result}] OK");
return true;
}
else
{
ErrorLog($"JogStop Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"GetDigitalOutput [{iOType}][{index}={result}] Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人关节运动
/// 运行当前加载的作业程序
/// </summary>
/// <param name="jointPos">机器人关节运动目标位置</param>
/// <param name="moveMode">指定运动模式：增量运动或绝对运动</param>
/// <param name="isBlock">设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口</param>
/// <param name="speed">机器人关节运动速度，单位：rad/s</param>
/// <returns></returns>
bool JointMove(JKTYPE.JointValue jointPos,JKTYPE.MoveMode moveMode,bool isBlock,double speed)
public bool Run()
{
int rtn = jakaAPI.joint_move(ref _handle,ref jointPos,moveMode,isBlock,speed);
int rtn = jakaAPI.program_run(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"JointMove OK");
return true;
InfoLog($"Run OK");
return false;
}
else
{
ErrorLog($"JointMove Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"Run Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人末端直线运动
/// 暂停当前运行的作业程序
/// </summary>
/// <param name="endPos">机器人末端运动目标位置</param>
/// <param name="moveMode">指定运动模式：增量运动或绝对运动</param>
/// <param name="isBlock">设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口</param>
/// <param name="speed">机器人直线运动速度，单位：mm/s</param>
/// <returns></returns>
bool LinaerMove(JKTYPE.CartesianPose endPos, JKTYPE.MoveMode moveMode, bool isBlock, double speed)
public bool Pause()
{
int rtn = jakaAPI.linear_move(ref _handle, ref endPos, moveMode, isBlock, speed);
int rtn = jakaAPI.program_pause(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"LinaerMove OK");
return true;
InfoLog($"Pause OK");
return false;
}
else
{
ErrorLog($"LinaerMove Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"Pause Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人伺服位置控制模式使能
/// 继续运行当前暂停的作业程序
/// </summary>
/// <param name="enable">TRUE 为进入伺服位置控制模式，FALSE 表示退出该模式</param>
/// <returns></returns>
public bool ServoMoveEnable(bool enable)
public bool Resume()
{
int rtn = jakaAPI.servo_move_enable(ref _handle,enable);
int rtn = jakaAPI.program_resume(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"ServoMoveEnable OK");
return true;
InfoLog($"Resume OK");
return false;
}
else
{
ErrorLog($"ServoMoveEnable Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"Resume Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人关节空间伺服模式运动
/// </summary>
/// <param name="jointPos">机器人关节运动目标位置</param>
/// <param name="moveMode">指定运动模式：绝对运动或相对运动</param>
/// <returns></returns>
bool ServoJ(JKTYPE.JointValue jointPos,JKTYPE.MoveMode moveMode)
{
int rtn = jakaAPI.servo_j(ref _handle,ref jointPos,moveMode);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"ServoJ OK");
return true;
}
else
{
ErrorLog($"ServoJ Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人关节空间伺服模式运动扩展
/// 终止当前执行的作业程序
/// </summary>
/// <param name="jointPos">机器人关节运动目标位置</param>
/// <param name="moveMode">指定运动模式：增量运动或绝对运动</param>
/// <param name="stepNum">倍分周期，servo_j 运动周期为 step_num*8ms，其中 step_num>=1</param>
/// <returns></returns>
bool ServoJExtend(JKTYPE.JointValue jointPos, JKTYPE.MoveMode moveMode,int stepNum)
public bool Abort()
{
int rtn = jakaAPI.servo_j_extend(ref _handle, ref jointPos, moveMode,stepNum);
int rtn = jakaAPI.program_abort(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"ServoJExtend OK");
InfoLog($"Abort OK");
return true;
}
else
{
ErrorLog($"ServoJExtend Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"Abort Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人笛卡尔空间伺服模式运动
/// 获取机器人作业程序的执行状态
/// </summary>
/// <param name="cartesianPose">机器人笛卡尔空间运动目标位置</param>
/// <param name="moveMode">指定运动模式：ABS 代表绝对运动，INCR 代表相对运动</param>
/// <param name="status">作业程序执行状态查询结果</param>
/// <returns></returns>
bool ServoP(JKTYPE.CartesianPose cartesianPose, JKTYPE.MoveMode moveMode)
public bool GetProgramState(out JKTYPE.ProgramState status)
{
int rtn = jakaAPI.servo_p(ref _handle, ref cartesianPose, moveMode);
status = new JKTYPE.ProgramState();
int rtn = jakaAPI.get_program_state(ref _handle,ref status);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"ServoP OK");
return true;
DebugLog($"GetProgramState OK");
return false;
}
else
{
ErrorLog($"ServoP Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"GetProgramState Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人笛卡尔空间伺服模式运动扩展
/// 获取机器人状态监测数据
/// </summary>
/// <param name="jointPos">机器人笛卡尔空间运动目标位置</param>
/// <param name="moveMode">指定运动模式：增量运动或绝对运动</param>
/// <param name="stepNum">倍分周期，servo_p 运动周期为 step_num*8ms，其中 step_num>=1</param>
/// <param name="robotStatus"></param>
/// <returns></returns>
bool ServoPExtend(JKTYPE.CartesianPose cartesianPose, JKTYPE.MoveMode moveMode, int stepNum)
public bool GetRobotStatus(out JKTYPE.RobotStatus robotStatus)
{
int rtn = jakaAPI.servo_p_extend(ref _handle, ref cartesianPose, moveMode, stepNum);
robotStatus = new JKTYPE.RobotStatus();
int rtn = jakaAPI.get_robot_status(ref _handle,ref robotStatus);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"ServoPExtend OK");
DebugLog($"GetRobotDtatus OK");
return true;
}
else
{
ErrorLog($"ServoPExtend Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"GetRobotDtatus Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置数字输出变量
/// 机器人运动终止
/// </summary>
/// <param name="iOType"> DO 类型</param>
/// <param name="index">DO 索引（从 0 开始）</param>
/// <param name="value">DO 设置值</param>
/// <returns></returns>
bool SetDigitalOutput(JKTYPE.IOType iOType,int index,bool value)
public bool MotionAbort()
{
int rtn = jakaAPI.set_digital_output(ref _handle, iOType, index,value);
int rtn = jakaAPI.motion_abort(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetDigitalOutput [{iOType}][{index}={value}] OK");
DebugLog($"MotionAbort OK");
return true;
}
else
{
ErrorLog($"SetDigitalOutput [{iOType}][{index}={value}] Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"MotionAbort Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置模拟输出变量
/// 设置机器人错误码文件存放路径,
/// 需要使用 get_last_error 接口时需要设置错误码文件路径，如果不使用
///get_last_error 接口，则不需要设置该接口
/// </summary>
/// <param name="iOType"> DO 类型</param>
/// <param name="index">DO 索引（从 0 开始）</param>
/// <param name="value">DO 设置值</param>
/// <param name="path"></param>
/// <returns></returns>
bool SetAnalogOutput(JKTYPE.IOType iOType, int index, float value)
bool SetErrorCodeFilePath(string path)
{
int rtn = jakaAPI.set_analog_output(ref _handle, iOType, index, value);
StringBuilder sb = new StringBuilder(path);
int rtn = jakaAPI.set_errorcode_file_path(ref _handle,sb);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetAnalogOutput [{iOType}][{index}={value}] OK");
DebugLog($"SetErrorCodeFilePath OK");
return true;
}
else
{
ErrorLog($"SetAnalogOutput [{iOType}][{index}={value}] Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"SetErrorCodeFilePath Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 查询数字输入状态
/// 获取机器人运行过程中最后一个错误码,当调用 clear_error 时，最后一个错误码会清零
/// </summary>
/// <param name="iOType"> DI 类型</param>
/// <param name="index">DI 索引（从 0 开始）</param>
/// <param name="value">DI 状态查询结果</param>
/// <param name="errorCode"></param>
/// <returns></returns>
public bool GetDigitalInput(JKTYPE.IOType iOType, int index,out bool result)
public bool GetLastError(ref JKTYPE.ErrorCode errorCode)
{
result = false;
int rtn = jakaAPI.get_digital_input(ref _handle, iOType, index,ref result);
int rtn = jakaAPI.get_last_error(ref _handle,ref errorCode);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetDigitalInput [{iOType}][{index}={result}] OK");
DebugLog($"GetLastError OK");
return true;
}
else
{
ErrorLog($"GetDigitalInput [{iOType}][{index}={result}] Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"GetLastError Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 查询数字输出状态
/// 清除错误，最后一个错误码会清零
/// </summary>
/// <param name="iOType"> DO 类型</param>
/// <param name="index">DO 索引（从 0 开始）</param>
/// <param name="value">DO 状态查询结果</param>
/// <returns></returns>
public bool GetDigitalOutput(JKTYPE.IOType iOType, int index, out bool result)
public bool ClearError()
{
result = false;
int rtn = jakaAPI.get_digital_output(ref _handle, iOType, index, ref result);
int rtn = jakaAPI.clear_error(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetDigitalOutput [{iOType}][{index}={result}] OK");
InfoLog($"ClearError OK");
return true;
}
else
{
ErrorLog($"GetDigitalOutput [{iOType}][{index}={result}] Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 运行当前加载的作业程序
/// </summary>
public bool Run()
{
int rtn = jakaAPI.program_run(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"Run OK");
return false;
}
else
{
ErrorLog($"Run Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 暂停当前运行的作业程序
/// </summary>
public bool Pause()
{
int rtn = jakaAPI.program_pause(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"Pause OK");
return false;
}
else
{
ErrorLog($"Pause Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"ClearError Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 继续运行当前暂停的作业程序
/// </summary>
public bool Resume()
void user_error_handle(int error_code)
{
int rtn = jakaAPI.program_resume(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"Resume OK");
return false;
}
else
{
ErrorLog($"Resume Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
ErrorLog($"机械臂发生异常,异常码:{error_code}");
}
#region 未使用
/// <summary>
/// 终止当前执行的作业程序
/// 设置机器人状态数据自动更新时间间隔
/// </summary>
public bool Abort()
/// <param name="ms"> 时间参数，单位毫秒</param>
/// <returns></returns>
public bool SetStatusDataUpdateTimeInterval(float ms)
{
int rtn = jakaAPI.program_abort(ref _handle);
int rtn = jakaAPI.set_status_data_update_time_interval(ref _handle, ms);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"Abort OK");
DebugLog($"SetStatusDataUpdateTimeInterval OK");
return true;
}
else
{
ErrorLog($"Abort Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"SetStatusDataUpdateTimeInterval Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 加载指定的作业程序
/// 设置网络异常，机器人终止运动等待时间
/// </summary>
/// <param name="file">加载指定的作业程序 （加载轨迹复现数据，轨迹复现数据的加载需要在文件夹名字前加上 track/）</param>
/// <param name="ms">时间参数，单位毫秒</param>
/// <param name="mnt">网络异常时机器人需要进行的动作类型</param>
/// <returns></returns>
public bool Load(string file)
public bool SetNetworkExceptionHandle(float ms, JKTYPE.ProcessType mnt)
{
int rtn = jakaAPI.program_load(ref _handle,file.ToCharArray());
int rtn = jakaAPI.set_network_exception_handle(ref _handle, ms, mnt);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"Load OK");
DebugLog($"SetNetworkExceptionHandle OK");
return true;
}
else
{
ErrorLog($"Load Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"SetNetworkExceptionHandle Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 获取已加载的作业程序的名字
/// 设置 SDK 日志路径
/// </summary>
/// <param name="file">程序文件路径</param>
/// <param name="filepath">SDK 日志路径</param>
/// <returns></returns>
public bool GetLoadedProgram(StringBuilder file)
public bool SetSDKFilePath(string filepath)
{
int rtn = jakaAPI.get_loaded_program(ref _handle,file);
char[] chars = filepath.ToCharArray();
int rtn = jakaAPI.set_SDK_filepath(ref _handle, ref chars);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetLoadedProgram OK");
DebugLog($"SetSDKFilePath OK");
return true;
}
else
{
ErrorLog($"GetLoadedProgram Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"SetSDKFilePath Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 获取机器人作业程序的执行状态
/// 设置 SDK 是否开启调试模式
/// </summary>
/// <param name="status">作业程序执行状态查询结果</param>
/// <param name="mode"></param>
/// <returns></returns>
public bool GetProgramState(out JKTYPE.ProgramState status)
public bool SetDebugMode(bool mode)
{
status = new JKTYPE.ProgramState();
int rtn = jakaAPI.get_program_state(ref _handle,ref status);
int rtn = jakaAPI.set_debug_mode(ref _handle, mode);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetProgramState OK");
return false;
DebugLog($"SetDebugMode OK");
return true;
}
else
{
ErrorLog($"GetProgramState Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"SetDebugMode Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
......@@ -579,7 +444,7 @@ namespace JAKA
public bool GetRapidRate(out double rate)
{
rate = 0;
int rtn = jakaAPI.get_rapidrate(ref _handle,ref rate);
int rtn = jakaAPI.get_rapidrate(ref _handle, ref rate);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetRapidRate OK");
......@@ -617,7 +482,7 @@ namespace JAKA
public bool IsInDragMode(out bool inDrag)
{
inDrag = false;
int rtn = jakaAPI.is_in_drag_mode(ref _handle,ref inDrag);
int rtn = jakaAPI.is_in_drag_mode(ref _handle, ref inDrag);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"IsInDragMode OK");
......@@ -732,7 +597,7 @@ namespace JAKA
/// <returns></returns>
public bool SetCollisionLevel(int level)
{
int rtn = jakaAPI.set_collision_level(ref _handle,level);
int rtn = jakaAPI.set_collision_level(ref _handle, level);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetCollisionLevel OK");
......@@ -752,7 +617,7 @@ namespace JAKA
public bool GetCollisionLevel(out int level)
{
level = 0;
int rtn = jakaAPI.get_collision_level(ref _handle,ref level);
int rtn = jakaAPI.get_collision_level(ref _handle, ref level);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetCollisionLevel OK");
......@@ -771,7 +636,7 @@ namespace JAKA
/// <returns></returns>
public bool SetPayload(JKTYPE.PayLoad payload)
{
int rtn = jakaAPI.set_payload(ref _handle,ref payload);
int rtn = jakaAPI.set_payload(ref _handle, ref payload);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetPayload OK");
......@@ -810,7 +675,7 @@ namespace JAKA
/// <returns></returns>
public bool GetSDKVersion(StringBuilder version)
{
int rtn = jakaAPI.get_sdk_version(ref _handle,version);
int rtn = jakaAPI.get_sdk_version(ref _handle, version);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetSDKVersion OK");
......@@ -822,186 +687,336 @@ namespace JAKA
}
return false;
}
/// <summary>
/// 获取机器人状态监测数据
/// 加载指定的作业程序
/// </summary>
/// <param name="robotStatus"></param>
/// <param name="file">加载指定的作业程序 （加载轨迹复现数据，轨迹复现数据的加载需要在文件夹名字前加上 track/）</param>
/// <returns></returns>
public bool GetRobotStatus(out JKTYPE.RobotStatus robotStatus)
public bool Load(string file)
{
robotStatus = new JKTYPE.RobotStatus();
int rtn = jakaAPI.get_robot_status(ref _handle,ref robotStatus);
int rtn = jakaAPI.program_load(ref _handle, file.ToCharArray());
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetRobotDtatus OK");
InfoLog($"Load OK");
return true;
}
else
{
ErrorLog($"GetRobotDtatus Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"Load Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置 SDK 是否开启调试模式
/// 获取已加载的作业程序的名字
/// </summary>
/// <param name="mode"></param>
/// <param name="file">程序文件路径</param>
/// <returns></returns>
public bool SetDebugMode(bool mode)
public bool GetLoadedProgram(StringBuilder file)
{
int rtn = jakaAPI.set_debug_mode(ref _handle,mode);
int rtn = jakaAPI.get_loaded_program(ref _handle, file);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetDebugMode OK");
DebugLog($"GetLoadedProgram OK");
return true;
}
else
{
ErrorLog($"SetDebugMode Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"GetLoadedProgram Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人运动终止
/// 机器人手动模式下运动
/// </summary>
/// <param name="aj_num">关节空间下代表关节号[0-5]，笛卡尔下依次为轴 x，y，z，rx，ry，rz</param>
/// <param name="move_mode">机器人运动模式，增量运动或者绝对运动(即持续 jog 运动)</param>
/// <param name="coordType">机器人运动坐标系，工具坐标系，基坐标系（当前的世界/用户坐标系）或关节空间</param>
/// <param name="vel_cmd">指令速度，旋转轴或关节运动单位为 rad/s，移动轴单位为 mm/</param>
/// <param name="pos_cmd">指令位置，旋转轴或关节运动单位为 rad，移动轴单位为 m</param>
/// <returns></returns>
public bool MotionAbort()
bool Jog(int aj_num, JKTYPE.MoveMode move_mode, JKTYPE.CoordType coordType, double vel_cmd, double pos_cmd)
{
int rtn = jakaAPI.motion_abort(ref _handle);
int rtn = jakaAPI.jog(ref _handle, aj_num, move_mode, coordType, vel_cmd, pos_cmd);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"MotionAbort OK");
DebugLog($"Jog OK");
return true;
}
else
{
ErrorLog($"MotionAbort Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"Jog Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置机器人错误码文件存放路径,
/// 需要使用 get_last_error 接口时需要设置错误码文件路径，如果不使用
///get_last_error 接口，则不需要设置该接口
/// 机器人手动模式下运动停止
/// </summary>
/// <param name="path"></param>
/// <param name="num">机械臂轴号 0-5，num为-1时，停止所有轴 </param>
/// <returns></returns>
bool SetErrorCodeFilePath(string path)
public bool JogStop(int num = -1)
{
StringBuilder sb = new StringBuilder(path);
int rtn = jakaAPI.set_errorcode_file_path(ref _handle,sb);
int rtn = jakaAPI.jog_stop(ref _handle, ref num);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetErrorCodeFilePath OK");
DebugLog($"JogStop OK");
return true;
}
else
{
ErrorLog($"SetErrorCodeFilePath Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"JogStop Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 获取机器人运行过程中最后一个错误码,当调用 clear_error 时，最后一个错误码会清零
/// 机器人关节运动
/// </summary>
/// <param name="errorCode"></param>
/// <param name="jointPos">机器人关节运动目标位置</param>
/// <param name="moveMode">指定运动模式：增量运动或绝对运动</param>
/// <param name="isBlock">设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口</param>
/// <param name="speed">机器人关节运动速度，单位：rad/s</param>
/// <returns></returns>
public bool GetLastError(ref JKTYPE.ErrorCode errorCode)
bool JointMove(JKTYPE.JointValue jointPos, JKTYPE.MoveMode moveMode, bool isBlock, double speed)
{
int rtn = jakaAPI.get_last_error(ref _handle,ref errorCode);
int rtn = jakaAPI.joint_move(ref _handle, ref jointPos, moveMode, isBlock, speed);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetLastError OK");
DebugLog($"JointMove OK");
return true;
}
else
{
ErrorLog($"GetLastError Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"JointMove Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 清除错误，最后一个错误码会清零
/// 机器人末端直线运动
/// </summary>
/// <param name="endPos">机器人末端运动目标位置</param>
/// <param name="moveMode">指定运动模式：增量运动或绝对运动</param>
/// <param name="isBlock">设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口</param>
/// <param name="speed">机器人直线运动速度，单位：mm/s</param>
/// <returns></returns>
public bool ClearError()
bool LinaerMove(JKTYPE.CartesianPose endPos, JKTYPE.MoveMode moveMode, bool isBlock, double speed)
{
int rtn = jakaAPI.clear_error(ref _handle);
int rtn = jakaAPI.linear_move(ref _handle, ref endPos, moveMode, isBlock, speed);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"ClearError OK");
DebugLog($"LinaerMove OK");
return true;
}
else
{
ErrorLog($"ClearError Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"LinaerMove Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置 SDK 日志路径
/// 机器人伺服位置控制模式使能
/// </summary>
/// <param name="filepath">SDK 日志路径</param>
/// <param name="enable">TRUE 为进入伺服位置控制模式，FALSE 表示退出该模式</param>
/// <returns></returns>
public bool SetSDKFilePath(string filepath)
public bool ServoMoveEnable(bool enable)
{
char[] chars = filepath.ToCharArray();
int rtn = jakaAPI.set_SDK_filepath(ref _handle, ref chars);
int rtn = jakaAPI.servo_move_enable(ref _handle, enable);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetSDKFilePath OK");
DebugLog($"ServoMoveEnable OK");
return true;
}
else
{
ErrorLog($"SetSDKFilePath Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"ServoMoveEnable Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置网络异常，机器人终止运动等待时间
/// 机器人关节空间伺服模式运动
/// </summary>
/// <param name="ms">时间参数，单位毫秒</param>
/// <param name="mnt">网络异常时机器人需要进行的动作类型</param>
/// <param name="jointPos">机器人关节运动目标位置</param>
/// <param name="moveMode">指定运动模式：绝对运动或相对运动</param>
/// <returns></returns>
public bool SetNetworkExceptionHandle(float ms,JKTYPE.ProcessType mnt)
bool ServoJ(JKTYPE.JointValue jointPos, JKTYPE.MoveMode moveMode)
{
int rtn = jakaAPI.set_network_exception_handle(ref _handle,ms,mnt);
int rtn = jakaAPI.servo_j(ref _handle, ref jointPos, moveMode);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetNetworkExceptionHandle OK");
DebugLog($"ServoJ OK");
return true;
}
else
{
ErrorLog($"SetNetworkExceptionHandle Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"ServoJ Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置机器人状态数据自动更新时间间隔
/// 机器人关节空间伺服模式运动扩展
/// </summary>
/// <param name="ms"> 时间参数，单位毫秒</param>
/// <param name="jointPos">机器人关节运动目标位置</param>
/// <param name="moveMode">指定运动模式：增量运动或绝对运动</param>
/// <param name="stepNum">倍分周期，servo_j 运动周期为 step_num*8ms，其中 step_num>=1</param>
/// <returns></returns>
public bool SetStatusDataUpdateTimeInterval(float ms)
bool ServoJExtend(JKTYPE.JointValue jointPos, JKTYPE.MoveMode moveMode, int stepNum)
{
int rtn = jakaAPI.set_status_data_update_time_interval(ref _handle, ms);
int rtn = jakaAPI.servo_j_extend(ref _handle, ref jointPos, moveMode, stepNum);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetStatusDataUpdateTimeInterval OK");
DebugLog($"ServoJExtend OK");
return true;
}
else
{
ErrorLog($"SetStatusDataUpdateTimeInterval Fail:{RtnCode.GetStrByCode(rtn)}");
ErrorLog($"ServoJExtend Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
void user_error_handle(int error_code)
/// <summary>
/// 机器人笛卡尔空间伺服模式运动
/// </summary>
/// <param name="cartesianPose">机器人笛卡尔空间运动目标位置</param>
/// <param name="moveMode">指定运动模式：ABS 代表绝对运动，INCR 代表相对运动</param>
/// <returns></returns>
bool ServoP(JKTYPE.CartesianPose cartesianPose, JKTYPE.MoveMode moveMode)
{
ErrorLog($"机械臂发生异常,异常码:{error_code}");
int rtn = jakaAPI.servo_p(ref _handle, ref cartesianPose, moveMode);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"ServoP OK");
return true;
}
else
{
ErrorLog($"ServoP Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人笛卡尔空间伺服模式运动扩展
/// </summary>
/// <param name="jointPos">机器人笛卡尔空间运动目标位置</param>
/// <param name="moveMode">指定运动模式：增量运动或绝对运动</param>
/// <param name="stepNum">倍分周期，servo_p 运动周期为 step_num*8ms，其中 step_num>=1</param>
/// <returns></returns>
bool ServoPExtend(JKTYPE.CartesianPose cartesianPose, JKTYPE.MoveMode moveMode, int stepNum)
{
int rtn = jakaAPI.servo_p_extend(ref _handle, ref cartesianPose, moveMode, stepNum);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"ServoPExtend OK");
return true;
}
else
{
ErrorLog($"ServoPExtend Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置数字输出变量
/// </summary>
/// <param name="iOType"> DO 类型</param>
/// <param name="index">DO 索引（从 0 开始）</param>
/// <param name="value">DO 设置值</param>
/// <returns></returns>
bool SetDigitalOutput(JKTYPE.IOType iOType, int index, bool value)
{
int rtn = jakaAPI.set_digital_output(ref _handle, iOType, index, value);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetDigitalOutput [{iOType}][{index}={value}] OK");
return true;
}
else
{
ErrorLog($"SetDigitalOutput [{iOType}][{index}={value}] Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 设置模拟输出变量
/// </summary>
/// <param name="iOType"> DO 类型</param>
/// <param name="index">DO 索引（从 0 开始）</param>
/// <param name="value">DO 设置值</param>
/// <returns></returns>
bool SetAnalogOutput(JKTYPE.IOType iOType, int index, float value)
{
int rtn = jakaAPI.set_analog_output(ref _handle, iOType, index, value);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"SetAnalogOutput [{iOType}][{index}={value}] OK");
return true;
}
else
{
ErrorLog($"SetAnalogOutput [{iOType}][{index}={value}] Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 查询数字输入状态
/// </summary>
/// <param name="iOType"> DI 类型</param>
/// <param name="index">DI 索引（从 0 开始）</param>
/// <param name="value">DI 状态查询结果</param>
/// <returns></returns>
public bool GetDigitalInput(JKTYPE.IOType iOType, int index, out bool result)
{
result = false;
int rtn = jakaAPI.get_digital_input(ref _handle, iOType, index, ref result);
if (rtn == RtnCode.ERR_SUCC)
{
DebugLog($"GetDigitalInput [{iOType}][{index}={result}] OK");
return true;
}
else
{
ErrorLog($"GetDigitalInput [{iOType}][{index}={result}] Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 注册机器人出错时的回调函数
/// </summary>
/// <returns></returns>
bool SetErrorHandler()
{
int rtn = jakaAPI.set_error_handler(ref _handle, user_error_handle);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"SetErrorHandler OK");
return true;
}
else
{
ErrorLog($"SetErrorHandler Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
/// <summary>
/// 机器人关机
/// </summary>
public bool ShutDown()
{
int rtn = jakaAPI.shut_down(ref _handle);
if (rtn == RtnCode.ERR_SUCC)
{
InfoLog($"ShutDown OK");
return true;
}
else
{
ErrorLog($"ShutDown Fail:{RtnCode.GetStrByCode(rtn)}");
}
return false;
}
#endregion
}
}
支持 Markdown 格式
你添加了 0 人 到此讨论。请谨慎行事。
Finish editing this message first!