Руководство

Мы управляем реальным или смоделированным роботом с помощью программы Python под названием soar, которая работает на ноутбуке. Soar позволяет вам управлять настоящим роботом или симулятором, и позволяет управлять с помощью джойстика или программы «brain». brain управляет роботом, используя модель transducer (как описано в главе 1), что означает, что программа должна преобразовывать входящие сенсорные сигналы в действия; это будет выполняться несколько раз в секунду. Вы можете запустить soar симулятор на своём компьютере, но для управления роботом вам потребуется запустить его на одном из лабораторных ноутбуков. Описания ниже применимы к лабораторным ноутбукам, но использование симулятора soar на вашем ноутбуке аналогично.

Сенсоры робота и действия

Робот имеет несколько сенсоров (способы получать информацию о внешнем мире) и действий (способов изменять состояние внешнего мира).

Колеса

Робот имеет два ведущих колеса, по одному на каждой стороне, и поворотное колесо сзади. Вы можете управлять роботами, указав скорость движения вперёд в метрах в секунду и скорость вращения в радианах в секунду.

Сенсоры

Роботы имеют восемь ультразвуковых преобразователей (сонары); это золотистые диски спереди. Они посылают звуковые импульсы и прислушиваются к отражениям. Сенсоры возвращают значения времени прохождения, то есть, сколько времени потребовалось звуку, чтобы вернуться. Процессор робота преобразует их в оценки расстояния.

Когда сонары посылают звуковой импульс, существует период, известный как «период затухания», когда датчик все ещё вибрирует от генерации импульса и не может эффективно улавливать эхо. Если объект находится настолько близко, что эхо возвращается в течение периода затухания, датчик не обнаружит объект. Датчики, как правило, достаточно надёжны, если ближайший объект находится на расстоянии от 10 сантиметров до метра от робота. Если датчик не обнаруживает эха, то расстояние далеко за пределами диапазона датчика.

В зависимости от материала объекта перед датчиком сонара звуковой импульс может отражаться в другом направлении, а не обратно к датчику. Это также приведёт к тому, что датчик не сможет обнаружить объект. Чтобы решить эту проблему, мы оклеили все наши «стены» пузырчатой плёнкой, из-за чего импульсы отражаются от стены во многих направлениях, что повышает вероятность того, что датчик обнаружит отражения.

Одометр

Робот имеет датчики вала на каждом из своих ведущих колёс, которые подсчитывают (доли) оборотов колёс. Процессор робота использует эти данные датчика для обновления предполагаемой позы (термин, который означает как положение, так и ориентацию) робота в глобальной системе отсчёта.

Рисунок 1. Глобальная система отсчёта одометрии

На рисунке 1 показана система отсчёта, в которой отображена одометрия робота. Когда робота включили, система отчёта инициализируется так, что её начало находится в центре робота, а положительная ось X указывает на переднюю часть робота. Теперь вы можете думать об этой системе отчёта, как о нарисованной на земле; когда вы перемещаете или вращаете робота, он продолжает сообщать о своей позе в этой системе отчёта.

Обратите внимание, что значение позы не изменится, если вы возьмёте настоящего робота и переместите его, не вращая колеса. Он знает что движется только благодаря вращению колёс. И помните, что одометрия далека от совершенства: колёса проскальзывают, и ошибка (особенно ошибка вращения) со временем увеличивается.

Аналого-цифровой интерфейс

Мы можем подключить к роботу дополнительные датчики и эффекторы через аналого-цифровой интерфейс. Из робота выходит кабель, который обеспечивает подключение к четырём аналого-цифровым преобразователям (они позволяют нам преобразовывать напряжения на входных проводах в значения, которые можно прочитать с помощью программного обеспечения) и одному цифро-аналоговому преобразователю (этот позволяет нам преобразовать число, записанное в программном обеспечении, в выходное напряжение). См. раздел 7.4 и раздел 7.5 для получения подробной информации об аппаратных подключениях этих входов.

Brains

soar brain имеет следующую структуру:


def setup():
	print("Loading brain")

def brainStart():
	print("Starting")

def step():
	print("Hello robot!")
