Контрольна робота 5 клас: Контрольні роботи з математики 5 клас для вчителів на порталі «На Урок»

Религия Соблюдение

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

Разнообразие и Включение

Университет Питтсбурга не терпит любых форм дискриминации. домогательства или преследования по признаку инвалидности, расы, цвета кожи, религии, национальности происхождение, родословная, генетическая информация, семейное положение, семейное положение, пол, возраст, сексуальная ориентация, статус ветерана или гендерная идентичность или другие факторы, такие как заявлено в Политике Университета по Разделу IX.Университет стремится к принятие оперативных мер, чтобы положить конец враждебной среде, которая мешает Миссия университета. Для получения дополнительной информации о политиках, процедурах и практики: https://www.diversity.pitt.edu/civil-rights-title-ix/policies-procedures-and-practices. Я прошу, чтобы все в классе старались помочь другим участникам этот класс может учиться в благоприятной и уважительной среде. Если есть случаях вышеупомянутых проблем, пожалуйста, свяжитесь с Разделом IX Координатор, позвонив по телефону 412-648-7860 или отправив электронное письмо titleixcoordinator @ pitt.edu.

Отчеты также можно подать онлайн: https://www.diversity.pitt.edu/civil-rights-title-ix/make-report

Вы может также решить сообщить об этом преподавателям / сотрудникам; они обязаны сообщите об этом в Управление разнообразия и интеграции Университета. если ты желая сохранить полную конфиденциальность, вы также можете связаться с университетом Консультационный центр (412-648-7930).

COVID-19 Заявление

В в разгар этой пандемии чрезвычайно важно, чтобы вы соблюдали общественные правила здравоохранения и стандарты здоровья Питтсбургского университета и методические рекомендации.Находясь в классе, как минимум это означает, что вы должны носить лицо. покрытие и соблюдение требований физического дистанцирования; другие требования могут быть добавлены Университетом в течение семестра. Эти правила были разработан для защиты здоровья и безопасности всех членов сообщества. Неспособность соблюдение этих требований приведет к тому, что вам не разрешат присутствовать занятие лично и может привести к нарушению поведения учащихся. Для большинства актуальную информацию и рекомендации, пожалуйста, посетите коронавирус.pitt.edu и проверяйте свою электронную почту Питта на наличие обновлений перед каждым занятием.

Связь с Инструктор по болезни

Как и в любой ситуации с отсутствием занятий (дистанционно или лично), студент, который заболел (хотя и связан с COVID-19 или не) несет ответственность за то, чтобы сообщить мне об отсутствии на курсах. Пожалуйста свяжитесь со мной и предоставьте документацию, если отсутствие влияет на контрольные / экзамены.Этот следует сделать по электронной почте как можно скорее.

Как использовать события клавиатуры класса роботов в Java?

пакет com.toolsqa.tutorials.actions;

import java.awt.AWTException;

import java.awt.Robot;

import java.awt.event.KeyEvent;

import java.io.IOException;

import org.openqa.selenium.Alert;

импорт орг.openqa.selenium.By;

импорт орг.openqa.selenium.Keys;

импорт орг.openqa.selenium.WebDriver;

import org.openqa.selenium.WebElement;

импорт org.openqa.selenium.firefox.FirefoxDriver;

import org.openqa.selenium.support.ui.ExpectedConditions;

import org.openqa.selenium.support.ui.WebDriverWait;

