├── PosLib.slx ├── JointLib.slx ├── VrepLib.slx ├── remoteApi.dll ├── docs ├── slide.pptx └── images │ ├── image-20230118170940186.png │ ├── image-20230118171043318.png │ ├── image-20230118171714383.png │ ├── image-20230118172154710.png │ ├── image-20230118172259049.png │ ├── image-20230118172511603.png │ ├── image-20230118172759234.png │ ├── image-20230118172957670.png │ ├── image-20230118173154659.png │ ├── image-20230118174623706.png │ ├── image-20230118174843123.png │ ├── image-20230118175144887.png │ └── image-20230118171043318-16740330473672.png ├── example ├── DEBUG.slx └── LinkRotation │ ├── LinkRotation.slx │ └── LinkRotation.ttt ├── slprj ├── _jitprj │ ├── jitEngineAccessInfo.mat │ ├── sqtdIu6w3FA4DPBnOhcGduF.l │ └── sqtdIu6w3FA4DPBnOhcGduF.mat ├── sim │ └── varcache │ │ └── DEBUG │ │ ├── varInfo.mat │ │ ├── checksumOfCache.mat │ │ └── tmwinternal │ │ └── simulink_cache.xml └── _sfprj │ ├── DEBUG │ └── _self │ │ └── sfun │ │ └── info │ │ └── binfo.mat │ ├── EMLReport │ ├── emlReportAccessInfo.mat │ └── sqtdIu6w3FA4DPBnOhcGduF.mat │ └── precompile │ ├── autoInferAccessInfo.mat │ ├── 8voCxzJw9SIpSRd9et0cWB.mat │ └── YgC5RaoIs9eTRK9XHs2AwC.mat ├── debug.m ├── slblocks.m ├── InitSim.m ├── LICENSE ├── GetJointPosition.m ├── SetJointVelocity.m ├── SyncTriger.m ├── SetObjectOrientationByRPY.m ├── SetObjectRotationByRPY.m ├── GetObjectPose.m ├── README.md ├── remoteApiProto.m └── remApi.m /PosLib.slx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/PosLib.slx -------------------------------------------------------------------------------- /JointLib.slx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/JointLib.slx -------------------------------------------------------------------------------- /VrepLib.slx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/VrepLib.slx -------------------------------------------------------------------------------- /remoteApi.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/remoteApi.dll -------------------------------------------------------------------------------- /docs/slide.pptx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/slide.pptx -------------------------------------------------------------------------------- /example/DEBUG.slx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/example/DEBUG.slx -------------------------------------------------------------------------------- /example/LinkRotation/LinkRotation.slx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/example/LinkRotation/LinkRotation.slx -------------------------------------------------------------------------------- /example/LinkRotation/LinkRotation.ttt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/example/LinkRotation/LinkRotation.ttt -------------------------------------------------------------------------------- /slprj/_jitprj/jitEngineAccessInfo.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_jitprj/jitEngineAccessInfo.mat -------------------------------------------------------------------------------- /slprj/sim/varcache/DEBUG/varInfo.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/sim/varcache/DEBUG/varInfo.mat -------------------------------------------------------------------------------- /docs/images/image-20230118170940186.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118170940186.png -------------------------------------------------------------------------------- /docs/images/image-20230118171043318.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118171043318.png -------------------------------------------------------------------------------- /docs/images/image-20230118171714383.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118171714383.png -------------------------------------------------------------------------------- /docs/images/image-20230118172154710.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118172154710.png -------------------------------------------------------------------------------- /docs/images/image-20230118172259049.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118172259049.png -------------------------------------------------------------------------------- /docs/images/image-20230118172511603.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118172511603.png -------------------------------------------------------------------------------- /docs/images/image-20230118172759234.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118172759234.png -------------------------------------------------------------------------------- /docs/images/image-20230118172957670.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118172957670.png -------------------------------------------------------------------------------- /docs/images/image-20230118173154659.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118173154659.png -------------------------------------------------------------------------------- /docs/images/image-20230118174623706.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118174623706.png -------------------------------------------------------------------------------- /docs/images/image-20230118174843123.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118174843123.png -------------------------------------------------------------------------------- /docs/images/image-20230118175144887.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118175144887.png -------------------------------------------------------------------------------- /slprj/_jitprj/sqtdIu6w3FA4DPBnOhcGduF.l: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_jitprj/sqtdIu6w3FA4DPBnOhcGduF.l -------------------------------------------------------------------------------- /slprj/_jitprj/sqtdIu6w3FA4DPBnOhcGduF.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_jitprj/sqtdIu6w3FA4DPBnOhcGduF.mat -------------------------------------------------------------------------------- /slprj/_sfprj/DEBUG/_self/sfun/info/binfo.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_sfprj/DEBUG/_self/sfun/info/binfo.mat -------------------------------------------------------------------------------- /slprj/sim/varcache/DEBUG/checksumOfCache.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/sim/varcache/DEBUG/checksumOfCache.mat -------------------------------------------------------------------------------- /slprj/_sfprj/EMLReport/emlReportAccessInfo.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_sfprj/EMLReport/emlReportAccessInfo.mat -------------------------------------------------------------------------------- /slprj/_sfprj/precompile/autoInferAccessInfo.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_sfprj/precompile/autoInferAccessInfo.mat -------------------------------------------------------------------------------- /slprj/_sfprj/EMLReport/sqtdIu6w3FA4DPBnOhcGduF.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_sfprj/EMLReport/sqtdIu6w3FA4DPBnOhcGduF.mat -------------------------------------------------------------------------------- /slprj/_sfprj/precompile/8voCxzJw9SIpSRd9et0cWB.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_sfprj/precompile/8voCxzJw9SIpSRd9et0cWB.mat -------------------------------------------------------------------------------- /slprj/_sfprj/precompile/YgC5RaoIs9eTRK9XHs2AwC.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/slprj/_sfprj/precompile/YgC5RaoIs9eTRK9XHs2AwC.mat -------------------------------------------------------------------------------- /docs/images/image-20230118171043318-16740330473672.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sunshineharry/VrepSimulink/HEAD/docs/images/image-20230118171043318-16740330473672.png -------------------------------------------------------------------------------- /debug.m: -------------------------------------------------------------------------------- 1 | clc; 2 | clear; 3 | port = 19999; 4 | InitSim; 5 | object_name = 'L2'; 6 | relative_handle = -1; 7 | [~, object_handle] = vrep.simxGetObjectHandle(clientID, object_name, vrep.simx_opmode_blocking); 8 | -------------------------------------------------------------------------------- /slblocks.m: -------------------------------------------------------------------------------- 1 | function blkStruct = slblocks 2 | 3 | Browser.Library = 'VrepLib'; % 此处可根据模型名字修改 4 | Browser.Name = 'VrepLib'; % 该名字为库中所看到的名字 5 | Browser.IsFlat = 0; % 判断模块是否有下一级 6 | blkStruct.Browser = Browser; % 此处命名随意 -------------------------------------------------------------------------------- /slprj/sim/varcache/DEBUG/tmwinternal/simulink_cache.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 2kwY2ay8+EMJBQyoLF3cCRQpjY2R/pHz5y3WlpAqBokSgx/aP4nOonOm93zlYky9Dc7MLlCGfEeJthPxsfnsTw== 5 | 6 | -------------------------------------------------------------------------------- /InitSim.m: -------------------------------------------------------------------------------- 1 | %% 初始化通讯 2 | 3 | %% 加载Vrep提供的函数库 4 | vrep = remApi('remoteApi'); 5 | 6 | %% 启动一个连接 7 | % 关闭所有的潜在连接 8 | vrep.simxFinish(-1); 9 | % 建立连接 10 | % 第一个参数是 Vrep 服务端的 IP 地址，如果是本机则为 127.0.0.1 11 | % 第二个参数是端口号，对应 Vrep 脚本 sysCall_init 中的 simRemoteApi.start(19999) 12 | % 第 3,4,5 个参数和超时等待相关 13 | % 第六个参数是数据包通信频率，默认5ms 14 | clientID = vrep.simxStart('127.0.0.1', port, true, true, 5000, 5); 15 | % 判断连接是否成功 16 | if (clientID <= -1) % 连接失败 17 | msgbox("Connect to Vrep failed!","Error","error"); 18 | end 19 | 20 | %% 以同步模式运行 21 | vrep.simxSynchronous(clientID, true); 22 | 23 | %% 由于在第一个仿真步长无法获取正确的信息，所以先运行一次，顺带在Vrep中提示连接成功 24 | vrep.simxSynchronousTrigger(clientID); 25 | vrep.simxAddStatusbarMessage(clientID, 'Connection to VrepLib Success!', vrep.simx_opmode_oneshot); 26 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 sunshineharry 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /GetJointPosition.m: -------------------------------------------------------------------------------- 1 | function [sys,x0,str,ts] = GetJointPosition(t,x,u,flag,vrep,clientID,joint_name,is_use_radian) 2 | switch flag 3 | case 0 4 | [sys,x0,str,ts]=mdlInitializeSizes; 5 | case 1 6 | sys=mdlDerivatives(t,x,u); 7 | case 2 8 | sys=mdlUpdate(t,x,u); 9 | case 3 10 | sys=mdlOutputs(t,x,u,vrep,clientID,joint_name,is_use_radian); 11 | case {4,9} 12 | sys=[]; 13 | otherwise 14 | error(['Unhandled flag = ',num2str(flag)]); 15 | end 16 | end 17 | 18 | function [sys,x0,str,ts] = mdlInitializeSizes 19 | sizes = simsizes; 20 | sizes.NumContStates = 0; 21 | sizes.NumDiscStates = 0; 22 | sizes.NumOutputs = 1; 23 | sizes.NumInputs = 0; 24 | sizes.DirFeedthrough = 1; 25 | sizes.NumSampleTimes = 1; 26 | sys = simsizes(sizes); 27 | x0 = []; 28 | str = []; 29 | ts = [0 0]; 30 | end 31 | 32 | function sys = mdlUpdate(t,x,u) 33 | sys = []; 34 | end 35 | 36 | function sys = mdlOutputs(t,x,u,vrep,clientID,joint_name,is_use_radian) 37 | % 获取句柄，你要对什么对象进行操作，需要先获取句柄 38 | [~, joint_handle] = vrep.simxGetObjectHandle(clientID, joint_name, vrep.simx_opmode_blocking); 39 | [~, position] = vrep.simxGetJointPosition(clientID, joint_handle, vrep.simx_opmode_blocking); 40 | if is_use_radian 41 | sys(1) = double(position); 42 | else 43 | sys(1) = double(rad2deg(position)); 44 | end 45 | end -------------------------------------------------------------------------------- /SetJointVelocity.m: -------------------------------------------------------------------------------- 1 | function [sys,x0,str,ts] = SetJointVelocity(t,x,u,flag,vrep,clientID,joint_name,is_use_radian) 2 | switch flag 3 | case 0 4 | [sys,x0,str,ts]=mdlInitializeSizes; 5 | case 1 6 | sys=mdlDerivatives(t,x,u); 7 | case 2 8 | sys=mdlUpdate(t,x,u,vrep,clientID,joint_name,is_use_radian); 9 | case 3 10 | sys=mdlOutputs(t,x,u); 11 | case {4,9} 12 | sys=[]; 13 | otherwise 14 | error(['Unhandled flag = ',num2str(flag)]); 15 | end 16 | end 17 | 18 | function [sys,x0,str,ts] = mdlInitializeSizes 19 | sizes = simsizes; 20 | sizes.NumContStates = 0; 21 | sizes.NumDiscStates = 0; 22 | sizes.NumOutputs = 0; 23 | sizes.NumInputs = 1; 24 | sizes.DirFeedthrough = 1; 25 | sizes.NumSampleTimes = 1; 26 | sys = simsizes(sizes); 27 | x0 = []; 28 | str = []; 29 | ts = [0 0]; 30 | end 31 | 32 | function sys = mdlUpdate(t,x,u,vrep,clientID,joint_name,is_use_radian) 33 | % 获取句柄，你要对什么对象进行操作，需要先获取句柄 34 | [res,joint_handle] = vrep.simxGetObjectHandle(clientID, joint_name, vrep.simx_opmode_blocking); 35 | if is_use_radian 36 | vrep.simxSetJointTargetVelocity(clientID, joint_handle, u(1), vrep.simx_opmode_oneshot); 37 | else 38 | vrep.simxSetJointTargetVelocity(clientID, joint_handle, deg2rad(u(1)), vrep.simx_opmode_oneshot); 39 | end 40 | sys = []; 41 | end 42 | 43 | function sys = mdlOutputs(t,x,u) 44 | sys = []; 45 | end -------------------------------------------------------------------------------- /SyncTriger.m: -------------------------------------------------------------------------------- 1 | function [sys,x0,str,ts] = SyncTriger(t,x,u,flag,vrep,clientID) 2 | % s-Function 的入口 3 | % 函数的四个输入分别为采样时间t、状态x、输入u和仿真流程控制标志变量flag 4 | % 函数的四个输出分别为： 5 | % sys数组包含某个子函数返回的值 6 | % x0为所有状态的初始化向量 7 | % str是保留参数，总是一个空矩阵 8 | % Ts返回系统采样时间 9 | switch flag 10 | case 0 11 | [sys,x0,str,ts]=mdlInitializeSizes; 12 | case 1 13 | sys=mdlDerivatives(t,x,u); 14 | case 2 15 | sys=mdlUpdate(t,x,u,vrep,clientID); 16 | case 3 17 | sys=mdlOutputs(t,x,u); 18 | case {4,9} 19 | sys=[]; 20 | otherwise 21 | error(['Unhandled flag = ',num2str(flag)]); 22 | end 23 | end 24 | 25 | %% 初始化回调子函数 26 | % 提供状态、输入、输出、采样时间数目和初始状态的值 27 | % 初始化阶段，标志变量flag首先被置为0，S-function首次被调用时 28 | % 该子函数首先被调用，且为S-function模块提供下面信息 29 | % 该子函数必须存在 30 | function [sys,x0,str,ts] = mdlInitializeSizes 31 | sizes = simsizes; % 生成sizes数据结构，信息被包含在其中 32 | sizes.NumContStates = 0; % 连续状态数，缺省为0 33 | sizes.NumDiscStates = 0; % 离散状态数，缺省为0 34 | sizes.NumOutputs = 0; % 输出个数，缺省为0 35 | sizes.NumInputs = 0; % 输入个数，缺省为0 36 | sizes.DirFeedthrough = 1; % 是否存在直馈通道，1存在，0不存在 37 | sizes.NumSampleTimes = 1; % 采样时间个数，至少是一个 38 | sys = simsizes(sizes); % 返回size数据结构所包含的信息 39 | x0 = []; % 设置初始状态 40 | str = []; % 保留变量置空 41 | ts = [0 0]; %设置采样时间 42 | end 43 | 44 | %% 状态更新回调子函数 45 | % 给定t、x、u计算离散状态的更新 46 | % 每个仿真步内必然调用该子函数，不论是否有意义 47 | % 除了在此描述系统的离散状态方程外，还可以在此添加其他每个仿真步内都必须执行的代码 48 | function sys = mdlUpdate(t,x,u,vrep,clientID) 49 | vrep.simxSynchronousTrigger(clientID); 50 | sys = []; 51 | end 52 | 53 | %% 计算输出回调函数 54 | % 给定t,x,u计算输出，可以在此描述系统的输出方程 55 | % 该子函数必须存在 56 | function sys = mdlOutputs(t,x,u) 57 | sys = []; 58 | end 59 | -------------------------------------------------------------------------------- /SetObjectOrientationByRPY.m: -------------------------------------------------------------------------------- 1 | % 【注】：函数是将新的坐标系【设置到】某个位置，而不是在之前的基础上进行移动 2 | function [sys,x0,str,ts] = SetObjectOrientationByRPY(t,x,u,flag,vrep,clientID,object_name,relative_object_name) 3 | switch flag 4 | case 0 5 | [sys,x0,str,ts]=mdlInitializeSizes; 6 | case 1 7 | sys=mdlDerivatives(t,x,u); 8 | case 2 9 | sys=mdlUpdate(t,x,u); 10 | case 3 11 | sys=mdlOutputs(t,x,u,vrep,clientID,object_name,relative_object_name); 12 | case {4,9} 13 | sys=[]; 14 | otherwise 15 | error(['Unhandled flag = ',num2str(flag)]); 16 | end 17 | end 18 | 19 | function [sys,x0,str,ts] = mdlInitializeSizes 20 | sizes = simsizes; 21 | sizes.NumContStates = 0; 22 | sizes.NumDiscStates = 0; 23 | sizes.NumOutputs = 0; 24 | sizes.NumInputs = 3; 25 | sizes.DirFeedthrough = 1; 26 | sizes.NumSampleTimes = 1; 27 | sys = simsizes(sizes); 28 | x0 = []; 29 | str = []; 30 | ts = [0 0]; 31 | end 32 | 33 | function sys = mdlUpdate(~,~,~) 34 | sys = []; 35 | end 36 | 37 | function sys = mdlOutputs(~,~,u,vrep,clientID,object_name,relative_object_name) 38 | % 获取物体的句柄 39 | [~, object_handle] = vrep.simxGetObjectHandle(clientID, object_name, vrep.simx_opmode_blocking); 40 | 41 | % 获取参考系的句柄 42 | if strcmp(relative_object_name, 'world') % 相对于世界坐标系 43 | relative_handle = -1; 44 | elseif strcmp(relative_object_name, 'parent') % 相对于父坐标系 45 | relative_handle = vrep.sim_handle_parent; 46 | else 47 | [~, relative_handle] = vrep.simxGetObjectHandle(clientID, relative_object_name, vrep.simx_opmode_blocking); 48 | end 49 | 50 | % 控制，我不理解为什么官方手册说的是欧拉角，根据官方手册，（https://www.coppeliarobotics.com/helpFiles/en/positionOrientationTransformation.htm） 51 | % R = Rx*Ry*Rz 52 | % RPY为 u = [roll, pitch, yaw] 53 | % R = Rotx(yaw) * Roty(pitch) * Rotz(roll) 54 | vrep.simxSetObjectOrientation(clientID, object_handle, relative_handle, [u(3),u(2),u(1)], vrep.simx_opmode_oneshot); 55 | 56 | sys = []; 57 | end -------------------------------------------------------------------------------- /SetObjectRotationByRPY.m: -------------------------------------------------------------------------------- 1 | % 【注】：函数是将新的坐标系【设置到】某个位置，而不是在之前的基础上进行移动 2 | function [sys,x0,str,ts] = SetObjectRotationByRPY(t,x,u,flag,vrep,clientID,object_name,relative_object_name) 3 | switch flag 4 | case 0 5 | [sys,x0,str,ts]=mdlInitializeSizes; 6 | case 1 7 | sys=mdlDerivatives(t,x,u); 8 | case 2 9 | sys=mdlUpdate(t,x,u); 10 | case 3 11 | sys=mdlOutputs(t,x,u,vrep,clientID,object_name,relative_object_name); 12 | case {4,9} 13 | sys=[]; 14 | otherwise 15 | error(['Unhandled flag = ',num2str(flag)]); 16 | end 17 | end 18 | 19 | function [sys,x0,str,ts] = mdlInitializeSizes 20 | sizes = simsizes; 21 | sizes.NumContStates = 0; 22 | sizes.NumDiscStates = 0; 23 | sizes.NumOutputs = 0; 24 | sizes.NumInputs = 3; 25 | sizes.DirFeedthrough = 1; 26 | sizes.NumSampleTimes = 1; 27 | sys = simsizes(sizes); 28 | x0 = []; 29 | str = []; 30 | ts = [0 0]; 31 | end 32 | 33 | function sys = mdlUpdate(~,~,~) 34 | sys = []; 35 | end 36 | 37 | function sys = mdlOutputs(~,~,u,vrep,clientID,object_name,relative_object_name) 38 | % 获取物体的句柄 39 | [~, object_handle] = vrep.simxGetObjectHandle(clientID, object_name, vrep.simx_opmode_blocking); 40 | 41 | % 获取参考系的句柄 42 | if strcmp(relative_object_name, 'world') % 相对于世界坐标系 43 | relative_handle = -1; 44 | elseif strcmp(relative_object_name, 'parent') % 相对于父坐标系 45 | relative_handle = vrep.sim_handle_parent; 46 | else 47 | [~, relative_handle] = vrep.simxGetObjectHandle(clientID, relative_object_name, vrep.simx_opmode_blocking); 48 | end 49 | 50 | % 通过相对量计算绝对量 51 | [~,xyz] = vrep.simxGetObjectOrientation(clientID, object_handle, relative_handle, vrep.simx_opmode_blocking); 52 | R = rpy2r(u')*rotx(xyz(1))*roty(xyz(2))*rotz(xyz(3)); 53 | finla_rpy = tr2rpy(R); 54 | 55 | % 控制 56 | vrep.simxSetObjectOrientation(clientID, object_handle, relative_handle, [finla_rpy(3),finla_rpy(2),finla_rpy(1)], vrep.simx_opmode_oneshot); 57 | 58 | sys = []; 59 | end -------------------------------------------------------------------------------- /GetObjectPose.m: -------------------------------------------------------------------------------- 1 | function [sys,x0,str,ts] = GetObjectPose(t,x,u,flag,vrep,clientID,object_name,relative_object_name) 2 | switch flag 3 | case 0 4 | [sys,x0,str,ts]=mdlInitializeSizes; 5 | case 1 6 | sys=mdlDerivatives(t,x,u); 7 | case 2 8 | sys=mdlUpdate(t,x,u); 9 | case 3 10 | sys=mdlOutputs(t,x,u,vrep,clientID,object_name,relative_object_name); 11 | case {4,9} 12 | sys=[]; 13 | otherwise 14 | error(['Unhandled flag = ',num2str(flag)]); 15 | end 16 | end 17 | 18 | function [sys,x0,str,ts] = mdlInitializeSizes 19 | sizes = simsizes; 20 | sizes.NumContStates = 0; 21 | sizes.NumDiscStates = 0; 22 | sizes.NumOutputs = 6; 23 | sizes.NumInputs = 0; 24 | sizes.DirFeedthrough = 1; 25 | sizes.NumSampleTimes = 1; 26 | sys = simsizes(sizes); 27 | x0 = []; 28 | str = []; 29 | ts = [0 0]; 30 | end 31 | 32 | function sys = mdlUpdate(~,~,~) 33 | sys = []; 34 | end 35 | 36 | function sys = mdlOutputs(t,x,u,vrep,clientID,object_name,relative_object_name) 37 | % 获取物体的句柄 38 | [~, object_handle] = vrep.simxGetObjectHandle(clientID, object_name, vrep.simx_opmode_blocking); 39 | 40 | % 获取参考系的句柄 41 | if strcmp(relative_object_name, 'world') % 相对于世界坐标系 42 | relative_handle = -1; 43 | elseif strcmp(relative_object_name, 'parent') % 相对于父坐标系 44 | relative_handle = vrep.sim_handle_parent; 45 | else 46 | [~, relative_handle] = vrep.simxGetObjectHandle(clientID, relative_object_name, vrep.simx_opmode_blocking); 47 | end 48 | 49 | % 获取相对位置 50 | [~, position] = vrep.simxGetObjectPosition(clientID, object_handle, relative_handle, vrep.simx_opmode_blocking); 51 | [~,xyz] = vrep.simxGetObjectOrientation(clientID, object_handle, relative_handle, vrep.simx_opmode_blocking); 52 | % [~,quat] = vrep.simxGetObjectQuaternion(clientID, object_handle, relative_handle, vrep.simx_opmode_blocking); 53 | 54 | % xyz转欧拉角 55 | xyz = double(xyz); 56 | r = SO3.Rx(xyz(1)) * SO3.Ry(xyz(2)) * SO3.Rz(xyz(3)); 57 | eul = r.toeul(); 58 | 59 | % 输出 60 | sys = [double(position),eul]; 61 | end -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # A simple library to link Simulink and Vrep/CoppeliaSim 2 | 3 | ## Dependence 4 | 5 | - Robotics Toolbox (V10, latest): https://petercorke.com/toolboxes/robotics-toolbox/ 6 | 7 | ## 1. Operations in Vrep 8 | 9 | I have a simple mechanism with two links shown in figure below. 10 | 11 | ![image-20230118171043318](docs/images/image-20230118171043318-16740330473672.png) 12 | 13 | All you have to do is open the main lua script and specify the port number. The default port is 19999. 14 | 15 | ![image-20230118171714383](docs/images/image-20230118171714383.png) 16 | 17 | ## 2. Operations in MATLAB/Simulink 18 | 19 | ### Step1: Add toolbox to MATLAB Path and Refresh the Simulink Library 20 | 21 | If everything is ok, you will see Vreplib displayed in Simulink Library 22 | 23 | ![image-20230118172511603](docs/images/image-20230118172511603.png) 24 | 25 | ### Step2: Create a new simulink model and set it to `Fixed-step` 26 | 27 | ![image-20230118172154710](docs/images/image-20230118172154710.png) 28 | 29 | The `Fixed-step size` should be chose as same as the `dt` in Vrep. 30 | 31 | ![image-20230118172259049](docs/images/image-20230118172259049.png) 32 | 33 | ### Step3: Set the InitFun of Simulink 34 | 35 | 1). Open the `Model Properties ` 36 | 37 | ![image-20230118172759234](docs/images/image-20230118172759234.png) 38 | 39 | 2). Add init function 40 | 41 | ![image-20230118172957670](docs/images/image-20230118172957670.png) 42 | 43 | ```matlab 44 | port = 19999; % Change according to actual situation 45 | InitSim; 46 | ``` 47 | 48 | ### Step4: Create the model 49 | 50 | Firstly, add the `Sync Triger` in the beginning of the model 51 | 52 | ![image-20230118174623706](docs/images/image-20230118174623706.png) 53 | 54 | Then, add the `SetJointVelocity` model, you should enter joint name and confirm whether to use radian system. 55 | 56 | ![image-20230118174843123](docs/images/image-20230118174843123.png) 57 | 58 | ​ In the same way, configure other modules. 59 | 60 | ### Step5: Enjoy it !!! 61 | 62 | ![image-20230118175144887](docs/images/image-20230118175144887.png) 63 | 64 | **Note:** 65 | 66 | For more detailed information, please refer to /docs/slide.ppt. and you can watch the video in https://www.bilibili.com/video/BV1M84y187R1. I will update a English version video in Youtube soon. 67 | 68 | ## Implementation 69 | 70 | Todo 71 | 72 | ## 4. The other blocks in coming soon !!! 73 | 74 | ## 5. Use in MacOS or Linux 75 | 76 | copy the `remoteApi.so` ro `remoteApi.dylib` in it. 77 | 78 | -------------------------------------------------------------------------------- /remoteApiProto.m: -------------------------------------------------------------------------------- 1 | function [methodinfo,structs,enuminfo,ThunkLibName]=remoteApiProto 2 | %REMOTEAPIPROTO Create structures to define interfaces found in 'extApi'. 3 | 4 | %This function was generated by loadlibrary.m parser version 1.1.6.32 5 | %perl options:'extApi.i -outfile=remoteApiProto.m' 6 | ival={cell(1,0)}; % change 0 to the actual number of functions to preallocate the data. 7 | structs=[];enuminfo=[];fcnNum=1; 8 | fcns=struct('name',ival,'calltype',ival,'LHS',ival,'RHS',ival,'alias',ival); 9 | ThunkLibName=[]; 10 | 11 | % extern simxInt mtlb_simxSetJointPosition ( simxInt clientID , simxInt jointHandle , simxFloat* position , simxInt operationMode ); 12 | fcns.name{fcnNum}='mtlb_simxSetJointPosition'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 13 | % extern simxInt mtlb_simxSetJointTargetVelocity ( simxInt clientID , simxInt jointHandle , simxFloat* targetVelocity , simxInt operationMode ); 14 | fcns.name{fcnNum}='mtlb_simxSetJointTargetVelocity'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 15 | % extern simxInt mtlb_simxSetJointTargetPosition ( simxInt clientID , simxInt jointHandle , simxFloat* targetPosition , simxInt operationMode ); 16 | fcns.name{fcnNum}='mtlb_simxSetJointTargetPosition'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 17 | % extern simxInt mtlb_simxSetJointForce ( simxInt clientID , simxInt jointHandle , simxFloat* force , simxInt operationMode ); 18 | fcns.name{fcnNum}='mtlb_simxSetJointForce'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 19 | % extern simxInt mtlb_simxSetFloatSignal ( simxInt clientID , const simxChar * signalName , simxFloat* signalValue , simxInt operationMode ); 20 | fcns.name{fcnNum}='mtlb_simxSetFloatSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 21 | % extern simxInt mtlb_simxSetObjectFloatParameter ( simxInt clientID , simxInt objectHandle , simxInt parameterID , simxFloat* parameterValue , simxInt operationMode ); 22 | fcns.name{fcnNum}='mtlb_simxSetObjectFloatParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 23 | % extern simxInt mtlb_simxSetFloatingParameter ( simxInt clientID , simxInt paramIdentifier , simxFloat* paramValue , simxInt operationMode ); 24 | fcns.name{fcnNum}='mtlb_simxSetFloatingParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 25 | % extern simxInt mtlb_simxCreateDummy ( simxInt clientID , simxFloat* size , const simxUChar * colors , simxInt * objectHandle , simxInt operationMode ); 26 | fcns.name{fcnNum}='mtlb_simxCreateDummy'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'singlePtr', 'uint8Ptr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 27 | 28 | % extern simxInt mtlb_simxReadProximitySensor(simxInt* clientIDandSensorHandle,simxUChar* detectionState,simxFloat* detectedPoint,simxInt* detectedObjectHandle,simxFloat* detectedSurfaceNormalVector,simxInt operationMode); 29 | fcns.name{fcnNum}='mtlb_simxReadProximitySensor'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32Ptr', 'uint8Ptr', 'singlePtr', 'int32Ptr', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 30 | % extern simxInt mtlb_simxAuxiliaryConsoleOpen(simxInt* clientIDandMaxLinesAndModeAndPositionAndSize,const simxChar* title,simxFloat* textColor,simxFloat* backgroundColor,simxInt* consoleHandle,simxInt operationMode); 31 | fcns.name{fcnNum}='mtlb_simxAuxiliaryConsoleOpen'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32Ptr', 'int8Ptr', 'singlePtr', 'singlePtr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 32 | % extern simxInt mtlb_simxDisplayDialog(simxInt* clientIDandDlgTypeAndOperationMode,const simxChar* titleText,const simxChar* mainText,const simxChar* initialText,const simxFloat* titleColorsAndDlgColors,simxInt* dialogHandleAndUiHandle); 33 | fcns.name{fcnNum}='mtlb_simxDisplayDialog'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32Ptr', 'int8Ptr', 'int8Ptr','int8Ptr', 'singlePtr', 'int32Ptr'};fcnNum=fcnNum+1; 34 | % extern simxInt mtlb_simxQuery(simxInt* clientIDandSignalLengthAndTimeOutInMs,const simxChar* signalName,const simxUChar* signalValue,const simxChar* retSignalName,simxUChar** retSignalValue,simxInt* retSignalLength); 35 | fcns.name{fcnNum}='mtlb_simxQuery'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32Ptr', 'int8Ptr', 'uint8Ptr', 'int8Ptr', 'uint8PtrPtr', 'int32Ptr'};fcnNum=fcnNum+1; 36 | % extern simxInt mtlb_simxGetObjectGroupData(simxInt* clientIDandObjectTypeAndDataTypeAndOperationMode,simxInt* handlesCountAndIntDataCountAndFloatDataCountAndStringDataCount,simxInt** handles,simxInt** intData,simxFloat** floatData,simxChar** stringData); 37 | fcns.name{fcnNum}='mtlb_simxGetObjectGroupData'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32Ptr', 'int32Ptr', 'int32PtrPtr', 'int32PtrPtr', 'singlePtrPtr', 'int8PtrPtr'};fcnNum=fcnNum+1; 38 | % extern simxInt mtlb_simxCallScriptFunction_a(const simxInt* variousIntsIn,const simxChar* scriptDescriptionAndFunctionName,const simxInt* inInt,const simxFloat* inFloat,const simxChar* inString,const simxUChar* inBuffer); 39 | fcns.name{fcnNum}='mtlb_simxCallScriptFunction_a'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32Ptr', 'int8Ptr', 'int32Ptr', 'singlePtr', 'int8Ptr', 'uint8Ptr'};fcnNum=fcnNum+1; 40 | % extern simxInt mtlb_simxCallScriptFunction_b(simxInt clientID,simxInt* variousIntsOut,simxInt** outInt,simxFloat** outFloat,simxChar** outString,simxUChar** outBuffer); 41 | fcns.name{fcnNum}='mtlb_simxCallScriptFunction_b'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32Ptr', 'int32PtrPtr', 'singlePtrPtr', 'int8PtrPtr', 'uint8PtrPtr'};fcnNum=fcnNum+1; 42 | 43 | 44 | 45 | % extern simxInt simxGetJointPosition ( simxInt clientID , simxInt jointHandle , simxFloat * position , simxInt operationMode ); 46 | fcns.name{fcnNum}='simxGetJointPosition'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 47 | % extern simxInt simxGetJointMatrix ( simxInt clientID , simxInt jointHandle , simxFloat * matrix , simxInt operationMode ); 48 | fcns.name{fcnNum}='simxGetJointMatrix'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 49 | % extern simxInt simxSetSphericalJointMatrix ( simxInt clientID , simxInt jointHandle , simxFloat * matrix , simxInt operationMode ); 50 | fcns.name{fcnNum}='simxSetSphericalJointMatrix'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 51 | % extern simxInt simxGetJointForce ( simxInt clientID , simxInt jointHandle , simxFloat * force , simxInt operationMode ); 52 | fcns.name{fcnNum}='simxGetJointForce'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 53 | % extern simxInt simxReadForceSensor ( simxInt clientID , simxInt forceSensorHandle , simxUChar * state , simxFloat * forceVector , simxFloat * torqueVector , simxInt operationMode ); 54 | fcns.name{fcnNum}='simxReadForceSensor'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'uint8Ptr', 'singlePtr', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 55 | % extern simxInt simxBreakForceSensor ( simxInt clientID , simxInt forceSensorHandle , simxInt operationMode ); 56 | fcns.name{fcnNum}='simxBreakForceSensor'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 57 | % extern simxInt simxReadVisionSensor ( simxInt clientID , simxInt sensorHandle , simxUChar * detectionState , simxFloat ** auxValues , simxInt ** auxValuesCount , simxInt operationMode ); 58 | fcns.name{fcnNum}='simxReadVisionSensor'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'uint8Ptr', 'singlePtrPtr', 'int32PtrPtr', 'int32'};fcnNum=fcnNum+1; 59 | % extern simxInt simxGetObjectHandle ( simxInt clientID , const simxChar * objectName , simxInt * handle , simxInt operationMode ); 60 | fcns.name{fcnNum}='simxGetObjectHandle'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 61 | % extern simxInt simxGetVisionSensorImage ( simxInt clientID , simxInt sensorHandle , simxInt * resolution , simxUChar ** image , simxUChar options , simxInt operationMode ); 62 | fcns.name{fcnNum}='simxGetVisionSensorImage'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr', 'uint8PtrPtr', 'uint8', 'int32'};fcnNum=fcnNum+1; 63 | % extern simxInt simxSetVisionSensorImage ( simxInt clientID , simxInt sensorHandle , simxUChar * image , simxInt bufferSize , simxUChar options , simxInt operationMode ); 64 | fcns.name{fcnNum}='simxSetVisionSensorImage'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'uint8Ptr', 'int32', 'uint8', 'int32'};fcnNum=fcnNum+1; 65 | % extern simxInt simxGetVisionSensorDepthBuffer ( simxInt clientID , simxInt sensorHandle , simxInt * resolution , simxFloat ** buffer , simxInt operationMode ); 66 | fcns.name{fcnNum}='simxGetVisionSensorDepthBuffer'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr', 'singlePtrPtr', 'int32'};fcnNum=fcnNum+1; 67 | % extern simxInt simxGetObjectChild ( simxInt clientID , simxInt parentObjectHandle , simxInt childIndex , simxInt * childObjectHandle , simxInt operationMode ); 68 | fcns.name{fcnNum}='simxGetObjectChild'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 69 | % extern simxInt simxGetObjectParent ( simxInt clientID , simxInt childObjectHandle , simxInt * parentObjectHandle , simxInt operationMode ); 70 | fcns.name{fcnNum}='simxGetObjectParent'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 71 | % extern simxInt simxLoadModel ( simxInt clientID , const simxChar * modelPathAndName , simxUChar options , simxInt * baseHandle , simxInt operationMode ); 72 | fcns.name{fcnNum}='simxLoadModel'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 73 | % extern simxInt simxLoadUI ( simxInt clientID , const simxChar * uiPathAndName , simxUChar options , simxInt * count , simxInt ** uiHandles , simxInt operationMode ); 74 | fcns.name{fcnNum}='simxLoadUI'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8', 'int32Ptr', 'int32PtrPtr', 'int32'};fcnNum=fcnNum+1; 75 | % extern simxInt simxLoadScene ( simxInt clientID , const simxChar * scenePathAndName , simxUChar options , simxInt operationMode ); 76 | fcns.name{fcnNum}='simxLoadScene'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8', 'int32'};fcnNum=fcnNum+1; 77 | % extern simxInt simxStartSimulation ( simxInt clientID , simxInt operationMode ); 78 | fcns.name{fcnNum}='simxStartSimulation'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32'};fcnNum=fcnNum+1; 79 | % extern simxInt simxPauseSimulation ( simxInt clientID , simxInt operationMode ); 80 | fcns.name{fcnNum}='simxPauseSimulation'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32'};fcnNum=fcnNum+1; 81 | % extern simxInt simxStopSimulation ( simxInt clientID , simxInt operationMode ); 82 | fcns.name{fcnNum}='simxStopSimulation'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32'};fcnNum=fcnNum+1; 83 | % extern simxInt simxGetUIHandle ( simxInt clientID , const simxChar * uiName , simxInt * handle , simxInt operationMode ); 84 | fcns.name{fcnNum}='simxGetUIHandle'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 85 | % extern simxInt simxGetUISlider ( simxInt clientID , simxInt uiHandle , simxInt uiButtonID , simxInt * position , simxInt operationMode ); 86 | fcns.name{fcnNum}='simxGetUISlider'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 87 | % extern simxInt simxSetUISlider ( simxInt clientID , simxInt uiHandle , simxInt uiButtonID , simxInt position , simxInt operationMode ); 88 | fcns.name{fcnNum}='simxSetUISlider'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 89 | % extern simxInt simxGetUIEventButton ( simxInt clientID , simxInt uiHandle , simxInt * uiEventButtonID , simxInt * auxValues , simxInt operationMode ); 90 | fcns.name{fcnNum}='simxGetUIEventButton'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 91 | % extern simxInt simxGetUIButtonProperty ( simxInt clientID , simxInt uiHandle , simxInt uiButtonID , simxInt * prop , simxInt operationMode ); 92 | fcns.name{fcnNum}='simxGetUIButtonProperty'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 93 | % extern simxInt simxSetUIButtonProperty ( simxInt clientID , simxInt uiHandle , simxInt uiButtonID , simxInt prop , simxInt operationMode ); 94 | fcns.name{fcnNum}='simxSetUIButtonProperty'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 95 | % extern simxInt simxAddStatusbarMessage ( simxInt clientID , const simxChar * message , simxInt operationMode ); 96 | fcns.name{fcnNum}='simxAddStatusbarMessage'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32'};fcnNum=fcnNum+1; 97 | % extern simxInt simxAuxiliaryConsoleClose ( simxInt clientID , simxInt consoleHandle , simxInt operationMode ); 98 | fcns.name{fcnNum}='simxAuxiliaryConsoleClose'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 99 | % extern simxInt simxAuxiliaryConsolePrint ( simxInt clientID , simxInt consoleHandle , const simxChar * txt , simxInt operationMode ); 100 | fcns.name{fcnNum}='simxAuxiliaryConsolePrint'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int8Ptr', 'int32'};fcnNum=fcnNum+1; 101 | % extern simxInt simxAuxiliaryConsoleShow ( simxInt clientID , simxInt consoleHandle , simxUChar showState , simxInt operationMode ); 102 | fcns.name{fcnNum}='simxAuxiliaryConsoleShow'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'uint8', 'int32'};fcnNum=fcnNum+1; 103 | % extern simxInt simxGetObjectOrientation ( simxInt clientID , simxInt objectHandle , simxInt relativeToObjectHandle , simxFloat * eulerAngles , simxInt operationMode ); 104 | fcns.name{fcnNum}='simxGetObjectOrientation'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 105 | % extern simxInt simxGetObjectPosition ( simxInt clientID , simxInt objectHandle , simxInt relativeToObjectHandle , simxFloat * position , simxInt operationMode ); 106 | fcns.name{fcnNum}='simxGetObjectPosition'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 107 | % extern simxInt simxSetObjectOrientation ( simxInt clientID , simxInt objectHandle , simxInt relativeToObjectHandle , const simxFloat * eulerAngles , simxInt operationMode ); 108 | fcns.name{fcnNum}='simxSetObjectOrientation'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 109 | % extern simxInt simxSetObjectPosition ( simxInt clientID , simxInt objectHandle , simxInt relativeToObjectHandle , const simxFloat * position , simxInt operationMode ); 110 | fcns.name{fcnNum}='simxSetObjectPosition'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 111 | % extern simxInt simxSetObjectParent ( simxInt clientID , simxInt objectHandle , simxInt parentObject , simxUChar keepInPlace , simxInt operationMode ); 112 | fcns.name{fcnNum}='simxSetObjectParent'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'uint8', 'int32'};fcnNum=fcnNum+1; 113 | % extern simxInt simxSetUIButtonLabel ( simxInt clientID , simxInt uiHandle , simxInt uiButtonID , const simxChar * upStateLabel , const simxChar * downStateLabel , simxInt operationMode ); 114 | fcns.name{fcnNum}='simxSetUIButtonLabel'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int8Ptr', 'int8Ptr', 'int32'};fcnNum=fcnNum+1; 115 | % extern simxInt simxGetLastErrors ( simxInt clientID , simxInt * errorCnt , simxChar ** errorStrings , simxInt operationMode ); 116 | fcns.name{fcnNum}='simxGetLastErrors'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32Ptr', 'int8PtrPtr', 'int32'};fcnNum=fcnNum+1; 117 | % extern simxInt simxGetArrayParameter ( simxInt clientID , simxInt paramIdentifier , simxFloat * paramValues , simxInt operationMode ); 118 | fcns.name{fcnNum}='simxGetArrayParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 119 | % extern simxInt simxSetArrayParameter ( simxInt clientID , simxInt paramIdentifier , const simxFloat * paramValues , simxInt operationMode ); 120 | fcns.name{fcnNum}='simxSetArrayParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 121 | % extern simxInt simxGetBooleanParameter ( simxInt clientID , simxInt paramIdentifier , simxUChar * paramValue , simxInt operationMode ); 122 | fcns.name{fcnNum}='simxGetBooleanParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'uint8Ptr', 'int32'};fcnNum=fcnNum+1; 123 | % extern simxInt simxSetBooleanParameter ( simxInt clientID , simxInt paramIdentifier , simxUChar paramValue , simxInt operationMode ); 124 | fcns.name{fcnNum}='simxSetBooleanParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'uint8', 'int32'};fcnNum=fcnNum+1; 125 | % extern simxInt simxGetIntegerParameter ( simxInt clientID , simxInt paramIdentifier , simxInt * paramValue , simxInt operationMode ); 126 | fcns.name{fcnNum}='simxGetIntegerParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 127 | % extern simxInt simxSetIntegerParameter ( simxInt clientID , simxInt paramIdentifier , simxInt paramValue , simxInt operationMode ); 128 | fcns.name{fcnNum}='simxSetIntegerParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 129 | % extern simxInt simxGetFloatingParameter ( simxInt clientID , simxInt paramIdentifier , simxFloat * paramValue , simxInt operationMode ); 130 | fcns.name{fcnNum}='simxGetFloatingParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 131 | % extern simxInt simxGetStringParameter ( simxInt clientID , simxInt paramIdentifier , simxChar ** paramValue , simxInt operationMode ); 132 | fcns.name{fcnNum}='simxGetStringParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int8PtrPtr', 'int32'};fcnNum=fcnNum+1; 133 | % extern simxInt simxGetCollisionHandle ( simxInt clientID , const simxChar * collisionObjectName , simxInt * handle , simxInt operationMode ); 134 | fcns.name{fcnNum}='simxGetCollisionHandle'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 135 | % extern simxInt simxGetDistanceHandle ( simxInt clientID , const simxChar * distanceObjectName , simxInt * handle , simxInt operationMode ); 136 | fcns.name{fcnNum}='simxGetDistanceHandle'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 137 | % extern simxInt simxGetCollectionHandle ( simxInt clientID , const simxChar * collectionName , simxInt * handle , simxInt operationMode ); 138 | fcns.name{fcnNum}='simxGetCollectionHandle'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 139 | % extern simxInt simxReadCollision ( simxInt clientID , simxInt collisionObjectHandle , simxUChar * collisionState , simxInt operationMode ); 140 | fcns.name{fcnNum}='simxReadCollision'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'uint8Ptr', 'int32'};fcnNum=fcnNum+1; 141 | % extern simxInt simxReadDistance ( simxInt clientID , simxInt distanceObjectHandle , simxFloat * minimumDistance , simxInt operationMode ); 142 | fcns.name{fcnNum}='simxReadDistance'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 143 | % extern simxInt simxRemoveObject ( simxInt clientID , simxInt objectHandle , simxInt operationMode ); 144 | fcns.name{fcnNum}='simxRemoveObject'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 145 | % extern simxInt simxRemoveModel ( simxInt clientID , simxInt objectHandle , simxInt operationMode ); 146 | fcns.name{fcnNum}='simxRemoveModel'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 147 | % extern simxInt simxRemoveUI ( simxInt clientID , simxInt uiHandle , simxInt operationMode ); 148 | fcns.name{fcnNum}='simxRemoveUI'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 149 | % extern simxInt simxCloseScene ( simxInt clientID , simxInt operationMode ); 150 | fcns.name{fcnNum}='simxCloseScene'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32'};fcnNum=fcnNum+1; 151 | % extern simxInt simxGetObjects ( simxInt clientID , simxInt objectType , simxInt * objectCount , simxInt ** objectHandles , simxInt operationMode ); 152 | fcns.name{fcnNum}='simxGetObjects'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr', 'int32PtrPtr', 'int32'};fcnNum=fcnNum+1; 153 | % extern simxInt simxEndDialog ( simxInt clientID , simxInt dialogHandle , simxInt operationMode ); 154 | fcns.name{fcnNum}='simxEndDialog'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 155 | % extern simxInt simxGetDialogInput ( simxInt clientID , simxInt dialogHandle , simxChar ** inputText , simxInt operationMode ); 156 | fcns.name{fcnNum}='simxGetDialogInput'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int8PtrPtr', 'int32'};fcnNum=fcnNum+1; 157 | % extern simxInt simxGetDialogResult ( simxInt clientID , simxInt dialogHandle , simxInt * result , simxInt operationMode ); 158 | fcns.name{fcnNum}='simxGetDialogResult'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 159 | % extern simxInt simxCopyPasteObjects ( simxInt clientID , const simxInt * objectHandles , simxInt objectCount , simxInt ** newObjectHandles , simxInt * newObjectCount , simxInt operationMode ); 160 | fcns.name{fcnNum}='simxCopyPasteObjects'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32Ptr', 'int32', 'int32PtrPtr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 161 | % extern simxInt simxGetObjectSelection ( simxInt clientID , simxInt ** objectHandles , simxInt * objectCount , simxInt operationMode ); 162 | fcns.name{fcnNum}='simxGetObjectSelection'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32PtrPtr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 163 | % extern simxInt simxSetObjectSelection ( simxInt clientID , const simxInt * objectHandles , simxInt objectCount , simxInt operationMode ); 164 | fcns.name{fcnNum}='simxSetObjectSelection'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32Ptr', 'int32', 'int32'};fcnNum=fcnNum+1; 165 | % extern simxInt simxClearFloatSignal ( simxInt clientID , const simxChar * signalName , simxInt operationMode ); 166 | fcns.name{fcnNum}='simxClearFloatSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32'};fcnNum=fcnNum+1; 167 | % extern simxInt simxClearIntegerSignal ( simxInt clientID , const simxChar * signalName , simxInt operationMode ); 168 | fcns.name{fcnNum}='simxClearIntegerSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32'};fcnNum=fcnNum+1; 169 | % extern simxInt simxClearStringSignal ( simxInt clientID , const simxChar * signalName , simxInt operationMode ); 170 | fcns.name{fcnNum}='simxClearStringSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32'};fcnNum=fcnNum+1; 171 | % extern simxInt simxGetFloatSignal ( simxInt clientID , const simxChar * signalName , simxFloat * signalValue , simxInt operationMode ); 172 | fcns.name{fcnNum}='simxGetFloatSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 173 | % extern simxInt simxGetIntegerSignal ( simxInt clientID , const simxChar * signalName , simxInt * signalValue , simxInt operationMode ); 174 | fcns.name{fcnNum}='simxGetIntegerSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 175 | % extern simxInt simxGetStringSignal ( simxInt clientID , const simxChar * signalName , simxUChar ** signalValue , simxInt * signalLength , simxInt operationMode ); 176 | fcns.name{fcnNum}='simxGetStringSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8PtrPtr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 177 | % extern simxInt simxGetAndClearStringSignal ( simxInt clientID , const simxChar * signalName , simxUChar ** signalValue , simxInt * signalLength , simxInt operationMode ); 178 | fcns.name{fcnNum}='simxGetAndClearStringSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8PtrPtr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 179 | % extern simxInt simxReadStringStream ( simxInt clientID , const simxChar * signalName , simxUChar ** signalValue , simxInt * signalLength , simxInt operationMode ); 180 | fcns.name{fcnNum}='simxReadStringStream'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8PtrPtr', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 181 | % extern simxInt simxSetIntegerSignal ( simxInt clientID , const simxChar * signalName , simxInt signalValue , simxInt operationMode ); 182 | fcns.name{fcnNum}='simxSetIntegerSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32', 'int32'};fcnNum=fcnNum+1; 183 | % extern simxInt simxSetStringSignal ( simxInt clientID , const simxChar * signalName , const simxUChar * signalValue , simxInt signalLength , simxInt operationMode ); 184 | fcns.name{fcnNum}='simxSetStringSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8Ptr', 'int32', 'int32'};fcnNum=fcnNum+1; 185 | % extern simxInt simxAppendStringSignal ( simxInt clientID , const simxChar * signalName , const simxUChar * signalValue , simxInt signalLength , simxInt operationMode ); 186 | fcns.name{fcnNum}='simxAppendStringSignal'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8Ptr', 'int32', 'int32'};fcnNum=fcnNum+1; 187 | % extern simxInt simxWriteStringStream ( simxInt clientID , const simxChar * signalName , const simxUChar * signalValue , simxInt signalLength , simxInt operationMode ); 188 | fcns.name{fcnNum}='simxWriteStringStream'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'uint8Ptr', 'int32', 'int32'};fcnNum=fcnNum+1; 189 | % extern simxInt simxGetObjectFloatParameter ( simxInt clientID , simxInt objectHandle , simxInt parameterID , simxFloat * parameterValue , simxInt operationMode ); 190 | fcns.name{fcnNum}='simxGetObjectFloatParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 191 | % extern simxInt simxGetObjectIntParameter ( simxInt clientID , simxInt objectHandle , simxInt parameterID , simxInt * parameterValue , simxInt operationMode ); 192 | fcns.name{fcnNum}='simxGetObjectIntParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 193 | % extern simxInt simxSetObjectIntParameter ( simxInt clientID , simxInt objectHandle , simxInt parameterID , simxInt parameterValue , simxInt operationMode ); 194 | fcns.name{fcnNum}='simxSetObjectIntParameter'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 195 | % extern simxInt simxGetModelProperty ( simxInt clientID , simxInt objectHandle , simxInt * prop , simxInt operationMode ); 196 | fcns.name{fcnNum}='simxGetModelProperty'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr', 'int32'};fcnNum=fcnNum+1; 197 | % extern simxInt simxSetModelProperty ( simxInt clientID , simxInt objectHandle , simxInt prop , simxInt operationMode ); 198 | fcns.name{fcnNum}='simxSetModelProperty'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32', 'int32'};fcnNum=fcnNum+1; 199 | % extern simxInt simxGetObjectVelocity ( simxInt clientID , simxInt objectHandle , simxFloat * linearVelocity , simxFloat * angularVelocity , simxInt operationMode ); 200 | fcns.name{fcnNum}='simxGetObjectVelocity'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'singlePtr', 'singlePtr', 'int32'};fcnNum=fcnNum+1; 201 | % extern simxInt simxStart ( const simxChar * connectionAddress , simxInt connectionPort , simxUChar waitUntilConnected , simxUChar doNotReconnectOnceDisconnected , simxInt timeOutInMs , simxInt commThreadCycleInMs ); 202 | fcns.name{fcnNum}='simxStart'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int8Ptr', 'int32', 'uint8', 'uint8', 'int32', 'int32'};fcnNum=fcnNum+1; 203 | % extern simxVoid simxFinish ( simxInt clientID ); 204 | fcns.name{fcnNum}='simxFinish'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}=[]; fcns.RHS{fcnNum}={'int32'};fcnNum=fcnNum+1; 205 | % extern simxInt simxGetPingTime ( simxInt clientID , simxInt * pingTime ); 206 | fcns.name{fcnNum}='simxGetPingTime'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32Ptr'};fcnNum=fcnNum+1; 207 | % extern simxInt simxGetLastCmdTime ( simxInt clientID ); 208 | fcns.name{fcnNum}='simxGetLastCmdTime'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32'};fcnNum=fcnNum+1; 209 | % extern simxInt simxSynchronousTrigger ( simxInt clientID ); 210 | fcns.name{fcnNum}='simxSynchronousTrigger'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32'};fcnNum=fcnNum+1; 211 | % extern simxInt simxSynchronous ( simxInt clientID , simxUChar enable ); 212 | fcns.name{fcnNum}='simxSynchronous'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'uint8'};fcnNum=fcnNum+1; 213 | % extern simxInt simxPauseCommunication ( simxInt clientID , simxUChar pause ); 214 | fcns.name{fcnNum}='simxPauseCommunication'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'uint8'};fcnNum=fcnNum+1; 215 | % extern simxInt simxGetInMessageInfo ( simxInt clientID , simxInt infoType , simxInt * info ); 216 | fcns.name{fcnNum}='simxGetInMessageInfo'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr'};fcnNum=fcnNum+1; 217 | % extern simxInt simxGetOutMessageInfo ( simxInt clientID , simxInt infoType , simxInt * info ); 218 | fcns.name{fcnNum}='simxGetOutMessageInfo'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int32', 'int32Ptr'};fcnNum=fcnNum+1; 219 | % extern simxInt simxGetConnectionId ( simxInt clientID ); 220 | fcns.name{fcnNum}='simxGetConnectionId'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32'};fcnNum=fcnNum+1; 221 | % extern simxUChar * simxCreateBuffer ( simxInt bufferSize ); 222 | fcns.name{fcnNum}='simxCreateBuffer'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='uint8Ptr'; fcns.RHS{fcnNum}={'int32'};fcnNum=fcnNum+1; 223 | % extern simxVoid simxReleaseBuffer ( simxUChar * buffer ); 224 | fcns.name{fcnNum}='simxReleaseBuffer'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}=[]; fcns.RHS{fcnNum}={'uint8Ptr'};fcnNum=fcnNum+1; 225 | % extern simxInt simxTransferFile ( simxInt clientID , const simxChar * filePathAndName , const simxChar * fileName_serverSide , simxInt timeOut , simxInt operationMode ); 226 | fcns.name{fcnNum}='simxTransferFile'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int8Ptr', 'int32', 'int32'};fcnNum=fcnNum+1; 227 | % extern simxInt simxEraseFile ( simxInt clientID , const simxChar * fileName_serverSide , simxInt operationMode ); 228 | fcns.name{fcnNum}='simxEraseFile'; fcns.calltype{fcnNum}='cdecl'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int32', 'int8Ptr', 'int32'};fcnNum=fcnNum+1; 229 | methodinfo=fcns; 230 | -------------------------------------------------------------------------------- /remApi.m: -------------------------------------------------------------------------------- 1 | classdef remApi 2 | 3 | properties 4 | libName; 5 | hFile; 6 | end 7 | properties (Constant) 8 | 9 | % Scene object types 10 | sim_object_shape_type =0; 11 | sim_object_joint_type =1; 12 | sim_object_graph_type =2; 13 | sim_object_camera_type =3; 14 | sim_object_dummy_type =4; 15 | sim_object_proximitysensor_type =5; 16 | sim_object_reserved1 =6; 17 | sim_object_reserved2 =7; 18 | sim_object_path_type =8; 19 | sim_object_visionsensor_type =9; 20 | sim_object_volume_type =10; 21 | sim_object_mill_type =11; 22 | sim_object_forcesensor_type =12; 23 | sim_object_light_type =13; 24 | sim_object_mirror_type =14; 25 | 26 | %General object types 27 | sim_appobj_object_type =109; 28 | sim_appobj_collision_type =110; 29 | sim_appobj_distance_type =111; 30 | sim_appobj_simulation_type =112; 31 | sim_appobj_ik_type =113; 32 | sim_appobj_constraintsolver_type=114; 33 | sim_appobj_collection_type =115; 34 | sim_appobj_ui_type =116; 35 | sim_appobj_script_type =117; 36 | sim_appobj_pathplanning_type =118; 37 | sim_appobj_RESERVED_type =119; 38 | sim_appobj_texture_type =120; 39 | 40 | % Ik calculation methods 41 | sim_ik_pseudo_inverse_method =0; 42 | sim_ik_damped_least_squares_method =1; 43 | sim_ik_jacobian_transpose_method =2; 44 | 45 | % Ik constraints 46 | sim_ik_x_constraint =1; 47 | sim_ik_y_constraint =2; 48 | sim_ik_z_constraint =4; 49 | sim_ik_alpha_beta_constraint=8; 50 | sim_ik_gamma_constraint =16; 51 | sim_ik_avoidance_constraint =64; 52 | 53 | % Ik calculation results 54 | sim_ikresult_not_performed =0; 55 | sim_ikresult_success =1; 56 | sim_ikresult_fail =2; 57 | 58 | % Scene object sub-types 59 | sim_light_omnidirectional_subtype =1; 60 | sim_light_spot_subtype =2; 61 | sim_light_directional_subtype =3; 62 | sim_joint_revolute_subtype =10; 63 | sim_joint_prismatic_subtype =11; 64 | sim_joint_spherical_subtype =12; 65 | sim_shape_simpleshape_subtype =20; 66 | sim_shape_multishape_subtype =21; 67 | sim_proximitysensor_pyramid_subtype =30; 68 | sim_proximitysensor_cylinder_subtype=31; 69 | sim_proximitysensor_disc_subtype =32; 70 | sim_proximitysensor_cone_subtype =33; 71 | sim_proximitysensor_ray_subtype =34; 72 | sim_mill_pyramid_subtype =40; 73 | sim_mill_cylinder_subtype =41; 74 | sim_mill_disc_subtype =42; 75 | sim_mill_cone_subtype =42; 76 | sim_object_no_subtype =200; 77 | 78 | 79 | %Scene object main properties 80 | sim_objectspecialproperty_collidable =1; 81 | sim_objectspecialproperty_measurable =2; 82 | sim_objectspecialproperty_detectable_ultrasonic =16; 83 | sim_objectspecialproperty_detectable_infrared =32; 84 | sim_objectspecialproperty_detectable_laser =64; 85 | sim_objectspecialproperty_detectable_inductive =128; 86 | sim_objectspecialproperty_detectable_capacitive =256; 87 | sim_objectspecialproperty_renderable =512; 88 | sim_objectspecialproperty_detectable_all =496; 89 | sim_objectspecialproperty_cuttable =1024; 90 | sim_objectspecialproperty_pathplanning_ignored =2048; 91 | 92 | % Model properties 93 | sim_modelproperty_not_collidable =1; 94 | sim_modelproperty_not_measurable =2; 95 | sim_modelproperty_not_renderable =4; 96 | sim_modelproperty_not_detectable =8; 97 | sim_modelproperty_not_cuttable =16; 98 | sim_modelproperty_not_dynamic =32; 99 | sim_modelproperty_not_respondable =64; 100 | sim_modelproperty_not_reset =128; 101 | sim_modelproperty_not_visible =256; 102 | sim_modelproperty_not_model =61440; 103 | 104 | 105 | % Check the documentation instead of comments below!! 106 | sim_message_ui_button_state_change =0; 107 | sim_message_reserved9 =1; 108 | sim_message_object_selection_changed=2; 109 | sim_message_reserved10 =3; 110 | sim_message_model_loaded =4; 111 | sim_message_reserved11 =5; 112 | sim_message_keypress =6; 113 | sim_message_bannerclicked =7; 114 | sim_message_for_c_api_only_start =256; 115 | sim_message_reserved1 =257; 116 | sim_message_reserved2 =258; 117 | sim_message_reserved3 =259; 118 | sim_message_eventcallback_scenesave =260; 119 | sim_message_eventcallback_modelsave =261; 120 | sim_message_eventcallback_moduleopen =262; 121 | sim_message_eventcallback_modulehandle =263; 122 | sim_message_eventcallback_moduleclose =264; 123 | sim_message_reserved4 =265; 124 | sim_message_reserved5 =266; 125 | sim_message_reserved6 =267; 126 | sim_message_reserved7 =268; 127 | sim_message_eventcallback_instancepass =269; 128 | sim_message_eventcallback_broadcast =270; 129 | sim_message_eventcallback_imagefilter_enumreset =271; 130 | sim_message_eventcallback_imagefilter_enumerate =272; 131 | sim_message_eventcallback_imagefilter_adjustparams =273; 132 | sim_message_eventcallback_imagefilter_reserved =274; 133 | sim_message_eventcallback_imagefilter_process =275; 134 | sim_message_eventcallback_reserved1 =276; 135 | sim_message_eventcallback_reserved2 =277; 136 | sim_message_eventcallback_reserved3 =278; 137 | sim_message_eventcallback_reserved4 =279; 138 | sim_message_eventcallback_abouttoundo =280; 139 | sim_message_eventcallback_undoperformed =281; 140 | sim_message_eventcallback_abouttoredo =282; 141 | sim_message_eventcallback_redoperformed =283; 142 | sim_message_eventcallback_scripticondblclick =284; 143 | sim_message_eventcallback_simulationabouttostart =285; 144 | sim_message_eventcallback_simulationended =286; 145 | sim_message_eventcallback_reserved5 =287; 146 | sim_message_eventcallback_keypress =288; 147 | sim_message_eventcallback_modulehandleinsensingpart =289; 148 | sim_message_eventcallback_renderingpass =290; 149 | sim_message_eventcallback_bannerclicked =291; 150 | sim_message_eventcallback_menuitemselected =292; 151 | sim_message_eventcallback_refreshdialogs =293; 152 | sim_message_eventcallback_sceneloaded =294; 153 | sim_message_eventcallback_modelloaded =295; 154 | sim_message_eventcallback_instanceswitch =296; 155 | sim_message_eventcallback_guipass =297; 156 | sim_message_eventcallback_mainscriptabouttobecalled =298; 157 | sim_message_eventcallback_rmlposition =299; 158 | sim_message_eventcallback_rmlvelocity =300; 159 | 160 | sim_message_simulation_start_resume_request =4096; 161 | sim_message_simulation_pause_request =4097; 162 | sim_message_simulation_stop_request =4098; 163 | 164 | % Scene object properties 165 | sim_objectproperty_collapsed =16; 166 | sim_objectproperty_selectable =32; 167 | sim_objectproperty_reserved7 =64; 168 | sim_objectproperty_selectmodelbaseinstead =128; 169 | sim_objectproperty_dontshowasinsidemodel =256; 170 | sim_objectproperty_canupdatedna =1024; 171 | sim_objectproperty_selectinvisible =2048; 172 | sim_objectproperty_depthinvisible =4096; 173 | 174 | 175 | 176 | % type of arguments (input and output) for custom lua commands 177 | sim_lua_arg_nil =0; 178 | sim_lua_arg_bool =1; 179 | sim_lua_arg_int =2; 180 | sim_lua_arg_float =3; 181 | sim_lua_arg_string =4; 182 | sim_lua_arg_invalid =5; 183 | sim_lua_arg_table =8; 184 | 185 | % custom user interface properties 186 | sim_ui_property_visible =1; 187 | sim_ui_property_visibleduringsimulationonly =2; 188 | sim_ui_property_moveable =4; 189 | sim_ui_property_relativetoleftborder =8; 190 | sim_ui_property_relativetotopborder =16; 191 | sim_ui_property_fixedwidthfont =32; 192 | sim_ui_property_systemblock =64; 193 | sim_ui_property_settocenter =128; 194 | sim_ui_property_rolledup =256; 195 | sim_ui_property_selectassociatedobject =512; 196 | sim_ui_property_visiblewhenobjectselected =1024; 197 | 198 | 199 | % button properties 200 | sim_buttonproperty_button =0; 201 | sim_buttonproperty_label =1; 202 | sim_buttonproperty_slider =2; 203 | sim_buttonproperty_editbox =3; 204 | sim_buttonproperty_staydown =8; 205 | sim_buttonproperty_enabled =16; 206 | sim_buttonproperty_borderless =32; 207 | sim_buttonproperty_horizontallycentered =64; 208 | sim_buttonproperty_ignoremouse =128; 209 | sim_buttonproperty_isdown =256; 210 | sim_buttonproperty_transparent =512; 211 | sim_buttonproperty_nobackgroundcolor =1024; 212 | sim_buttonproperty_rollupaction =2048; 213 | sim_buttonproperty_closeaction =4096; 214 | sim_buttonproperty_verticallycentered =8192; 215 | sim_buttonproperty_downupevent =16384; 216 | 217 | 218 | % Simulation status 219 | sim_simulation_stopped =0; 220 | sim_simulation_paused =8; 221 | sim_simulation_advancing =16; 222 | sim_simulation_advancing_firstafterstop =16; 223 | sim_simulation_advancing_running =17; 224 | sim_simulation_advancing_lastbeforepause =19; 225 | sim_simulation_advancing_firstafterpause =20; 226 | sim_simulation_advancing_abouttostop =21; 227 | sim_simulation_advancing_lastbeforestop =22; 228 | 229 | 230 | % Script execution result (first return value) 231 | sim_script_no_error =0; 232 | sim_script_main_script_nonexistent =1; 233 | sim_script_main_script_not_called =2; 234 | sim_script_reentrance_error =4; 235 | sim_script_lua_error =8; 236 | sim_script_call_error =16; 237 | 238 | 239 | % Script types 240 | sim_scripttype_mainscript =0; 241 | sim_scripttype_childscript =1; 242 | sim_scripttype_jointctrlcallback =4; 243 | sim_scripttype_contactcallback =5; 244 | sim_scripttype_customizationscript =6; 245 | sim_scripttype_generalcallback =7; 246 | 247 | % API call error messages 248 | sim_api_errormessage_ignore =0; 249 | sim_api_errormessage_report =1; 250 | sim_api_errormessage_output =2; 251 | 252 | 253 | % special argument of some functions 254 | sim_handle_all =-2; 255 | sim_handle_all_except_explicit =-3; 256 | sim_handle_self =-4; 257 | sim_handle_main_script =-5; 258 | sim_handle_tree =-6; 259 | sim_handle_chain =-7; 260 | sim_handle_single =-8; 261 | sim_handle_default =-9; 262 | sim_handle_all_except_self =-10; 263 | sim_handle_parent =-11; 264 | 265 | % special handle flags 266 | sim_handleflag_assembly =4194304; 267 | sim_handleflag_model =8388608; 268 | 269 | 270 | % distance calculation methods 271 | sim_distcalcmethod_dl =0; 272 | sim_distcalcmethod_dac =1; 273 | sim_distcalcmethod_max_dl_dac =2; 274 | sim_distcalcmethod_dl_and_dac =3; 275 | sim_distcalcmethod_sqrt_dl2_and_dac2=4; 276 | sim_distcalcmethod_dl_if_nonzero =5; 277 | sim_distcalcmethod_dac_if_nonzero =6; 278 | 279 | 280 | % Generic dialog styles 281 | sim_dlgstyle_message =0; 282 | sim_dlgstyle_input =1; 283 | sim_dlgstyle_ok =2; 284 | sim_dlgstyle_ok_cancel =3; 285 | sim_dlgstyle_yes_no =4; 286 | sim_dlgstyle_dont_center =32; 287 | 288 | % Generic dialog return values 289 | sim_dlgret_still_open =0; 290 | sim_dlgret_ok =1; 291 | sim_dlgret_cancel =2; 292 | sim_dlgret_yes =3; 293 | sim_dlgret_no =4; 294 | 295 | 296 | % Path properties 297 | sim_pathproperty_show_line =1; 298 | sim_pathproperty_show_orientation =2; 299 | sim_pathproperty_closed_path =4; 300 | sim_pathproperty_automatic_orientation =8; 301 | sim_pathproperty_invert_velocity =16; 302 | sim_pathproperty_infinite_acceleration =32; 303 | sim_pathproperty_flat_path =64; 304 | sim_pathproperty_show_position =128; 305 | sim_pathproperty_auto_velocity_profile_translation =256; 306 | sim_pathproperty_auto_velocity_profile_rotation =512; 307 | sim_pathproperty_endpoints_at_zero =1024; 308 | sim_pathproperty_keep_x_up =2048; 309 | 310 | 311 | % drawing objects 312 | sim_drawing_points =0; 313 | sim_drawing_lines =1; 314 | sim_drawing_triangles =2; 315 | sim_drawing_trianglepoints =3; 316 | sim_drawing_quadpoints =4; 317 | sim_drawing_discpoints =5; 318 | sim_drawing_cubepoints =6; 319 | sim_drawing_spherepoints =7; 320 | 321 | sim_drawing_itemcolors =32; 322 | sim_drawing_vertexcolors =64; 323 | sim_drawing_itemsizes =128; 324 | sim_drawing_backfaceculling =256; 325 | sim_drawing_wireframe =512; 326 | sim_drawing_painttag =1024; 327 | sim_drawing_followparentvisibility =2048; 328 | sim_drawing_cyclic =4096; 329 | sim_drawing_50percenttransparency =8192; 330 | sim_drawing_25percenttransparency =16384; 331 | sim_drawing_12percenttransparency =32768; 332 | sim_drawing_emissioncolor =65536; 333 | sim_drawing_facingcamera =131072; 334 | sim_drawing_overlay =262144; 335 | sim_drawing_itemtransparency =524288; 336 | 337 | % banner values 338 | sim_banner_left =1; 339 | sim_banner_right =2; 340 | sim_banner_nobackground =4; 341 | sim_banner_overlay =8; 342 | sim_banner_followparentvisibility =16; 343 | sim_banner_clickselectsparent =32; 344 | sim_banner_clicktriggersevent =64; 345 | sim_banner_facingcamera =128; 346 | sim_banner_fullyfacingcamera =256; 347 | sim_banner_backfaceculling =512; 348 | sim_banner_keepsamesize =1024; 349 | sim_banner_bitmapfont =2048; 350 | 351 | % particle objects 352 | sim_particle_points1 =0; 353 | sim_particle_points2 =1; 354 | sim_particle_points4 =2; 355 | sim_particle_roughspheres =3; 356 | sim_particle_spheres =4; 357 | 358 | sim_particle_respondable1to4 =32; 359 | sim_particle_respondable5to8 =64; 360 | sim_particle_particlerespondable =128; 361 | sim_particle_ignoresgravity =256; 362 | sim_particle_invisible =512; 363 | sim_particle_itemsizes =1024; 364 | sim_particle_itemdensities =2048; 365 | sim_particle_itemcolors =4096; 366 | sim_particle_cyclic =8192; 367 | sim_particle_emissioncolor =16384; 368 | sim_particle_water =32768; 369 | sim_particle_painttag =65536; 370 | 371 | % custom user interface menu attributes 372 | sim_ui_menu_title =1; 373 | sim_ui_menu_minimize =2; 374 | sim_ui_menu_close =4; 375 | sim_ui_menu_systemblock =8; 376 | 377 | 378 | 379 | % Boolean parameters 380 | sim_boolparam_hierarchy_visible =0; 381 | sim_boolparam_console_visible =1; 382 | sim_boolparam_collision_handling_enabled =2; 383 | sim_boolparam_distance_handling_enabled =3; 384 | sim_boolparam_ik_handling_enabled =4; 385 | sim_boolparam_gcs_handling_enabled =5; 386 | sim_boolparam_dynamics_handling_enabled =6; 387 | sim_boolparam_joint_motion_handling_enabled =7; 388 | sim_boolparam_path_motion_handling_enabled =8; 389 | sim_boolparam_proximity_sensor_handling_enabled =9; 390 | sim_boolparam_vision_sensor_handling_enabled =10; 391 | sim_boolparam_mill_handling_enabled =11; 392 | sim_boolparam_browser_visible =12; 393 | sim_boolparam_scene_and_model_load_messages =13; 394 | sim_reserved0 =14; 395 | sim_boolparam_shape_textures_are_visible =15; 396 | sim_boolparam_display_enabled =16; 397 | sim_boolparam_infotext_visible =17; 398 | sim_boolparam_statustext_open =18; 399 | sim_boolparam_fog_enabled =19; 400 | sim_boolparam_rml2_available =20; 401 | sim_boolparam_rml4_available =21; 402 | sim_boolparam_mirrors_enabled =22; 403 | sim_boolparam_aux_clip_planes_enabled =23; 404 | sim_boolparam_full_model_copy_from_api =24; 405 | sim_boolparam_realtime_simulation =25; 406 | sim_boolparam_force_show_wireless_emission =27; 407 | sim_boolparam_force_show_wireless_reception =28; 408 | sim_boolparam_video_recording_triggered =29; 409 | sim_boolparam_threaded_rendering_enabled =32; 410 | sim_boolparam_fullscreen =33; 411 | sim_boolparam_headless =34; 412 | sim_boolparam_hierarchy_toolbarbutton_enabled =35; 413 | sim_boolparam_browser_toolbarbutton_enabled =36; 414 | sim_boolparam_objectshift_toolbarbutton_enabled =37; 415 | sim_boolparam_objectrotate_toolbarbutton_enabled=38; 416 | sim_boolparam_force_calcstruct_all_visible =39; 417 | sim_boolparam_force_calcstruct_all =40; 418 | sim_boolparam_exit_request =41; 419 | sim_boolparam_play_toolbarbutton_enabled =42; 420 | sim_boolparam_pause_toolbarbutton_enabled =43; 421 | sim_boolparam_stop_toolbarbutton_enabled =44; 422 | sim_boolparam_waiting_for_trigger =45; 423 | 424 | 425 | % Integer parameters 426 | sim_intparam_error_report_mode =0; 427 | sim_intparam_program_version =1; 428 | sim_intparam_instance_count =2; 429 | sim_intparam_custom_cmd_start_id =3; 430 | sim_intparam_compilation_version =4; 431 | sim_intparam_current_page =5; 432 | sim_intparam_flymode_camera_handle =6; 433 | sim_intparam_dynamic_step_divider =7; 434 | sim_intparam_dynamic_engine =8; 435 | sim_intparam_server_port_start =9; 436 | sim_intparam_server_port_range =10; 437 | sim_intparam_visible_layers =11; 438 | sim_intparam_infotext_style =12; 439 | sim_intparam_settings =13; 440 | sim_intparam_edit_mode_type =14; 441 | sim_intparam_server_port_next =15; 442 | sim_intparam_qt_version =16; 443 | sim_intparam_event_flags_read =17; 444 | sim_intparam_event_flags_read_clear =18; 445 | sim_intparam_platform =19; 446 | sim_intparam_scene_unique_id =20; 447 | sim_intparam_work_thread_count =21; 448 | sim_intparam_mouse_x =22; 449 | sim_intparam_mouse_y =23; 450 | sim_intparam_core_count =24; 451 | sim_intparam_work_thread_calc_time_ms =25; 452 | sim_intparam_idle_fps =26; 453 | sim_intparam_prox_sensor_select_down =27; 454 | sim_intparam_prox_sensor_select_up =28; 455 | sim_intparam_stop_request_counter =29; 456 | sim_intparam_program_revision =30; 457 | sim_intparam_mouse_buttons =31; 458 | sim_intparam_dynamic_warning_disabled_mask =32; 459 | sim_intparam_simulation_warning_disabled_mask =33; 460 | sim_intparam_scene_index =34; 461 | sim_intparam_motionplanning_seed =35; 462 | sim_intparam_speedmodifier =36; 463 | 464 | % Float parameters 465 | sim_floatparam_rand =0; 466 | sim_floatparam_simulation_time_step =1; 467 | sim_floatparam_stereo_distance =2; 468 | 469 | % String parameters 470 | sim_stringparam_application_path =0; 471 | sim_stringparam_video_filename =1; 472 | sim_stringparam_app_arg1 =2; 473 | sim_stringparam_app_arg2 =3; 474 | sim_stringparam_app_arg3 =4; 475 | sim_stringparam_app_arg4 =5; 476 | sim_stringparam_app_arg5 =6; 477 | sim_stringparam_app_arg6 =7; 478 | sim_stringparam_app_arg7 =8; 479 | sim_stringparam_app_arg8 =9; 480 | sim_stringparam_app_arg9 =10; 481 | sim_stringparam_scene_path_and_name =13; 482 | 483 | % Array parameters 484 | sim_arrayparam_gravity =0; 485 | sim_arrayparam_fog =1; 486 | sim_arrayparam_fog_color =2; 487 | sim_arrayparam_background_color1=3; 488 | sim_arrayparam_background_color2=4; 489 | sim_arrayparam_ambient_light =5; 490 | sim_arrayparam_random_euler =6; 491 | 492 | sim_objintparam_visibility_layer= 10; 493 | sim_objfloatparam_abs_x_velocity= 11; 494 | sim_objfloatparam_abs_y_velocity= 12; 495 | sim_objfloatparam_abs_z_velocity= 13; 496 | sim_objfloatparam_abs_rot_velocity= 14; 497 | sim_objfloatparam_objbbox_min_x= 15; 498 | sim_objfloatparam_objbbox_min_y= 16; 499 | sim_objfloatparam_objbbox_min_z= 17; 500 | sim_objfloatparam_objbbox_max_x= 18; 501 | sim_objfloatparam_objbbox_max_y= 19; 502 | sim_objfloatparam_objbbox_max_z= 20; 503 | sim_objfloatparam_modelbbox_min_x= 21; 504 | sim_objfloatparam_modelbbox_min_y= 22; 505 | sim_objfloatparam_modelbbox_min_z= 23; 506 | sim_objfloatparam_modelbbox_max_x= 24; 507 | sim_objfloatparam_modelbbox_max_y= 25; 508 | sim_objfloatparam_modelbbox_max_z= 26; 509 | sim_objintparam_collection_self_collision_indicator= 27; 510 | sim_objfloatparam_transparency_offset= 28; 511 | sim_objintparam_child_role= 29; 512 | sim_objintparam_parent_role= 30; 513 | sim_objintparam_manipulation_permissions= 31; 514 | sim_objintparam_illumination_handle= 32; 515 | 516 | sim_visionfloatparam_near_clipping= 1000; 517 | sim_visionfloatparam_far_clipping= 1001; 518 | sim_visionintparam_resolution_x= 1002; 519 | sim_visionintparam_resolution_y= 1003; 520 | sim_visionfloatparam_perspective_angle= 1004; 521 | sim_visionfloatparam_ortho_size= 1005; 522 | sim_visionintparam_disabled_light_components= 1006; 523 | sim_visionintparam_rendering_attributes= 1007; 524 | sim_visionintparam_entity_to_render= 1008; 525 | sim_visionintparam_windowed_size_x= 1009; 526 | sim_visionintparam_windowed_size_y= 1010; 527 | sim_visionintparam_windowed_pos_x= 1011; 528 | sim_visionintparam_windowed_pos_y= 1012; 529 | sim_visionintparam_pov_focal_blur= 1013; 530 | sim_visionfloatparam_pov_blur_distance= 1014; 531 | sim_visionfloatparam_pov_aperture= 1015; 532 | sim_visionintparam_pov_blur_sampled= 1016; 533 | sim_visionintparam_render_mode= 1017; 534 | 535 | sim_jointintparam_motor_enabled= 2000; 536 | sim_jointintparam_ctrl_enabled= 2001; 537 | sim_jointfloatparam_pid_p= 2002; 538 | sim_jointfloatparam_pid_i= 2003; 539 | sim_jointfloatparam_pid_d= 2004; 540 | sim_jointfloatparam_intrinsic_x= 2005; 541 | sim_jointfloatparam_intrinsic_y= 2006; 542 | sim_jointfloatparam_intrinsic_z= 2007; 543 | sim_jointfloatparam_intrinsic_qx= 2008; 544 | sim_jointfloatparam_intrinsic_qy= 2009; 545 | sim_jointfloatparam_intrinsic_qz= 2010; 546 | sim_jointfloatparam_intrinsic_qw= 2011; 547 | sim_jointfloatparam_velocity= 2012; 548 | sim_jointfloatparam_spherical_qx= 2013; 549 | sim_jointfloatparam_spherical_qy= 2014; 550 | sim_jointfloatparam_spherical_qz= 2015; 551 | sim_jointfloatparam_spherical_qw= 2016; 552 | sim_jointfloatparam_upper_limit= 2017; 553 | sim_jointfloatparam_kc_k= 2018; 554 | sim_jointfloatparam_kc_c= 2019; 555 | sim_jointfloatparam_ik_weight= 2021; 556 | sim_jointfloatparam_error_x= 2022; 557 | sim_jointfloatparam_error_y= 2023; 558 | sim_jointfloatparam_error_z= 2024; 559 | sim_jointfloatparam_error_a= 2025; 560 | sim_jointfloatparam_error_b= 2026; 561 | sim_jointfloatparam_error_g= 2027; 562 | sim_jointfloatparam_error_pos= 2028; 563 | sim_jointfloatparam_error_angle= 2029; 564 | sim_jointintparam_velocity_lock= 2030; 565 | sim_jointintparam_vortex_dep_handle= 2031; 566 | sim_jointfloatparam_vortex_dep_multiplication= 2032; 567 | sim_jointfloatparam_vortex_dep_offset= 2033; 568 | 569 | sim_shapefloatparam_init_velocity_x= 3000; 570 | sim_shapefloatparam_init_velocity_y= 3001; 571 | sim_shapefloatparam_init_velocity_z= 3002; 572 | sim_shapeintparam_static= 3003; 573 | sim_shapeintparam_respondable= 3004; 574 | sim_shapefloatparam_mass= 3005; 575 | sim_shapefloatparam_texture_x= 3006; 576 | sim_shapefloatparam_texture_y= 3007; 577 | sim_shapefloatparam_texture_z= 3008; 578 | sim_shapefloatparam_texture_a= 3009; 579 | sim_shapefloatparam_texture_b= 3010; 580 | sim_shapefloatparam_texture_g= 3011; 581 | sim_shapefloatparam_texture_scaling_x= 3012; 582 | sim_shapefloatparam_texture_scaling_y= 3013; 583 | sim_shapeintparam_culling= 3014; 584 | sim_shapeintparam_wireframe= 3015; 585 | sim_shapeintparam_compound= 3016; 586 | sim_shapeintparam_convex= 3017; 587 | sim_shapeintparam_convex_check= 3018; 588 | sim_shapeintparam_respondable_mask= 3019; 589 | sim_shapefloatparam_init_velocity_a= 3020; 590 | sim_shapefloatparam_init_velocity_b= 3021; 591 | sim_shapefloatparam_init_velocity_g= 3022; 592 | sim_shapestringparam_color_name= 3023; 593 | sim_shapeintparam_edge_visibility= 3024; 594 | sim_shapefloatparam_shading_angle= 3025; 595 | sim_shapefloatparam_edge_angle= 3026; 596 | sim_shapeintparam_edge_borders_hidden= 3027; 597 | 598 | sim_proxintparam_ray_invisibility= 4000; 599 | 600 | sim_forcefloatparam_error_x= 5000; 601 | sim_forcefloatparam_error_y= 5001; 602 | sim_forcefloatparam_error_z= 5002; 603 | sim_forcefloatparam_error_a= 5003; 604 | sim_forcefloatparam_error_b= 5004; 605 | sim_forcefloatparam_error_g= 5005; 606 | sim_forcefloatparam_error_pos= 5006; 607 | sim_forcefloatparam_error_angle= 5007; 608 | 609 | sim_lightintparam_pov_casts_shadows= 8000; 610 | 611 | sim_cameraintparam_disabled_light_components= 9000; 612 | sim_camerafloatparam_perspective_angle= 9001; 613 | sim_camerafloatparam_ortho_size= 9002; 614 | sim_cameraintparam_rendering_attributes= 9003; 615 | sim_cameraintparam_pov_focal_blur= 9004; 616 | sim_camerafloatparam_pov_blur_distance= 9005; 617 | sim_camerafloatparam_pov_aperture= 9006; 618 | sim_cameraintparam_pov_blur_samples= 9007; 619 | 620 | sim_dummyintparam_link_type= 10000; 621 | 622 | sim_mirrorfloatparam_width= 12000; 623 | sim_mirrorfloatparam_height= 12001; 624 | sim_mirrorfloatparam_reflectance= 12002; 625 | sim_mirrorintparam_enable= 12003; 626 | 627 | sim_pplanfloatparam_x_min= 20000; 628 | sim_pplanfloatparam_x_range= 20001; 629 | sim_pplanfloatparam_y_min= 20002; 630 | sim_pplanfloatparam_y_range= 20003; 631 | sim_pplanfloatparam_z_min= 20004; 632 | sim_pplanfloatparam_z_range= 20005; 633 | sim_pplanfloatparam_delta_min= 20006; 634 | sim_pplanfloatparam_delta_range= 20007; 635 | 636 | sim_mplanintparam_nodes_computed= 25000; 637 | sim_mplanintparam_prepare_nodes= 25001; 638 | sim_mplanintparam_clear_nodes= 25002; 639 | 640 | % User interface elements 641 | sim_gui_menubar =1; 642 | sim_gui_popups =2; 643 | sim_gui_toolbar1 =4; 644 | sim_gui_toolbar2 =8; 645 | sim_gui_hierarchy =16; 646 | sim_gui_infobar =32; 647 | sim_gui_statusbar =64; 648 | sim_gui_scripteditor =128; 649 | sim_gui_scriptsimulationparameters =256; 650 | sim_gui_dialogs =512; 651 | sim_gui_browser =1024; 652 | sim_gui_all =65535; 653 | 654 | 655 | % Joint modes 656 | sim_jointmode_passive =0; 657 | sim_jointmode_motion =1; 658 | sim_jointmode_ik =2; 659 | sim_jointmode_ikdependent =3; 660 | sim_jointmode_dependent =4; 661 | sim_jointmode_force =5; 662 | 663 | 664 | % Navigation and selection modes with the mouse. 665 | sim_navigation_passive =0; 666 | sim_navigation_camerashift =1; 667 | sim_navigation_camerarotate =2; 668 | sim_navigation_camerazoom =3; 669 | sim_navigation_cameratilt =4; 670 | sim_navigation_cameraangle =5; 671 | sim_navigation_camerafly =6; 672 | sim_navigation_objectshift =7; 673 | sim_navigation_objectrotate =8; 674 | sim_navigation_reserved2 =9; 675 | sim_navigation_reserved3 =10; 676 | sim_navigation_jointpathtest =11; 677 | sim_navigation_ikmanip =12; 678 | sim_navigation_objectmultipleselection =13; 679 | 680 | sim_navigation_reserved4 =256; 681 | sim_navigation_clickselection =512; 682 | sim_navigation_ctrlselection =1024; 683 | sim_navigation_shiftselection =2048; 684 | sim_navigation_camerazoomwheel =4096; 685 | sim_navigation_camerarotaterightbutton =8192; 686 | 687 | 688 | % Remote API message header structure 689 | simx_headeroffset_crc =0; 690 | simx_headeroffset_version =2; 691 | simx_headeroffset_message_id =3; 692 | simx_headeroffset_client_time =7; 693 | simx_headeroffset_server_time =11; 694 | simx_headeroffset_scene_id =15; 695 | simx_headeroffset_server_state =17; 696 | 697 | % Remote API command header 698 | simx_cmdheaderoffset_mem_size =0; 699 | simx_cmdheaderoffset_full_mem_size =4; 700 | simx_cmdheaderoffset_pdata_offset0 =8; 701 | simx_cmdheaderoffset_pdata_offset1 =10; 702 | simx_cmdheaderoffset_cmd =14; 703 | simx_cmdheaderoffset_delay_or_split =18; 704 | simx_cmdheaderoffset_sim_time =20; 705 | simx_cmdheaderoffset_status =24; 706 | simx_cmdheaderoffset_reserved =25; 707 | 708 | 709 | % Regular operation modes 710 | simx_opmode_oneshot =0; 711 | simx_opmode_blocking =65536; 712 | simx_opmode_oneshot_wait =65536; 713 | simx_opmode_continuous =131072; 714 | simx_opmode_streaming =131072; 715 | 716 | % Operation modes for heavy data 717 | simx_opmode_oneshot_split =196608; 718 | simx_opmode_continuous_split =262144; 719 | simx_opmode_streaming_split =262144; 720 | 721 | % Special operation modes 722 | simx_opmode_discontinue =327680; 723 | simx_opmode_buffer =393216; 724 | simx_opmode_remove =458752; 725 | 726 | 727 | % Command return codes 728 | simx_return_ok =0; 729 | simx_return_novalue_flag =1; 730 | simx_return_timeout_flag =2; 731 | simx_return_illegal_opmode_flag =4; 732 | simx_return_remote_error_flag =8; 733 | simx_return_split_progress_flag =16; 734 | simx_return_local_error_flag =32; 735 | simx_return_initialize_error_flag =64; 736 | 737 | % Following for backward compatibility (same as above) 738 | simx_error_noerror =0; 739 | simx_error_novalue_flag =1; 740 | simx_error_timeout_flag =2; 741 | simx_error_illegal_opmode_flag =4; 742 | simx_error_remote_error_flag =8; 743 | simx_error_split_progress_flag =16; 744 | simx_error_local_error_flag =32; 745 | simx_error_initialize_error_flag =64; 746 | 747 | end 748 | methods 749 | 750 | %constructor 751 | function obj = remApi(libname,hfile) 752 | obj.libName = libname; 753 | %fprintf('Running Matlab %s\n',computer('arch')); 754 | disp('Note: always make sure you use the corresponding remoteApi library'); 755 | disp('(i.e. 32bit Matlab will not work with 64bit remoteApi, and vice-versa)'); 756 | if ~libisloaded(obj.libName) 757 | if exist('hfile','var') 758 | obj.hFile = hfile; 759 | loadlibrary(obj.libName,obj.hFile); 760 | else 761 | loadlibrary(obj.libName,@remoteApiProto); 762 | end 763 | end 764 | end 765 | 766 | %destructor 767 | 768 | function delete(obj) 769 | % we keep the library in memory for now unloadlibrary(obj.libName); 770 | end 771 | 772 | 773 | %api methods 774 | 775 | function [rtn] = simxStart(obj,server,port,waitUntilConnected,doNotReconnectOnceDisconnected,timeOutInMs,commThreadCycleInMs) 776 | server_intval = int8([server,0]); 777 | server_ptr = libpointer('int8Ptr',server_intval); 778 | rtn = calllib(obj.libName,'simxStart',server_ptr,port,uint8(waitUntilConnected),uint8(doNotReconnectOnceDisconnected),timeOutInMs,commThreadCycleInMs); 779 | end 780 | 781 | function simxFinish(obj,clientID) 782 | calllib(obj.libName,'simxFinish',clientID); 783 | end 784 | 785 | function rtn = simxAddStatusbarMessage(obj,clientID,message,operationmode) 786 | message_ = libpointer('int8Ptr',[int8(message) 0]); 787 | operationmode_ = int32(operationmode); 788 | 789 | [rtn message_] = calllib(obj.libName,'simxAddStatusbarMessage',clientID,message_,operationmode_); 790 | end 791 | 792 | function rtn = simxAuxiliaryConsoleClose(obj,clientID,console, operationmode) 793 | console_ = int32(console); 794 | operationmode_ = int32(operationmode); 795 | 796 | rtn = calllib(obj.libName,'simxAuxiliaryConsoleClose',clientID,console_,operationmode_) 797 | end 798 | 799 | function rtn = simxAuxiliaryConsolePrint(obj,clientID,console,text,operationmode) 800 | console_ = int32(console); 801 | operationmode_ = int32(operationmode); 802 | 803 | if text 804 | text_ = libpointer('int8Ptr',[int8(text) 0]); 805 | else 806 | text_ = []; 807 | end 808 | 809 | rtn = calllib(obj.libName,'simxAuxiliaryConsolePrint',clientID,console_,text_,operationmode_); 810 | end 811 | 812 | function rtn = simxAuxiliaryConsoleShow(obj,clientID,consoleHandle,showState,operationMode) 813 | consoleHandle_ = int32(consoleHandle); 814 | showState_ = uint8(showState); 815 | operationMode_ = int32(operationMode); 816 | 817 | rtn = calllib(obj.libName,'simxAuxiliaryConsoleShow',clientID,consoleHandle_,showState_,operationMode_); 818 | end 819 | 820 | function rtn = simxBreakForceSensor(obj,clientID,forceSensorHandle,operationMode) 821 | forceSensorHandle_ = int32(forceSensorHandle); 822 | operationMode_ = int32(operationMode); 823 | 824 | rtn = calllib(obj.libName, 'simxBreakForceSensor',clientID,forceSensorHandle_,operationMode_); 825 | end 826 | 827 | function rtn = simxClearFloatSignal(obj,clientID,signalName,operationMode) 828 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 829 | operationMode_ = int32(operationMode); 830 | 831 | rtn = calllib(obj.libName,'simxClearFloatSignal',clientID,signalName_,operationMode_); 832 | end 833 | 834 | function rtn = simxClearIntegerSignal(obj,clientID,signalName,operationMode) 835 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 836 | operationMode_ = int32(operationMode); 837 | 838 | rtn = calllib(obj.libName,'simxClearIntegerSignal',clientID,signalName_,operationMode_); 839 | end 840 | 841 | function rtn = simxClearStringSignal(obj,clientID,signalName,operationMode) 842 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 843 | operationMode_ = int32(operationMode); 844 | 845 | rtn = calllib(obj.libName,'simxClearStringSignal',clientID,signalName_,operationMode_); 846 | end 847 | 848 | function rtn = simxCloseScene(obj,clientID,operationMode) 849 | operationMode_ = int32(operationMode); 850 | 851 | rtn = calllib(obj.libName,'simxCloseScene',clientID,operationMode_); 852 | end 853 | 854 | function [rtn newObjectHandles] = simxCopyPasteObjects(obj,clientID,objectHandles,operationMode) 855 | objectHandles_ = libpointer('int32Ptr',int32(objectHandles)); 856 | objectCount_ = int32(numel(objectHandles)); 857 | newObjectHandles_ = libpointer('int32Ptr',[]); 858 | newObjectCount_ = libpointer('int32Ptr',int32(0)); 859 | operationMode_ = int32(operationMode); 860 | 861 | [rtn objectHandles_ newObjectHandles_ newObjectCount_] = calllib(obj.libName,'simxCopyPasteObjects',clientID,objectHandles_,objectCount_,newObjectHandles_,newObjectCount_,operationMode_); 862 | 863 | if (rtn==0)&&(newObjectCount_>0) 864 | newObjectHandles = zeros(1,newObjectCount_); 865 | newObjectHandles_.setdatatype('int32Ptr',1,newObjectCount_); 866 | for i=1:newObjectCount_; 867 | newObjectHandles(i) = newObjectHandles_.value(i); 868 | end 869 | else 870 | newObjectHandles=[]; 871 | end 872 | end 873 | 874 | function buffer = simxCreateBuffer(obj,bufferSize) 875 | bufferSize_ = int32(bufferSize); 876 | 877 | buffer = calllib(obj.libName,'simxCreateBuffer',bufferSize_); 878 | end 879 | 880 | function rtn = simxEndDialog(obj,clientID,dialogHandle,operationMode) 881 | operationMode_ = int32(operationMode); 882 | dialogHandle_ = int32(dialogHandle); 883 | 884 | rtn = calllib(obj.libName,'simxEndDialog',clientID,dialogHandle_,operationMode_); 885 | end 886 | 887 | function rtn = simxEraseFile(obj,clientID,fileName_serverSide,operationMode) 888 | fileName_serverSide_ = libpointer('int8Ptr',[int8(fileName_serverSide) 0]); 889 | operationMode_ = int32(operationMode); 890 | 891 | [rtn fileName_serverSide_] = calllib(obj.libName,'simxEraseFile',clientID,fileName_serverSide_,operationMode_); 892 | end 893 | 894 | function [rtn paramValues ]= simxGetArrayParameter(obj,clientID,paramIdentifier,operationMode) 895 | paramIdentifier_ = int32(paramIdentifier); 896 | operationMode_ = int32(operationMode); 897 | paramValues = libpointer('singlePtr',single([0 0 0])); 898 | 899 | [rtn paramValues] = calllib(obj.libName,'simxGetArrayParameter',clientID,paramIdentifier_,paramValues ,operationMode_); 900 | end 901 | 902 | function [rtn paramValues ]= simxGetBooleanParameter(obj,clientID,paramIdentifier,operationMode) 903 | paramIdentifier_ = int32(paramIdentifier); 904 | operationMode_ = int32(operationMode); 905 | paramValues = libpointer('uint8Ptr',uint8(0)); 906 | 907 | [rtn paramValues] = calllib(obj.libName,'simxGetBooleanParameter',clientID,paramIdentifier_,paramValues ,operationMode_); 908 | end 909 | 910 | function [rtn handle] = simxGetCollisionHandle(obj,clientID,collisionObjectName,operationMode) 911 | collisionObjectName_ = libpointer('int8Ptr',[int8(collisionObjectName) 0]); 912 | handle_ = libpointer('int32Ptr',int32(0)); 913 | operationMode_ = int32(operationMode); 914 | 915 | [rtn collisionObjectName_ handle] = calllib(obj.libName,'simxGetCollisionHandle',clientID,collisionObjectName_,handle_ ,operationMode_); 916 | end 917 | 918 | function [rtn handle] = simxGetCollectionHandle(obj,clientID,collectionName,operationMode) 919 | collectionName_ = libpointer('int8Ptr',[int8(collectionName) 0]); 920 | handle_ = libpointer('int32Ptr',int32(0)); 921 | operationMode_ = int32(operationMode); 922 | 923 | [rtn collectionName_ handle] = calllib(obj.libName,'simxGetCollectionHandle',clientID,collectionName_,handle_ ,operationMode_); 924 | end 925 | 926 | function rtn = simxGetConnectionId(obj,clientID) 927 | rtn = calllib(obj.libName,'simxGetConnectionId',clientID); 928 | end 929 | 930 | function [rtn inputText]= simxGetDialogInput(obj,clientID,dialogHandle,operationMode) 931 | dialogHandle_ = int32(dialogHandle); 932 | inputText_ = libpointer('int8PtrPtr'); 933 | operationMode_ = int32(operationMode); 934 | 935 | [rtn inputText_ ] = calllib(obj.libName,'simxGetDialogInput',clientID,dialogHandle_,inputText_,operationMode_); 936 | 937 | if (rtn==0) 938 | s=1; 939 | inputText_.setdatatype('int8Ptr',1,s); 940 | value = inputText_.value(s); 941 | while(value ~= 0) 942 | inputText_.setdatatype('int8Ptr',1,s); 943 | value = inputText_.value(s); 944 | s=s+1; 945 | end 946 | tmp = inputText_.value(1:s-1); 947 | inputText = char(tmp); 948 | else 949 | inputText = []; 950 | end 951 | end 952 | 953 | function [rtn result]= simxGetDialogResult (obj,clientID,dialogHandle,operationMode) 954 | dialogHandle_ = int32(dialogHandle); 955 | result = libpointer('int32Ptr',int32(0)); 956 | operationMode_ = int32(operationMode); 957 | 958 | [rtn result] = calllib(obj.libName,'simxGetDialogResult',clientID,dialogHandle_,result,operationMode_); 959 | end 960 | 961 | function [rtn handle] = simxGetDistanceHandle(obj,clientID,distanceObjectName,operationMode) 962 | distanceObjectName_ = libpointer('int8Ptr',[int8(distanceObjectName) 0]); 963 | handle_ = libpointer('int32Ptr',int32(0)); 964 | operationMode_ = int32(operationMode); 965 | 966 | [rtn distanceObjectName_ handle] = calllib(obj.libName,'simxGetDistanceHandle',clientID,distanceObjectName_,handle_ ,operationMode_); 967 | end 968 | 969 | function [rtn paramValue]= simxGetFloatingParameter(obj,clientID,paramIdentifier,operationMode) 970 | paramIdentifier_ = int32(paramIdentifier); 971 | operationMode_ = int32(operationMode); 972 | paramValue = libpointer('singlePtr',single(0)); 973 | 974 | [rtn paramValue] = calllib(obj.libName,'simxGetFloatingParameter',clientID,paramIdentifier_,paramValue,operationMode_); 975 | end 976 | 977 | function [rtn signalValue]= simxGetFloatSignal(obj,clientID,signalName,operationMode) 978 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 979 | signalValue = libpointer('singlePtr',single(0)); 980 | operationMode_ = int32(operationMode); 981 | 982 | [rtn signalName_ signalValue] = calllib(obj.libName,'simxGetFloatSignal',clientID,signalName_,signalValue,operationMode_); 983 | end 984 | 985 | function [rtn info]= simxGetInMessageInfo(obj,clientID,infoType) 986 | infoType_ = int32(infoType); 987 | info = libpointer('int32Ptr',int32(0)); 988 | 989 | [rtn info] = calllib(obj.libName,'simxGetInMessageInfo',clientID,infoType_,info); 990 | end 991 | 992 | function [rtn paramValue]= simxGetIntegerParameter (obj,clientID,paramIdentifier,operationMode) 993 | paramIdentifier_ = int32(paramIdentifier); 994 | operationMode_ = int32(operationMode); 995 | paramValue = libpointer('int32Ptr',int32(0)); 996 | 997 | [rtn paramValue] = calllib(obj.libName,'simxGetIntegerParameter',clientID,paramIdentifier_,paramValue,operationMode_); 998 | end 999 | 1000 | function [rtn signalValue]= simxGetIntegerSignal(obj,clientID,signalName,operationMode) 1001 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 1002 | signalValue = libpointer('int32Ptr',int32(0)); 1003 | operationMode_ = int32(operationMode); 1004 | 1005 | [rtn signalName signalValue] = calllib(obj.libName,'simxGetIntegerSignal',clientID,signalName_,signalValue,operationMode_); 1006 | end 1007 | 1008 | function [rtn matrix] = simxGetJointMatrix(obj,clientID,jointHandle,operationMode) 1009 | jointHandle_ = int32(jointHandle); 1010 | matrix = libpointer('singlePtr',single([0 0 0 0 0 0 0 0 0 0 0 0])); 1011 | operationMode_ = int32(operationMode); 1012 | 1013 | [rtn matrix ] = calllib(obj.libName,'simxGetJointMatrix',clientID,jointHandle_,matrix, operationMode_); 1014 | end 1015 | 1016 | function [rtn position] = simxGetJointPosition(obj,clientID,handle,option) 1017 | handle_ = int32(handle); 1018 | option_ = int32(option); 1019 | 1020 | [rtn position] = calllib(obj.libName,'simxGetJointPosition',clientID,handle_,single(43),option_); 1021 | end 1022 | 1023 | function rtn = simxGetLastCmdTime(obj,clientID) 1024 | rtn = calllib(obj.libName,'simxGetLastCmdTime',clientID); 1025 | end 1026 | 1027 | function [rtn errorStrings]= simxGetLastErrors(obj,clientID,operationMode) 1028 | errorCnt = libpointer('int32Ptr',int32(0)); 1029 | errorStrings_ = libpointer('int8PtrPtr'); 1030 | operationMode_ = int32(operationMode); 1031 | 1032 | [rtn errorCnt errorStrings_ ] = calllib(obj.libName,'simxGetLastErrors',clientID,errorCnt,errorStrings_,operationMode_); 1033 | 1034 | if (rtn==0) 1035 | errorStrings = cell(double(errorCnt)); 1036 | s=1; 1037 | for i=1:errorCnt 1038 | begin = s; 1039 | errorStrings_.setdatatype('int8Ptr',1,s); 1040 | value = errorStrings_.value(s); 1041 | while(value ~= 0) 1042 | errorStrings_.setdatatype('int8Ptr',1,s); 1043 | value = errorStrings_.value(s); 1044 | s=s+1; 1045 | end 1046 | tmp = errorStrings_.value(begin:s-1); 1047 | errorStrings(i) = cellstr(char(tmp)); 1048 | end 1049 | else 1050 | errorStrings=[]; 1051 | end 1052 | end 1053 | 1054 | function [rtn prop] = simxGetModelProperty(obj,clientID,objectHandle,operationMode) 1055 | objectHandle_ = int32(objectHandle); 1056 | operationMode_ = int32(operationMode); 1057 | prop = libpointer('int32Ptr',int32(0)); 1058 | 1059 | [rtn prop ] = calllib(obj.libName,'simxGetModelProperty',clientID,objectHandle_,prop,operationMode_); 1060 | end 1061 | 1062 | function [rtn childObjectHandle] = simxGetObjectChild(obj,clientID,parentObjectHandle,childIndex,operationMode) 1063 | parentObjectHandle_ = int32(parentObjectHandle); 1064 | childIndex_ = int32(childIndex); 1065 | childObjectHandle = libpointer('int32Ptr',int32(0)); 1066 | operationMode_ = int32(operationMode); 1067 | 1068 | [rtn childObjectHandle ] = calllib(obj.libName,'simxGetObjectChild',clientID,parentObjectHandle_,childIndex_,childObjectHandle,operationMode_); 1069 | end 1070 | 1071 | function [rtn paramValue]= simxGetObjectFloatParameter(obj,clientID,objectHandle,parameterID,operationMode) 1072 | objectHandle_ = int32(objectHandle); 1073 | parameterID_ = int32(parameterID); 1074 | operationMode_ = int32(operationMode); 1075 | paramValue = libpointer('singlePtr',single(0)); 1076 | 1077 | [rtn paramValue] = calllib(obj.libName,'simxGetObjectFloatParameter',clientID,objectHandle_,parameterID_,paramValue,operationMode_); 1078 | end 1079 | 1080 | function [rtn handle] = simxGetObjectHandle(obj,clientID,name,operationmode) 1081 | name_ptr = libpointer('int8Ptr',[uint8(name) 0]); 1082 | handle_ptr = libpointer('int32Ptr',int32(0)); 1083 | operationmode_ = int32(operationmode); 1084 | 1085 | [rtn name_ptr handle] = calllib(obj.libName,'simxGetObjectHandle',clientID,name_ptr,handle_ptr,operationmode_); 1086 | end 1087 | 1088 | function [rtn paramValue]= simxGetObjectIntParameter(obj,clientID,objectHandle,parameterID,operationMode) 1089 | objectHandle_ = int32(objectHandle); 1090 | parameterID_ = int32(parameterID); 1091 | operationMode_ = int32(operationMode); 1092 | paramValue = libpointer('int32Ptr',int32(0)); 1093 | 1094 | [rtn paramValue] = calllib(obj.libName,'simxGetObjectIntParameter',clientID,objectHandle_,parameterID_,paramValue,operationMode_); 1095 | end 1096 | 1097 | function [rtn eulerAngles] = simxGetObjectOrientation(obj,clientID,objectHandle,relativeToObjectHandle,operationMode) 1098 | objectHandle_ = int32(objectHandle); 1099 | relativeToObjectHandle_ = int32(relativeToObjectHandle); 1100 | operationMode_ = int32(operationMode); 1101 | eulerAngles = libpointer('singlePtr', single([0 0 0])); 1102 | 1103 | [rtn eulerAngles] = calllib(obj.libName,'simxGetObjectOrientation',clientID,objectHandle_,relativeToObjectHandle_,eulerAngles ,operationMode_); 1104 | end 1105 | 1106 | function [rtn quaternion_coeffs] = simxGetObjectQuaternion(obj,clientID,objectHandle,relativeToObjectHandle,operationMode) 1107 | objectHandle_ = int32(objectHandle); 1108 | relativeToObjectHandle_ = int32(relativeToObjectHandle); 1109 | operationMode_ = int32(operationMode); 1110 | quaternion_coeffs = libpointer('singlePtr', single([0 0 0 0])); 1111 | 1112 | [rtn quaternion_coeffs] = calllib(obj.libName,'simxGetObjectQuaternion',clientID,objectHandle_,relativeToObjectHandle_,quaternion_coeffs ,operationMode_); 1113 | end 1114 | 1115 | function [rtn parentObjectHandle] = simxGetObjectParent(obj,clientID,objectHandle,operationMode) 1116 | objectHandle_ = int32(objectHandle); 1117 | parentObjectHandle = libpointer('int32Ptr',int32(0)); 1118 | operationMode_ = int32(operationMode); 1119 | 1120 | [rtn parentObjectHandle] = calllib(obj.libName,'simxGetObjectParent',clientID,objectHandle_,parentObjectHandle,operationMode); 1121 | end 1122 | 1123 | function [rtn position] = simxGetObjectPosition(obj,clientID,objectHandle,relativeToObjectHandle,operationMode) 1124 | objectHandle_ = int32(objectHandle); 1125 | relativeToObjectHandle_ = int32(relativeToObjectHandle); 1126 | operationMode_ = int32(operationMode); 1127 | position = libpointer('singlePtr', single([0 0 0])); 1128 | 1129 | [rtn position] = calllib(obj.libName,'simxGetObjectPosition',clientID,objectHandle_,relativeToObjectHandle_,position ,operationMode_); 1130 | end 1131 | 1132 | function [rtn objectHandles] = simxGetObjects(obj,clientID,objectType,operationMode) 1133 | objectType_ = int32(objectType); 1134 | objectHandles_ = libpointer('int32PtrPtr'); 1135 | objectCount = libpointer('int32Ptr',int32(0)); 1136 | operationMode_ = int32(operationMode); 1137 | 1138 | [rtn objectCount objectHandles_] = calllib(obj.libName,'simxGetObjects',clientID,objectType_,objectCount,objectHandles_,operationMode_); 1139 | 1140 | if (rtn==0) 1141 | if(objectCount > 0 ) 1142 | objectHandles_.setdatatype('int32Ptr',1,objectCount); 1143 | objectHandles = objectHandles_.value; 1144 | else 1145 | objectHandles = []; 1146 | end 1147 | else 1148 | objectHandles = []; 1149 | end 1150 | end 1151 | 1152 | function [rtn objectHandles ] = simxGetObjectSelection(obj,clientID,operationMode) 1153 | objectHandles_ = libpointer('int32PtrPtr'); 1154 | objectCount = libpointer('int32Ptr',int32(0)); 1155 | operationMode_ = int32(operationMode); 1156 | 1157 | [rtn objectHandles_ objectCount] = calllib(obj.libName,'simxGetObjectSelection',clientID,objectHandles_ ,objectCount,operationMode_); 1158 | 1159 | if (rtn==0) 1160 | if(objectCount > 0) 1161 | objectHandles_.setdatatype('int32Ptr',1,objectCount); 1162 | objectHandles = objectHandles_.value; 1163 | else 1164 | objectHandles = []; 1165 | end 1166 | else 1167 | objectHandles = []; 1168 | end 1169 | end 1170 | 1171 | function [rtn info]= simxGetOutMessageInfo(obj,clientID,infoType) 1172 | infoType_ = int32(infoType); 1173 | info = libpointer('int32Ptr',int32(0)); 1174 | 1175 | [rtn info] = calllib(obj.libName,'simxGetOutMessageInfo',clientID,infoType_,info); 1176 | end 1177 | 1178 | function [rtn pingTime]= simxGetPingTime(obj,clientID) 1179 | pingTime = libpointer('int32Ptr',int32(0)); 1180 | 1181 | [rtn pingTime] = calllib(obj.libName,'simxGetPingTime',clientID,pingTime); 1182 | end 1183 | 1184 | function [rtn paramValue]= simxGetStringParameter(obj,clientID,paramIdentifier,operationMode) 1185 | paramIdentifier_ = int32(paramIdentifier); 1186 | operationMode_ = int32(operationMode); 1187 | paramValue_ = libpointer('int8PtrPtr'); 1188 | 1189 | [rtn paramValue_] = calllib(obj.libName,'simxGetStringParameter',clientID,paramIdentifier_,paramValue_,operationMode_); 1190 | 1191 | if(rtn == 0) 1192 | s=1; 1193 | paramValue_.setdatatype('int8Ptr',1,s); 1194 | value = paramValue_.value(s); 1195 | while(value ~= 0) 1196 | paramValue_.setdatatype('int8Ptr',1,s); 1197 | value = paramValue_.value(s); 1198 | s=s+1; 1199 | end 1200 | tmp = paramValue_.value(1:s-1); 1201 | paramValue = char(tmp); 1202 | else 1203 | paramValue = []; 1204 | end 1205 | end 1206 | 1207 | function [rtn signalValue ]= simxGetStringSignal(obj,clientID,signalName,operationMode) 1208 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 1209 | signalValue_ = libpointer('uint8PtrPtr'); 1210 | signalLength= libpointer('int32Ptr',int32(0)); 1211 | operationMode_ = int32(operationMode); 1212 | 1213 | [rtn signalName_ signalValue_ signalLength ] = calllib(obj.libName,'simxGetStringSignal',clientID,signalName_,signalValue_,signalLength ,operationMode_); 1214 | 1215 | if (rtn==0) 1216 | if (signalLength>0) 1217 | signalValue_.setdatatype('uint8Ptr',1,double(signalLength)); 1218 | signalValue = char(signalValue_.value); 1219 | else 1220 | signalValue = []; 1221 | end 1222 | else 1223 | signalValue = []; 1224 | end 1225 | end 1226 | 1227 | function [rtn signalValue ]= simxGetAndClearStringSignal(obj,clientID,signalName,operationMode) 1228 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 1229 | signalValue_ = libpointer('uint8PtrPtr'); 1230 | signalLength= libpointer('int32Ptr',int32(0)); 1231 | operationMode_ = int32(operationMode); 1232 | 1233 | [rtn signalName_ signalValue_ signalLength ] = calllib(obj.libName,'simxGetAndClearStringSignal',clientID,signalName_,signalValue_,signalLength ,operationMode_); 1234 | 1235 | if (rtn==0) 1236 | if (signalLength>0) 1237 | signalValue_.setdatatype('uint8Ptr',1,double(signalLength)); 1238 | signalValue = char(signalValue_.value); 1239 | else 1240 | signalValue = []; 1241 | end 1242 | else 1243 | signalValue = []; 1244 | end 1245 | end 1246 | 1247 | function [rtn prop] = simxGetUIButtonProperty(obj,clientID,uiHandle,uiButtonID,operationMode) 1248 | uiHandle_ = int32(uiHandle); 1249 | operationMode_ = int32(operationMode); 1250 | uiButtonID_ = int32(uiButtonID); 1251 | prop = libpointer('int32Ptr',int32(0)); 1252 | 1253 | [rtn prop ] = calllib(obj.libName,'simxGetUIButtonProperty',clientID,uiHandle_,uiButtonID_,prop,operationMode_); 1254 | end 1255 | 1256 | function [rtn uiEventButtonID auxValues] = simxGetUIEventButton(obj,clientID,uiHandle,operationMode) 1257 | uiHandle_ = int32(uiHandle); 1258 | operationMode_ = int32(operationMode); 1259 | uiEventButtonID = libpointer('int32Ptr',int32(0)); 1260 | auxValues = libpointer('int32Ptr',int32([0 0])); 1261 | 1262 | [rtn uiEventButtonID auxValues] = calllib(obj.libName,'simxGetUIEventButton',clientID,uiHandle_,uiEventButtonID ,auxValues ,operationMode_); 1263 | end 1264 | 1265 | function [rtn handle] = simxGetUIHandle(obj,clientID,uiName,operationMode) 1266 | uiName_ = libpointer('int8Ptr',[int8(uiName) 0]); 1267 | operationMode_ = int32(operationMode); 1268 | handle = libpointer('int32Ptr',int32(0)); 1269 | 1270 | [rtn uiName handle] = calllib(obj.libName,'simxGetUIHandle',clientID,uiName_,handle,operationMode_); 1271 | end 1272 | 1273 | function [rtn position] = simxGetUISlider(obj,clientID,uiHandle,uiButtonID,operationMode) 1274 | uiHandle_ = int32(uiHandle); 1275 | operationMode_ = int32(operationMode); 1276 | uiButtonID_ = int32(uiButtonID); 1277 | position = libpointer('int32Ptr',int32(0)); 1278 | 1279 | [rtn position ] = calllib(obj.libName,'simxGetUISlider',clientID,uiHandle_,uiButtonID_,position,operationMode_) 1280 | end 1281 | 1282 | function [rtn resolution_ buffer] = simxGetVisionSensorDepthBuffer(obj,clientID,handle,operationmode) 1283 | resolution = [0 0]; 1284 | resolution_ = libpointer('int32Ptr',int32(resolution)); 1285 | buffer = libpointer('singlePtr',[]); 1286 | operationmode_ = int32(operationmode); 1287 | handle_ = int32(handle); 1288 | 1289 | [rtn resolution_ buffer] = calllib(obj.libName,'simxGetVisionSensorDepthBuffer',clientID,handle_,resolution_,buffer,operationmode_); 1290 | end 1291 | 1292 | function [rtn resolution_ buffer] = simxGetVisionSensorDepthBuffer2(obj,clientID,handle,operationmode) 1293 | resolution = [0 0]; 1294 | resolution_ = libpointer('int32Ptr',int32(resolution)); 1295 | buffer_ = libpointer('singlePtr',[]); 1296 | operationmode_ = int32(operationmode); 1297 | handle_ = int32(handle); 1298 | 1299 | [rtn resolution_ buffer_] = calllib(obj.libName,'simxGetVisionSensorDepthBuffer',clientID,handle_,resolution_,buffer_,operationmode_); 1300 | 1301 | if (rtn==0)&(nargout>2) 1302 | if((resolution_(1) ~= 0) && (resolution_(2) ~= 0)) 1303 | buffer_.setdatatype('singlePtr',1,resolution_(1)*resolution_(2)); 1304 | buffer = flipdim(permute(reshape(buffer_.Value, resolution_(1), resolution_(2)), [2 1]), 1); 1305 | end 1306 | else 1307 | buffer = []; 1308 | end 1309 | end 1310 | 1311 | % function [rtn resolution_ buffer] = simxGetVisionSensorDepthBuffer2(obj,clientID,handle,operationmode) 1312 | % resolution = [0 0]; 1313 | % resolution_ = libpointer('int32Ptr',int32(resolution)); 1314 | % buffer_ = libpointer('singlePtr',[]); 1315 | % operationmode_ = int32(operationmode); 1316 | % handle_ = int32(handle); 1317 | % 1318 | % [rtn resolution_ buffer_] = calllib(obj.libName,'simxGetVisionSensorDepthBuffer',clientID,handle_,resolution_,buffer_,operationmode_); 1319 | % 1320 | % if (rtn==0) 1321 | % if((resolution_(1) ~= 0) && (resolution_(2) ~= 0)) 1322 | % buffer_.setdatatype('singlePtr',1,resolution_(1)*resolution_(2)); 1323 | % buffer = zeros(resolution_(1),resolution_(2)); 1324 | % buffer = cast(buffer,'single'); 1325 | % for i = resolution_(1):-1:1; 1326 | % count = (resolution_(1)-i)*resolution_(2); 1327 | % for j = 1:resolution_(2); 1328 | % buffer(i,j) = single(buffer_.value(count+j)); 1329 | % end 1330 | % end 1331 | % end 1332 | % else 1333 | % buffer = []; 1334 | % end 1335 | % end 1336 | 1337 | function [rtn resolution_ image] = simxGetVisionSensorImage(obj,clientID,handle,options,operationmode) 1338 | resolution = [0 0]; 1339 | resolution_ = libpointer('int32Ptr',int32(resolution)); 1340 | image = libpointer('uint8Ptr',[]); 1341 | options_ = uint8(options); 1342 | operationmode_ = int32(operationmode); 1343 | handle_ = int32(handle); 1344 | 1345 | [rtn resolution_ image] = calllib(obj.libName,'simxGetVisionSensorImage',clientID,handle_,resolution_,image,options_,operationmode_); 1346 | end 1347 | 1348 | function [rtn resolution_ image] = simxGetVisionSensorImage2(obj,clientID,handle,options,operationmode) 1349 | resolution = [0 0]; 1350 | resolution_ = libpointer('int32Ptr',int32(resolution)); 1351 | image_ = libpointer('uint8Ptr',[]); 1352 | options_ = uint8(options); 1353 | operationmode_ = int32(operationmode); 1354 | handle_ = int32(handle); 1355 | 1356 | [rtn resolution_ image_] = calllib(obj.libName,'simxGetVisionSensorImage',clientID,handle_,resolution_,image_,options_,operationmode_); 1357 | 1358 | if (rtn==0)&(nargout>2) 1359 | if((resolution_(1) ~= 0) && (resolution_(2) ~= 0)) 1360 | if(options == 1) %grayscale image 1361 | image_.setdatatype('uint8Ptr',1,resolution_(1)*resolution_(2)); 1362 | image = flipdim(permute(reshape(image_.Value, resolution_(1), resolution_(2)), [2 1]), 1); 1363 | else 1364 | image_.setdatatype('uint8Ptr',1,resolution_(1)*resolution_(2)*3); 1365 | image = flipdim(permute(reshape(image_.Value, 3, resolution_(1), resolution_(2)), [3 2 1]), 1); 1366 | end 1367 | end 1368 | else 1369 | image = []; 1370 | end 1371 | end 1372 | 1373 | function [rtn force]= simxJointGetForce(obj,clientID,jointHandle,operationMode) 1374 | jointHandle_ = int32(jointHandle); 1375 | operationMode_ = int32(operationMode); 1376 | force = libpointer('single',single(0)); 1377 | 1378 | [rtn force ] = calllib(obj.libName,'simxGetJointForce',clientID,jointHandle_,single(0),operationMode_); 1379 | end 1380 | 1381 | function [rtn force]= simxGetJointForce(obj,clientID,jointHandle,operationMode) 1382 | jointHandle_ = int32(jointHandle); 1383 | operationMode_ = int32(operationMode); 1384 | force = libpointer('single',single(0)); 1385 | 1386 | [rtn force ] = calllib(obj.libName,'simxGetJointForce',clientID,jointHandle_,single(0),operationMode_); 1387 | end 1388 | 1389 | function [rtn force]= simxGetJointMaxForce(obj,clientID,jointHandle,operationMode) 1390 | jointHandle_ = int32(jointHandle); 1391 | operationMode_ = int32(operationMode); 1392 | force = libpointer('single',single(0)); 1393 | 1394 | [rtn force ] = calllib(obj.libName,'simxGetJointMaxForce',clientID,jointHandle_,single(0),operationMode_); 1395 | end 1396 | 1397 | function [rtn baseHandle]= simxLoadModel(obj,clientID,modelPathAndName,options,operationMode) 1398 | modelPathAndName_ = libpointer('int8Ptr',[int8(modelPathAndName) 0]); 1399 | options_ = uint8(options); 1400 | baseHandle= libpointer('int32Ptr',int32(0)); 1401 | operationMode_ = int32(operationMode); 1402 | 1403 | [rtn modelPathAndName_ baseHandle] = calllib(obj.libName,'simxLoadModel',clientID,modelPathAndName_,options_,baseHandle,operationMode_); 1404 | end 1405 | 1406 | function [rtn ]= simxLoadScene(obj,clientID,scenePathAndName,options,operationMode) 1407 | scenePathAndName_ = libpointer('int8Ptr',[int8(scenePathAndName) 0]); 1408 | options_ = uint8(options); 1409 | operationMode_ = int32(operationMode); 1410 | 1411 | [rtn scenePathAndName_ ] = calllib(obj.libName,'simxLoadScene',clientID,scenePathAndName_,options_,operationMode_); 1412 | end 1413 | 1414 | function [rtn uiHandles] = simxLoadUI(obj,clientID,uiPathAndName,options,operationMode) 1415 | uiPathAndName_ = libpointer('int8Ptr',int8([uiPathAndName 0])); 1416 | options_ = uint8(options); 1417 | count = libpointer('int32Ptr', int32(0)); 1418 | uiHandles_ = libpointer('int32Ptr'); 1419 | operationMode_ = int32(operationMode); 1420 | 1421 | [rtn uiPathAndName_ count uiHandles_ ] = calllib(obj.libName,'simxLoadUI',clientID,uiPathAndName_,options_,count ,uiHandles_ ,operationMode_); 1422 | 1423 | if (rtn==0) 1424 | if(count > 0) 1425 | uiHandles_.setdatatype('int32Ptr',1,count); 1426 | uiHandles = uiHandles_.value; 1427 | else 1428 | uiHandles = []; 1429 | end 1430 | uiHandles_.setdatatype('uint8Ptr',2,2); 1431 | obj.simxReleaseBuffer(uiHandles_); 1432 | else 1433 | uiHandles = []; 1434 | end 1435 | end 1436 | 1437 | function rtn = simxPauseSimulation(obj,clientID,operationMode) 1438 | operationMode_ = int32(operationMode); 1439 | 1440 | rtn = calllib(obj.libName,'simxPauseSimulation',clientID,operationMode_); 1441 | end 1442 | 1443 | function [rtn collisionState]= simxReadCollision(obj,clientID,collisionObjectHandle,operationMode) 1444 | collisionObjectHandle_ = int32(collisionObjectHandle); 1445 | operationMode_ = int32(operationMode); 1446 | collisionState = libpointer('uint8Ptr',uint8(0)); 1447 | 1448 | [rtn collisionState] = calllib(obj.libName,'simxReadCollision',clientID,collisionObjectHandle_,collisionState,operationMode_); 1449 | end 1450 | 1451 | function [rtn minimumDistance]= simxReadDistance(obj,clientID,distanceObjectHandle,operationMode) 1452 | distanceObjectHandle_ = int32(distanceObjectHandle); 1453 | operationMode_ = int32(operationMode); 1454 | minimumDistance = libpointer('singlePtr',single(0)); 1455 | 1456 | [rtn minimumDistance] = calllib(obj.libName,'simxReadDistance',clientID,distanceObjectHandle_,minimumDistance,operationMode_); 1457 | end 1458 | 1459 | function [rtn state forceVector torqueVector]= simxReadForceSensor(obj,clientID,forceSensorHandle,operationMode) 1460 | forceSensorHandle_ = int32(forceSensorHandle); 1461 | state = libpointer('uint8Ptr', uint8(0)); 1462 | forceVector = libpointer('singlePtr', single([0 0 0])); 1463 | torqueVector = libpointer('singlePtr', single([0 0 0])); 1464 | operationMode_ = int32(operationMode); 1465 | 1466 | [rtn state forceVector torqueVector] = calllib(obj.libName,'simxReadForceSensor',clientID,forceSensorHandle_,state ,forceVector, torqueVector,operationMode_); 1467 | end 1468 | 1469 | function [rtn detectionState auxValues auxValuesCount ] = simxReadVisionSensor(obj,clientID,sensorHandle,operationmode) 1470 | detectionState = libpointer('uint8Ptr',uint8(0)); 1471 | auxValues_ = libpointer('singlePtrPtr'); 1472 | auxValuesCount_ = libpointer('int32PtrPtr'); 1473 | operationmode_ = int32(operationmode); 1474 | sensorHandle_ = int32(sensorHandle); 1475 | 1476 | [rtn detectionState auxValues_ auxValuesCount_] = calllib(obj.libName,'simxReadVisionSensor',clientID,sensorHandle_,detectionState ,auxValues_,auxValuesCount_,operationmode_); 1477 | 1478 | auxValues = []; 1479 | auxValuesCount = []; 1480 | if ~isempty(auxValuesCount_), 1481 | if isempty(auxValues_), 1482 | error('Error: auxValues_ is empty (error 0). Please contact Renaud Detry and report exactly this error message.'); 1483 | end 1484 | if rtn == 0, 1485 | auxValuesCount_.setdatatype('int32Ptr',1); 1486 | packets=auxValuesCount_.value(1); 1487 | auxValuesCount_.setdatatype('int32Ptr',packets+1); 1488 | auxValuesCount = auxValuesCount_.Value(2:(packets+1)); 1489 | auxValues_.setdatatype('singlePtr',sum(auxValuesCount)); 1490 | if(rtn == 0)&(nargout>1) 1491 | auxValues = auxValues_.Value'; 1492 | end 1493 | end 1494 | auxValuesCount_.setdatatype('uint8Ptr',2,2); 1495 | auxValues_.setdatatype('uint8Ptr',2,2); 1496 | obj.simxReleaseBuffer(auxValuesCount_); 1497 | obj.simxReleaseBuffer(auxValues_); 1498 | else 1499 | if ~isempty(auxValues_), 1500 | error('Error: auxValues_ is *not* empty (error 1). Please contact Renaud Detry and report exactly this error message.'); 1501 | end 1502 | end 1503 | end 1504 | 1505 | function [] = simxReleaseBuffer(obj,buffer) 1506 | buffer_ = calllib(obj.libName,'simxReleaseBuffer',buffer); 1507 | end 1508 | 1509 | function [rtn ] = simxRemoveObject(obj,clientID,objectHandle,operationMode) 1510 | objectHandle_ = int32(objectHandle); 1511 | operationMode_ = int32(operationMode); 1512 | 1513 | [rtn ] = calllib(obj.libName,'simxRemoveObject',clientID,objectHandle_,operationMode_); 1514 | end 1515 | 1516 | function [rtn ] = simxRemoveModel(obj,clientID,objectHandle,operationMode) 1517 | objectHandle_ = int32(objectHandle); 1518 | operationMode_ = int32(operationMode); 1519 | 1520 | [rtn ] = calllib(obj.libName,'simxRemoveModel',clientID,objectHandle_,operationMode_); 1521 | end 1522 | 1523 | function [rtn ] = simxRemoveUI(obj,clientID,uiHandle,operationMode) 1524 | uiHandle_ = int32(uiHandle); 1525 | operationMode_ = int32(operationMode); 1526 | 1527 | [rtn ] = calllib(obj.libName,'simxRemoveUI',clientID,uiHandle_,operationMode_); 1528 | end 1529 | 1530 | function [rtn ]= simxSetArrayParameter(obj,clientID,paramIdentifier,paramValues,operationMode) 1531 | paramIdentifier_ = int32(paramIdentifier); 1532 | num_ele = numel(paramValues); 1533 | if (num_ele < 3) 1534 | error('paramValues should have 3 values'); 1535 | else 1536 | paramValues_ = libpointer('singlePtr',single(paramValues)); 1537 | operationMode_ = int32(operationMode); 1538 | 1539 | [rtn paramValues_ ] = calllib(obj.libName,'simxSetArrayParameter',clientID,paramIdentifier_,paramValues_,operationMode_); 1540 | end 1541 | end 1542 | 1543 | function [rtn ]= simxSetBooleanParameter(obj,clientID,paramIdentifier,paramValue,operationMode) 1544 | paramIdentifier_ = int32(paramIdentifier); 1545 | paramValue_ = uint8(paramValue); 1546 | operationMode_ = int32(operationMode); 1547 | 1548 | [rtn ] = calllib(obj.libName,'simxSetBooleanParameter',clientID,paramIdentifier_,paramValue_,operationMode_); 1549 | end 1550 | 1551 | function [rtn ]= simxSetIntegerParameter(obj,clientID,paramIdentifier,paramValue,operationMode) 1552 | paramIdentifier_ = int32(paramIdentifier); 1553 | paramValue_ = int32(paramValue); 1554 | operationMode_ = int32(operationMode); 1555 | 1556 | [rtn ] = calllib(obj.libName,'simxSetIntegerParameter',clientID,paramIdentifier_,paramValue_,operationMode_); 1557 | end 1558 | 1559 | function [rtn ]= simxSetIntegerSignal(obj,clientID,signalName,signalValue,operationMode) 1560 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 1561 | signalValue_ = int32(signalValue); 1562 | operationMode_ = int32(operationMode); 1563 | 1564 | [rtn signalName_ ] = calllib(obj.libName,'simxSetIntegerSignal',clientID,signalName_,signalValue_,operationMode_); 1565 | end 1566 | 1567 | function [rtn ]= simxSetModelProperty(obj,clientID,objectHandle,prop,operationMode) 1568 | objectHandle_ = int32(objectHandle); 1569 | prop_ = int32(prop); 1570 | operationMode_ = int32(operationMode); 1571 | 1572 | [rtn ] = calllib(obj.libName,'simxSetModelProperty',clientID,objectHandle_,prop_,operationMode_); 1573 | end 1574 | 1575 | function [rtn ]= simxSetObjectIntParameter(obj,clientID,objectHandle,parameterID,parameterValue,operationMode) 1576 | objectHandle_ = int32(objectHandle); 1577 | parameterID_ = int32(parameterID); 1578 | parameterValue_ = int32(parameterValue); 1579 | operationMode_ = int32(operationMode); 1580 | 1581 | [rtn ] = calllib(obj.libName,'simxSetObjectIntParameter',clientID,objectHandle_,parameterID_,parameterValue_,operationMode_); 1582 | end 1583 | 1584 | function [rtn ]= simxSetObjectOrientation(obj,clientID,objectHandle,relativeToObjectHandle,eulerAngles,operationMode) 1585 | objectHandle_ = int32(objectHandle); 1586 | relativeToObjectHandle_ = int32(relativeToObjectHandle); 1587 | num_ele = numel(eulerAngles); 1588 | if (num_ele < 3) 1589 | error('Euler angles should have 3 values'); 1590 | return; 1591 | else 1592 | eulerAngles_ = libpointer('singlePtr',single(eulerAngles)); 1593 | operationMode_ = int32(operationMode); 1594 | 1595 | [rtn ] = calllib(obj.libName,'simxSetObjectOrientation',clientID,objectHandle_,relativeToObjectHandle_,eulerAngles_,operationMode_); 1596 | end 1597 | end 1598 | 1599 | function [rtn ]= simxSetObjectQuaternion(obj,clientID,objectHandle,relativeToObjectHandle,quaternion_coeffs,operationMode) 1600 | objectHandle_ = int32(objectHandle); 1601 | relativeToObjectHandle_ = int32(relativeToObjectHandle); 1602 | num_ele = numel(quaternion_coeffs); 1603 | if (num_ele < 4) 1604 | error('A quaternion should have 4 values'); 1605 | return; 1606 | else 1607 | quaternion_ = libpointer('singlePtr',single(quaternion_coeffs)); 1608 | operationMode_ = int32(operationMode); 1609 | 1610 | [rtn ] = calllib(obj.libName,'simxSetObjectQuaternion',clientID,objectHandle_,relativeToObjectHandle_,quaternion_,operationMode_); 1611 | end 1612 | end 1613 | 1614 | function [rtn] = simxSetObjectParent(obj,clientID,objectHandle,parentObject,keepInPlace,operationMode) 1615 | objectHandle_ = int32(objectHandle); 1616 | parentObject_ = int32(parentObject); 1617 | keepInPlace_ = uint8(keepInPlace); 1618 | operationMode_ = int32(operationMode); 1619 | 1620 | [rtn ] = calllib(obj.libName,'simxSetObjectParent',clientID,objectHandle_ ,parentObject_,keepInPlace_,operationMode_); 1621 | end 1622 | 1623 | function rtn = simxSetObjectPosition(obj,clientID,handle,rel_pos,position,option) 1624 | if (numel(position) < 3) 1625 | error('position should have 3 values'); 1626 | return; 1627 | end 1628 | 1629 | handle_ = int32(handle); 1630 | rel_pos_ = int32(rel_pos); 1631 | option_ = int32(option); 1632 | pos_ptr = libpointer('singlePtr',single(position)); 1633 | 1634 | [rtn pos_ptr] = calllib(obj.libName,'simxSetObjectPosition',clientID,handle_,rel_pos_,pos_ptr,option_); 1635 | end 1636 | 1637 | function [rtn] = simxSetObjectSelection(obj,clientID,objectHandles,operationMode) 1638 | objectHandles_ = libpointer('int32Ptr',int32(objectHandles)); 1639 | objectCount = numel(objectHandles); 1640 | operationMode_ = int32(operationMode); 1641 | 1642 | [rtn objectHandles_ ] = calllib(obj.libName,'simxSetObjectSelection',clientID,objectHandles_ ,objectCount,operationMode_); 1643 | end 1644 | 1645 | function [rtn ]= simxSetSphericalJointMatrix(obj,clientID,jointHandle,matrix,operationMode) 1646 | jointHandle_ = int32(jointHandle); 1647 | num_ele = numel(matrix); 1648 | if (num_ele < 12) 1649 | error('matrix should have 12 values'); 1650 | return; 1651 | else 1652 | matrix_ = libpointer('singlePtr',single(matrix)); 1653 | operationMode_ = int32(operationMode); 1654 | 1655 | [rtn signalName_ ] = calllib(obj.libName,'simxSetSphericalJointMatrix',clientID,jointHandle_,matrix_,operationMode_); 1656 | end 1657 | end 1658 | 1659 | function [rtn ]= simxSetStringSignal(obj,clientID,signalName,signalValue,operationMode) 1660 | signalLength_ = int32(length(signalValue)); 1661 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 1662 | signalValue_ = libpointer('uint8Ptr',[uint8(signalValue) 0]); 1663 | operationMode_ = int32(operationMode); 1664 | 1665 | [rtn signalName_ signalValue_ ] = calllib(obj.libName,'simxSetStringSignal',clientID,signalName_,signalValue_,signalLength_ ,operationMode_); 1666 | end 1667 | 1668 | function [rtn ]= simxAppendStringSignal(obj,clientID,signalName,signalValue,operationMode) 1669 | signalLength_ = int32(length(signalValue)); 1670 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 1671 | signalValue_ = libpointer('uint8Ptr',[uint8(signalValue) 0]); 1672 | operationMode_ = int32(operationMode); 1673 | 1674 | [rtn signalName_ signalValue_ ] = calllib(obj.libName,'simxAppendStringSignal',clientID,signalName_,signalValue_,signalLength_ ,operationMode_); 1675 | end 1676 | 1677 | function [rtn ] = simxSetUIButtonLabel(obj,clientID,uiHandle,uiButtonID,upStateLabel,downStateLabel,operationMode) 1678 | uiHandle_ = int32(uiHandle); 1679 | operationMode_ = int32(operationMode); 1680 | uiButtonID_ = int32(uiButtonID); 1681 | upStateLabel_ = libpointer('int8Ptr',int8([upStateLabel 0])); 1682 | downStateLabel_ = libpointer('int8Ptr',int8([downStateLabel 0])); 1683 | 1684 | [rtn upStateLabel_ downStateLabel_] = calllib(obj.libName,'simxSetUIButtonLabel',clientID,uiHandle_,uiButtonID_,upStateLabel_,downStateLabel_,operationMode_); 1685 | end 1686 | 1687 | function [rtn ] = simxSetUIButtonProperty(obj,clientID,uiHandle,uiButtonID,prop,operationMode) 1688 | uiHandle_ = int32(uiHandle); 1689 | operationMode_ = int32(operationMode); 1690 | uiButtonID_ = int32(uiButtonID); 1691 | prop_ = int32(prop); 1692 | 1693 | [rtn ] = calllib(obj.libName,'simxSetUIButtonProperty',clientID,uiHandle_,uiButtonID_,prop_,operationMode_); 1694 | end 1695 | 1696 | function [rtn] = simxSetUISlider (obj,clientID,uiHandle,uiButtonID,position,operationMode) 1697 | uiHandle_ = int32(uiHandle); 1698 | operationMode_ = int32(operationMode); 1699 | uiButtonID_ = int32(uiButtonID); 1700 | position_ = int32(position); 1701 | 1702 | [rtn] = calllib(obj.libName,'simxSetUISlider',clientID,uiHandle_,uiButtonID_,position_,operationMode_) 1703 | end 1704 | 1705 | function rtn = simxSetVisionSensorImage(obj,clientID,handle,image,buffsize,options,operationmode) 1706 | handle_ = int32(handle); 1707 | buffsize_ = int32(buffsize); 1708 | options_ = uint8(options); 1709 | operationmode_ = int32(operationmode); 1710 | 1711 | [rtn image] = calllib(obj.libName,'simxSetVisionSensorImage',clientID,handle_,image,buffsize_,options_,operationmode_); 1712 | end 1713 | 1714 | function rtn = simxSetVisionSensorImage2(obj,clientID,handle,image,operationmode) 1715 | handle_ = int32(handle); 1716 | [m n o] = size(image); 1717 | buffsize_ = int32(m*n*o); 1718 | if(o == 1) 1719 | options_ = uint8(1); 1720 | else 1721 | options_ = uint8(0); 1722 | end 1723 | operationmode_ = int32(operationmode); 1724 | 1725 | % optimization courtesy of Renaud Detry: 1726 | imdata= cast(reshape(permute(flipdim(image, 1), [3 2 1]), 1, buffsize_),'uint8'); 1727 | 1728 | % imdata = zeros(1,buffsize_); 1729 | % imdata= cast(imdata,'uint8'); 1730 | % 1731 | % for i = m:-1:1; 1732 | % count = (m-i)*n*o; 1733 | % for j = 1:o:n*o; 1734 | % for k=1:o; 1735 | % if(o==1) 1736 | % l=j; 1737 | % else 1738 | % l=int32(j/o) +1; 1739 | % end 1740 | % imdata(count+j+k-1) = image(i,l,k); 1741 | % end 1742 | % end 1743 | % end 1744 | 1745 | image_ = libpointer('uint8Ptr',imdata); 1746 | 1747 | [rtn image_] = calllib(obj.libName,'simxSetVisionSensorImage',clientID,handle_,image_,buffsize_,options_,operationmode_); 1748 | end 1749 | 1750 | function rtn = simxStartSimulation(obj,clientID,operationMode) 1751 | operationMode_ = int32(operationMode); 1752 | 1753 | rtn = calllib(obj.libName,'simxStartSimulation',clientID,operationMode_); 1754 | end 1755 | 1756 | function rtn = simxStopSimulation(obj,clientID,operationMode) 1757 | operationMode_ = int32(operationMode); 1758 | 1759 | rtn = calllib(obj.libName,'simxStopSimulation',clientID,operationMode_); 1760 | end 1761 | 1762 | function rtn = simxSynchronous(obj,clientID,enable) 1763 | enable_ = uint8(enable); 1764 | 1765 | rtn = calllib(obj.libName,'simxSynchronous',clientID,enable_); 1766 | end 1767 | 1768 | function rtn = simxPauseCommunication(obj,clientID,enable) 1769 | enable_ = uint8(enable); 1770 | 1771 | rtn = calllib(obj.libName,'simxPauseCommunication',clientID,enable_); 1772 | end 1773 | 1774 | function rtn = simxSynchronousTrigger(obj,clientID) 1775 | rtn = calllib(obj.libName,'simxSynchronousTrigger',clientID); 1776 | end 1777 | 1778 | function rtn = simxTransferFile(obj,clientID,filePathAndName,fileName_serverSide,timeOut,operationMode) 1779 | filePathAndName_ = libpointer('int8Ptr',[int8(filePathAndName) 0]); 1780 | fileName_serverSide_ = libpointer('uint8Ptr',[uint8(fileName_serverSide) 0]); 1781 | timeOut_ = int32(timeOut); 1782 | operationMode_ = int32(operationMode); 1783 | 1784 | [rtn filePathAndName_ fileName_serverSide_] = calllib(obj.libName,'simxTransferFile',clientID,filePathAndName_,fileName_serverSide_,timeOut_,operationMode_); 1785 | end 1786 | 1787 | function [rtn linearVelocity angularVelocity]= simxGetObjectVelocity(obj,clientID,objectHandle,operationMode) 1788 | objectHandle_ = int32(objectHandle); 1789 | linearVelocity = libpointer('singlePtr', single([0 0 0])); 1790 | angularVelocity = libpointer('singlePtr', single([0 0 0])); 1791 | operationMode_ = int32(operationMode); 1792 | 1793 | [rtn linearVelocity angularVelocity] = calllib(obj.libName,'simxGetObjectVelocity',clientID,objectHandle_,linearVelocity, angularVelocity,operationMode_); 1794 | end 1795 | 1796 | function [string]= simxPackInts(obj,intArray) 1797 | string=char(typecast(int32(intArray),'uint8')); 1798 | end 1799 | function [intArray]= simxUnpackInts(obj,string) 1800 | intArray=typecast(uint8(int32(string)),'int32'); 1801 | end 1802 | function [string]= simxPackFloats(obj,floatArray) 1803 | string=char(typecast(single(floatArray),'uint8')); 1804 | end 1805 | function [floatArray]= simxUnpackFloats(obj,string) 1806 | floatArray=typecast(uint8(single(string)),'single'); 1807 | end 1808 | 1809 | 1810 | 1811 | 1812 | 1813 | 1814 | 1815 | function rtn = simxSetJointPosition(obj,clientID,handle,position,option) 1816 | handle_ = int32(handle); 1817 | position_ = libpointer('singlePtr',single(position)); 1818 | option_ = int32(option); 1819 | rtn = calllib(obj.libName,'mtlb_simxSetJointPosition',clientID,handle_,position_,option_); 1820 | end 1821 | 1822 | function [rtn ]= simxSetJointTargetVelocity(obj,clientID,objectHandle,targetVelocity,operationMode) 1823 | objectHandle_ = int32(objectHandle); 1824 | targetVelocity_ = libpointer('singlePtr',single(targetVelocity)); 1825 | operationMode_ = int32(operationMode); 1826 | 1827 | [rtn ] = calllib(obj.libName,'mtlb_simxSetJointTargetVelocity',clientID,objectHandle_,targetVelocity_,operationMode_); 1828 | end 1829 | 1830 | function [rtn ]= simxSetJointTargetPosition(obj,clientID,objectHandle,targetPosition,operationMode) 1831 | objectHandle_ = int32(objectHandle); 1832 | targetPosition_ = libpointer('singlePtr',single(targetPosition)); 1833 | operationMode_ = int32(operationMode); 1834 | 1835 | [rtn ] = calllib(obj.libName,'mtlb_simxSetJointTargetPosition',clientID,objectHandle_,targetPosition_,operationMode_); 1836 | end 1837 | 1838 | function [rtn ]= simxSetJointForce(obj,clientID,objectHandle,force,operationMode) 1839 | objectHandle_ = int32(objectHandle); 1840 | force_ = libpointer('singlePtr',single(force)); 1841 | operationMode_ = int32(operationMode); 1842 | 1843 | [rtn ] = calllib(obj.libName,'mtlb_simxSetJointForce',clientID,objectHandle_,force_,operationMode_); 1844 | end 1845 | 1846 | function [rtn ]= simxSetJointMaxForce(obj,clientID,objectHandle,force,operationMode) 1847 | objectHandle_ = int32(objectHandle); 1848 | force_ = libpointer('singlePtr',single(force)); 1849 | operationMode_ = int32(operationMode); 1850 | 1851 | [rtn ] = calllib(obj.libName,'mtlb_simxSetJointMaxForce',clientID,objectHandle_,force_,operationMode_); 1852 | end 1853 | 1854 | function [rtn ]= simxSetFloatSignal(obj,clientID,signalName,signalValue,operationMode) 1855 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 1856 | signalValue_ = libpointer('singlePtr',single(signalValue)); 1857 | operationMode_ = int32(operationMode); 1858 | 1859 | [rtn signalName_ ] = calllib(obj.libName,'mtlb_simxSetFloatSignal',clientID,signalName_,signalValue_,operationMode_); 1860 | end 1861 | 1862 | function [rtn ]= simxSetObjectFloatParameter(obj,clientID,objectHandle,parameterID,parameterValue,operationMode) 1863 | objectHandle_ = int32(objectHandle); 1864 | parameterID_ = int32(parameterID); 1865 | parameterValue_ = libpointer('singlePtr',single(parameterValue)); 1866 | operationMode_ = int32(operationMode); 1867 | 1868 | [rtn ] = calllib(obj.libName,'mtlb_simxSetObjectFloatParameter',clientID,objectHandle_,parameterID_,parameterValue_,operationMode_); 1869 | end 1870 | 1871 | function [rtn ]= simxSetFloatingParameter(obj,clientID,paramIdentifier,paramValue,operationMode) 1872 | paramIdentifier_ = int32(paramIdentifier); 1873 | paramValue_ = libpointer('singlePtr',single(paramValue)); 1874 | operationMode_ = int32(operationMode); 1875 | 1876 | [rtn ] = calllib(obj.libName,'mtlb_simxSetFloatingParameter',clientID,paramIdentifier_,paramValue_,operationMode_); 1877 | end 1878 | 1879 | function [rtn handle] = simxCreateDummy(obj,clientID,size,colors,operationmode) 1880 | size_ = libpointer('singlePtr',single(size)); 1881 | operationmode_ = int32(operationmode); 1882 | 1883 | if (numel(colors) < 12)&&(numel(colors) ~= 0) 1884 | error('colors should have 12 values'); 1885 | return; 1886 | end 1887 | 1888 | color_ = libpointer('uint8Ptr',uint8(colors)); 1889 | handle_ = libpointer('int32Ptr',int32(0)); 1890 | 1891 | [rtn s c handle] = calllib(obj.libName,'mtlb_simxCreateDummy',clientID,size_,color_,handle_,operationmode_); 1892 | end 1893 | 1894 | 1895 | 1896 | 1897 | function [rtn detectionState detectedPoint detectedObjectHandle detectedSurfaceNormalVector]= simxReadProximitySensor(obj,clientID,sensorHandle,operationMode) 1898 | clientIDandSensorHandle = libpointer('int32Ptr',int32([clientID,sensorHandle])); 1899 | detectionState = libpointer('uint8Ptr', uint8(0)); 1900 | detectedPoint = libpointer('singlePtr', single([0 0 0])); 1901 | detectedSurfaceNormalVector = libpointer('singlePtr', single([0 0 0])); 1902 | detectedObjectHandle = libpointer('int32Ptr',int32(0)); 1903 | operationMode_ = int32(operationMode); 1904 | 1905 | [rtn clientIDandSensorHandle detectionState detectedPoint detectedObjectHandle detectedSurfaceNormalVector] = calllib(obj.libName,'mtlb_simxReadProximitySensor',clientIDandSensorHandle,detectionState ,detectedPoint , detectedObjectHandle ,detectedSurfaceNormalVector,operationMode_); 1906 | end 1907 | 1908 | function [rtn console_handle] = simxAuxiliaryConsoleOpen(obj,clientID,title,maxLines,mode,position,size,textcolor,backgroundcolor,operationmode) 1909 | 1910 | posx=-10000; 1911 | posy=-10000; 1912 | sizex=-10000; 1913 | sizey=-10000; 1914 | 1915 | if (numel(position) < 2)&&(numel(position) ~= 0) 1916 | error('position should have 2 values'); 1917 | return; 1918 | end 1919 | if (numel(size) < 2)&&(numel(size) ~= 0) 1920 | error('size should have 2 values'); 1921 | return; 1922 | end 1923 | 1924 | if (numel(position) >= 2) 1925 | posx=position(1); 1926 | posy=position(2); 1927 | end 1928 | if (numel(size) >= 2) 1929 | sizex=size(1); 1930 | sizey=size(2); 1931 | end 1932 | 1933 | clientIDandMaxLinesAndModeAndPositionAndSize = libpointer('int32Ptr',int32([clientID,maxLines,mode,posx,posy,sizex,sizey])); 1934 | title_ = libpointer('int8Ptr',[int8(title) 0]); 1935 | 1936 | if (numel(textcolor) < 3)&&(numel(textcolor) ~= 0) 1937 | error('textcolor should have 3 values'); 1938 | return; 1939 | end 1940 | if (numel(backgroundcolor) < 3)&&(numel(backgroundcolor) ~= 0) 1941 | error('backgroundcolor should have 3 values'); 1942 | return; 1943 | end 1944 | 1945 | textcolor_ = libpointer('singlePtr',single(textcolor)); 1946 | backgroundcolor_ = libpointer('singlePtr',single(backgroundcolor)); 1947 | consolehandle_ = libpointer('int32Ptr',int32(0)); 1948 | operationmode_ = int32(operationmode); 1949 | 1950 | [rtn clientIDandMaxLinesAndModeAndPositionAndSize a b c console_handle] = calllib(obj.libName,'mtlb_simxAuxiliaryConsoleOpen',clientIDandMaxLinesAndModeAndPositionAndSize,title_,textcolor_,backgroundcolor_,consolehandle_,operationmode); 1951 | end 1952 | 1953 | function [rtn dialogHandle uiHandle] = simxDisplayDialog(obj,clientID,titleText,mainText,dialogType,initialText,titleColors,dialogColors,operationMode) 1954 | 1955 | if (numel(titleColors) < 6)&&(numel(titleColors) ~= 0) 1956 | error('titleColors should have 6 values'); 1957 | return; 1958 | end 1959 | if (numel(dialogColors) < 6)&&(numel(dialogColors) ~= 0) 1960 | error('dialogColors should have 6 values'); 1961 | return; 1962 | end 1963 | 1964 | clientIDandDlgTypeAndOperationMode = libpointer('int32Ptr',int32([clientID,dialogType,operationMode])); 1965 | colors = [-20000.0 -20000.0 -20000.0 -20000.0 -20000.0 -20000.0 -20000.0 -20000.0 -20000.0 -20000.0 -20000.0 -20000.0]; 1966 | if (numel(titleColors) >= 6) 1967 | for i = 1:6 1968 | colors(i)=titleColors(i) 1969 | end 1970 | end 1971 | if (numel(dialogColors) >= 6) 1972 | for i = 1:6 1973 | colors(6+i)=dialogColors(i) 1974 | end 1975 | end 1976 | 1977 | clientHandleAndUiHandle = libpointer('int32Ptr',int32([0,0])); 1978 | 1979 | titleText_ = libpointer('int8Ptr',[int8(titleText) 0]); 1980 | mainText_ = libpointer('int8Ptr',[int8(mainText) 0]); 1981 | initialText_ = libpointer('int8Ptr',[int8(initialText) 0]); 1982 | 1983 | [rtn clientIDandDlgTypeAndOperationMode b c d colors clientHandleAndUiHandle] = calllib(obj.libName,'mtlb_simxDisplayDialog',clientIDandDlgTypeAndOperationMode,titleText_,mainText_,initialText_,colors,clientHandleAndUiHandle); 1984 | 1985 | dialogHandle = clientHandleAndUiHandle(1); 1986 | uiHandle = clientHandleAndUiHandle(2); 1987 | end 1988 | 1989 | function [rtn retSignalValue]= simxQuery(obj,clientID,signalName,signalValue,retSignalName,timeOutInMs) 1990 | 1991 | clientIDandSignalLengthAndTimeOutInMs = libpointer('int32Ptr',int32([clientID,length(signalValue),timeOutInMs])); 1992 | 1993 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 1994 | signalValue_ = libpointer('uint8Ptr',[uint8(signalValue) 0]); 1995 | retSignalName_ = libpointer('int8Ptr',[int8(retSignalName) 0]); 1996 | retSignalValue_ = libpointer('uint8PtrPtr'); 1997 | retSignalLength_= libpointer('int32Ptr',int32(0)); 1998 | timeOutInMs_ = int32(timeOutInMs); 1999 | 2000 | [rtn clientIDandSignalLengthAndTimeOutInMs signalName_,signalValue_, retSignalName_, retSignalValue_, retSignalLength_] = calllib(obj.libName,'mtlb_simxQuery',clientIDandSignalLengthAndTimeOutInMs,signalName_,signalValue_, retSignalName_, retSignalValue_, retSignalLength_); 2001 | 2002 | if (rtn==0) 2003 | if (retSignalLength_>0) 2004 | retSignalValue_.setdatatype('uint8Ptr',1,double(retSignalLength_)); 2005 | retSignalValue = char(retSignalValue_.value); 2006 | else 2007 | retSignalValue = []; 2008 | end 2009 | else 2010 | retSignalValue = []; 2011 | end 2012 | end 2013 | 2014 | function [rtn retHandles retInts retFloats retStrings]= simxGetObjectGroupData(obj,clientID,objectType,dataType,operationMode) 2015 | 2016 | clientIDandObjectTypeAndDataTypeAndOperationMode = libpointer('int32Ptr',int32([clientID,objectType,dataType,operationMode])); 2017 | 2018 | handlesCountAndIntDataCountAndFloatDataCountAndStringDataCount = libpointer('int32Ptr',int32([0,0,0,0])); 2019 | 2020 | retHandles_ = libpointer('int32PtrPtr'); 2021 | retInts_ = libpointer('int32PtrPtr'); 2022 | retFloats_ = libpointer('singlePtrPtr'); 2023 | retStrings_ = libpointer('int8PtrPtr'); 2024 | 2025 | [rtn clientIDandObjectTypeAndDataTypeAndOperationMode handlesCountAndIntDataCountAndFloatDataCountAndStringDataCount retHandles_ retInts_ retFloats_ retStrings_ ] = calllib(obj.libName,'mtlb_simxGetObjectGroupData',clientIDandObjectTypeAndDataTypeAndOperationMode,handlesCountAndIntDataCountAndFloatDataCountAndStringDataCount,retHandles_,retInts_,retFloats_,retStrings_); 2026 | 2027 | handlesCount_ = handlesCountAndIntDataCountAndFloatDataCountAndStringDataCount(1); 2028 | intsCount_ = handlesCountAndIntDataCountAndFloatDataCountAndStringDataCount(2); 2029 | floatsCount_ = handlesCountAndIntDataCountAndFloatDataCountAndStringDataCount(3); 2030 | stringsCount_ = handlesCountAndIntDataCountAndFloatDataCountAndStringDataCount(4); 2031 | 2032 | if (rtn==0) 2033 | if (handlesCount_~=0) 2034 | retHandles_.setdatatype('int32Ptr',1,handlesCount_); 2035 | retHandles = retHandles_.value; 2036 | else 2037 | retHandles=[]; 2038 | end 2039 | 2040 | if (intsCount_~=0) 2041 | retInts_.setdatatype('int32Ptr',1,intsCount_); 2042 | retInts = retInts_.value; 2043 | else 2044 | retInts=[]; 2045 | end 2046 | 2047 | if (floatsCount_~=0) 2048 | retFloats_.setdatatype('singlePtr',1,floatsCount_); 2049 | retFloats = retFloats_.value; 2050 | else 2051 | retFloats=[]; 2052 | end 2053 | 2054 | retStrings = cell(double(stringsCount_)); 2055 | s=1; 2056 | for i=1:stringsCount_ 2057 | begin = s; 2058 | retStrings_.setdatatype('int8Ptr',1,s); 2059 | value = retStrings_.value(s); 2060 | while(value ~= 0) 2061 | retStrings_.setdatatype('int8Ptr',1,s); 2062 | value = retStrings_.value(s); 2063 | s=s+1; 2064 | end 2065 | tmp = retStrings_.value(begin:s-1); 2066 | retStrings(i) = cellstr(char(tmp)); 2067 | end 2068 | 2069 | else 2070 | retHandles=[]; 2071 | retInts=[]; 2072 | retFloats=[]; 2073 | retStrings=[]; 2074 | end 2075 | end 2076 | 2077 | 2078 | function [rtn retInts retFloats retStrings retBuffer]= simxCallScriptFunction(obj,clientID,scriptDescription,options,functionName,inInts,inFloats,inStrings,inBuffer,operationMode) 2079 | 2080 | if (length(inStrings)>0) 2081 | if (inStrings(length(inStrings))~=0) 2082 | inStrings=[inStrings 0]; 2083 | end 2084 | end 2085 | strCnt=0; 2086 | for i = 1:length(inStrings) 2087 | if (inStrings(i)==0) 2088 | strCnt=strCnt+1; 2089 | end 2090 | end 2091 | variousIntsIn_ = libpointer('int32Ptr',int32([clientID,options,numel(inInts),numel(inFloats),strCnt,numel(inBuffer),operationMode])); 2092 | scriptDescriptionAndFunctionName_ = libpointer('int8Ptr',int8([scriptDescription 0 functionName 0])); 2093 | inInts_ = libpointer('int32Ptr',int32(inInts)); 2094 | inFloats_ = libpointer('singlePtr',single(inFloats)); 2095 | inStrings_ = libpointer('int8Ptr',int8(inStrings)); 2096 | inBuffer_ = libpointer('uint8Ptr',uint8(inBuffer)); 2097 | 2098 | calllib(obj.libName,'mtlb_simxCallScriptFunction_a',variousIntsIn_,scriptDescriptionAndFunctionName_,inInts_,inFloats_,inStrings_,inBuffer_); 2099 | 2100 | variousIntsOut = libpointer('int32Ptr',int32([0,0,0,0])); 2101 | outInts_ = libpointer('int32PtrPtr'); 2102 | outFloats_ = libpointer('singlePtrPtr'); 2103 | outStrings_ = libpointer('int8PtrPtr'); 2104 | outBuffer_ = libpointer('uint8PtrPtr'); 2105 | 2106 | [rtn variousIntsOut outInts_ outFloats_ outStrings_ outBuffer_ ] = calllib(obj.libName,'mtlb_simxCallScriptFunction_b',clientID,variousIntsOut,outInts_,outFloats_,outStrings_,outBuffer_); 2107 | 2108 | outIntCnt_ = variousIntsOut(1); 2109 | outFloatCnt_ = variousIntsOut(2); 2110 | outStringCnt_ = variousIntsOut(3); 2111 | outBufferSize_ = variousIntsOut(4); 2112 | 2113 | if (rtn==0) 2114 | if (outIntCnt_~=0) 2115 | outInts_.setdatatype('int32Ptr',1,outIntCnt_); 2116 | retInts = outInts_.value; 2117 | else 2118 | retInts=[]; 2119 | end 2120 | 2121 | if (outFloatCnt_~=0) 2122 | outFloats_.setdatatype('singlePtr',1,outFloatCnt_); 2123 | retFloats = outFloats_.value; 2124 | else 2125 | retFloats=[]; 2126 | end 2127 | 2128 | if (outStringCnt_>0) 2129 | s=1; 2130 | outStrings_.setdatatype('int8Ptr',1,s); 2131 | charValue = outStrings_.value(s); 2132 | while (outStringCnt_>0) 2133 | while(charValue ~= 0) 2134 | s=s+1; 2135 | outStrings_.setdatatype('int8Ptr',1,s); 2136 | charValue = outStrings_.value(s); 2137 | end 2138 | outStringCnt_=outStringCnt_-1; 2139 | if (outStringCnt_>0) 2140 | s=s+1; 2141 | outStrings_.setdatatype('int8Ptr',1,s); 2142 | charValue = outStrings_.value(s); 2143 | end 2144 | end 2145 | tmp = outStrings_.value(1:s); 2146 | retStrings = char(tmp); 2147 | else 2148 | retStrings = []; 2149 | end 2150 | 2151 | if (outBufferSize_~=0) 2152 | outBuffer_.setdatatype('uint8Ptr',1,outBufferSize_); 2153 | retBuffer = outBuffer_.value; 2154 | else 2155 | retBuffer=[]; 2156 | end 2157 | else 2158 | retInts=[]; 2159 | retFloats=[]; 2160 | retStrings=[]; 2161 | retBuffer=[]; 2162 | end 2163 | end 2164 | 2165 | 2166 | function [rtn signalValue ]= simxReadStringStream(obj,clientID,signalName,operationMode) 2167 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 2168 | signalValue_ = libpointer('uint8PtrPtr'); 2169 | signalLength= libpointer('int32Ptr',int32(0)); 2170 | operationMode_ = int32(operationMode); 2171 | 2172 | [rtn signalName_ signalValue_ signalLength ] = calllib(obj.libName,'simxReadStringStream',clientID,signalName_,signalValue_,signalLength ,operationMode_); 2173 | 2174 | if (rtn==0) 2175 | if (signalLength>0) 2176 | signalValue_.setdatatype('uint8Ptr',1,double(signalLength)); 2177 | signalValue = char(signalValue_.value); 2178 | else 2179 | signalValue = []; 2180 | end 2181 | else 2182 | signalValue = []; 2183 | end 2184 | end 2185 | 2186 | function [rtn ]= simxWriteStringStream(obj,clientID,signalName,signalValue,operationMode) 2187 | signalLength_ = int32(length(signalValue)); 2188 | signalName_ = libpointer('int8Ptr',[int8(signalName) 0]); 2189 | signalValue_ = libpointer('uint8Ptr',[uint8(signalValue) 0]); 2190 | operationMode_ = int32(operationMode); 2191 | 2192 | [rtn signalName_ signalValue_ ] = calllib(obj.libName,'simxWriteStringStream',clientID,signalName_,signalValue_,signalLength_ ,operationMode_); 2193 | end 2194 | 2195 | end 2196 | end 2197 | --------------------------------------------------------------------------------