RoboML - язык описания структуры робота

Автор: Маркеев Андрей

Перепечатка материалов статьи
разрешена только с письменного разрешения автора,
и при указании прямой ссылки на его сайт.

При проектировании собственного робота, автор составлял во множестве схемы и диаграммы самых разных типов. Сначала - без учета каких-либо стандартов, затем - с помощью языка UML (Universal Markup Language - универсальный язык разметки). Получившиеся диаграммы и схемы поголовно имеют один и тот же недостаток, имя ему - неполнота. В результате поиска возможностей устранения этого недостатка, появилась эта статья.

Как Вы наверное уже догадались, RoboML - это специальный язык для описания структуры робота.

Такой язык может быть очень полезен любому роботостроителю, так как позволяет стандартизировать подход к описанию робота. Иными словами, меньше шансов что-то пропустить при проектировании будущего робота. И больше шансов найти ошибки в проекте в самое короткое время.

Кроме того, наличие RoboML позволяет хранить информацию по нескольким роботам в единообразном формате, осуществлять сортировку и выборку по нескольким признакам, обмениваться информацией с другими сайтами. Наконец, на основе описания RoboML может быть сгенерирован шаблон кода системы управления для будущего робота.

К сожалению, язык RoboML пока не получил широкого признания. Более того, разработка языка RoboML еще далеко не закончена. В Рунете я нашел только пару упоминаний «вскользь» этого языка, да и англоязычный интернет - не переполнен. Пока... Судя по растущему быстрыми темпами интересу людей к робототехнике - что-то вроде RoboML обязательно должно появиться в ближайшее время, и получить широкое распространение.

Так что имею честь представить Вам первое описание RoboML в русскоязычном интернете, возможно, оно Вам поможет при создании собственного робота.

RoboML - Robot Markup Language (Язык разметки для роботов) - представляет собой язык разметки, наподобие HTML, описанный с помощью XML-схемы. RoboML позволяет описать робота с двух точек зрения: кинематической, и с точки зрения организации системы управления.

Кинематическое описание робота определяет форму робота в пространстве. Для этого необходимо, во-первых, задать систему координат, во-вторых - совокупность геометрических фигур и линий, являющихся контуром тела робота.

По описанию робота с точки зрения системы управления можно понять, как действует робот, на основе чего он принимает решения, из каких функциональных систем состоит. Это описание - наиболее интересное. RoboML предлагает прежде всего определить общие для всего робота входные данные, реакцию на эти данные и функцию, которая описывает зависимость реакции от входных данных.

Также внутри описания с точки зрения системы управления - присутствует возможность описания всех частей, из которых функционально состоит робот. А именно - управляющих агрегатов, исполнительных механизмов и датчиков.

Рассмотрим, как все это записывается в RoboML.

Верхушкой описания RoboML является тег <hardware>. Hardware в переводе на русский - "железо". Очевидно, планируется создание еще одной схемы <software>, описывающей робота с точки зрения программной реализации - но пока других тегов, кроме <hardware>, не существует.

Внутри <hardware> располагаются элементы <kinematics> (кинематика) и <control-system> (система управления).

Остановимся подробно на <kinematics>: это, как Вы помните, кинематическое описание робота, т.е. описание его положения и конфигурации в пространстве. Прежде всего, необходимо задать систему координат:

   <referenceFrame name="main" parentFrameName=""> - система координат
      <origin> - начало координат, задается тремя точками
         <x-coordinate value="0"/> - X
         <y-coordinate value="0"/> - Y
         <z-coordinate value="0"/> - Z
      </origin>
      <basis> - базис-векторы
         <x-axis> - ось X
            <alpha value="1"/>
            <beta value="0"/>
            <gamma value="0"/>
         <y-axis> - ось Y
            <alpha value="0"/>
            <beta value="1"/>
            <gamma value="0"/>
         <z-axis> - ось Z
            <alpha value="0"/>
            <beta value="0"/>
            <gamma value="1"/>
      </basis>
   </referenceFrame>

Как видно, все очень просто. В примере представлен простейший случай системы координат. Задаем начало координат, и базис-векторы для каждой из трех осей. Следует отметить, что систем координат может быть несколько, и они могут быть различным образом смещены друг относительно друга. В дальнейшем, при определении геометрии тела робота, для каждого его <shape>-элемента (shape - контур, фигура) можно задавать использование отдельной системы координат, с помощью атрибута referenceFrameName.