открытый класс RobotKeyboardDemo {

public static void main (String [] args) выбрасывает InterruptedException, AWTException, IOException {

System.setProperty («webdriver.gecko.driver «,» C: \\ Selenium \\ lib \\ geckodriver-v0.24.0-win64 \\ geckodriver.exe «);

// Создайте новый экземпляр драйвера Firefox

WebDriver driver = new FirefoxDriver ();

String URL = «https://demoqa.com/keyboard-events/»;

// Запустить браузер

driver.get (URL);

// развернуть браузер

driver. manage (). window (). maximize ();

Thread.sleep (2000);

// Будет нажата кнопка Обзор

WebElement webElement = driver.findElement (By.id («browseFile»));

// нажмите кнопку Обзор

webElement.sendKeys (Keys.ENTER);

// Создаем объект класса Robot

Robot robot = new Robot ();

// Код для входа D1.txt

// Нажмите клавишу Shify

robot.keyPress (KeyEvent.VK_SHIFT);

// Нажмите d, он набирается как верхний регистр D при нажатии клавиши Shift

robot.keyPress (KeyEvent.VK_D);

// Отпустите клавишу SHIFT, чтобы отключить эффект верхнего регистра.

robot.keyRelease (KeyEvent.VK_SHIFT);

robot.keyPress (KeyEvent.VK_1);

robot.keyPress (KeyEvent.VK_PERIOD);

robot.keyPress (KeyEvent.VK_T);

robot.keyPress (KeyEvent.VK_X);

robot.keyPress (KeyEvent.VK_T);

// Нажмите ENTER, чтобы закрыть всплывающее окно

robot.keyPress (KeyEvent.VK_ENTER);

// Подождите 1 секунду

Thread.sleep (1000);

// Это всего лишь часть проверки, примите предупреждение

webElement = driver.findElement (By.id («uploadButton»));

webElement.click ();

WebDriverWait wait = новый WebDriverWait (драйвер, 10);

Alert myAlert = wait.until (ExpectedConditions.alertIsPresent ());

// Принять предупреждение

myAlert.accept ();

// Закройте главное окно

driver.close ();

}

}

Учебное пособие по программированию робототехники: как программировать простого робота

Примечание редактора: 16 октября 2018 года эта статья была переработана для работы с новейшими технологиями.

Посмотрим правде в глаза, роботы — это круто. Они также собираются когда-нибудь править миром, и, надеюсь, в то время они пожалеют своих бедных создателей из мягкой плоти (они же разработчики робототехники) и помогут нам построить космическую утопию, наполненную изобилием. Я, конечно, шучу, но только вроде.

Стремясь хоть как-то повлиять на этот вопрос, в прошлом году я прошел курс теории управления автономными роботами, кульминацией которого стало создание симулятора робота на основе Python, который позволил мне практиковать теорию управления на простом, мобильном, программируемом устройстве. робот.

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

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

• Математика — мы будем использовать некоторые тригонометрические функции и векторы
• Python — поскольку Python является одним из наиболее популярных базовых языков программирования роботов, мы будем использовать базовые библиотеки и функции Python.

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

Наконец, дополнительные темы, которые помогут вам лучше следовать этому руководству, — это знать, что такое конечный автомат и как работают датчики диапазона и энкодеры.

Проблема программируемого робота: восприятие против реальности и хрупкость управления

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

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

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

Это одна из основных причин того, что программирование робототехники так сложно. Мы часто видим видео, на которых новейший исследовательский робот выполняет в лаборатории фантастические трюки с ловкостью, навигацией или командной работой, и у нас возникает соблазн спросить: «Почему это не используется в реальном мире?» Что ж, в следующий раз, когда вы посмотрите такое видео, посмотрите, насколько строго контролируется лабораторная среда.В большинстве случаев эти роботы могут выполнять эти впечатляющие задачи только до тех пор, пока условия окружающей среды остаются в узких рамках его внутренней модели. Таким образом, одним из ключей к развитию робототехники является разработка более сложных, гибких и надежных моделей, и это продвижение зависит от ограничений доступных вычислительных ресурсов.

Одним из ключей к развитию робототехники является разработка более сложных, гибких и надежных моделей.

[Боковое примечание: и философы, и психологи отметили бы, что живые существа также страдают от зависимости от собственного внутреннего восприятия того, что им говорят их чувства.Многие успехи в робототехнике достигаются благодаря наблюдению за живыми существами и их реакции на неожиданные раздражители. Подумай об этом. Какова ваша внутренняя модель мира? Он отличается от муравья, а от рыбы? (Надеюсь.) Однако, подобно муравью и рыбе, он, вероятно, слишком упрощает некоторые реалии мира. Когда ваши предположения о мире неверны, вы рискуете потерять контроль над ситуацией. Иногда мы называем это «опасностью». Так же, как наш маленький робот пытается выжить в неизвестной вселенной, мы все тоже.Это мощное открытие для робототехников.]

