当利用可执行文件处理打乱的魔方，会得到一串类似F1U2B1D3……的字符，这些字符代表了还原魔方的动作，了解他们的具体含义就是最后我们需要解决的问题，而这个问题跟前面的比起来要简单得多。

6.1 动作表示

魔方一共有6个面，针对某1个面我们来拧他，分解后实际会得到3个基本动作：顺时针90度、顺时针180度、逆时针90度。看到这些有没有觉得亲切？这与之前我们分解EV3底座动作很类似。

对这3种动作用1 2 3来表示：

• 1：顺时针90度
• 2：顺时针180度
• 3：逆时针90度

结合6个面的表示法U F R B L D，就可以完成每个面的动作表示。比如：F1表示F面顺时针90度、R2表示R面顺时针180度……

最后就是对这些魔方动作，结合EV3机器人的动作，完成程序设计。

6.2 程序设计

# 转魔方的机器人马达指令
# U面旋转
def twist_u_clockwise():
  base_anticlockwise()
  hand_turn()
  hand_press()
  base_anticlockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()
  base_clockwise()
def twist_u_anticlockwise():
  base_anticlockwise()
  hand_turn()
  hand_press()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()
  base_clockwise()
def twist_u_reverse():
  base_anticlockwise()
  hand_turn()
  hand_press()
  base_clockwise()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()
  base_clockwise()

# D面旋转
def twist_d_clockwise():
  base_clockwise()
  hand_turn()
  hand_press()
  base_anticlockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()
  base_anticlockwise()
def twist_d_anticlockwise():
  base_clockwise()
  hand_turn()
  hand_press()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()
  base_anticlockwise()
def twist_d_reverse():
  base_clockwise()
  hand_turn()
  hand_press()
  base_clockwise()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()
  base_anticlockwise()

# F面旋转
def twist_f_clockwise():
  hand_turn()
  hand_turn()
  hand_press()
  base_anticlockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_raise()
def twist_f_anticlockwise():
  hand_turn()
  hand_turn()
  hand_press()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_raise()
def twist_f_reverse():
  hand_turn()
  hand_turn()
  hand_press()
  base_clockwise()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_raise()

# B面旋转
def twist_b_clockwise():
  hand_press()
  base_anticlockwise()
  hand_raise()
def twist_b_anticlockwise():
  hand_press()
  base_clockwise()
  hand_raise()
def twist_b_reverse():
  hand_press()
  base_clockwise()
  base_clockwise()
  hand_raise()

# L面旋转
def twist_l_clockwise():
  hand_turn()
  hand_press()
  base_anticlockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()
def twist_l_anticlockwise():
  hand_turn()
  hand_press()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()
def twist_l_reverse():
  hand_turn()
  hand_press()
  base_clockwise()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_turn()
  hand_turn()
  hand_raise()

# R面旋转
def twist_r_clockwise():
  hand_turn()
  hand_turn()
  hand_turn()
  hand_press()
  base_anticlockwise()
  hand_raise()
  hand_turn()
  hand_raise()
def twist_r_anticlockwise():
  hand_turn()
  hand_turn()
  hand_turn()
  hand_press()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_raise()
def twist_r_reverse():
  hand_turn()
  hand_turn()
  hand_turn()
  hand_press()
  base_clockwise()
  base_clockwise()
  hand_raise()
  hand_turn()
  hand_raise()

# 动作对应关系
move_step = {
  "U1":twist_u_clockwise,
  "U2":twist_u_reverse,
  "U3":twist_u_anticlockwise,
  "D1":twist_d_clockwise,
  "D2":twist_d_reverse,
  "D3":twist_d_anticlockwise,
  "F1":twist_f_clockwise,
  "F2":twist_f_reverse,
  "F3":twist_f_anticlockwise,
  "B1":twist_b_clockwise,
  "B2":twist_b_reverse,
  "B3":twist_b_anticlockwise,
  "L1":twist_l_clockwise,
  "L2":twist_l_reverse,
  "L3":twist_l_anticlockwise,
  "R1":twist_r_clockwise,
  "R2":twist_r_reverse,
  "R3":twist_r_anticlockwise
}
###==================================================###

###=================MAIN FUNCTION====================###
def main():
  # 扫描魔方
  cube_scan = buildup_cube_module()
  # 建立模型
  cube_module = cvt2reid(cube_scan)
  # 植入算法
  cube_solved = cube_algorithm(cube_module)

  # 分解动作
  for i in range(len(cube_solved)/2):
    solve_step = cube_solved[i*2]+cube_solved[i*2+1]
    # 执行动作
    move_step[solve_step]

  # 结束任务
  end_of_mission()