Замечание: Автор данной статьи выражает большое сомнение, что система координат, отличная от приведенной выше, вообще будет когда-либо иметь место. Видимо, разработчики RoboML просто перестраховались, как и с определениями многих элементов.

Давайте теперь рассмотрим описание геометрии тела робота. Сразу стоит отметить: геометрию робота не нужно формировать руками, за Вас это должна делать специальная программа, которая бы преобразовывала, например, чертежи из AutoCAD, в схемы на RoboML. Автору статьи такой программы найти не удалось, поэтому на сегодняшний день описание геометрии - больше теоретическая задача, нежели практическая. Ниже мы рассмотрим очень простой пример - всего лишь описание обычного "ящика" (параллелепипеда), чтобы Вы смогли оценить, насколько это трудоемко при работе вручную.

   <body name="box"> - описание геометрии тела
      <shape> - контур
         <polyhedron> - полигедрон (ящик)
            <polygon> - полигон
               <segment> - сегмент
                  <point> - точки...
                     <x-coordinate value="0"/>
                     <y-coordinate value="0"/>
                     <z-coordinate value="0"/>
                  </point>
                  <point>
                     <x-coordinate value="0"/>
                     <y-coordinate value="20" unit="cm"/>
                     <z-coordinate value="0"/>
                  </point>
                  <point>
                     <x-coordinate value="0"/>
                     <y-coordinate value="0"/>
                     <z-coordinate value="40" unit="cm"/>
                  </point>
                  <point>
                     <x-coordinate value="0"/>
                     <y-coordinate value="20" unit="cm"/>
                     <z-coordinate value="40" unit="cm"/>
                  </point>
                  <point>
                     <x-coordinate value="20" unit="cm"/>
                     <y-coordinate value="0"/>
                     <z-coordinate value="0"/>
                  </point>
                  <point>
                     <x-coordinate value="20" unit="cm"/>
                     <y-coordinate value="20" unit="cm"/>
                     <z-coordinate value="0"/>
                  </point>
                  <point>
                     <x-coordinate value="20" unit="cm"/>
                     <y-coordinate value="20" unit="cm"/>
                     <z-coordinate value="40" unit="cm"/>
                  </point>
                  <point>
                     <x-coordinate value="20" unit="cm"/>
                     <y-coordinate value="0"/>
                     <z-coordinate value="40" unit="cm"/> 
                  </point>
               </segment>
            </polygon>
         <polyhedron/>
      </shape>
   </body>

Кроме полигедрона, есть отдельные элементы для описания цилиндроида и эллипсоида, которые описывать на RoboML - еще сложнее. В любом случае, геометрия робота никак не предназначена для ручного ввода. Формализованное описание геометрии, зато, позволяет удобным способом передавать, хранить и обрабатывать трехмерную модель Вашего робота.

Обратите внимание на элементы, задающие координаты (x-coordinate, y-coordinate, z-coordinate). Все эти элементы имеют стандартный тип языка RoboML «числовое значение». Однако этот тип не такой уж простой. Элементы этого типа могут содержать следующие необязательные атрибуты:

• value - собственно значение, в виде числа
• unit - единица измерения, может принимать одно из следующих значений:
  • none - значение представляет из себя простое число, без единицы измерения
  • m - метры
  • cm - сантиметры
  • mm - миллиметры
  • m/s - метры в секунду (скорость)
  • m/s^2 - метры на секунду в квадрате (ускорение)
  • radian/s - радиан в секунду
  • radian/s^2 - радиан на секунду в квадрате
  • degree/s - градусов в секунду
  • degree/s^2 - градусов на секунду в квадрате
  • degree - градусы
  • radian - радианы
  • Newton - ньютоны
  • Volt - вольты
  • Newton*m - ньютонов на метр
• actuated - изменяемое (с помощью исполнительного механизма)
• observed - наблюдаемое (с помощью датчиков)
• fixed - зафиксированное

Если Вам уже кажется, что язык RoboML - трудный, неудобный или нелогичный, - поверьте, это не так. И запомните следующую простую истину: создание хорошего и объемлющего проекта по разработке робота - это 80% успеха Вашей разработки. А основная часть робота, и самая главная - это система управления. Давайте посмотрим, как она записывается на языке RoboML.