Программируемый симулятор робота

Симулятор, который я построил, написан на Python и очень умно назван Sobot Rimulator . Вы можете найти версию 1.0.0 на GitHub. В нем не так много наворотов, но он создан для одной цели очень хорошо: обеспечивает точное моделирование мобильного робота и дает начинающему робототехнику простую основу для практики программирования программного обеспечения роботов. Хотя всегда лучше иметь настоящего робота, чтобы играть с ним, хороший симулятор робота Python намного доступнее и является отличным местом для начала.

В реальных роботах программное обеспечение, генерирующее управляющие сигналы («контроллер»), должно работать на очень высокой скорости и производить сложные вычисления. Это влияет на выбор языков программирования роботов, которые лучше всего использовать: обычно для таких сценариев используется C ++, но в более простых робототехнических приложениях Python — очень хороший компромисс между скоростью выполнения и простотой разработки и тестирования.

Программное обеспечение, которое я написал, имитирует реального исследовательского робота под названием Khepera, но его можно адаптировать к ряду мобильных роботов с различными размерами и датчиками.Поскольку я пытался запрограммировать симулятор, максимально приближенный к возможностям реального робота, логику управления можно загрузить в настоящего робота Khepera с минимальным рефакторингом, и он будет работать так же, как моделируемый робот. Реализованные особенности относятся к Khepera III, но они могут быть легко адаптированы к новому Khepera IV.

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

В этом руководстве я опишу архитектуру программного обеспечения для управления роботами, которая поставляется с v1.0.0 из Sobot Rimulator , и предоставлю фрагменты из исходного кода Python (с небольшими изменениями для ясности). Тем не менее, я рекомендую вам погрузиться в источник и бездельничать. Симулятор был разветвлен и использовался для управления различными мобильными роботами, включая Roomba2 от iRobot. Точно так же, пожалуйста, не стесняйтесь разветвлять проект и улучшать его.

Управляющая логика робота ограничена следующими классами / файлами Python:

• моделей / супервайзер.py — этот класс отвечает за взаимодействие между моделируемым миром вокруг робота и самим роботом. Он развивает конечный автомат нашего робота и запускает контроллеры для вычисления желаемого поведения.
• models / supervisor_state_machine.py — этот класс представляет различные состояния , в которых может находиться робот, в зависимости от его интерпретации датчиков.
• Файлы в каталоге models / controllers — эти классы реализуют различное поведение робота при известном состоянии окружающей среды.В частности, в зависимости от конечного автомата выбирается конкретный контроллер.

Цель

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

Однако, чтобы усложнить ситуацию, окружение робота может быть усыпано препятствиями. Робот НЕ МОЖЕТ столкнуться с препятствием на пути к цели. Следовательно, если робот сталкивается с препятствием, ему придется найти путь, чтобы продолжить свой путь к цели.

Программируемый робот

Каждый робот имеет разные возможности и особенности управления. Давайте познакомимся с нашим смоделированным программируемым роботом.

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

Управляющие входы: датчики

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

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

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

Управляющие выходы: мобильность

Некоторые роботы передвигаются на ногах. Некоторые катятся, как мяч. Некоторые даже скользят, как змеи.

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

API

В Sobot Rimulator разделение между роботом «компьютером» и (смоделированным) физическим миром воплощено в файле robot_supervisor_interface.py , который определяет весь API для взаимодействия с датчиками и двигателями «реального робота»:

• read_proximity_sensors () возвращает массив из девяти значений в собственном формате датчиков
• read_wheel_encoders () возвращает массив из двух значений, указывающих общее количество тиков с начала
• set_wheel_drive_rates (v_l, v_r) принимает два значения (в радианах в секунду) и устанавливает эти два значения для скорости левого и правого колес

Этот интерфейс внутренне использует объект-робот, который предоставляет данные от датчиков и возможность перемещать двигатели или колеса.Если вы хотите создать другого робота, вам просто нужно предоставить другой класс робота Python, который может использоваться в том же интерфейсе, а остальная часть кода (контроллеры, супервизор и симулятор) будет работать из коробки!