if __name__ == '__main__':
  main()
###=====================EOF==========================###

写在最后

从打算做这个项目到最后完成，前后用了大约2个月的时间。不得不说，在程序设计和实验的过程中遇到了在做之前没有想到的困难。也许这个系列的文章中简单的一段话，在实际做的过程中却是经过了很长时间多次的学习、研究才完成的。

本来是想每年用LEGO完成一个项目，定的计划也是2015年完成数字识别机器人、2016年完成解魔方机器人，但随着自己对EV3各类传感器、马达以及ev3dev系统和Python语言的不断熟悉，今年的任务也就提前完成了。

整理文字的过程是一个很枯燥繁琐的过程，同样也是一个总结和分享的过程。不得不说，在写这段文字的时候还是很开心的。接下来做什么样的项目还没有想好，也许会跟网络编程或者物联网开放平台相关。

如果你对我关注的东西也感兴趣，欢迎共同探讨。

到此为止，魔方的扫描与计算机表示都已经完成，解决步骤的算法实现，应该说与EV3传感器和马达没有太多的关系，主要是由计算机完成的。魔方的解决是基于群论实现的，说实话我本人并没有对这种理论算法做进一步深入的研究，因为他确实需要时间去学习。好在一些网站早已经将这部分算法实现，并开源出来。Tomas Rokicki的个人主页包含了大量的算法和程序实现，感兴趣的同学强烈推荐：http://tomas.rokicki.com/

5.1 算法程序编译与使用

Tomas Rokicki曾发起过一次解魔方编程活动，所有参赛的程序都是开源的。同样，感兴趣研究魔方算法的同学可以自行围观：http://tomas.rokicki.com/cubecontest/winners.html

如前所述，我只是需要在EV3中使用这些程序，下载其中一个代码，然后按照代码所使用的编程语言进行编译，即可得到可执行的文件。

在此我使用页面中排名第2的程序（pochmann），作者使用C++，因此我们使用C++编译器将代码编译为可执行程序。以g++编译器为例，执行：

g++ JohnnyX.cpp -o pochmann.exe

所获得的pochmann.exe即为解魔方算法的可执行文件。参照这个程序的使用说明，程序的使用方法是：

• 输入：可执行文件 魔方的状态表示
• 输出：魔方的解法

新的问题出现了，程序输入中的魔方的状态表示是什么样的？跟我们在上一章整理的表达式有什么关系吗？

5.2 魔方色块表示法

先来看个结论，采用色块表示法，一个还原的魔方可表示为：

UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR

不要被这个东西吓到，我们慢慢来看，就会发现并没有那么难。

字母含义

这一串字符中，一共包含了6个字母：U F R B L D，分别代表了一个魔方的上面（Up）、前面（Front）、右面（Right）、后面（Back）、左面（Left）、底面（Down）

魔方的轴

也许你会发现一个问题，就是用这6个字母表示魔方的6个面，如果魔方变换了方位那6个面的方向不是也变了？这就需要说明一下魔方的轴。

如果你手边有一个魔方，那么仔细注意魔方6个面的中心点，然后保持中心点的方向不动，试着去转动6个面，你一定会发现，无论你怎么转动这些面，这6个中心点的位置是不会发生变化的。

比如下面这两幅图：打乱前和打乱后，白色、绿色、红色面的中心点并未变化。也即魔方的轴在拧魔方的过程中，相对位置是不会发生变化的。

还原状态

打乱状态

魔方的色块

魔方由8个角块、12个棱块和6个中心块组成。中心块的位置固定在十字架上。每个角块3面有颜色、每个棱块2面有颜色、每个中心块1面有颜色。

由于中心块的相对位置不变，对于角块和棱块可以用每个面所属的方向进行描述。依然，一个还原的魔方棱块和角块可以表示为：

• 棱块 UF UR UB UL DF DR DB DL FR FL BR BL
• 角块 UFR URB UBL ULF DRF DFL DLB DBR

新的问题又来了，一个打乱的魔方怎么表示？

打乱魔方的色块表示

首先我们还是来看那个还原的魔方表示：

UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR

现在已经知道了那么表示棱块和角块，但其实这个表示是包含两个隐含属性的，分别是：色块位置、颜色方向