def brainStop():
	print("Stopping")

Процедура setup вызывается один раз, когда brain файл считывается интерпретатором. brainStart вызывается когда вы стартуете brain. step вызывается снова и снова, несколько раз в секунду. brain приведённый выше, если запущен, сначала напечатает Loading Brain, когда вы загрузите (или перезагрузите) файл, затем напечатает "Starting" при нажатии кнопки "Start" на Soar, затем просто продолжит печатать "Hello robot!" в окне сообщений soar, пока вы не остановите, после чего будет распечатано "Stoping".

Обычно мы будем использовать автоматы для управления нашими роботами. Вот очень простой мозг с контроллером конечного автомата:


import lib601.sm as sm
from soar.io import io

class MySMClass(sm.SM):
	def getNextValues(self, state, inp):
		return (None, io.Action(fvel = 0.1, rvel = 0))

def setup():
	robot.behavior = MySMClass()
	robot.behavior.start(verbose = True)

def step():
	robot.behavior.step(io.SensorInput()).execute()

Программа начинается с загрузки некоторых вспомогательных файлов. Затем мы задали тривиальный автомат, который всегда генерирует на выходе действие, которое устанавливает скорость движения робота вперёд 0.1 м/с, а скорость его вращения — 0. Мы будем называть behavior любой автомат, который потребляет поток экземпляров класса SensorInput и создаёт поток экземпляров класса Action. Обратите внимание, что и SensorInput, и Action определены в модуле soar под названием io, поэтому нам нужно добавить к ним префикс имени модуля.

Функция setup создаёт экземпляр MySMClass() behavior (если вы хотите использовать другой bihavior, вы создаёте его здесь) и запускает его. verbose аргумент start приводит к печати входных, выходных данных и состояния SM; вы можете подавить печать, установив для этого аргумента значение False (или удалив необязательный аргумент verbose из вызова).

Затем, наконец, в функции step мы вызываем io.SensorInput(), который создаёт экземпляр класса io.SensorInput, содержащий самые последние доступные данные датчиков. Он передаётся в качестве входных данных методу step конечного автомата, который вызывает метод generateOutput, который возвращает экземпляр класса io.Action. Наконец, мы вызываем execute этого действия, которое фактически отправляет команды роботу. Если то, как написано, кажется запутанным, вот альтернативная версия, которая проясняет происходящее


def step():
	inp = io.SensorInput()
	act = robot.behavior.step(inp)
	act.execute()

Атрибуты экземпляра io.Action:

Передача этих трёх значений в инициализатор создаст новый экземпляр. Вызов метода execute() на экземпляр Action заставит робота выполнить это действие.

Атрибуты экземпляра io.SensorInput :

Только в симуляторе иногда может быть полезно «обмануть» и ссылаться на "фактические" координаты робота в глобальной системе координат симулятора (а не в системе одометрии, где находился робот в начале). Если вы создадите экземпляр io.SensorInput так:


s = io.SensorInput(cheat = True)

тогда значения одометрии будут представлять собой фактические координаты в симуляторе. Выполнение этого действия на роботе приведёт к ошибке. Ситуация, в которой использование cheat-позы имеет реальное отличие, — это когда вы перетаскиваете смоделированного робота по экрану: обычная одометрия не знает, что робот переместился (поскольку колеса не вращались), но cheat-поза все равно будет точно знать, где он оказался. Используйте это только для специальной отладки, потому что настоящие роботы не могут делать ничего подобного!

Использование Soar симулятора.

Чтобы использовать brain для управления симулированным роботом, сделайте следующее:

Робот поедет вперёд и распечатает некоторые данные в окне. Чтобы остановить робота, нажмите кнопку «Stop». Не волнуйтесь, если он продолжит печатать какое-то время. Весь этот текст где-то хранится и ждёт печати.

Обычно, вы определяете soar brain в файле и загружаете его в soar. Если при загрузке мозга произошла ошибка, вы увидите сообщение об ошибке (красным цветом). Если вам нужно отредактировать файл brain, вы можете отредактировать его в редакторе, а затем приказать Soar перезагрузить мозг, нажав кнопку «reload brain». Reload Brain and World кнопка также перезагрузит мозг, а в симуляторе вернёт робота в исходную позу. На Pioneer перезагрузка мира приведёт к сбросу последовательного соединения с роботом, в результате чего робот сбросит свою одометрию в исходное положение.

