一体式树莓派六轴机械臂

产品简介

树莓派六轴协作机器人，臂展280mm，采用树莓派微处理器，体积小巧但功能强大，支持多平台二次开发，内置Ubuntu系统，无需搭配PC主控，链接外设，即可快速构建机械臂编程教育、机械臂控制逻辑开发, ROS仿真实验，满足科研教育、智能家居、轻工业及商业应用等多种应用场景。

内嵌树莓派生态，开发无限可能

树莓派4B，1.5GHz 4核微处理器，运行Debian/Ubuntu平台。
支持4路USB，2路HDMI，标准化GPIO接口、TF卡可插拔。

自带ROS，图形化编程Mind+/Blockly

内置ROS仿真机械臂运行状态，超强扩展性。
Mind+/blockly可视化编程，同时支持通用Python软件接口。

图像识别丰富配件应用广泛

自带图像识别算法，可选配任意摄像头。
自主搭配显示器、夹爪吸泵等不同配件，实现更多应用化场景。

独特工业设计，极致小巧

一体化设计，整体机身结构紧凑，净重仅850g，十分便于携带。
模块化设计，备件少、维护成本低，可快速拆卸更换，实现即插即用。

高配置，搭配Lego接口

内含6个高性能伺服电机，响应快，惯量小，转动平滑。
底座及末端带有乐高科技件接口，适用于各项微型嵌入式设备开发。

技术规格

**重复定位精度：**±0.5mm
**电源输入：**8V-12V，5A
**通信：**Type-C
**工作半径：**280mm
**自由度：**6
**负载：**250g
**SOC：**Broadcom BCM2711
**CPU：**1.5GHz四核
**蓝牙/无线：**支持
**USB：**USB3.0x2; USB2.0 x2
**HDMI接口：**microHDMI x2
**IO接口：**40
**适用于：**独立工作
**编程平台：**Debian/ Ubuntu
**ROS/ Python：**内嵌
**图形化编程：**内嵌
**搭载摄像头：**选配任意摄像头
**重量：**850g
工作温度：-5 ~ 45°

基础功能应用

myStudio

可以烧入、更新固件，根据自己的使用场景，选择不同的固件并进行下载，同时学习相关的素材，适用于Windows, Mac, Linux等系统

根据不同的开发使用环境，下载不同的 PC，Basic 固件与 Atom 固件。

安装 myStudio

myStudio 下载地址

GitHub：https://github.com/elephantrobotics/myStudio

选择最新的版本（软件版本以实际页面软件版本为主，下图仅为示例）

然后针对不同的系统选择不同的版本即可

注意：后缀不同代表了适用于不同的系统。

.tra.xz —— Linux 系统

.dmg —— Mac 系统

.exe —— window 系统

安装驱动

根据自己所使用的操作系统，点击下方按钮下载相应的 CP210X 或 CP34X 驱动程序压缩包，在解压压缩包后，选择对应操作系统位数的安装包进行安装。

目前存在两种驱动芯片版本， CP210X （适用于CP2104版本）/CP34X （适用于CH9102版本）驱动程序压缩包。若不确定设备所使用的USB芯片，可同时安装两种驱动。（ CH9102_VCP_SER_MacOS 在安装过程中，可能出现报错，但实际上已经完成安装，忽略即可。）

对于 Mac OS，在安装之前确保系统 "偏好设置->安全性和隐私->通用" ，并允许从 App Store 和被认可的开发者。

下载底部 Basic 串口驱动程序 CP210X

串口驱动程序CP34X

下载末端 Atom 串口驱动程序

如何区分CP210X和CP34X芯片

打开设备管理器，查看端口(COM和LPT)，若端口(COM和LPT)显示USB-Enhanced-SERIAL CH9102，则为CP34X芯片

若端口(COM和LPT)显示Silicon Labs CP210x USB to UART Bridge，则为CP210X芯片

烧录 Basic 固件与 Atom 固件

basic与PC连接方式如图所示

首先用 USB 连接 Basic 开发板，myStudio 的连接窗口会显示出已连接的开发板，选中点击 Connect 即可

然后 Basic 和工具里面有 Basic 相关的固件,选择想要烧录的固件，点击烧录即可（未下载的固件请先点击“download”）

烧录 Atom 固件和 Basic 的烧录一样，用 usb 连接末端的 Atom

在Board一栏可以选择ATOM,侧边栏Basic就会出现 Atom 的固件，Atom 的固件就只有一个，点击烧入即可

出场固件介绍

1、拖动示教

机器人拖动示教，就是操作员可以直接拖动着机器人各关节，运动到理想的姿态，记录下来。

协作机器人是较早具有该功能的系统。这种示教方式可以避免传统示教的各种缺点，是机器人中一项很有应用前景的技术。

设备类型不同，操作方式也有所不同，大概步骤如下：

Atom 烧录最新版的 atomMain

Basic 烧录 minirobot，选择 Maincontrol 功能，微处理器类设备无需烧录 Basic

按下录制按钮/键盘按键

选择储存路径，微处理类设备无此步骤

可直接拖动机械臂各关节，移动至您预想的位置，完成一组运动

按下指定按钮/键盘按键进行保存

按下播放按钮/键盘按键/键盘按键

选择相对于的储存路径，机械臂开始运动

按下退出按钮/键盘按键，退出此功能

2、机械臂校准

校准机械臂是对机械臂精准控制的前提，设置关节零位，初始化电机的电位值是后续进行进阶开发的基础。

设备类型不同，操作方式也有所不同，大概步骤如下：

Atom 烧录最新版的 atomMain

Basic 烧录 minirobot，选择 Calibration 功能，微处理器类设备无需烧录 Basic

将机械臂各关节转至零位状态（零位刻度线对齐），按校准按钮，开始校准机械臂

按下测试按钮，测试机械臂各关节零位

按下退出按钮，退出此功能

3、通讯转发

通讯的时效性对于微控制器机械臂至关重要，对于微控制器机械臂来说，我们通常对底座的 Basic 发送控制指令，通过通讯转发，末端执行器将对指令进行解析，继而执行目标动作。

该功能现主要用于客户在不同环境下自行开发机械臂。

设备类型不同，操作方式也有所不同，大概步骤如下：

Atom 烧录最新版的 atomMain

Basic 烧录 minirobot，选择 Transponder 功能，微处理器类设备无需烧录 Basic

按下检测键，检测 Basic 和末端执行器 Atom 是否正常通讯

按下退出按钮，退出此功能

4、连接检测

接检测是一项用机械臂中电机以及 Atom 连接状态的检测功能。这项功能便于排除设备故障。

连接检测中看到机械臂的设备连接状态，包括舵机的连接以及 Atom 的通讯状态。微控制器类设备中 Basic 上会显示设备的当前固件版本。

设备类型不同，操作方式也有所不同，大概步骤如下：

Atom 烧录最新版的 atomMain

Basic 烧录 minirobot，选择 Information 功能，微处理器类设备无需烧录 Basic

按下检测键，检测设备连接状态

按下固件查看键，查看当前固件版本

按下退出按钮，退出此功能

首次使用

1、树莓派机械臂所含产品内容

树莓派机械臂

机械臂-产品画册

机械臂-配套电源

USB-Type C

跳线

M4*35，杯头内六角，全螺纹，不锈钢螺丝

内六角扳手

2、确认工作环境与指标

请将机器人系统设置在符合如表所述条件的环境中，以便发挥、维持本机的性能并安全地进行使用。

环境	指标
温度	-10℃~45℃
相对湿度	20%~70%
室内外要求	室内
其他环境要求	避免阳光照射；远离灰尘、油烟、盐分、铁屑等；远离易燃性、腐蚀性液体与气体；不得与水接触；不传递冲击与振动等；远离强电磁干扰源

3、连接

连接电源适配器：

连接电脑：

4、电源

必须使用外部电源进行供电，以提供足够的电量：

额定电压：7-9V

额定电流：3-5A

插头类型：DC 5.5mm x 2.1

注意，不能仅仅使用插入Basic的TypeC进行供电。

使用官方适配的电源，以免对机械臂造成损害。

5、固定机械臂

在机械臂的运动过程中，如果不将机械臂的底面与桌面或其他底面相连，仍然会造成机械臂的摇晃或倾覆。

常见的固定机械臂的方式如下：

使用乐高插键固定在具有乐高接口的底座上

我们搭配的底座有 2 种：平面吸盘底座与 G 型夹底座

平面底座

在底座的四角安装吸盘并拧紧。

用附带的乐高科技件，连接平面底座和机械臂底部。

将四个吸盘固定在平整光滑平面后方可开始使用。

技巧：可以适当在吸盘下加入少量不导电液体，以填补吸盘与桌面的缝隙，以获得最佳吸附效果。

G型底座

用G形夹将底座固定在桌子边沿

用附带的乐高科技件，连接底座和机械臂底部

确定稳固后方可开始使用

开发与使用

【1】基于 Mind+ 的开发使用

Mind+是一个完全可视化的模块化编程软件，属于图形化编程语言。

使用 Mind+ 的时候，用户可以通过拖曳模块，来构建代码逻辑，过程很像搭积木。

在用户视角下， Mind+ 是一个简单易用的可视化工具，用来生成代码。在开发者视角下， myBlockly 是一个文本框，里边包含了用户输入好的代码。

代码生成到文本框的过程，就是用户在 Mind+ 里拖曳的过程。

安装Mind+：

Mind+下载地址

mind+ windows版本

mind+ macos版本

mind+ linux版本

1.进入mind+选择python模式

2.选择拓展

3.选择用户库并在搜索框内输入关键字(elephant,mycobot,pi)获取大象机器人相关用户库,再点击返回回到操作界面

4.在操作界面滑到最底部找到大象机器人用户库，并拖动积木块执行相关操作