• 色块位置 UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR
• 颜色方向 UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR

色块位置很好理解，正如前文所述，就是每个色块位置的方向型表示。而颜色方向可以理解为，色块某一面的颜色与某个中心色块颜色相同，那么这个色块某一面的颜色所属方向，即为那个中心色块颜色的方向。

比如，在下面这个魔方里面，位置处于FR的色块，色块的F面是红色、R面是蓝色，分别与魔方F面和U面的中心点的颜色一样，所以这个色块的颜色方向为：FU。

如果理解了上面这个例子，那么再来看色块位置和颜色方向两行的表示，可以说角块的表示方法只是按照“颜色方向”对魔方进行描述，而描述的顺序是按照“色块位置”执行的。

5.3 程序设计

# 将6x9个面的表示转换为12+8个色块的表示
#                   +--5U-+
#                   |0 1 2|
#                   |3 4 5|
#                   |6 7 8|
# +--0F-+--1R-+--2B-+--3L-+
# |0 1 2|0 1 2|0 1 2|0 1 2|
# |3 4 5|3 4 5|3 4 5|3 4 5|
# |6 7 8|6 7 8|6 7 8|6 7 8|
# +-----+-----+-----+--4D-+
#                   |0 1 2|
#                   |3 4 5|
#                   |6 7 8|
#                   +-----+
# 输入：6x9个面的表示法
# 输出：12+8个块的表示法

def cvt2reid(orignal):
  c = str(orignal)

  # 各个面的中心块代表该面的颜色方向
  c2r = {c[5][4]:'U', c[0][4]:'F', c[1][4]:'R', c[2][4]:'B', c[3][4]:'L', c[4][4]:'D'}

  # 按照指定规律进行色块组合
  reid_mode = c2r[c[5][5]]+c2r[c[0][1]]+' '+c2r[c[5][1]]+c2r[c[1][1]]+' '+c2r[c[5][3]]+c2r[c[2][1]]+' '+c2r[c[5][7]]+c2r[c[3][1]]+' '+\
              c2r[c[4][5]]+c2r[c[0][7]]+' '+c2r[c[4][7]]+c2r[c[1][7]]+' '+c2r[c[4][3]]+c2r[c[2][7]]+' '+c2r[c[4][1]]+c2r[c[3][7]]+' '+\
              c2r[c[0][5]]+c2r[c[1][3]]+' '+c2r[c[0][3]]+c2r[c[3][5]]+' '+c2r[c[2][3]]+c2r[c[1][5]]+' '+c2r[c[2][5]]+c2r[c[3][3]]+' '+\
              c2r[c[5][2]]+c2r[c[0][2]]+c2r[c[1][0]]+' '+c2r[c[5][0]]+c2r[c[1][2]]+c2r[c[2][0]]+' '+\
              c2r[c[5][6]]+c2r[c[2][2]]+c2r[c[3][0]]+' '+c2r[c[5][8]]+c2r[c[3][2]]+c2r[c[0][0]]+' '+\
              c2r[c[4][8]]+c2r[c[1][6]]+c2r[c[0][8]]+' '+c2r[c[4][2]]+c2r[c[0][6]]+c2r[c[3][8]]+' '+\
              c2r[c[4][0]]+c2r[c[3][6]]+c2r[c[2][8]]+' '+c2r[c[4][6]]+c2r[c[2][6]]+c2r[c[1][8]]

  # 返回色块表示列表
  return reid_mode

# 借助编译好的解魔方可执行文件，完成魔方还原步骤
# 此处使用pochmann提供的解决方法
def cube_algorithm(cube_unsolved):
  cube_solved = os.popen('pochmann.exe '+cube_unsolved).readline()
	
  # 返回还原魔方的步骤
  return cube_solved

4.3 调整顺序

虽然魔方每个面都扫描完了，但是有没有发现什么问题？没错，色块的顺序有点乱，通常我们习惯下面这种顺序来表示：

                   +--5--+
                   |0 1 2|
                   |3 4 5|
                   |6 7 8|
 +--0--+--1--+--2--+--3--+
 |0 1 2|0 1 2|0 1 2|0 1 2|
 |3 4 5|3 4 5|3 4 5|3 4 5|
 |6 7 8|6 7 8|6 7 8|6 7 8|
 +-----+-----+-----+--4--+
                   |0 1 2|
                   |3 4 5|
                   |6 7 8|
                   +-----+

调整顺序其实就是某两个色块进行对调，同样并没有什么难度，需要的只是耐心和细心。