Что касается сонаров на симуляторе, вы увидите линии, выступающие из робота в различных точках: они представляют собой пути прохождения сигналов датчиков сонаров. Эти смоделированные датчики следуют идеальной модели: они всегда измеряют расстояние (с небольшим количеством добавленного случайного шума) по лучу до первой поверхности, с которой они соприкасаются. Линия рисуется красным, когда сонар не обнаруживает отражения. В симуляторе можно брать и перетаскивать робота мышкой во время работы мозга и смотреть, как меняются показания.

Вы можете заметить, что смоделированный робот иногда становится красным. Это означает, что он находится рядом со стенами или сталкивается с ними. Если он застрял и вы посылаете ему команды двигаться вперёд, ничего не произойдёт. Однако вы все равно можете двигать назад или поворачивать его.

Использование робота Pioner

Вы можете подключить робота к лабораторному ноутбуку, (1) подключив короткий синий USB-кабель-адаптер к ноутбуку, (2) подключив USB-адаптер к одному концу последовательного кабеля и (3) подключив другой конец последовательный кабель к последовательному разъёму на роботе, который находится рядом с панелью с выключателем питания и световыми индикаторами на боковой стороне робота.

Перед подключением обязательно завяжите последовательный кабель простым узлом вокруг ручки на задней стороне робота. Это обеспечит разгрузку от натяжения и не позволит последовательному кабелю отсоединиться от робота или погнуть разъём, если его потянуть.

Начните с включения робота. Чтобы управлять роботом с помощью джойстика, нажмите Pioneer и Joystick, а затем Start. Щелчком и перетаскиванием в появившемся окне джойстика можно управлять скоростью движения вперёд и вращения робота.

Советы

Для запуска робота:

Трассировка и построение графиков

В Soar есть средства для выполнения различных видов трассировки и построения графиков для отладки ваших программ и документирования результатов. Здесь мы опишем эти средства.

Видеть то, что видит робот

Часто важно знать, что говорят датчики робота, чтобы понять, почему робот ведёт себя именно так, или задокументировать результат эксперимента. Для этого есть несколько полезных инструментов. Чтобы использовать многие из этих инструментов, вам необходимо создать экземпляр RobotGraphics в вашей функции start. Обычно это будет выглядеть так:


def setup():
	robot.gfx = gfx.RobotGraphics(sonarMonitor = True, 
	drawSlimeTrail = True)
	
	

slime trails (след слизи) и static plots (описанные ниже) будут рисоваться, когда soar остановлен. Это всегда делается, когда вы нажимаете кнопку Stop в soar, но если вы хотите, чтобы brain soar автоматически останавливал, когда контрольное состояние достигнуто, вы можете добавить следующую строку в step функцию:


io.done(robot.behavior.isDone())

Монитор сонара

Просмотр показаний сонара робота в режиме реального времени может быть полезен либо для обнаружения проблем с оборудованием, либо в качестве инструмента отладки для лучшего понимания поведения вашего brain. Монитор сонара, показанный выше, обеспечивает графическое отображение показаний сонара робота, независимо от того, подключено ли Soar к симулятору робота или к Pioneer. Как и сонары в симуляторе, сонары представлены чёрной линией, которая становится красной, когда сонар вообще не слышит эха.

Slime trails(След слизи)

Часто полезно знать, где находился робот во время выполнения. Мы не можем знать это точно на реальном роботе, но можем получить некоторое представление о том, что происходит, глядя на позу, сообщаемую одометрией. Мы делаем это, рисуя «slime trail» пути робота, как если бы это была улитка. Цвет тропы постоянно меняется вдоль неё, чтобы дать вам представление о времени, когда были заняты определённые места. На рисунке 2 показан пример следа слизи.

Рисунок 2. Слизистый след робота, идущего за стеной, в мире обучающего симулятора.