简单的机械臂摆动示例：

Mind+详细使用介绍请点击此处

【2】基于 RoboFlow 的开发使用

RoboFlow 操作系统提供了人机交互界面（它的功能有坐标控制、角度控制、io控制、轨迹录制、夹爪控制等），便于操作人员与机械臂进行交互，正确使用机械臂。也就是说，用户在使用机器人时，大多数时候都是通过使用 RoboFlow 操作系统实现。

例如，由于 RoboFlow 操作系统在示教器中运行，用户可以利用示教器这个载体，进行手动操作机器人、编程和其他操作。也可以利用操作系统OS进行机器人系统与其他机器人或设备的通信。总而言之，凭借着界面友好、功能丰富等优点，RoboFlow 操作系统的出现，让用户开始使用大象机器人时更容易上手，从而使得人人都可以成为机器人的指挥官。

使用前提：通过使用 mystudio 烧录相应的固件。在 Atom 中烧录最新版的 atomMain(出厂默认已烧录)

环境搭建

1.先将设备连接

2.RoboFlow 下载

RoboFlow 简单使用

1.登录

注意：登陆密码为：mycobot

当系统成功启动后，将会进入如图所示的RoboFlow操作系统的登录界面。

选择登录用户名“Admin”或其他管理员用户名（只有管理员权限才允许编辑和调试程序），点击密码框将会出现如图所示的弹窗

默认管理员用户“Admin”对应的登录密码是“aaa”（如若选择了其他管理员用户名则输入对应登录密码），输入密码点击“OK”，再点击“登录”，即可成功登录。

2.上电

登录成功后，将会进入如图所示的主菜单界面。

在主菜单界面中，选择“配置中心”，将会进入如图下所示的界面(此时还未上电)。

在确保急停旋钮未被按下的情况下，点击“启动机器人”按键。此时界面将会发生变化，将会出现“正在上电中”图标。如若上电成功，将会出现“正常”状态。如若失败，请检查是否缺少执行哪些步骤。

完成上一个步骤后，在配置中心中点击“< 主菜单”按键即可返回主菜单。