Симулятор

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

Файл world.py — это класс Python, который представляет смоделированный мир с роботами и препятствиями внутри. Функция step внутри этого класса заботится о развитии нашего простого мира:

• Применение правил физики к движениям робота
• Учет столкновений с препятствиями
• Ввод новых значений для датчиков робота

В конце концов, он вызывает диспетчеров роботов, ответственных за выполнение программного обеспечения мозга робота.

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

  # пошаговое моделирование через один временной интервал
def step (self):
dt = self.dt
# шагаем всем роботам
для робота в self.robots:
# шаг движения робота
robot.step_motion (dt)

# применяем физические взаимодействия
self.physics.apply_physics ()

# ПРИМЕЧАНИЕ: супервизоры должны бежать последними, чтобы убедиться, что они наблюдают за «текущим» миром.
# шаг все супервизоры
для руководителя в себе.руководители:
supervisor.step (dt)

# увеличить мировое время
self.world_time + = dt
  

Функция apply_physics () внутренне обновляет значения датчиков приближения робота, чтобы супервизор мог оценить среду на текущем этапе моделирования. Те же принципы применимы к кодировщикам.

Простая модель

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

• Рельеф всегда ровный и ровный
• Препятствий не бывает круглых
• Колеса не пробуксовывают
• Ничто и никогда не сможет толкнуть робота вокруг
• Датчики никогда не выходят из строя и не дают ложных показаний
• Колеса всегда поворачиваются, когда им говорят на

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

Контур управления

Теперь мы войдем в ядро ​​нашего управляющего программного обеспечения и объясним поведение, которое мы хотим запрограммировать внутри робота. В эту структуру можно добавить дополнительные модели поведения, и вы должны попробовать свои собственные идеи после того, как закончите читать! Программное обеспечение для робототехники на основе поведения было предложено более 20 лет назад и до сих пор остается мощным инструментом для мобильной робототехники.Например, в 2007 году набор моделей поведения был использован в DARPA Urban Challenge — первом соревновании для автомобилей с автономным вождением!

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

1. Подайте управляющие сигналы.
2. Измерьте результаты.
3. Генерируйте новые управляющие сигналы, рассчитанные на то, чтобы приблизить нас к нашей цели.

Эти шаги повторяются снова и снова, пока мы не достигнем нашей цели. Чем больше раз мы сможем сделать это в секунду, тем более точным будет контроль над системой. Робот Sobot Rimulator повторяет эти шаги 20 раз в секунду (20 Гц), но многие роботы должны делать это тысячи или миллионы раз в секунду, чтобы иметь адекватный контроль. Вспомните наше предыдущее введение о разных языках программирования роботов для разных робототехнических систем и требований к скорости.

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

Изящный трюк: упрощение модели

Чтобы управлять роботом, который мы хотим запрограммировать, мы должны послать сигнал на левое колесо, сообщающее ему, как быстро повернуть, и отдельный сигнал на правое колесо, сообщающее и , как быстро вращаться.Назовем эти сигналы v L и v R . Однако постоянно думать в терминах v L и v R очень громоздко. Вместо того, чтобы спрашивать: «С какой скоростью мы хотим, чтобы вращалось левое колесо, и с какой скоростью мы хотим, чтобы вращалось правое колесо?» естественнее спросить: «С какой скоростью мы хотим, чтобы робот двигался вперед, и с какой скоростью мы хотим, чтобы он поворачивался или менял свой курс?» Назовем эти параметры скоростью v и угловой (вращательной) скоростью ω (читается «омега»).Оказывается, мы можем основывать всю нашу модель на v и ω вместо v L и v R , и только после того, как мы определили, как мы хотим, чтобы наш запрограммированный робот двигался, математически преобразовывать эти два значения в v L и v R нам нужно на самом деле управлять колесами робота. Это известно как одноколесный велосипед , модель управления.

Вот код Python, реализующий окончательное преобразование в супервизоре .py . Обратите внимание, что если ω равно 0, оба колеса будут вращаться с одинаковой скоростью:

  # генерировать и отправлять роботу правильные команды