Главное, что характеризует любую управляющую систему - это входные данные, функция преобразования и выходные данные. На основе этого принципа работает и RoboML.

Элемент <control-system> описывает систему управления, как совокупность из множества взаимосвязанных объектов, из которых состоит робот. Этими объектами являются:

• <plant> - исполнительные механизмы. В основном это двигатели и сервоприводы робота, и его сигнализаторы (т.е. светодиоды, дисплеи, динамики и т.д., все, с помощью чего робот может сигнализировать о своем состоянии). Обязательно присутствие хотя бы одного исполнительного механизма в схеме системы управления
• <sensor> - датчики. Приборы, с помощью которых робот собирает информацию об окружающей среде.
• <controller> - управляющие агрегаты. Это все микросхемы или устройства, осуществляющие непосредственное управление роботом. Например, это может быть микроконтроллер, КПК или ноутбук.

И сама система, и каждая из перечисленных ее составных частей, может включать три вида основных логических элементов:

• <input> - входные данные. (обязательно для <plant>)
• <transfer-function> - функция преобразования.
• <output> - выходные данные. (обязательно для <plant>)

Функция преобразования задается средствами языка MathML, в то время как входные и выходные данные - это числовые значения RoboML.

Причем формулы, описываемые с помощью MathML - можно генерировать автоматически. MathML является очень развитым языком, ему посвящены десятки страниц на сайте W3.org и множество других сайтов. Более того, есть и частичные русские переводы описания этого языка. Так что, перед тем, как начать писать формулы, как минимум скачайте MathML Generator, или воспользуйтесь online-генератором.