程序设计

# 输入未排序的魔方
def scan_reshape(orignal):
  result = np.zeros((6,9), np.uint8)
  for i in range(6):
    if i < 4:
      result[i,0] = orignal[i,4]
      result[i,1] = orignal[i,1]
      result[i,2] = orignal[i,2]
      result[i,3] = orignal[i,0]
      result[i,4] = orignal[i,3]
      result[i,5] = orignal[i,6]
      result[i,6] = orignal[i,7]
      result[i,7] = orignal[i,8]
      result[i,8] = orignal[i,5]
    else:
      result[i,0] = orignal[i,4]
      result[i,1] = orignal[i,8]
      result[i,2] = orignal[i,5]
      result[i,3] = orignal[i,2]
      result[i,4] = orignal[i,1]
      result[i,5] = orignal[i,0]
      result[i,6] = orignal[i,3]
      result[i,7] = orignal[i,6]
      result[i,8] = orignal[i,7]

  # 返回排好顺序的魔方
  return result

4.4 建立模型程序设计

# 扫描3遍取平均值作为扫描结果，按照顺序建立魔方模型
def buildup_cube_module():
  for i in range(3):
    ev3_tmp = scan_every_side()
    ev3_arr_rgb += ev3_tmp/3

  # RGB转HSV
  ev3_arr_hsv = cv2.cvtColor(ev3_arr_rgb, cv2.COLOR_RGB2HSV)

  # 取H值作为颜色区分的特征值
  ev3_arr_h = ev3_arr_hsv[:,:,0]
  h = ev3_arr_h.reshape(6*9)

  # 按照H值所处排序位置，确定色块的颜色类别
  pos = sort_pos(h).reshape(6, 9)

  # 9种颜色分别用0-8的数字表示
  for i in range(6):
    for j in range(9):
      h[pos[i,j]] = i
  ev3_arr_h = h.reshape(6, 9)
  ev3_cube = scan_reshape(ev3_arr_h)

  # 返回魔方模型
  return ev3_cube

4.5 引申阅读

下面这种方法通过RGB颜色空间进行色块划分，虽然我并没有采用，但从理论上我觉得是说得通的，感兴趣的同学可以看看并试验。

由于魔方需要识别的颜色和色块（点）也较少，因此可以考虑直接采用与每个面中心点的RGB值比较的方式进行归类。

当魔方转动时，其6个面中心点的绝对位置其实是不发生变化的。如果你把魔方安装下面这个方向放置，会发现无论怎样转动上面（UP）的中心点永远是白色、前面（FRONT）的中心点永远是绿色……

而RGB值的色彩空间模型实际上是一个以R、G、B为坐标轴值的一个正方体。这样可以想象6个面中心点的颜色也就分布在这个正方体的6个位置。

其余的48个色块所对应的RGB值，应该与各中心点之一的值接进，比如：所有白色色块的RGB值与上面（UP）中心点的值基本接近、所有绿色色块的RGB值与前面（FRONT）中心点的值基本接近……这种颜色的接近反映在RGB空间模型上，可以很好的理解为正方体上面有6×8个点分别与此前6个点的距离比较近。而这个距离又可以理解为三维空间的欧几里得距离，通过公式容易计算得出：

颜色差异 =  √((色块R值-中心R值)^2 + (色块G值-中心G值)^2 + (色块G值-中心G值)^2)

再对这48个差异值从小到大排序，前8位的色块就是与该中心点颜色相同的色块。

写在本章最后

如果你分步骤的执行程序会发现一个问题，就是色彩传感器经常无法对准每一个魔方色块，这也就直接导致了无法准确扫描到该色块的颜色，造成识别误差。这个问题目前还没有更好的解决办法，即使采用原作者的程序解开的成功率也并不高，原因就在于此。可以使用的办法就是多扫描几遍，或者在扫描时多取几个扫描点，最终取平均值作为扫描结果。

我们已经得到了6×9个RGB值，但这些都代表什么颜色？我们需要的是不同色块对应到6种不同的颜色，因此必须对这54个RGB值进行划分，使他们归到自己的颜色分类中。关于颜色分类其实属于数字图像处理学中的一个重要研究领域，在此仅对比较通用的一种方法进行介绍。

4.1 色彩模型转换