Если для аргумента drawSlimeTrail конструктора RobotGraphics установлено значение True, окно следа слизи появится, когда мозг перестанет работать. Если вы работаете на симуляторе, вы можете установить для drawSlimeTrail значение «Cheat», и при этом будет использоваться истинное положение робота, а не внутренние измерения одометрии робота, так что при перетаскивании робота след слизи будет показывать движение.

Динамическое построение графиков

Другой полезный инструмент, виртуальный осциллограф, в реальном времени отображает график некоторой произвольной функции значений датчиков робота. Функция addDynamicPlotFunction принимает кортеж (name, function), где name — это строка, отображаемая в легенде, а function — это функция, которая принимает экземпляр SensorInput и возвращает число.

На рисунке показано окно осциллографа, на котором отображается минимальное расстояние, сообщаемое двумя крайними правыми датчиками сонара ("right dist"), и среднее расстояние, сообщаемое двумя передними сонаром ("front dist"). Мы создаём эти графики, добавляя следующие строки в функцию setup.


robot.gfx.addDynamicPlotFunctions(('right dist',
	lambda inp: min(inp.sonars[6:])))
robot.gfx.addDynamicPlotFunctions(('front dist',
	lambda imp: sum(inp.sonars[3:5])/2.0))
	

Кнопка Configure Oscilloscope позволяет настроить границы осей и метки на графике. По умолчанию границы оси y представляют собой минимальное и максимальное значение y, наблюдаемое на данный момент.

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


robot.gfx.addDynamicPlotFunction((['neck', 'left', 'right'],
	lambda inp: inp.analogInputs[0:3]))

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

Статическое построение графиков

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

Класс RobotGraphics предоставляет addStatic-PlotFunction, который аналогичен addDynamic-PlotFunction, за исключением того, что он может принимать два разных сигнала, поэтому важно указать, какой из них является сигналом оси X, а какой — сигналом оси Y. Если аргумент x не предоставлен, по умолчанию сигнал отображается как функция количества шагов.

Код ниже, помещённый в функцию start, создаст график, подобный показанному на рисунке: интенсивность света в левом глазу робота как функция угла робота относительно его первоначальной ориентации. Аргумент ConnectPoints — это логическое значение, определяющее, следует ли рисовать линию между каждой точкой на графике.


startTheta = io.SensorInput().odometry.theta
robot.gfx.addStaticPlotFunction(
	x=('angle', lambda inp: sartTheta-inp.odometry.theta),
	y=('left eye', lambda inp: inp.analogInputs[1]),
	conectPoints=True)
	

Вывод информации об конечном автомате

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

Построение графиков переменных автомата

Мы можем создавать статические или динамические графики входов, состояний и выходов конечного автомата почти так же, как мы создаём графики значений датчиков. Сначала мы проиллюстрируем этот процесс на примере, а затем подробно объясним этапы. В примере показано, как построить статический график скорости движения на выходе конечного автомата со следованием за стеной.

  1. Убедитесь, что у интересующего конечного автомата есть имя (подробнее о методах именования см. ниже):
    		
    		myMachine = WallFollowerSM()
    		myMachine.name = 'wallFollow'
    		def setup():
    			robot.behavior = myMachine # Может быть комбинацией автоматов
    			
    		
  2. Добавьте статический "зонд"(probe) конечного автомата к экземпляру RobotGraphics:
    		
    		robot.gfx.addStaitcPlotSMProbe(y = ('forward vel', 'wallFollow', 'output',
    			lambda outp: outp.fvel))
    			
    		
  3. Запустите автомат со списком графических задач (обычно это делается по умолчанию):
    		
    		robot.behavior.start(robot.gfx.tasks())
    		
    		

После того, как вы выполните эти три шага, вы должны получить статический или динамический график количества вашего конечного автомата, когда вы запустите свой brain. На первом этапе вам необходимо дать имя машине, которую вы хотите контролировать. Есть несколько способов сделать это:

Второй шаг включает в себя создание зонда конечного автомата для передачи экземпляру RobotGraphics. Зонд конечного автомата представляет собой кортеж: (signalName, machineName, mode, plotFunction).