def _send_robot_commands (сам):
  # ...
  v_l, v_r = self._uni_to_diff (v, омега)
  self.robot.set_wheel_drive_rates (v_l, v_r)

def _uni_to_diff (self, v, omega):
  # v = поступательная скорость (м / с)
  # омега = угловая скорость (рад / с)

  R = self.robot_wheel_radius
  L = self.robot_wheel_base_length

  v_l = ((2.0 * v) - (омега * L)) / (2.0 * R)
  v_r = ((2,0 * v) + (омега * L)) / (2,0 * R)

  вернуть v_l, v_r
  

Оценка состояния: робот, познай себя

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

• Направление на препятствия
• Расстояние до препятствий
• Положение робота
• Заголовок робота

Первые два свойства определяются показаниями датчика приближения и довольно просты.Функция API read_proximity_sensors () возвращает массив из девяти значений, по одному для каждого датчика. Мы заранее знаем, что седьмое показание, например, соответствует датчику, который указывает на 75 градусов вправо от робота.

Таким образом, если это значение показывает значение, соответствующее расстоянию 0,1 метра, мы знаем, что есть препятствие на расстоянии 0,1 метра, 75 градусов влево. Если препятствий нет, датчик вернет значение максимальной дальности 0,2 метра.Таким образом, если мы прочитаем 0,2 метра на датчике 7, мы предположим, что на самом деле препятствий в этом направлении нет.

Из-за того, как работают инфракрасные датчики (измерение инфракрасного отражения), возвращаемые ими числа являются нелинейным преобразованием фактического обнаруженного расстояния. Таким образом, функция Python для определения указанного расстояния должна преобразовывать эти показания в метры. Это делается в supervisor.py следующим образом:

  # обновить расстояния, указанные датчиками приближения
def _update_proximity_sensor_distances (self):
    себя.близости_sensor_distances = [0,02- (журнал (значение чтения / 3960,0)) / 30,0 для
        readval в self.robot.read_proximity_sensors ()]
  

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

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

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

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

Ниже приведена полная функция одометрии в supervisor.py , которая обновляет оценку позы робота. Обратите внимание, что поза робота состоит из координат x и y и заголовка theta , который измеряется в радианах от положительной оси X.Положительное значение x — на восток, положительное — y — на север. Таким образом, заголовок 0 указывает на то, что робот смотрит прямо на восток. Робот всегда принимает исходную позу (0, 0), 0 .

  # обновить расчетное положение робота, используя показания датчика положения колеса
def _update_odometry (самостоятельно):
  R = self.robot_wheel_radius
  N = плавающее (self.wheel_encoder_ticks_per_revolution)
  
  # считываем значения энкодера колеса
  ticks_left, ticks_right = self.robot.read_wheel_encoders ()
  
  # получить разницу в тиках с последней итерации
  d_ticks_left = ticks_left - self.prev_ticks_left
  d_ticks_right = ticks_right - self.prev_ticks_right
  
  # оценить движения колеса
  d_left_wheel = 2 * pi * R * (d_ticks_left / N)
  d_right_wheel = 2 * pi * R * (d_ticks_right / N)
  d_center = 0,5 * (d_left_wheel + d_right_wheel)
  
  # рассчитываем новую позу
  prev_x, prev_y, prev_theta = self.estimated_pose.scalar_unpack ()
  new_x = prev_x + (d_center * cos (prev_theta))
  new_y = prev_y + (d_center * sin (prev_theta))
  new_theta = prev_theta + ((d_right_wheel - d_left_wheel) / self.robot_wheel_base_length)
  
  # обновить оценку позы с новыми значениями
  self.estimated_pose.scalar_update (new_x, new_y, new_theta)
  
  # сохраняем текущий счетчик тиков для следующей итерации
  self.prev_ticks_left = ticks_left
  self.prev_ticks_right = ticks_right
  

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

Методы программирования роботов на Python: поведение к цели

Высшая цель существования нашего маленького робота в этом руководстве по программированию — добраться до цели.Так как же заставить колеса повернуться, чтобы добраться туда? Давайте начнем с небольшого упрощения нашего мировоззрения и предположим, что на пути нет препятствий.