色彩模型是描述使用一组值（通常使用3个、4个值或者颜色成分）表示颜色方法的抽象数学模型。例如三原色光模式（RGB） 和印刷四分色模式（CMYK）都是色彩模型。EV3颜色传感器获得的就是RGB模型，可以表示为三维直角坐标颜色系统的一个单位正方体。

在大多数的彩色图形显示设备一般都是使用红、绿、蓝三原色，我们的真实感图形学中的主要的颜色模型也是RGB模型，但是红、绿、蓝颜色模型用起来不太方便，它与直观的颜色概念如色调、饱和度和亮度等没有直接的联系。比如，我们很难从RGB的取值上区分这个颜色属于哪个色域，因此根据不同应用，还有HSV、HSI、CHL、LAB、CMY等其他色彩模型。由于颜色本身并没有发生变化，只是各个色彩模型表示颜色的方法不同，色彩模型之间可以通过固定的公式进行相互转换。

HSV、HSI、LAB都可以很好的将色相以一定规律排列出来。在本项目中，使用HSV模型作为颜色识别的色彩模型。关于HSV模型的详细描述，可以参见这里。

交给OpenCV

在程序实现方面，我更建议使用已经投入大量应用的函数库，而不是自己重新写一遍。因为已投入应用的函数库经过了长期的优化，能够保证实现的效率和安全。尽管RGB转HSV的程序实现很简单，只要按照公式直译成程序即可，但我还是使用了OpenCV的cvtColor函数。

在此之前，需要按照OpenCV模块，官方网站给出了比较详细的安装方法。ev3dev基于Debian系统，可以通过apt-get install python-opencv指令进行模块及相关依赖包的安装。

OpenCV为图像处理提供了大量的算法实现函数，在处理魔方色块时，我们可以将6×9个色块理解为一张大小为6×9的图像，每个色块为图像中的一个像素点,然后对这张图像进行RGB到HSV的转换。

对于这个图像与魔方色块的对应表示关系为：

• [0,0]表示图像第1行第1列的像素点，对应魔方上为第1个扫描面的第1个扫描色块
• [0,1]表示图像第1行第2列的像素点，对应魔方上为第1个扫描面的第2个扫描色块
• [3,4]表示图像第3行第4列的像素点，对应魔方上为第3个扫描面的第4个扫描色块

OpenCV的程序实现

# 仅为示例，非实际使用程序
image_hsv = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2HSV)

此时得到的image_hsv为一张大小为6×9的HSV图像，image_hsv[0,0,0]为第1行第1列的H值，image_hsv[0,0,1]为第1行第1列的S值，image_hsv[0,0,2]为第1行第1列的V值。

4.2 色块划分

利用HSV色彩空间的性质，通过对所有色块H值的排序，然后再以每9个色块为一组，可以得到每个色块的分组，也就得到了该色块所属的颜色类别。

通过一个简单的例子能帮助更好理解。假设我们有9个色块，一共3种颜色，这9个色块的H值分别如下：

位置	[0]	[1]	[2]	[3]	[4]	[5]	[6]	[7]	[8]
H值	22	121	25	186	190	118	24	124	188

接下来我们按这9个色块的H值从小到大排序，排序的同时他们的位置也随着调整：

位置	[0]	[6]	[2]	[5]	[1]	[7]	[3]	[8]	[4]
H值	22	24	25	118	121	124	186	188	190

我们知道一共有3种颜色，按照这个排序，每3个色块归为一组。也就是说位置在[0][6][2]的色块是同一种颜色，[5][1][7]为同一种颜色，[3][8][4]为同一种颜色。

位置排序程序

如果理解了以上的划分原理，开始写程序会发现一个问题。与通常的排序不同，这里不是只对位置上的值排序，而是通过位置上值的大小完成对位置的排序。在程序设计过程中，需要额外增加一个变量来记录位置的变换。

# 按照数组值的大小完成数组位置的排序
# 输入：l为要排序的数组
def sort_pos(l):

  # 定义pos数组，与l相同大小，初始化为l的原始位置
  pos = np.arange(len(l))
  for i in range(len(l)-1):
    for j in range(len(l)-i-1):

      # 按照l数组的值的大小进行比对
      if l[j] > l[j+1]:

        # 调整pos的值，即记录l位置的变化
        pos[j], pos[j+1] = pos[j+1], pos[j]

  # 返回排序后位置的变化情况
  return pos

这一节确实有一些难理解，先多看看上面表格里排序的例子，再去试着理解程序会更好一些。