Вы можете передать такой зонд либо в addStaticSMProbe, либо в addDynamicSMProbe в зависимости от ситуации.

Verbosity

Иногда интересующее вас значение лучше наблюдать, распечатывая его, а не рисуя на графике. Самый простой способ распечатать большое количество отладочной информации — установить для параметра verbose значение True (по умолчанию оно равно False), а для параметра Compact — значение False (по умолчанию оно равно True), когда вы вызываете start своего поведения. Это напечатает входные, выходные данные и состояние каждого примитива. машины и состояние машин комбинатора на каждом шаге. Имя каждой машины также будет распечатано. По умолчанию имена назначаются системой в виде класса экземпляра машины и числа для уникальности. Распечатка будет выглядеть примерно так:


Step: 0
Cascade_1
upDownSM Counter = 0
Sequence_2 Counter = 0
CountUntil_3 In: Sonar: [5, 5, 1.491, 0.627, 0.330, 0.230, 0.200, 0.265]; Odo:
pose:(-1.633, -1.341, 4.067); Analog: (0.000, 0.000, 0.000, 0.000) Out: -0.400 Next State:
-0.400
Output of upDownSM = -0.4
forwardSpeedSM In: -0.400 Out: Act: [-0.400, 0, 5.000] Next State: Act: [-0.400, 0,
5.000]
Step: 1
Cascade_1
upDownSM Counter = 0
Sequence_2 Counter = 0
CountUntil_3 In: Sonar: [5, 5, 5, 0.669, 0.356, 0.251, 0.219, 0.289]; Odo:
pose:(-1.614, -1.316, 4.067); Analog: (0.000, 0.000, 0.000, 0.000) Out: -0.300 Next State:
-0.300
Output of upDownSM = -0.3
forwardSpeedSM In: -0.300 Out: Act: [-0.300, 0, 5.000] Next State: Act: [-0.300, 0,
5.000]

Если этот режим слишком подробный, вы можете сделать две вещи:

  1. Установите для параметра Compact значение True (по умолчанию оно равно True) при вызове start. В этом случае результат будет выглядеть примерно так. Вы можете увидеть все состояние машины, но трудно сказать, какие её части принадлежат каким составляющим SM:
    		
    In: Sonar: [2.465, 1.352, 1.350, 2.465, 1.427, 1.139, 1.060, 0.785]; Odo: pose:(-0.987,
    1.493, 2.443); Analog: (0.000, 0.000, 0.000, 0.000) Out: Act: [-0.400, 0, 5.000] Next
    State: ((0, (0, -0.5)), None)
    In: Sonar: [2.465, 1.381, 1.386, 2.465, 1.466, 1.165, 1.087, 0.739]; Odo: pose:(-0.957,
    1.468, 2.443); Analog: (0.000, 0.000, 0.000, 0.000) Out: Act: [-0.300, 0, 5.000] Next
    State: ((0, (0, -0.40000000000000002)), None)
    
    		
  2. Установите для параметра printInput значение False при вызове start. Это позволит пропустить печать входных данных, что иногда полезно, если мешают сенсорные данные. В этом случае вывод будет выглядеть примерно так:
    		
    Out: Act: [-0.400, 0, 5.000] Next State: ((0, (0, -0.5)), None)
    Out: Act: [-0.300, 0, 5.000] Next State: ((0, (0, -0.40000000000000002)), None)
    
    		

Печать значений конечного автомата

Если всей этой печати слишком много, и вы просто хотите увидеть определённое значение, вы можете создать свою собственную задачу трассировки и передать её конечному автомату при его запуске. Эти задачи просто добавляются в список задач, созданных экземпляром RobotGraphics. В этом примере показано, как распечатать состояние двух автоматов, которые являются частью основного автомата поведения и имеют имена «sm1» и «sm2»:


robot.behavior.start(traceTasks = robot.gfx.tasks() +
[(’sm1’, ’state’, util.prettyPrint),
(’sm2’, ’state’, util.prettyPrint)])

Задача трассировки конечного автомата во многом похожа на проверку конечного автомата, описанную в ранее. Это кортеж: (machineName, mode, traceFunction).