![](https://img.dfrobot.com.cn/wiki/5ea64bf6cf1d8c7738ad2881/d50169cd0d48466b562768a98c32240c.png

3.新建空白程序

如图所示，点击“编写程序”，再选择“空白程序”。

执行完上一步操作后，进入程序编辑界面。

4.添加并编辑指令

如图所示，添加两条路点：绝对点指令，并示教两个点位（即利用快速移动工具手动操作机器人，控制机器人运动到某一位姿，返回，点击“保存当前点”。两个点位的示教步骤相同。如需验证保存点位，长按“移动到该点”按键可以手动操作控制机器人移动到示教点位。）。

编辑完成后，请注意保存程序文件。点击文件选项栏中的“保存”，将弹出窗口。点击“文件名”，将会出现输入键盘。输入文件名后，点击“OK”。将回到保存界面，点击“确定”，程序文件保存成功。保存成功后，在程序编辑界面左上角的程序名称将会被更改。

5.调试程序

如图所示，除了程序运行控制栏中提供的“下一步”、“运行”两个功能外，点击“高级功能”，可以进入更多设置的界面。

其中，“下一步”功能对应的是一步一步执行程序，点击一次只运行一步，如需继续运行则继续点击“下一步”。“运行”功能对应的是自动运行程序一次。

“高级功能”中，可以设置循环运行的次数，也可以无限循环运行。还可以控制程序以自动运行模式还是手动运行模式运行。在自动运行模式下可以使用“下一步”、“运行”和循环运行。在界面下选择“手动运行模式”，再选择循环运行中的“运行”或“无限循环”。即可进入手动运行模式下的运行界面。

如果使用手动模式调试程序，需要一直按住“Press Down”按键，才能继续运行。如果松开按键，则程序暂停，再按下，则继续运行。

6.保存并运行程序

如果调试完成，请确保已将调试完成的程序保存。返回主菜单后，选择编写程序--》“加载程序”。将会出现弹窗，选择调试完成的程序，点击“确定”。

选择程序后，将会进入运行程序界面，在此界面中，可以运行程序，查看程序运行信息。

注意：如果无法控制机械臂，请检查机械臂是否上电成功（未上电成功，请检查固件是否在Tansponder--》UART USB功能下），选择工具--》基础设置，下图为上电成功的状态：(也可以重新查看上电步骤）

简单示例

RoboFlow中关节和坐标控制在QuickMove页面中，运行RoboFlow，进入程序编辑界面，选择Tools--QuickMove。

控制机械臂运动方式分为连续运动、步进运动，连续运动按着按钮直到释放按钮，机械臂才会停止运动；步进运动，设置好增量，机械臂到达点位就会停止。

1.关节控制

oint Control为关节控制，Joint1-6分别对应关节1-6

功能说明：
1、speed处选择连续运动（Continue Motion）或者步进运动（Discrete Motion），如果时步进运动需要设置增量值；
2、Joint Control处每个关节都有加减角度按钮，减小角度按减号这边的按钮，加大角度按加号这边的按钮。连续运动，按下按钮后，直到释放按钮才会停止（达到限位后也会停止），步进运动到达点位就会停止（比如关节1现在角度30，增量值50，按下减号这边按钮，那么机械臂运动到-20就会停止），具体步骤点击此处

2.坐标控制

注意：使用坐标控制前，需要先按着home按钮（280需要按着home按钮，320点击一下home按钮即可），让机械臂达到一定的姿态，到达姿态后，再点击home按钮，会提示“机械臂已到达要求的点位”。

Coordinates Control为坐标控制
功能说明：
1、speed处选择连续运动（Continue Motion）或者步进运动（Discrete Motion），如果时步进运动需要设置增量值；
2、Coordinates Control处每个坐标轴都有加减按钮，减小按减号这边的按钮，加大按加号这边的按钮。连续运动，按下按钮后，直到释放按钮才会停止（达到限位后也会停止），步进运动到达点位就会停止（比如X轴现在坐标30，增量值50，按下加号这边按钮，那么机械臂运动到80就会停止），具体步骤点击此处

【3】基于 Python 的开发使用

环境搭建

pymycobot 是一个和机械臂进行串口通讯的 Python 包，支持 Python2, Python3.5 及之后版本

在使用 pymycobot 之前请确保你已经搭建好 Python 环境，拥有机械臂，并且做好了前置准备。

1）安装Python

进入Python官方下载页面

出现很多版本的，我们选择最新的版本

要确认自己是64位还是32位，可通过左面我的电脑图标右键选择属性，如下图显示是64位的操作系统，所以选择64位的python安装包

下载完成后点击运行，会出现安装界面，记得勾上

出现这个就安装成功了

运行Python 安装成功后，打开命令提示符窗口（win+R,在输入cmd回车），敲入python后，会出现两种情况：

情况一：

出现这个表示python安装成功。你看到提示符 >>> 就表示我们已经在Python交互式环境中了，可以输入任何Python代码，回车后会立刻得到执行结果。

情况二：

用错误的pythonn来代替python来用，这样才会提示出错误信息。

配置环境变量：这是因为Windows会根据一个Path的环境变量设定的路径去查找python.exe，如果没找到，就会报错。如果在安装时漏掉了勾选Add Python 3.9 to PATH，那就要手动把python.exe所在的路径添加到Path中。如果发现忘记勾选或者是不会设置PATH路径那么，你重新安装一遍记得勾选上Add Python 3.9 to PATH就ok了。(第2步：出现错误的信息一般都是没有配置环境变量导致的)

步骤：右键我的电脑–>选择属性–>选择高级系统设置–>选择右下角的环境变量

环境变量主要有用户变量和系统变量，需要设置的环境变量就在这两个变量中用户变量是将自己的下载的程序可以在cmd命令中使用，把程序的绝对路径写到用户变量中即可使用

再回去打开命令提示符窗口（win+R,在输入cmd回车），敲入python，显示这样就是没有问题了

2）安装Pycharm

pycharm是一款功能强大的python编辑器，具有跨平台性，下面来介绍一下pycharm在windows下是如何安装的。

PyCharm下载地址

进入该网站后，我们会看到如下界面

根据界面介绍下载文件，professional表示专业版，community是社区版，推荐安装社区版，因为是免费使用的。

1、当下载好以后，点击安装，我这里放的是E盘，修改好以后，看个人选择

点击Next进入下一步：

点击Install进行安装：安装完成后出现下图界面，点击Finish结束安装：

完成上面步骤说明Pycharm装好了，下面我们进入该软件，创建自己的第一个程序：

1.单击桌面上的pycharm图标，进入到pycharm中，直接点击OK。如下图所示：

2、我们选择第二个，然后点击Ok：

3、点击上图中的Accept进入下一步：

4、点击上图中的ok进入下一步：

5、点击 New Project，进入如下图的界面，图中的interpreter是选择你安装的python，Location可以自定义项目存放目录，选择好后，点击create。

6、在进入的界面如下图，鼠标右击图中箭头指向的地方，然后最后选择python file，在弹出的框中填写文件名（任意填写）。

7、文件创建成功后便进入如下的界面，便可以编写自己的程序了

3）机械臂使用前置准备

确保顶部的 Atom 烧入 AtomMain, 底部的 Basic 烧入 minirobot，选择 transponder 功能，设备固件的烧录请参考 MyStudio)章节

固件 AtomMain 和 minirobot 下载地址

你也可以用myStudio 来烧入固件，MyStudio 下载地址

Pip安装命令

打开一个控制台终端(快捷键Win+R,输入cmd进入终端)，输入以下命令：

pip install pymycobot --upgrade --user

Notes:

现在只支持 Atom2.4及之后版本. 如果你使用的之前版本, 请安装 pymycobot 1.0.7

打开一个控制台终端(快捷键Win+R,输入cmd进入终端)，输入以下命令：

pip install pymycobot==1.0.7 --user

源码安装

打开一个控制台终端(快捷键Win+R,输入cmd进入终端)，输入以下命令即可安装：


git clone https://github.com/elephantrobotics/pymycobot.git <your-path>   
#其中<your-path>填写你的安装地址，不填默认在当前路径


cd <your-path>/pymycobot    
#进入到下载包的pymycobot文件夹

#根据你的python版本运行下面其一命令    

# Install
 python2 setup.py install    
# or
 python3 setup.py install

4）Python的简单使用

使用方法

当您完成上方所诉步骤时，打开您安装好的pycharm，新建一个python文件，输入一下代码，导入我们的库：

from pymycobot import MyCobot, Angle, Coord, utils

当您在pycharm上导入您安装好的项目包，如输入：from pymycobot.mycobot import MyCobot，字体下方没有出现红色波浪线证明已经安装成功可以使用了，如果出现红色波浪线可以参考如何安装API库，如何调用API库

如果你不想通过上述命令安装API库，可以通过以下操作来使用。

首先，你需要到项目的 github 中将其下载到本地。

进入项目地址：https://github.com/elephantrobotics/pymycobot

然后点击网页右边code按钮，再点击Download ZIP下载到本地，将压缩包pymycobot文件项目中的 pymycobot 文件夹放入你python依赖库目录中，你就可以直接导入使用。

LED 闪烁

新建一个 Python 文件，输入以下代码可执行 LED 闪烁。

注意：各款设备的对应的波特率不尽相同，使用时请查阅资料了解其波特率，串口编号可通过计算器设备管理器或串口助手进行查看。

from pymycobot.mycobot import MyCobot

from pymycobot import PI_PORT, PI_BAUD      # 当使用树莓派版本的mycobot时，可以引用这两个变量进行MyCobot初始化，如不是可不填该行代码
import time
#以上需写在代码开头，意为导入项目包

# MyCobot 类初始化需要两个参数：串口和波特率
#   第一个是串口字符串， 如：
#       linux： "/dev/ttyUSB0"
#       windows: "COM3"
#   第二个是波特率：
#       M5版本为： 115200
#   以下为如:
#       mycobot-M5:
#           linux:
#              mc = MyCobot("/dev/ttyUSB0", 115200)
#           windows:
#              mc = MyCobot("COM3", 115200)
#       mycobot-raspi:
#           mc = MyCobot(PI_PORT, PI_BAUD)
#
# 初始化一个MyCobot对象
# 下面为 windows版本创建对象代码
mc = MyCobot("COM3", 115200)

i = 7
#循环7次
while i > 0:                            
    mc.set_color(0,0,255) #蓝灯亮
    time.sleep(2)    #等2秒                
    mc.set_color(255,0,0) #红灯亮
    time.sleep(2)    #等2秒
    mc.set_color(0,255,0) #绿灯亮
    time.sleep(2)    #等2秒
    i -= 1

运行结果：机器人顶部灯光蓝色、红色、绿色以2秒的间隔持续闪烁7次

5）使用案例

LED闪烁

from pymycobot.mycobot import MyCobot

from pymycobot import PI_PORT, PI_BAUD      # 当使用树莓派版本的mycobot时，可以引用这两个变量进行MyCobot初始化，如不是可不填该行代码
import time
#以上需写在代码开头，意为导入项目包

# MyCobot 类初始化需要两个参数：串口和波特率
#   第一个是串口字符串， 如：
#       linux： "/dev/ttyUSB0"
#       windows: "COM3"
#   第二个是波特率：
#       M5版本为： 115200
#   以下为如:
#       mycobot-M5:
#           linux:
#              mc = MyCobot("/dev/ttyUSB0", 115200)
#           windows:
#              mc = MyCobot("COM3", 115200)
#       mycobot-raspi:
#           mc = MyCobot(PI_PORT, PI_BAUD)
#
# 初始化一个MyCobot对象
# 下面为 windows版本创建对象代码
mc = MyCobot("COM3", 115200)

i = 7
#循环7次
while i > 0:                            
    mc.set_color(0,0,255) #蓝灯亮
    time.sleep(2)    #等2秒                
    mc.set_color(255,0,0) #红灯亮
    time.sleep(2)    #等2秒
    mc.set_color(0,255,0) #绿灯亮
    time.sleep(2)    #等2秒
    i -= 1

控制机械回原点

from pymycobot.mycobot import MyCobot
from pymycobot import PI_PORT, PI_BAUD  # 当使用树莓派版本的mycobot时，可以引用这两个变量进行MyCobot初始化

# MyCobot 类初始化需要两个参数：
#   第一个是串口字符串， 如：
#       linux： "/dev/ttyUSB0"
#       windows: "COM3"
#   第二个是波特率：
#       M5版本为： 115200
#
#   Example:
#       mycobot-M5:
#           linux:
#              mc = MyCobot("/dev/ttyUSB0", 115200)
#           windows:
#              mc = MyCobot("COM3", 115200)
#       mycobot-raspi:
#           mc = MyCobot(PI_PORT, PI_BAUD)
#
# 初始化一个MyCobot对象
# 下面为树莓派版本创建对象代码
mc = MyCobot(PI_PORT, PI_BAUD)

# 检测机械臂是否可烧入程序
if mc.is_controller_connected() != 1:
    print("请正确连接机械臂进行程序写入")
    exit(0)

# 对机械臂进行微调，确保调整后的位置所有卡口都对齐了
# 以机械臂卡口对齐为准，这里给出的仅是个案例
mc.send_angles([0, 0, 0, 0, 0, 0], 30)

# 对此时的位置进行校准，校准后的角度位置表示[0,0,0,0,0,0]，电位值表示[2048,2048,2048,2048,2048,2048]
# 该for循环相当于set_gripper_ini()这个方法
#for i in range(1, 7):
    #mc.set_servo_calibration(i)

单关节运动

from pymycobot import MyCobot

from pymycobot.genre import Angle

import time

# MyCobot 类初始化需要两个参数：

#  第一个是串口字符串， 如：

#    linux： "/dev/ttyUSB0"

#    windows: "COM3"

#  第二个是波特率：

#    M5版本为： 115200

#

#  Example:

#    mycobot-M5:

#      linux:
#        mc = MyCobot("/dev/ttyUSB0", 115200)

#      windows:

#        mc = MyCobot("COM3", 115200)

#    mycobot-raspi:

#      mc = MyCobot(PI_PORT, PI_BAUD)

#

# 初始化一个MyCobot对象

# 下面为树莓派版本创建对象代码

# mc = MyCobot(PI_PORT, PI_BAUD)

# 下面为M5版本创建对象代码

mc=MyCobot('COM3',115200)

# 机械臂复原

mc.send_angles([0, 0, 0, 0, 0, 0], 40)

time.sleep(3)

# 控制关节3运动70°

mc.send_angle(Angle.J3.value,70,40)

time.sleep(3)

# 控制关节4运动-70°

mc.send_angle(Angle.J4.value,-70,40)

time.sleep(3)

# 控制关节1运动90°

mc.send_angle(Angle.J1.value,90,40)

time.sleep(3)

# 控制关节5运动-90°

mc.send_angle(Angle.J5.value,-90,40)

time.sleep(3)

# 控制关节5运动90°

mc.send_angle(Angle.J5.value,90,40)

time.sleep(3)

多关节运动

import time
from pymycobot import MyCobot
# MyCobot 类初始化需要两个参数：
#   第一个是串口字符串， 如：
#       linux： "/dev/ttyUSB0"
#       windows: "COM3"
#   第二个是波特率：
#       M5版本为： 115200
#
#   Example:
#       mycobot-M5:
#           linux:
#              mc = MyCobot("/dev/ttyUSB0", 115200)
#           windows:
#              mc = MyCobot("COM3", 115200)
#       mycobot-raspi:
#           mc = MyCobot(PI_PORT, PI_BAUD)
#
# 初始化一个MyCobot对象
# 下面为树莓派版本创建对象代码
# mc = MyCobot(PI_PORT, PI_BAUD)

# 280-M5版本创建对象代码
mc=MyCobot('COM3',115200)
# 机械臂复原归零
mc.send_angles([0,0,0,0,0,0],50)
time.sleep(2.5)
# 控制多个关节转动的不同角度
mc.send_angles([90,45,-90,90,-90,90],50)
time.sleep(2.5)
# 机械臂复原归零

mc.send_angles([0,0,0,0,0,0],50)
time.sleep(2.5)
# 控制多个关节转动的不同角度
mc.send_angles([-90,-45,90,-90,90,-90],50)
time.sleep(2.5)

控制机械臂左右摆动

from pymycobot.mycobot import MyCobot
from pymycobot.genre import Angle
from pymycobot import PI_PORT, PI_BAUD  # 当使用树莓派版本的mycobot时，可以引用这两个变量进行MyCobot初始化
import time
# 初始化一个MyCobot对象
# Pi版本
# mc = MyCobot(PI_PORT, PI_BAUD)
# M5版本
mc = MyCobot("COM3", 115200)
# 获得当前位置的坐标
angle_datas = mc.get_angles()
print(angle_datas)

# 用数列传递传递坐标参数，让机械臂移动到指定位置
mc.send_angles([0, 0, 0, 0, 0, 0], 50)
print(mc.is_paused())
# 设置等待时间，确保机械臂已经到达指定位置
# while not mc.is_paused():
time.sleep(2.5)

# 让关节1移动到90这个位置
mc.send_angle(Angle.J1.value, 90, 50)

# 设置等待时间，确保机械臂已经到达指定位置
time.sleep(2)

# 设置循环次数
num = 5

# 让机械臂左右摇摆
while num > 0:
    # 让关节2移动到50这个位置
    mc.send_angle(Angle.J2.value, 50, 50)
    # 设置等待时间，确保机械臂已经到达指定位置
    time.sleep(1.5)
    # 让关节2移动到-50这个位置
    mc.send_angle(Angle.J2.value, -50, 50)
    # 设置等待时间，确保机械臂已经到达指定位置
    time.sleep(1.5)
    num -= 1
# 让机械臂缩起来。你可以手动摆动机械臂，然后使用get_angles()函数获得坐标数列，
# 通过该函数让机械臂到达你所想的位置。
mc.send_angles([88.68, -138.51, 155.65, -128.05, -9.93, -15.29], 50)

# 设置等待时间，确保机械臂已经到达指定位置
time.sleep(2.5)
# 让机械臂放松，可以手动摆动机械臂
mc.release_all_servos()

控制机械臂跳舞

from pymycobot.mycobot import MyCobot
from pymycobot import PI_PORT, PI_BAUD  # 当使用树莓派版本的mycobot时，可以引用这两个变量进行MyCobot初始化
import time

if __name__ == '__main__':
    # MyCobot 类初始化需要两个参数：
    #   第一个是串口字符串， 如：
    #       linux： "/dev/ttyUSB0"
    #       windows: "COM3"
    #   第二个是波特率：
    #       M5版本为： 115200
    #
    #   Example:
    #       mycobot-M5:
    #           linux:
    #              mc = MyCobot("/dev/ttyUSB0", 115200)
    #           windows:
    #              mc = MyCobot("COM3", 115200)
    #       mycobot-raspi:
    #           mc = MyCobot(PI_PORT, PI_BAUD)
    #
    # 初始化一个MyCobot对象
    # 下面为树莓派版本创建对象代码
    mc = MyCobot(PI_PORT, PI_BAUD)
    # M5版本
    # mc = MyCobot("COM3",115200)

    # 设置开始开始时间
    start = time.time()
    # 让机械臂到达指定位置
    mc.send_angles([-1.49, 115, -153.45, 30, -33.42, 137.9], 80)
    # 判断其是否到达指定位置
    while not mc.is_in_position([-1.49, 115, -153.45, 30, -33.42, 137.9], 0):
        # 让机械臂恢复运动
        mc.resume()
        # 让机械臂移动0.5s
        time.sleep(0.5)
        # 暂停机械臂移动
        mc.pause()
        # 判断移动是否超时
        if time.time() - start > 3:
            break
    # 设置开始时间
    start = time.time()
    # 让运动持续30秒
    while time.time() - start < 30:
        # 让机械臂快速到达该位置
        mc.send_angles([-1.49, 115, -153.45, 30, -33.42, 137.9], 80)
        # 将灯的颜色为[0,0,50]
        mc.set_color(0, 0, 50)
        time.sleep(0.7)
        # 让机械臂快速到达该位置
        mc.send_angles([-1.49, 55, -153.45, 80, 33.42, 137.9], 80)
        # 将灯的颜色为[0,50,0]
        mc.set_color(0, 50, 0)
        time.sleep(0.7)

夹爪控制

from pymycobot import PI_PORT, PI_BAUD  # 当使用树莓派版本的mycobot时，可以引用这两个变量进行MyCobot初始化
from pymycobot.mycobot import MyCobot
import time
def gripper_test(mc):
    print("Start check IO part of api\n")
    # 检测夹爪是否正在移动
    flag = mc.is_gripper_moving()
    print("Is gripper moving: {}".format(flag))
    time.sleep(1)

    # Set the current position to (2048).
    # Use it when you are sure you need it.
    # Gripper has been initialized for a long time. Generally, there
    # is no need to change the method.
    # mc.set_gripper_ini()
    # 设置关节点1，让其转动到2048这个位置
    mc.set_encoder(1, 2048)
    time.sleep(2)
    # 设置六个关节位，让机械臂以20的速度转动到该位置

    mc.set_encoders([1024, 1024, 1024, 1024, 1024, 1024], 20)
    # mc.set_encoders([2048, 2900, 2048, 2048, 2048, 2048], 20)
    # mc.set_encoders([2048, 3000,3000, 3000, 2048, 2048], 50)
    time.sleep(3)
    # 获取关节点1的位置信息
    print(mc.get_encoder(1))
    # 设置夹爪转动到2048这个位置
    mc.set_encoder(7, 2048)
    time.sleep(3)
    # 设置夹爪让其转到1300这个位置
    mc.set_encoder(7, 1300)
    time.sleep(3)

    # 以70的速度让夹爪到达2048状态，2048会报错，故改成255
    mc.set_gripper_value(255, 70)
    time.sleep(3)
    # 以70的速度让夹爪到达1500状态，1500会报错，故改成255
    mc.set_gripper_value(255, 70)
    time.sleep(3)

    num=5
    while num>0:
        # 设置夹爪的状态，让其以70的速度快速打开爪子
        mc.set_gripper_state(0, 70)
        time.sleep(3)
        # 设置夹爪的状态，让其以70的速度快速收拢爪子
        mc.set_gripper_state(1, 70)
        time.sleep(3)
        num-=1

    # 获取夹爪的值
    print("")
    print(mc.get_gripper_value())
    # mc.release_all_servos()

if __name__ == "__main__":
    # MyCobot 类初始化需要两个参数：
    #   第一个是串口字符串， 如：
    #       linux： "/dev/ttyUSB0"
    #       windows: "COM3"
    #   第二个是波特率：
    #       M5版本为： 115200
    #
    #   Example:
    #       mycobot-M5:
    #           linux:
    #              mc = MyCobot("/dev/ttyUSB0", 115200)
    #           windows:
    #              mc = MyCobot("COM3", 115200)
    #       mycobot-raspi:
    #           mc = MyCobot(PI_PORT, PI_BAUD)
    #
    # 初始化一个MyCobot对象
    # 下面为树莓派版本创建对象代码
    # mc = MyCobot(PI_PORT, PI_BAUD)
    # M5版本
    mc = MyCobot('COM3', 115200)
    # 让其移动到零位

    mc.set_encoders([2048, 2048, 2048, 2048, 2048, 2048], 20)
    time.sleep(3)
    gripper_test(mc)

吸泵控制

from pymycobot.mycobot import MyCobot
from pymycobot import PI_PORT, PI_BAUD  # 当使用树莓派版本的mycobot时，可以引用这两个变量进行MyCobot初始化
import time

# MyCobot 类初始化需要两个参数：
#   第一个是串口字符串， 如：
#       linux： "/dev/ttyUSB0"
#       windows: "COM3"
#   第二个是波特率：
#       M5版本为： 115200
#
#   Example:
#       mycobot-M5:
#           linux:
#              mc = MyCobot("/dev/ttyUSB0", 115200)
#           windows:
#              mc = MyCobot("COM3", 115200)
#       mycobot-raspi:
#           mc = MyCobot(PI_PORT, PI_BAUD)
#
# 初始化一个MyCobot对象
# 下面为M5版本创建对象代码
mc =MyCobot('COM3',115200)
# 机械臂运动的位置
angles = [
            [92.9, -10.1, -60, 5.8, -2.02, -37.7],
            [92.9, -53.7, -83.05, 50.09, -0.43, -38.75],
            [92.9, -10.1, -87.27, 5.8, -2.02, -37.7]
        ]


# 开启吸泵
def pump_on():
    # 让2号位工作
    mc.set_basic_output(2, 0)
    # 让5号位工作
    mc.set_basic_output(5, 0)

# 停止吸泵
def pump_off():
    # 让2号位停止工作
    mc.set_basic_output(2, 1)
    # 让5号位停止工作
    mc.set_basic_output(5, 1)


# 机械臂复原
mc.send_angles([0, 0, 0, 0, 0, 0], 30)
time.sleep(3)

#开启吸泵
pump_on()
mc.send_angles(angles[2], 30)
time.sleep(2)

#吸取小物块
mc.send_angles(angles[1], 30)
time.sleep(2)
mc.send_angles(angles[0], 30)
time.sleep(2)
mc.send_angles(angles[1], 30)
time.sleep(2)

#关闭吸泵
pump_off()
mc.send_angles(angles[0], 40)
time.sleep(1.5)
280-Pi版本：

from pymycobot.mycobot import MyCobot
from pymycobot import PI_PORT, PI_BAUD  # 当使用树莓派版本的mycobot时，可以引用这两个变量进行MyCobot初始化
import RPi.GPIO as GPIO
import time

# MyCobot 类初始化需要两个参数：
#   第一个是串口字符串， 如：
#       linux： "/dev/ttyUSB0"
#       windows: "COM3"
#   第二个是波特率：
#       M5版本为： 115200
#
#   Example:
#       mycobot-M5:
#           linux:
#              mc = MyCobot("/dev/ttyUSB0", 115200)
#           windows:
#              mc = MyCobot("COM3", 115200)
#       mycobot-raspi:
#           mc = MyCobot(PI_PORT, PI_BAUD)
#
# 初始化一个MyCobot对象
# 下面为树莓派版本创建对象代码
mc = MyCobot(PI_PORT, PI_BAUD)

# 机械臂运动的位置
angles = [
            [92.9, -10.1, -60, 5.8, -2.02, -37.7],
            [92.9, -53.7, -83.05, 50.09, -0.43, -38.75],
            [92.9, -10.1, -87.27, 5.8, -2.02, -37.7]
        ]
# 初始化吸泵
GPIO.setmode(GPIO.BCM)
GPIO.setup(20, GPIO.OUT)
GPIO.setup(21, GPIO.OUT)

# 开启吸泵
def pump_on():
    # 让20号位工作
    GPIO.output(20，0)
    # 让21号位工作
    GPIO.output(21，0)

# 停止吸泵
def pump_off():
    # 让20号位停止工作
    GPIO.output(21，1)
    # 让21号位停止工作
    GPIO.output(21，1)


# 机械臂复原
mc.send_angles([0, 0, 0, 0, 0, 0], 30)
time.sleep(3)

#开启吸泵
pump_on()
mc.send_angles(angles[2], 30)
time.sleep(2)

#吸取小物块
mc.send_angles(angles[1], 30)
time.sleep(2)
mc.send_angles(angles[0], 30)
time.sleep(2)
mc.send_angles(angles[1], 30)
time.sleep(2)

#关闭吸泵
pump_off()
mc.send_angles(angles[0], 40)
time.sleep(1.5)

【4】基于 C++ 的开发使用

1）环境搭建

Windows环境配置

1、下载：

首先在官网下载vs2019。

2、安装：

安装完成后，会出现下图所示界面，主要选择“通用Windows平台开发、使用C++的桌面开发、ASRNET和Web开发”这3个（此处只是建议，具体可根据自己的需求选择，vs2019安装时间较长）。

3、环境变量配置：

此电脑--》右键属性--》高级系统设置--》环境变量--》看系统变量处，点击新建--》变量名：VCINSTALLDIR 变量值：找到Redist所在目录(如：D:\vs2019\VC），具体点此所示

安装qt5.12.10

1、下载：

下载qt5.12.10及以上版本都可以，具体点此所示

2、安装：

首先登录qt账号，没有就先注册。接下来会出现选择组件的界面，windows上选择MinGW和MSVC即可，具体如下图所示：

3、环境变量配置：

此电脑--》右键属性--》高级系统设置--》环境变量--》看系统变量处，点击新建--》变量名：QTDIR 变量值：msvc2017_64所在目录（如：D:\qt5.12.10\5.12.10\msvc2017_64，具体看自己电脑的安装路径），具体点此所示

安装qt插件vsaddin

1、下载：

首先选择对应vs2019的vsaddin版本,具体操作点此所示

2、安装：直接安装即可

3、配置：

vs2019菜单栏扩展--》QT VS ToolS--》QT Versions--》add new qtversion Path选择msvc2017_64所在路径（如：D:\qt5.12.10\5.12.10\msvc2017_64），具体操作点此所示

Linux环境配置

安装qt5.12.10

1、下载：

下载地址和Windows一样，选择linux上的安装包即可，具体可看上面的操作步骤。

2、安装：

命令行安装：运行./“安装包名称”，如果没有执行权限，加执行权限：sudo chmod +x “安装包名称”，然后进入图形界面，和Windows一样；

图形界面安装：和Windows一样。

建议直接普通用户权限安装qt，安装成功后可以执行qmake --version，出现如下界面安装成功，点此所示

3、配置：

打开配置文件，普通用户安装qt：vi ~/.bashrc，root用户安装qt：vi ~/.profile。在配置文件中添加：export QTDIR=“qt所在目录”（如：export QTDIR=$HOME/Qt/5.12.10/gcc_64），具体点此所示

2）编译运行

下载

1 源码下载

github上下载MycobotCpp。

8.2.1.2 动态库下载

依赖库下载（下载最新版本，注意选择Windows或者Linux，后缀.zip为Windows所需要的库，.tar.gz为Linux需要的库）

Windows下运行

1 编译

vs2019打开MycobotCpp,选择x64-Release编译（启动项旁边，如果没有，点击下拉框--》管理配置进行添加），同时cmake设置的配置处也要选择release，最后点击生成。注意：一定选择x64-Release进行编译，具体点此所示

2 运行

手下添加库文件：将.lib添加到myCobotCpp/lib，.lib和.dll添加到myCobotCppExample.exe同级目录下，如out/build/x64-Release/bin（.lib和.dll这两个文件在myCobotCpp-0.0.3-windows-msvc-x86_64.zip压缩包内）
再运行：选择启动项（绿色播放键旁，也就是运行按钮旁），下拉选择myCobotCppEXample.exe(bin\myCobotCppExample.exe)，点击运行，具体点此所示

3 常见问题及解决办法：

运行时错误：

1、如果myCobotCpp.dll缺失，将之前放到lib目录下的myCobotCpp.dll放到mycobotcppexample.exe所在目录下

2、如果报缺少QT5Core.dll，打开qt command（菜单栏搜索QT），选择msvc 2017 64-bit，执行windeployqt --release myCobotCppExample.exe所在目录（如：windeployqt --release D:\vs2019\myCobotCpp\out\build\x64-Release\bin）此处执行命令后如果报找不到vs安装路径，请检查vs环境变量的设置

3、以上步骤执行后，如果报缺少qt5serialport.dll文件，将qt安装目录处的此文件(路径如：D:\qt5.12.10\5.12.10\msvc2017_64\bin)，拷贝到myCobotCppExample.exe所在目录

Linux下运行

1 编译构建

1、mkdir build && cd build

2、cmake ..

3、cmake --build .

2 运行

1、复制所有.so文件到lib目录下

2、命令行运行：./bin/myCobotCppExample（此处是在build目录下运行）

例如Ubuntu20.04上运行

编译

1、mkdir build && cd build

2、cmake ..

3、cmake --build .

运行

1、复制所有.so文件到lib目录下（注意下载后解压，不要在Windows解压后复制到Ubuntu，直接在Ubuntu解压，如：tar -xvf 然后直接拖动文件到终端）

2、将libQt5SerialPort.so.5(在QT安装目录，如：/home/“用户名”/Qt5.12.10/5.12.10/gcc_64/lib)软链接到mycobotcpp/build/bin（不要直接复制），命令如下（注意选择你们的路径）：ln -s /home/“用户名”/Qt5.12.10/5.12.10/gcc_64/lib/libQt5SerialPort.so.5 /home/“用户名”/myCobotCpp/build/bin/libQt5SerialPort.so.5

3 常见问题及解决办法

1、编译时出错：

找不到QTDIR。解决：查看QTDIR是否配置正确，可在命令行输出查看：echo $QTDIR
2、运行时出错：

串口问题：无法打开串口。解决：修改机械臂串口权限，不能直接chmod...，这样每次重启都要再次该权限。直接修改文件：

1.cd /etc/udev/rules.d

2.sudo gedit 20-usb-serial.rules

3.在文件在加入：KERNEL=="ttyUSB*" MODE="0777"

3、找不到文件问题：如无法打开或者找不到libQt5SerialPort.so.5。解决：检查上面的运行步骤2

注意:

如果不使用cmake编译，如直接在MFC中使用，按下图所示进行配置：

3)使用案例

关节控制

int main(int argc, char* argv[])
try {
    QCoreApplication a(argc, argv);
    using namespace std::chrono_literals;
    if (!mycobot::MyCobot::I().IsControllerConnected()) {
        std::cerr << "Robot is not connected\n";
        exit(EXIT_FAILURE);
    }
    std::cout << "Robot is connected\n";
    mycobot::MyCobot::I().PowerOn();
    mycobot::MyCobot::I().StopRobot();
    std::cout << "Robot is moving: " << mycobot::MyCobot::I().IsMoving() << "\n";
    mycobot::Angles angles = mycobot::MyCobot::I().GetAngles();
    std::this_thread::sleep_for(200ms);
    mycobot::Coords coords = mycobot::MyCobot::I().GetCoords();
    angles = mycobot::MyCobot::I().GetAngles();
    std::cout << "[" << angles[mycobot::J1] << ", " << angles[mycobot::J2] << ", " << angles[mycobot::J3] << ", "
        << angles[mycobot::J4] << ", " << angles[mycobot::J5] << ", " << angles[mycobot::J6] << "]";
    mycobot::Angles goal_angles = { 5, 5, 5, 5, 5, 5 };
    mycobot::MyCobot::I().WriteAngles(goal_angles);
    while (!mycobot::MyCobot::I().IsInPosition(goal_angles, false)) {
        angles = mycobot::MyCobot::I().GetAngles();
        std::cout << "[" << angles[mycobot::J1] << ", " << angles[mycobot::J2] << ", "
            << angles[mycobot::J3] << ", " << angles[mycobot::J4] << ", "
            << angles[mycobot::J5] << ", " << angles[mycobot::J6] << "]" << std::flush;
        std::this_thread::sleep_for(200ms);
    }

    mycobot::MyCobot::I().JogAngle(mycobot::Joint::J1, 1, 5);
    std::this_thread::sleep_for(5000ms);
    mycobot::MyCobot::I().StopRobot();

    std::cout << "\n";
    exit(EXIT_SUCCESS);
} catch (std::error_code&) {
    std::cerr << "System error. Exiting.\n";
    exit(EXIT_FAILURE);
} catch (...) {
    std::cerr << "Unknown exception thrown. Exiting.\n";
    exit(EXIT_FAILURE);
}

坐标控制

int main(int argc, char* argv[])
try {
    QCoreApplication a(argc, argv);
    using namespace std::chrono_literals;
    if (!mycobot::MyCobot::I().IsControllerConnected()) {
        std::cerr << "Robot is not connected\n";
        exit(EXIT_FAILURE);
    }
    std::cout << "Robot is connected\n";
    mycobot::MyCobot::I().PowerOn();
    mycobot::MyCobot::I().StopRobot();
    std::cout << "Robot is moving: " << mycobot::MyCobot::I().IsMoving() << "\n";
    mycobot::Angles angles = mycobot::MyCobot::I().GetAngles();
    std::this_thread::sleep_for(200ms);
    mycobot::Coords coords = mycobot::MyCobot::I().GetCoords();
    angles = mycobot::MyCobot::I().GetAngles();
    std::cout << "[" << angles[mycobot::J1] << ", " << angles[mycobot::J2] << ", " << angles[mycobot::J3] << ", "
        << angles[mycobot::J4] << ", " << angles[mycobot::J5] << ", " << angles[mycobot::J6] << "]";
    mycobot::Angles goal_angles = { 5, 5, 5, 5, 5, 5 };
    mycobot::MyCobot::I().WriteAngles(goal_angles);
    while (!mycobot::MyCobot::I().IsInPosition(goal_angles, false)) {
        angles = mycobot::MyCobot::I().GetAngles();
        std::cout << "[" << angles[mycobot::J1] << ", " << angles[mycobot::J2] << ", "
            << angles[mycobot::J3] << ", " << angles[mycobot::J4] << ", "
            << angles[mycobot::J5] << ", " << angles[mycobot::J6] << "]" << std::flush;
        std::this_thread::sleep_for(200ms);
    }

    mycobot::MyCobot::I().JogAngle(mycobot::Joint::J1, 1, 5);
    std::this_thread::sleep_for(5000ms);
    mycobot::MyCobot::I().StopRobot();

    std::cout << "\n";
    exit(EXIT_SUCCESS);
} catch (std::error_code&) {
    std::cerr << "System error. Exiting.\n";
    exit(EXIT_FAILURE);
} catch (...) {
    std::cerr << "Unknown exception thrown. Exiting.\n";
    exit(EXIT_FAILURE);
}

IO控制

int main(int argc, char* argv[])
try {
QCoreApplication a(argc, argv);
using namespace std::chrono_literals;
if (!mycobot::MyCobot::I().IsControllerConnected()) {
    std::cerr << "Robot is not connected\n";
    exit(EXIT_FAILURE);
}
std::cout << "Robot is connected\n";
mycobot::MyCobot::I().PowerOn();

mycobot::MyCobot::I().SleepSecond(1);//需要等待1S，让前面的动作做完

//设置io输出，2、5、26为m5输出引脚
mycobot::MyCobot::I().SetBasicOut(2, 1);
mycobot::MyCobot::I().SleepSecond(1);
mycobot::MyCobot::I().SetBasicOut(5, 1);
mycobot::MyCobot::I().SleepSecond(1);
mycobot::MyCobot::I().SetBasicOut(26, 1);
mycobot::MyCobot::I().SleepSecond(1);

//m5输入引脚 35、36 第一次会出现延迟
/*for (int i = 0; i < 2; i++) {
    std::cout << "35= " << mycobot::MyCobot::I().GetBasicIn(35) << std::endl;
    mycobot::MyCobot::I().SleepSecond(1);
    std::cout << "36= " << mycobot::MyCobot::I().GetBasicIn(36) << std::endl;
    mycobot::MyCobot::I().SleepSecond(1);
}*/

//atom输出引脚 23 33
/*mycobot::MyCobot::I().SetDigitalOut(23, 1);
mycobot::MyCobot::I().SleepSecond(1);
mycobot::MyCobot::I().SetDigitalOut(33, 1);
mycobot::MyCobot::I().SleepSecond(1);*/

//atom输入引脚22 19 第一次会出现延迟
/*for (int i = 0; i < 2; i++) {
    std::cout << "22= " << mycobot::MyCobot::I().GetDigitalIn(22) << std::endl;
    mycobot::MyCobot::I().SleepSecond(1);
    std::cout << "19= " << mycobot::MyCobot::I().GetDigitalIn(19) << std::endl;
    mycobot::MyCobot::I().SleepSecond(1);
}*/

//自适应夹爪 1--open 0--close 由于第一次有延迟，发送两次
/*for (int i = 0; i < 2; i++) {
    mycobot::MyCobot::I().SetGriper(1);
    mycobot::MyCobot::I().SleepSecond(3);
    mycobot::MyCobot::I().SetGriper(0);
    mycobot::MyCobot::I().SleepSecond(3);
}*/

//电动夹爪 1-开 0-关  由于第一次有延迟，发送两次
/*for (int i = 0; i < 2; i++) {
    mycobot::MyCobot::I().SetElectricGriper(1);
    mycobot::MyCobot::I().SleepSecond(1);
    mycobot::MyCobot::I().SetElectricGriper(0);
    mycobot::MyCobot::I().SleepSecond(1);
}*/
/*mycobot::MyCobot::I().StopRobot();
std::cout << "Robot is moving: " << mycobot::MyCobot::I().IsMoving() << "\n";
mycobot::Angles angles = mycobot::MyCobot::I().GetAngles();
std::this_thread::sleep_for(200ms);
mycobot::Coords coords = mycobot::MyCobot::I().GetCoords();
angles = mycobot::MyCobot::I().GetAngles();
std::cout << "[" << angles[mycobot::J1] << ", " << angles[mycobot::J2] << ", " << angles[mycobot::J3] << ", "
    << angles[mycobot::J4] << ", " << angles[mycobot::J5] << ", " << angles[mycobot::J6] << "]";
mycobot::Angles goal_angles = { 1, 0, 0, 0, 0, 0 };
mycobot::MyCobot::I().WriteAngles(goal_angles,180);
while (!mycobot::MyCobot::I().IsInPosition(goal_angles, false)) {
    angles = mycobot::MyCobot::I().GetAngles();
    std::cout << "[" << angles[mycobot::J1] << ", " << angles[mycobot::J2] << ", "
        << angles[mycobot::J3] << ", " << angles[mycobot::J4] << ", "
        << angles[mycobot::J5] << ", " << angles[mycobot::J6] << "]" << std::flush;
    std::this_thread::sleep_for(200ms);
}

//mycobot::MyCobot::I().JogAngle(mycobot::Joint::J1, 1, 5);
std::this_thread::sleep_for(5000ms);
mycobot::MyCobot::I().StopRobot();*/

std::cout << "\n";
exit(EXIT_SUCCESS);
} catch (std::error_code&) {
std::cerr << "System error. Exiting.\n";
exit(EXIT_FAILURE);
} catch (...) {
std::cerr << "Unknown exception thrown. Exiting.\n";
exit(EXIT_FAILURE);
}

夹爪控制

int main(int argc, char* argv[])
try {
QCoreApplication a(argc, argv);
using namespace std::chrono_literals;
if (!mycobot::MyCobot::I().IsControllerConnected()) {
    std::cerr << "Robot is not connected\n";
    exit(EXIT_FAILURE);
}
std::cout << "Robot is connected\n";
mycobot::MyCobot::I().PowerOn();

mycobot::MyCobot::I().SleepSecond(1);//需要等待1S，让前面的动作做完

//设置io输出，2、5、26为m5输出引脚
mycobot::MyCobot::I().SetBasicOut(2, 1);
mycobot::MyCobot::I().SleepSecond(1);
mycobot::MyCobot::I().SetBasicOut(5, 1);
mycobot::MyCobot::I().SleepSecond(1);
mycobot::MyCobot::I().SetBasicOut(26, 1);
mycobot::MyCobot::I().SleepSecond(1);

//m5输入引脚 35、36 第一次会出现延迟
/*for (int i = 0; i < 2; i++) {
    std::cout << "35= " << mycobot::MyCobot::I().GetBasicIn(35) << std::endl;
    mycobot::MyCobot::I().SleepSecond(1);
    std::cout << "36= " << mycobot::MyCobot::I().GetBasicIn(36) << std::endl;
    mycobot::MyCobot::I().SleepSecond(1);
}*/

//atom输出引脚 23 33
/*mycobot::MyCobot::I().SetDigitalOut(23, 1);
mycobot::MyCobot::I().SleepSecond(1);
mycobot::MyCobot::I().SetDigitalOut(33, 1);
mycobot::MyCobot::I().SleepSecond(1);*/

//atom输入引脚22 19 第一次会出现延迟
/*for (int i = 0; i < 2; i++) {
    std::cout << "22= " << mycobot::MyCobot::I().GetDigitalIn(22) << std::endl;
    mycobot::MyCobot::I().SleepSecond(1);
    std::cout << "19= " << mycobot::MyCobot::I().GetDigitalIn(19) << std::endl;
    mycobot::MyCobot::I().SleepSecond(1);
}*/

//自适应夹爪 1--open 0--close 由于第一次有延迟，发送两次
for (int i = 0; i < 2; i++) {
    mycobot::MyCobot::I().SetGriper(1);
    mycobot::MyCobot::I().SleepSecond(3);
    mycobot::MyCobot::I().SetGriper(0);
    mycobot::MyCobot::I().SleepSecond(3);
}

//电动夹爪 1-开 0-关  由于第一次有延迟，发送两次
/*for (int i = 0; i < 2; i++) {
    mycobot::MyCobot::I().SetElectricGriper(1);
    mycobot::MyCobot::I().SleepSecond(1);
    mycobot::MyCobot::I().SetElectricGriper(0);
    mycobot::MyCobot::I().SleepSecond(1);
}*/
/*mycobot::MyCobot::I().StopRobot();
std::cout << "Robot is moving: " << mycobot::MyCobot::I().IsMoving() << "\n";
mycobot::Angles angles = mycobot::MyCobot::I().GetAngles();
std::this_thread::sleep_for(200ms);
mycobot::Coords coords = mycobot::MyCobot::I().GetCoords();
angles = mycobot::MyCobot::I().GetAngles();
std::cout << "[" << angles[mycobot::J1] << ", " << angles[mycobot::J2] << ", " << angles[mycobot::J3] << ", "
    << angles[mycobot::J4] << ", " << angles[mycobot::J5] << ", " << angles[mycobot::J6] << "]";
mycobot::Angles goal_angles = { 1, 0, 0, 0, 0, 0 };
mycobot::MyCobot::I().WriteAngles(goal_angles,180);
while (!mycobot::MyCobot::I().IsInPosition(goal_angles, false)) {
    angles = mycobot::MyCobot::I().GetAngles();
    std::cout << "[" << angles[mycobot::J1] << ", " << angles[mycobot::J2] << ", "
        << angles[mycobot::J3] << ", " << angles[mycobot::J4] << ", "
        << angles[mycobot::J5] << ", " << angles[mycobot::J6] << "]" << std::flush;
    std::this_thread::sleep_for(200ms);
}

//mycobot::MyCobot::I().JogAngle(mycobot::Joint::J1, 1, 5);
std::this_thread::sleep_for(5000ms);
mycobot::MyCobot::I().StopRobot();*/

std::cout << "\n";
exit(EXIT_SUCCESS);
} catch (std::error_code&) {
std::cerr << "System error. Exiting.\n";
exit(EXIT_FAILURE);
} catch (...) {
std::cerr << "Unknown exception thrown. Exiting.\n";
exit(EXIT_FAILURE);
}

【5】基于 C# 的开发使用

1）环境搭建

Windows环境配置

安装vs2019

1、下载：

首先在官网下载vs2019。
2、安装：

安装完成后，会出现下图所示界面，主要选.NET桌面开发即可（此处只是建议，具体可根据自己的需求选择，vs2019安装时间较长）。

树莓派机械臂环境配置

1 安装monodevelop

1、安装

按次序执行下面命令进行安装，也可以查看官网说明：

sudo apt install apt-transport-https dirmngr

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF echo "deb https://download.mono-project.com/repo/ubuntu vs-bionic main" | sudo tee /etc/apt/sources.list.d/mono-official-vs.list

sudo apt update

sudo apt-get install monodevelop

2、测试

测试是否安装成功，请查看此文档。

2）编译运行

下载

1 源码下载

github上下载Mycobot.csharp。

9.2.1.2 动态库下载

运行案例，需要用到此动态库，它封装了控制机械臂的API：

1、选择最新版本，具体如下图所示：

2、动态库分Windows（Windows分.net和.net framework，如何区分，请看下面的Windows下运行）和树莓派系统版本，具体如下图所示：

Windows下运行

1 直接运行github下载的Mycobot.csharp案例:

1、双击打开Mycobot.csharp.sln(确保电脑安装了vs2019，如果未安装，请看环境搭建）

2、编译运行项目，查看机械臂串口号，如果与示例不一致，请修改串口号，具体可点此所示

2 在自己的项目中调用Mycobot.csharp动态库:

1、检查项目的目标框架，然后下载相应动态库。如果你项目的目标框架（target frame）是.net core,下载 net core/Mycobot.csharp.dll,如果目标框架是.net framework,下载 net framework/Mycobot.csharp.dll)，具体步骤点此所示

2、导入Mycobot.csharp.dll到项目中，具体步骤点此所示

3、添加system.io.ports到 .csproj( 项目名称,该文件位于项目目录中),具体请看像下面的图片:
frame: .net core

frame: .net framework

3 问题

在使用过程中可能碰到的问题:

1、问题: System.Runtime, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies...

解决:更新你的sdk(if .net core,update to 5.0 and choose,if .net framework update to 4.0 and choose 4.7.2),点此查看

2、问题:System.IO.FileNotFoundException:“Could not load file or assembly 'System.IO.Ports, Version=6.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51'.

解决:请看上面调用动态库的第3步

树莓派机械臂上运行

1、创建一个 C#控制台应用程序（console application）;

2、复制文件program.cs,然后将program.cs粘贴到新创建的C#控制台应用程序;

3、将program.cs中的端口号改为/dev/ttyAMA0(MyCobot mc = new MyCobot("/dev/ttyAMA0"));

4、将编译方式改为Release;

5、将Mycobot.csharp.dll库文件加入项目中，library:ReFerences-->Edit References-->.Net Assembly-->Browse(path for .dll)，点此查看

6、运行. 注意:编译&&运行,整个操作过程可以点此查看

3）使用案例

关节控制

Mycobot.csharp源码中的program.cs是完整的使用案例程序，可以在此基础上根据需要修改。

using System;

namespace Mycobot.csharp
{
    class Test 
    {
        static void Main(string[] args)
        {
            MyCobot mc = new MyCobot("/dev/ttyUSB0");
            mc.Open();
            // int[] angles = new[] {100, 100, 100, 100, 100, 100};
            // mc.SendAngles(angles, 50);
            // Thread.Sleep(5000);
            // var recv = mc.GetAngles();
            // foreach (var v in recv)
            // {
                // Console.WriteLine(v);
            // }

            // int[] coords = new[] {160, 160, 160, 0, 0, 0};
            // mc.SendCoords(coords, 90, 1);
            // Thread.Sleep(5000);
            // var recv = mc.GetCoords();
            // foreach (var v in recv)
            // {
                // Console.WriteLine(v);
            // }

            mc.SendOneAngle(1, 100,70);

            // byte[] setColor = {0xfe, 0xfe, 0x05, 0x6a, 0xff, 0x00, 0x00, 0xfa};
            mc.Close();
        }
    }

坐标控制

Mycobot.csharp源码中的program.cs是完整的使用案例程序，可以在此基础上根据需要修改。

using System;

namespace Mycobot.csharp
{
    class Test 
    {
        static void Main(string[] args)
        {
            MyCobot mc = new MyCobot("/dev/ttyUSB0");
            mc.Open();
            // int[] angles = new[] {100, 100, 100, 100, 100, 100};
            // mc.SendAngles(angles, 50);
            // Thread.Sleep(5000);
            // var recv = mc.GetAngles();
            // foreach (var v in recv)
            // {
                // Console.WriteLine(v);
            // }

            // int[] coords = new[] {160, 160, 160, 0, 0, 0};
            // mc.SendCoords(coords, 90, 1);
            // Thread.Sleep(5000);
            // var recv = mc.GetCoords();
            // foreach (var v in recv)
            // {
                // Console.WriteLine(v);
            // }

            mc.SendOneAngle(1, 100,70);

            // byte[] setColor = {0xfe, 0xfe, 0x05, 0x6a, 0xff, 0x00, 0x00, 0xfa};
            mc.Close();
        }
    }

IO控制

Mycobot.csharp源码中的program.cs是完整的使用案例程序，可以在此基础上根据需要修改。

using System;
using System.Threading;

namespace Mycobot.csharp
{
    class Test
    {
        static void Main(string[] args)
        {
            MyCobot mc = new MyCobot("COM57");//树莓派机械臂串口名称：/dev/ttyAMA0
            mc.Open();
            Thread.Sleep(5000);//windows打开串口后，需要等待5s，Windows打开串口底部basic会重启

            //set basic output io
            /*mc.SetBasicOut(2, 1);
            Thread.Sleep(100);
            mc.SetBasicOut(5, 1);
            Thread.Sleep(100);
            mc.SetBasicOut(26, 1);
            Thread.Sleep(100);*/

            //get basic input io
            Console.WriteLine(mc.GetBasicIn(35));
            Thread.Sleep(100);
            Console.WriteLine(mc.GetBasicIn(36));
            Thread.Sleep(100);

            //set atom output io
            /*mc.SetDigitalOut(23, 0);
            Thread.Sleep(100);
            mc.SetDigitalOut(33, 0);
            Thread.Sleep(100);*/

            //get m5 input io
            /*Console.WriteLine(mc.GetDigitalIn(19));
            Thread.Sleep(100);
            Console.WriteLine(mc.GetDigitalIn(22));
            Thread.Sleep(100);*/

            mc.Close();
        }
    }
}

夹爪控制

using System;
using System.Threading;

namespace Mycobot.csharp
{
    class Test
    {
        static void Main(string[] args)
        {
            MyCobot mc = new MyCobot("COM57");//树莓派机械臂串口名称：/dev/ttyAMA0
            mc.Open();
            Thread.Sleep(5000);//windows打开串口后，需要等待5s，Windows打开串口底部basic会重启

            //set gripper open or close 0--close 100-open max 0-100
            mc.setGripperValue(0, 10);
            Thread.Sleep(3000);
            mc.setGripperValue(50, 100);
            Thread.Sleep(3000);

            //set electric gripper
            mc.setEletricGripper(0);
            Thread.Sleep(100);
            mc.setEletricGripper(1);
            Thread.Sleep(100);

            //get gripper state 0--close 1--open
            Console.WriteLine(mc.getGripperValue());
            mc.Close();
        }
    }
}

【6】基于 JavaScript 的开发使用

1）开发前准备

windows32位下载地址

windows64位下载地址

macOs下载地址

1 Windows Node环境搭建

第一步下载完成后，双击下载好的安装包，开始安装Node.js，点击next按钮

第二步勾选左下红框内选项,再点击next

第三步自定义安装目录

第四步默认点击next按钮继续下一步

第五步点击install

第六步点击finsh安装完成

第七步 win+r打开运行，输入cmd进入命令指示符

第八步输入node -v获取node版本，显示版本则安装成功

2 MacOs node环境搭建

第一步下载完成后，双击下载好的安装包，开始安装Node.js，点击next按钮,点击继续

第二步再次点击继续

第三步点击同意继续下一步

第四步点击自定义，选择安装地址，或是点击安装继续安装,并输入你的密码进行安装

第五步提示安装成功点击关闭,退出安装程序

鼠标右键点击桌面选择打卡终端，进入终端后输入node -v,显示node版本号则表示安装成功

3 Linux node环境搭建

第一步 Node 官网已经把 linux 下载版本更改为已编译好的版本了，我们可以直接下载解压后使用：

# wget https://nodejs.org/dist/v10.9.0/node-v10.9.0-linux-x64.tar.xz    // 下载
# tar xf  node-v10.9.0-linux-x64.tar.xz       // 解压
# cd node-v10.9.0-linux-x64/                  // 进入解压目录
# ./bin/node -v                               // 执行node命令 查看版本
v10.9.0

第二步解压文件的 bin 目录底下包含了 node、npm 等命令，我们可以使用 ln 命令来设置软连接：

ln -s /usr/software/nodejs/bin/npm   /usr/local/bin/ 
ln -s /usr/software/nodejs/bin/node   /usr/local/bin/

4 Ubuntu 源码安装 Node.js

第一步以下部分我们将介绍在 Ubuntu Linux 下使用源码安装 Node.js 。其他的 Linux 系统，如 Centos 等类似如下安装步骤。在 Github 上获取 Node.js 源码：

$ sudo git clone https://github.com/nodejs/node.git
Cloning into 'node'...

第二步修改目录权限

$ sudo chmod -R 755 node

第三步使用 ./configure 创建编译文件，并按照：

$ cd node
$ sudo ./configure
$ sudo make
$ sudo make install

第四步查看 node 版本：

$ node --version
v0.10.25

2）开发准备

1 下载项目文件

打开命令提示符

git clone https://github.com/elephantrobotics/jsmycobot.git

2 开发程序初始化

注意:在下载好的项目文件内打开命令提示符

<!-- 初始化程序,并且安装运行程序所需要的所有插件 -->
npm i

3 初始化程序

<!-- 导入步骤1-1所安装的插件 -->
const mycobot = require("mycobot")

<!-- 初始化程序，mycobot.connect(串口编号,串口波特率) -->
const obj = mycobot.connect("COM15",115200)

<!-- 写入第一个指令,给机械臂通电并保持当前机械臂的姿势 -->
obj.write(mycobot.powerOn())

3）使用案例

IO控制

<!-- 初始化程序 -->
const mycobot = require('mycobot')

const obj = mycobot.connect('COM15',115200)

<!-- 设置ATOM指示灯颜色 mycobot.setColor(redValue,greenValue,blueVaule)-->
<!-- 注意:三个参数限值为0~255 -->
obj.write(mycobot.setColor(125,11,9))

<!-- 将当前机械臂的角度以及坐标设置为机械臂运作起点 -->
obj.write(mycobot.setGripperInit())

单关节控制

<!-- 初始化程序 -->
const mycobot = require('mycobot')

const obj = mycobot.connect('COM15',115200)

<!-- 设置单独机械臂的角度 mycobot.sendAngle(机械臂ID,角度值,机械臂调整角度时运转的速度)-->
<!-- 注意:在设置更换角度的值得时候，需要注意机械臂关节的数量,4节则输入1~4;6节则输入1~6,否则报错 -->
<!-- 四轴六轴机械臂角度设置详见1-3图表 -->
obj.write(mycobot.sendAngle(1,110,10))

<!-- 设置单独机械臂的坐标 mycobot.sendCoord(机械臂ID,坐标值,机械臂调整坐标时的运动速度)-->
obj.write(mycobot.sendCoord(1,20,10))

多关节控制

注意：在操作多关节时，应按照机械臂关节数，填入相对应数量的参数

<!-- 初始化程序 -->
const mycobot = require('mycobot')

const obj = mycobot.connect('COM15',115200)

<!-- 设置多关节机械臂角度 mycobot.sendAngles([关节一角度,关节二角度,关节三角度,关节四角度,关节五角度,关节六角度],关节运作速度) -->
obj.write(mycobot.sendAngles([-110,23,-22,110],20))

<!-- 设置多关节机械臂坐标 mycobot.sendCoords([关节一坐标,关节二坐标,关节三坐标,关节四坐标,关节五坐标,关节六坐标],关节运作速度) -->
obj.write(mycobot.sendCoords([22.5,12,-22,45],20))

夹爪控制

<!-- 初始化程序 -->
const mycobot = require('mycobot')

const obj = mycobot.connect('COM15',115200)

<!-- 设置夹爪的开关状态 mycobot.setGripperState(开关状态,运作速度)-->
<!-- 注意：开关状态参考值:0为打开,1为关闭,并且运作速度限值0~100 -->
obj.write(mycobot.setGripperState(0,10))

<!-- 设置夹爪的角度值 mycobot.setGripperValue(角度值,速度)-->
<!-- 注意:角度值与速度值限值为0~100 -->
obj.write(mycobot.setGripperValue(80,20)))

综合示例1

<!-- 初始化程序 -->
const mycobot = require('mycobot')
const obj = mycobot.connect('COM15',115200)

<!-- 假设连接的是四轴机械臂 -->
const name = "myPallizer"
<!-- 如果连接的设备是六轴机械臂的话 -->
if(name == "myCobot"){
    <!-- 设置六个关节各自的角度 -->
    obj.write(mycobot.sendAngles([-1.49,115,-153.45,30,-33.42,137.9],80))
    <!-- 并且判断是否到达该坐标 -->
    if(obj.write(mycobot.isInPosition([-1.49,115,-153.45,30,-33.42,137.9],0)) == 1){
        <!-- 恢复机械臂运动 -->
        obj.write(mycobot.programResume())
        <!-- 等待0.5秒 -->
        settimeout(() =>{
            <!-- 暂停机械臂运动 -->
            obj.write(mycobot.programPause())
        },500)
    }
}else{
    <!-- 设置四个关节各自的角度 -->
    obj.write(mycobot.sendAngles([-1.49,45,-23,30],80))
    <!-- 设置ATOM指示灯的颜色 -->
    obj.write(mycobot.setColor(0,0,50))
    <!-- 等待0.7秒 -->
    settimeout(() =>{
        <!-- 再次设置四个关节各自的角度 -->
        obj.write(mycobot.sendAngles([-1.49,60,11,30],80))
        <!-- 设置ATOM指示灯的颜色 -->
        obj.write(mycobot.setColor(0,50,0))
    },700)

}

综合示例2

<!-- 初始化程序 -->
const mycobot = require('mycobot')
const obj = mycobot.connect('COM15',115200)

<!-- 获取当前所有关节的角度 -->
const botData = obj.write(mycobot.getAngles())
<!-- 输出当前所有关节的角度 -->
console.log(botdata)
<!-- 设置当前所有关节的角度 -->
obj.write(mycobot.sendAngles([0,0,0,0],50))
<!-- 打印机械臂当前是否到达该位置 -->
console.log(obj.write(mycobot.isInPosition([0,0,0,0,0,0],0)) == 1)

<!-- 等待3秒后 -->
settimeout(() =>{
    <!-- 设置第一个关节的角度 -->
    obj.write(mycobot.sendAngle(1,90,50))
},3000)

<!-- 等待两秒后 -->
settimeout(() =>{
    <!-- 将关节二角度设置为50度 -->
    obj.write(mycobot.sendAngle(2,50,50))
},2000)
<!-- 等待1.5秒后 -->
settimeout(() =>{
    <!-- 将关节三角度设置为50度 -->
    obj.write(mycobot.sendAngle(3,-50,50))
},1500)
<!-- 等待1.5秒后 -->
settimeout(() =>{
    <!-- 设置机械臂所有关节角度 -->
    obj.write(mycobot.sendAngles([88.68, -138.51, 155.65, -128.05, -9.93, -15.29],50))
},1500)
<!-- 等待2.5秒后 -->
settimeout(() =>{
    <!-- 将机械臂设置为自由模式 -->
    obj.write(mycobot.releaseAllServos())
},2500)

版本更新说明

性能提升

1.重复定位精度

更换了myCobot内部的部分零件，使用了质量更好、精度更高的零件，使得myCobot 280机械臂的重复定位精度到达了±0.5mm 。重复定位精度上的显著提升，使得myCobot 280机械臂可以适用于更多得场景，完成更加精细的工作，让准商业应用成为可能！

2.寿命增加100%

通过材质和结构上的更新，经过严格的测试，在保证性价比的同时，2023版myCobot 280在使用寿命上将较过去增加100%。

3.自干涉检测

对myCobot机械臂的运动算法重新进行了设计，在这次更新后，myCobot机械臂拥有了自干涉检测功能。

4.通信速度5倍提升

通信速度指的是机械臂从接受到指令到反馈的时间，通信速度的高低极大影响了机械臂的工作学习效率和使用体验，在本次更新中，通过硬件方面的强化，myCobot 280机械臂的通信速度达到了20ms，较之前提升近五倍。

5整体关节优化

使用了许多不同的材质和组合方式进行了多次的测试，最终挑选出最为合适的搭配，使得2023版本的myCobot 280在稳定性、耐用性、精确性上都有了十足的提升。
在机械臂内部，将关节电机全部更换为了全金属电机，即便反复拆装也不会损坏，一定程度上提升了机械臂的可玩性。同时，对机械臂关节进行了微调，增加连轴件的长度，让机械臂运动更丝滑。

6.刚度提升，整体不易破坏

在外壳部分，加入了加强筋，同时增加了材料中的PC比例占比，外壳整体刚性获得了极大的提升，硬度和抗破坏能力显著增加。

新增3大功能

1.支持写字画画

机械臂精度和稳定性的提升，运动学算法全新升级，可以书写出流畅的线条，支持简单绘画，给用户更大的创意空间。

2.APP控制

支持通过myCobot_Control App进行手机无线控制；手机对机械臂的控制是通过安装在主控板上的蓝牙模块实现对机械臂每个自由度的单独控制，也可以通过APP中的按钮配置使机械臂实现各种不同动作。

3.手柄控制

支持myCobot_Gamepad无线遥控器控制；手柄控制模式通过安装在主控板上的手柄接收器接收手柄发送的控制信息，从而实现对机械臂的控制；此模式效率高，操作简便。

更多问题及有趣的应用，可以 访问论坛 进行查阅或发帖。

DFRobot商城购买链接