Это становится простой задачей, и ее можно легко запрограммировать на Python. Если мы пойдем вперед, глядя на цель, мы доберемся до нее. Благодаря одометрии мы знаем наши текущие координаты и направление. Мы также знаем координаты цели, потому что они были запрограммированы заранее. Поэтому, используя небольшую линейную алгебру, мы можем определить вектор от нашего местоположения к цели, как в go_to_goal_controller.py :

  # вернуть вектор курса к цели в системе отсчета робота
def calculate_gtg_heading_vector (сам):
  # получаем обратную позу робота
  robot_inv_pos, robot_inv_theta = self.supervisor.estimated_pose (). inverse (). vector_unpack ()
  
  # вычисляем вектор цели в системе отсчета робота
  цель = self.supervisor.goal ()
  goal = linalg.rotate_and_translate_vector (цель, robot_inv_theta, robot_inv_pos)
  
  возвратный гол
  

Обратите внимание, что мы получаем вектор к цели в системе отсчета робота, а НЕ в мировых координатах.Если цель находится на оси X в системе отсчета робота, это означает, что она находится прямо перед роботом. Таким образом, угол этого вектора относительно оси X — это разница между нашим курсом и тем курсом, которым мы хотим быть. Другими словами, это ошибка между нашим текущим состоянием и тем, каким мы хотим видеть текущее состояние. Поэтому мы хотим, чтобы отрегулировал скорость поворота ω так, чтобы угол между нашим курсом и целью изменился в сторону 0. Мы хотим минимизировать ошибку:

  # вычислить условия ошибки
theta_d = atan2 (сам.gtg_heading_vector [1], self.gtg_heading_vector [0])

# вычислить угловую скорость
omega = self.kP * theta_d
  

self.kP в приведенном выше фрагменте реализации контроллера Python является усилением управления. Это коэффициент, который определяет, насколько быстро мы перейдем к соотношению к тому, насколько далеко от цели, которая стоит перед нами. Если ошибка в нашем заголовке 0 , то скорость поворота тоже 0 . В реальной функции Python внутри файла go_to_goal_controller.py , вы увидите больше аналогичных приростов, поскольку мы использовали ПИД-регулятор вместо простого пропорционального коэффициента.

Теперь, когда у нас есть угловая скорость ω , как нам определить нашу поступательную скорость v ? Хорошее общее практическое правило — это то, которое вы, вероятно, знаете инстинктивно: если мы не делаем поворот, мы можем двигаться вперед на полной скорости, и чем быстрее мы поворачиваем, тем больше нам следует замедляться. Это обычно помогает нам поддерживать стабильность нашей системы и действовать в рамках нашей модели.Таким образом, v является функцией ω . В go_to_goal_controller.py уравнение:

  # вычислить поступательную скорость
# скорость равна v_max, когда omega равно 0,
# быстро падает до нуля, поскольку | omega | поднимается
v = self.supervisor.v_max () / (абс (омега) + 1) ** 0,5
  

Предлагается уточнить эту формулу, чтобы учесть, что мы обычно замедляемся, когда приближаемся к цели, чтобы достичь ее с нулевой скоростью. Как бы изменилась эта формула? Он должен каким-то образом включать замену v_max () чем-то, пропорциональным расстоянию.Хорошо, мы почти завершили единственный контур управления. Осталось только преобразовать эти два параметра модели одноколесного велосипеда в дифференциальные скорости колес и послать сигналы на колеса. Вот пример траектории робота под управлением контроллера перехода к цели без препятствий:

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

Методы программирования роботов на Python: поведение без препятствий

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

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

Соответственно, когда перед нами нет препятствий, мы хотим, чтобы наш опорный вектор просто указывал вперед. Тогда ω будет нулевым, а v будет максимальной скоростью. Однако, как только мы обнаруживаем препятствие с помощью наших датчиков приближения, мы хотим, чтобы опорный вектор указывал в любом направлении от препятствия. Это заставит ω взлететь, чтобы отвлечь нас от препятствия, и заставит v упасть, чтобы убедиться, что мы случайно не натолкнемся на препятствие в процессе.

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