Как видим, система управления описывается гораздо проще и логичнее, чем геометрия робота. Чтобы продемонстрировать возможности RoboML, рассмотрим следующий пример:

   <control-system name="simple control system">
      <sensor name="clock"> <!-- датчик-часы -->
         <output name="time" observed> <!-- здесь хранится текущее время в секундах -->
      </sensor>
      <sensor name="left sensor" sensor-type="tactile"> <!-- левый датчик препятствия -->
         <output name="need go right" observed>
      </sensor>
      <sensor name="right sensor" sensor-type="tactile"> <!-- правый датчик препятствия -->
         <output name="need go left" observed>
      </sensor>
      <controller name="microcontroller"> <!-- микроконтроллер, осуществляющий управление -->

         <!-- описания переменных текущего состояния -->
         <input name="reverse time end" value="0" /> <!-- конечное время, когда нужно начать снова двигаться вперед -->
         <input name="last reverse turn" value="2" /> <!-- куда последний раз поворачивали при реверсе -->

         <transfer-function>

            <var-spec var-name="goright" var-source-name="need go right" />
            <var-spec var-name="goleft" var-source-name="need go left" />
            <var-spec var-name="now" var-source-name="time" />
            <var-spec var-name="reversetime" var-source-name="reverse time end" />
            <var-spec var-name="lastturn" var-source-name="last reverse turn" />
            <var-spec var-name="turnto" var-source-name="turn result" />
            <var-spec var-name="moveto" var-source-name="move result" />

            <!-- определяем время для реверса, и нужно ли оно вообще -->
            

            <math>
              <mrow>
                <mi>reversetime</mi>
                <mo>=</mo>
                <piecewise>
                   <piece>
                        <apply><plus/><ci> now </ci><cn > 6 </cn></apply>
                        <apply>
                           <and/>
                           <apply><eq/><ci> goleft </ci> <cn> 1 </cn></apply>
                           <apply><eq/><ci> goright </ci> <cn> 1 </cn></apply>
                        </apply>
                   </piece>
                   <piece>
                        <ci> reversetime </ci>
                        <apply>
                           <or/>
                           <apply><eq/><ci> goleft </ci> <cn> 0 </cn></apply>
                           <apply><eq/><ci> goright </ci> <cn> 0 </cn></apply>
                        </apply>
                   </piece>
                </piecewise>
              </mrow>
            </math>

            <!-- определяем новое значение moveto (0 - вперед, 1 - назад) -->
            

            <math>
              <mrow>
                <mi>moveto</mi>
                <mo>=</mo>
                <piecewise>
                   <piece>
                        <cn>0</cn>
                        <apply><leq/><ci> reversetime </ci> <ci> now </ci></apply>
                   </piece>
                   <piece>
                        <cn> 1 </cn>
                        <apply><gt/><ci> reversetime </ci> <ci> now </ci></apply>
                   </piece>
                </piecewise>
              </mrow>
            </math>

            <!-- определяем, куда поворачивать: 0 - двигаться прямо, 1 - влево, 2 - вправо -->
            

            <math>
              <mrow>
                <mi>turnto</mi>
                <mo>=</mo>
                <piecewise>
                   <piece>
                        <cn>0</cn>
                        <apply>
                           <and/>
                           <apply><leq/><ci> reversetime </ci> <ci> now </ci></apply>
                           <apply><eq/><ci> goleft </ci> <cn> 0 </cn></apply>
                           <apply><eq/><ci> goright </ci> <cn> 0 </cn></apply>
                        </apply>
                   </piece>
                   <piece>
                        <cn> 1 </cn>
                        <apply>
                           <or/>
                           <apply>
                              <and/>
                              <apply><gt/><ci> reversetime </ci> <ci> now </ci></apply>
                              <apply><eq/><ci> lastturn </ci> <cn> 2 </cn></apply>
                           </apply>
                           <apply>
                              <and/>
                              <apply><leq/><ci> reversetime </ci> <ci> now </ci></apply>
                              <apply><eq/><ci> goleft </ci> <cn> 1 </cn></apply>
                           </apply>
                        </apply>
                   </piece>
                   <piece>
                        <cn> 2 </cn>
                        <apply>
                           <or/>
                           <apply>
                              <and/>
                              <apply><gt/><ci> reversetime </ci> <ci> now </ci></apply>
                              <apply><eq/><ci> lastturn </ci> <cn> 1 </cn></apply>
                           </apply>
                           <apply>
                              <and/>
                              <apply><leq/><ci> reversetime </ci> <ci> now </ci></apply>
                              <apply><eq/><ci> goright </ci> <cn> 1 </cn></apply>
                           </apply>
                        </apply>
                   </piece>
                </piecewise>
              </mrow>
            </math>

            <!-- определяем, куда поворачивали последний раз -->
            

            <math>
              <mrow>
                <mi>lastturn</mi>
                <mo>=</mo>
                <piecewise>
                   <piece>
                        <cn> 1 </cn>
                        <apply>
                           <and/>
                           <apply><eq/><ci> reversetime </ci> <ci> now </ci></apply>
                           <apply><eq/><ci> lastturn </ci> <cn> 2 </cn></apply>
                        </apply>
                   </piece>
                   <piece>
                        <cn> 2 </cn>
                        <apply>
                           <and/>
                           <apply><eq/><ci> reversetime </ci> <ci> now </ci></apply>
                           <apply><eq/><ci> lastturn </ci> <cn> 1 </cn></apply>
                        </apply>
                   </piece>
                </piecewise>
              </mrow>
            </math>

         </transfer-function>
      </controller>
      <plant name="turn drive"> <!-- поворотные двигатели -->
         <input name="turn param" />
         <output name="turn result"/>
      </plant>
      <plant name="move drive"> <!-- основные двигатели -->
         <input name="move param" />
         <output name="move result"/>
      </plant>
   </control-system>

Из этого примера очевидно, что описываемый робот состоит из двух датчиков препятствия, контроллера, поворотного механизма и основных двигателей. Реализуется следующая модель поведения:

1. Eсли правый датчик фиксирует препятствие - осуществляем поворот налево
2. Eсли левый датчик фиксирует препятствие - осуществляем поворот направо
3. Eсли оба датчика фиксируют препятствие - двигаемся назад с поворотом в течение 6 секунд. Поворот осуществляется по очереди, то вправо, то влево, сменяясь при каждом следующем реверсе.

Итак, мы только что описали с помощью RoboML простого робота, который осуществляет объезд препятствий. Более сложные роботы, например, созданные на основе компьютера, или ноутбука - могут включать сотни и тысячи переменных и формул преобразования. Несмотря на кажущуюся трудоемкость, созданная с помощью RoboML схема может стать основой для генерации шаблона кода, и является стандартизированной формой представления данных о системе управления робота. На данный момент программы-генератора для RoboML не существует, однако будем надеяться, что она скоро появится.

Подводя итог, хочется отметить, что у RoboML и его аналогов - большое будущее, и с каждым годом такого рода язык будет становиться все более востребованным.

Сайты о RoboML

• Официальный сайт RoboML на английском языке.