要想让机器人完成解魔方的各种动作，我们先来分解每个马达的最基本的动作，然后通过这些基本的动作组合实现机器人更复杂的动作指令。根据马达的不同位置和作用，我们将EV3 MindCub3r的三个马达命名为：底座马达、手臂马达和探头马达。

底座马达基本动作

底座马达负责转动底座，自身可以完成魔方的旋转、配合手臂可以完成拧魔方最底层、配合探头可以完成魔方各个色块的颜色扫描。因此，底座马达的基本动作可以总结为：

• 顺时针旋转90度
• 逆时针旋转90度
• 顺时针旋转180度（也可以采用逆时针，这里使用顺时针）
• 顺时针旋转45度（也可以采用逆时针，区别在于色块扫描的顺序，这里使用顺时针）

第一个问题：如何让底座转90度？

仔细观察搭建图不难发现，动力系统是通过安装在大型马达上的一个小齿轮，带动底座下面的一个大齿轮完成的，并不很复杂。两个齿轮的传动比为1:3，即小齿轮转动3圈相当于大齿轮转动1圈。因此如果要底座转动90度，马达应转动270度，LEGO EV3的大型马达转1圈相应的走360步、即1步等于1度。

第二个问题：如何表示马达的运行位置？

EV3的马达属于伺服马达，这种马达的优势就是可以通过转动的步数精确计算马达的位置（position），无论马达处在停止还是运行状态都可以读取当前位置。对于位置可以这样理解：设想马达刚连接到EV3端口上，此时的位置为0；当顺时针转动一圈之后，此时的位置是360；再逆时针转一圈，位置又回到0；如果继续逆时针转动，位置就会变为相应的负数。如果持续的转动，位置的值也会持续的增加（或减少）。

对于马达运行位置的表示，EV3提供了两种方式：绝对位置、相对位置：

• 绝对位置：采用这种表示方式，无论马达此时的位置值是多少，都会运行到设置的位置值。比如：此时马达的位置值是360，设置运行到绝对位置90，马达不会顺时针转动90步，而是逆时针转动270步，之后位置值变为90。
• 相对位置：采用这种表示方式，运行的位置只是相对马达当前位置的位移。比如：此时马达的位置值是360，设置运行到绝对位置90，马达将会顺时针转动90步，之后位置值变为450。

对于底座马达，我们需要采用相对位置的运行方式。

第三个问题：马达每次停止都有一些位移误差？

显然，这种位移误差对于需要精准控制底座角度的需求是无法容忍的。要想解决这个问题，需要先了解EV3马达的停止模式。EV3马达有三种停止模式：coast、brake、hold：

• coast模式：马达得到停止指令时，停止供电，随惯性再转会停止。
• brake模式：马达得到停止指令时，停止供电，立刻停止转动，制动距离较coast模式要短得多。
• hold模式：马达得到停止指令时，马达并不会停止供电，而是将马达稳稳的保持在停止时的位置，此时如果你用外力强制改变他的位置，马达会强有力的跟你较劲，还是会转回它的位置。

综上，使用hold模式能够更精准的控制马达所转动的角度，也不会使底座发生“变形”。

最后：马达的速度设置

EV3马达的速度有两种表达方式：速度值、占空比：

• 速度值：马达的速度值单位为：步/秒，由于EV3马达一圈正好360步，因此等同于：角度/秒。
• 占空比：使用占空比表达马达的速度，取值范围-100%到100%，100%为顺时针最大速度。

这两种方式对于底座马达都可以，通常如果对速度的精度需求不那么大的情况下，可以采用占空比的方式。

程序设计

import ev3dev

# 底座的EV3大型马达接入主控制器A口
base = ev3dev.large_motor('outA')

if base.connected == True:
  # 设置速度控制模式为占空比
  base.speed_regulation_enabled = 'off'
  # 设置马达停止模式为hold
  base.stop_command = 'hold'

# 底座顺时针旋转90度，占空比75%
def base_clockwise():
   base.run_to_rel_pos(position_sp=270, duty_cycle_sp=75)
   while 'holding' not in base.state: time.sleep(0.2)

# 底座逆时针旋转90度，占空比75%
def base_anticlockwise():
  base.run_to_rel_pos(position_sp=-270, duty_cycle_sp=75)
  while 'holding' not in base.state: time.sleep(0.2)

# 底座顺时针旋转45度，占空比30%
def base_step():
  base.run_to_rel_pos(position_sp=135, duty_cycle_sp=30)
  while 'holding' not in base.state: time.sleep(0.2)