Для обычного робота с другим расположением датчиков можно применить ту же идею, но может потребоваться изменение веса и / или дополнительная осторожность, когда датчики симметричны спереди и сзади робота, поскольку взвешенная сумма может стать нуль.

Вот код, который делает это в escape_obstacles_controller.py :

  # коэффициент усиления датчика (веса)
self.sensor_gains = [1.0+ ((0.4 * абс (p.theta)) / пи)
                      для p в supervisor.proximity_sensor_placements ()]

# ...

# возвращаем вектор уклонения от препятствий в системе отсчета робота
# также возвращает векторы к обнаруженным препятствиям в системе отсчета робота
def calculate_ao_heading_vector (сам):
  # инициализировать вектор
  Препятствие_векторах = [[0.0, 0,0]] * len (self.proximity_sensor_placements)
  ao_heading_vector = [0,0, 0,0]
  
  # получаем расстояния, указанные по показаниям сенсоров робота
  sensor_distances = self.supervisor.proximity_sensor_distances ()
  
  # вычислить положение обнаруженных препятствий и найти вектор уклонения
  robot_pos, robot_theta = self.supervisor.estimated_pose (). vector_unpack ()
  
  для i в диапазоне (len (sensor_distances)):
    # вычисляем положение препятствия
    sensor_pos, sensor_theta = self.близости_sensor_placements [i] .vector_unpack ()
    vector = [sensor_distances [i], 0,0]
    vector = linalg.rotate_and_translate_vector (vector, sensor_theta, sensor_pos)
    Препятствие_вектора [i] = вектор # сохранить векторы препятствия в системе отсчета робота
    
    # накапливаем вектор курса в системе отсчета робота
    ao_heading_vector = linalg.add (ao_heading_vector,
                                 linalg.scale (вектор, self.sensor_gains [i]))
                                 
  вернуть ao_heading_vector, преподобный_вектор
  

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

Методы программирования роботов на Python: гибридные автоматы (конечный автомат поведения)

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

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

Наша платформа роботов Python реализует конечный автомат в файле supervisor_state_machine.py .

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

Однако оказывается, что эта логика вызовет множество проблем. Что эта система будет иметь тенденцию делать, когда сталкивается с препятствием, так это отвернуться от него, а затем, как только она отошла от него, развернуться назад и снова столкнуться с ним.В результате получается бесконечный цикл быстрого переключения, который делает робота бесполезным. В худшем случае робот может переключаться между поведением с помощью на каждой итерации контура управления — состояние, известное как условие Зенона .

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

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

Методы программирования роботов на Python: поведение следования за стеной

Вот идея: когда мы сталкиваемся с препятствием, снимаем показания двух датчиков, которые находятся ближе всего к препятствию, и используем их для оценки поверхности препятствия. Затем просто установите наш опорный вектор параллельно этой поверхности. Продолжайте следовать по этой стене, пока A) препятствие больше не будет между нами и целью, и B) мы не приблизимся к цели, чем были в начале. Тогда мы можем быть уверены, что правильно преодолели препятствие.

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

Определение опорных векторов следящей стены оказывается немного сложнее, чем опорные векторы уклонения от препятствий или движения к цели.Взгляните на код Python в follow_wall_controller.py , чтобы увидеть, как это делается.

Дизайн окончательного контроля

Окончательный дизайн управления использует поведение следящей стены почти для всех столкновений с препятствиями. Однако, если робот окажется в труднодоступном месте, опасно близко к столкновению, он переключится в режим чистого избегания препятствий, пока не окажется на более безопасном расстоянии, а затем вернется к следящей стене. После успешного преодоления препятствий робот переходит к цели.Вот диаграмма окончательного состояния, которая запрограммирована внутри supervisor_state_machine.py :

Вот робот, успешно перемещающийся в многолюдной среде, используя эту схему управления:

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

Твик, твик, твик: пробная версия и ошибка

Схема управления, поставляемая с Sobot Rimulator, очень тонко настроена.Потребовалось много часов, чтобы настроить одну маленькую переменную здесь и другое уравнение там, чтобы заставить ее работать так, как я был удовлетворен. Программирование робототехники часто связано с большим количеством простых старых проб и ошибок. Роботы очень сложны, и есть несколько способов заставить их вести себя оптимальным образом в среде симулятора роботов … по крайней мере, не намного меньше машинного обучения, но это совсем другая баня червей.

Робототехника часто включает в себя множество простых старых проб и ошибок.

Я рекомендую вам поиграть с контрольными переменными в Sobot Rimulator, понаблюдать и попытаться интерпретировать результаты. Все изменения следующих элементов оказывают сильное влияние на поведение моделируемого робота:

• Ошибка прироста кПа в каждом контроллере
• Коэффициент усиления датчика, используемый контроллером объезда препятствий
• Вычисление v как функции ω в каждом контроллере
• Расстояние от препятствия, используемое контроллером следящей стены
• Условия переключения, используемые supervisor_state_machine.ру
• Практически все остальное

Когда программируемые роботы выходят из строя

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

Во вселенной мобильных роботов «мозг» нашего маленького робота находится на более простом конце спектра. Многие из возникающих сбоев можно было бы преодолеть, добавив в систему более совершенное программное обеспечение. Более продвинутые роботы используют такие методы, как , отображают , чтобы запоминать, где он был, и избегать повторения одних и тех же вещей снова и снова; эвристика , чтобы генерировать приемлемые решения, когда идеального решения не найдено; и машинное обучение , чтобы более точно настроить различные параметры управления, управляющие поведением робота.

Пример того, что будет дальше

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

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

Благодарность: Я хотел бы поблагодарить доктора Магнуса Эгерштедта и Жан-Пьера де ла Круа из Технологического института Джорджии за то, что они научили меня всему этому, и за их энтузиазм по поводу моей работы над Sobot Rimulator.

Изучите робототехнику с нуля: 5 бесплатных онлайн-ресурсов

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

1 | Введение в робототехнику от QUT Robot Academy

The Robot Academy — это открытый учебный ресурс и совместный проект профессора Питера Корке и Квинслендского технологического университета (QUT). Курс включает в себя университетский уровень, короткие видеоуроки и полностью онлайн-курсы, которые помогут вам понять и подготовиться к робототехнике будущего.Доступно более 200 уроков, к которым вы можете получить доступ в любое время и в любом порядке. Курсы делятся на мастер-классы, разовые уроки и онлайн-курсы.

Мастер-классы включают курсы визуального содержания по основам робототехники, 2D и 3D геометрии, измерению движения, траекториям и траекториям, роботизированным манипуляторам и кинематике движения вперед, кинематике скорости в 2D и 3D, управлению суставами роботов, динамике твердого тела, роботизированному зрению, и т.д. Вы можете легко создавать списки просмотра со ссылками на уроки.Одним из преимуществ мастер-классов является то, что вы можете выбрать предмет и посмотреть набор видеороликов, связанных с этой конкретной темой.

Щелкните здесь, чтобы начать изучение курса.

2 | Введение в робототехнику MIT OpenCourseWare

MIT OpenCourseWare (OCW) — это веб-публикация практически всего содержания курсов MIT. Курс, представленный в этой публикации, включает обзор механизмов роботов, динамики и интеллектуальных средств управления, а также включает следующие темы: плоская и пространственная кинематика и планирование движения; проектирование механизмов манипуляторов и мобильных роботов, мульти-твердотельная динамика, трехмерное графическое моделирование; конструкция управления, исполнительные механизмы и датчики; беспроводные сети, моделирование задач, человеко-машинный интерфейс и встроенное программное обеспечение.Также есть видео по проектам, где вы можете научиться создавать роботов, способных искать скрытые металлические диски и т. Д.

Щелкните здесь, чтобы начать изучение курса.

3 | Введение в робототехнику Стэнфордского университета,

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

Щелкните здесь, чтобы начать изучение курса.

4 | Управление мобильными роботами от Coursera

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

Щелкните здесь, чтобы начать изучение курса.