1.1. Что такое робот и какие они бывают

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

Робот – машина, которая сама узнаёт, что происходит вокруг, сама решает, что делать, и сама это делает. Решает она не «от ума», а по программе – списку правил, который заранее написал человек. Например: «впереди стена ближе 20 см – остановись и повернись».

Возьмём машинку на радиоуправлении. Моторы у неё есть, колёса есть, а решает за неё мальчик с пультом. Отпусти он пульт – машинка встанет или врежется в диван. Такую машину роботом не называют. А робот-пылесос ездит по квартире один: наткнулся бампером на ножку стула – сдал назад и повернул. Про такие машины говорят – автономные, то есть работающие без человека.

Роботов на свете много, и они совсем разные. Первое, что бросается в глаза, – умеет робот перемещаться или нет.

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

Мобильные роботы различаются тем, как они двигаются:

• Колёсные – самые простые и быстрые на ровном полу: складские тележки, роботы-пылесосы, роботы-доставщики, марсоходы.
• Гусеничные – гусеница давит на землю широкой лентой и не проваливается там, где колесо буксует: рыхлый снег, песок, завалы. Такие роботы помогают спасателям и сапёрам.
• Шагающие – на ногах, как собака или человек. Перешагивают камни и поднимаются по ступенькам, но устроены сложнее всех.
• Летающие – дроны-квадрокоптеры. Если дрон летит по заданному маршруту сам, без пилота с пультом, он тоже робот.
• Есть ещё плавающие и подводные роботы: они осматривают дно, трубы и опоры мостов.

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

Из истории. Первым в мире планетоходом, который успешно работал на другом небесном теле, стал советский «Луноход-1». Его доставила на Луну станция «Луна-17» 17 ноября 1970 года. У лунохода было восемь колёс, и у каждого – свой электромотор со своим редуктором (что такое редуктор, узнаешь в разделе 1.4). Он проработал на Луне около десяти месяцев и проехал 10 540 м. Строго говоря, роботом он не был: вёл его экипаж водителей с Земли, глядя на снимки с телекамер лунохода. Современные марсоходы часть пути уже прокладывают сами.

1.2. Из чего состоит мобильный робот

Датчики – органы чувств, контроллер – мозг, моторы – мышцы, батарейка – еда, которая даёт силы.

Разберём по деталям робота, которого собирают в кружках сферы «Роботех». Это небольшая тележка на двух колёсах с моторами и одном маленьком опорном колёсике.

Контроллер – «мозг» робота. Это плата с микроконтроллером – маленьким компьютером, уместившимся в одной микросхеме. В сфере «Роботех» работают с платой Arduino Uno. Программу пишут на компьютере и загружают в плату по USB-кабелю, после этого плата работает сама, хоть от батарейки. По краям платы – выводы (их ещё называют пинами): к ним проводами подключают датчики и другие устройства. Контроллер питается напряжением 5 В (вольт – единица напряжения; что это такое, разберём в главе 5).

Датчики – «органы чувств». Датчик переводит то, что происходит вокруг, в электрический сигнал, понятный контроллеру.

• Кнопка – самый простой датчик, датчик касания: нажата или нет.
• Ультразвуковой дальномер (в наборах – модуль HC-SR04 с двумя «глазами») измеряет расстояние до препятствия. Он пищит неслышным для нас звуком и ждёт эха, как летучая мышь.
• Датчик линии светит вниз на поле и ловит отражённый свет: белое поле отражает много, чёрная линия – мало. Так робот отличает линию от фона.
• Бывают и другие: фоторезистор чувствует яркость света, датчик температуры – тепло.

Исполнительные устройства – «мышцы и голос» робота. Они выполняют то, что решил контроллер.

• Мотор постоянного тока (его ещё называют DC-мотором, от английского direct current – постоянный ток) крутит колесо. Сам по себе такой моторчик вертится очень быстро, тысячи оборотов в минуту, но слабо: зажми вал пальцами – и он встанет. Поэтому к нему приделывают редуктор – коробочку с шестерёнками, которая замедляет вращение и делает его сильнее. Популярный «жёлтый моторчик» из учебных наборов – это как раз мотор вместе с редуктором.
• Сервомотор (сервопривод) – мотор, который поворачивает вал на заданный угол и держит его. Обычный сервомотор из учебного набора поворачивается в пределах от 0 до 180°. Им поворачивают клешню захвата, «руль» или датчик.
• Светодиод, пищалка, экранчик тоже выполняют команды контроллера: светятся, пищат, показывают числа.

Драйвер моторов – посредник между контроллером и моторами. С выводов контроллера идёт слабый ток – его хватает, чтобы зажечь светодиод, но не чтобы крутить мотор. Драйвер похож на водопроводный кран: контроллер лишь поворачивает «ручку», а «вода» – сильный ток – течёт к мотору прямо от батарейки. В курсе сферы используют микросхему драйвера L293D, она управляет двумя моторами сразу. Почему мотор нельзя подключить прямо к плате, подробно разберём в главе 5.

Источник питания – «еда» робота: батарейный отсек (например, четыре батарейки по 1,5 В дают вместе 6 В) или аккумулятор. Без него не заработает ничего.

Шасси, колёса и опорное колесо – «скелет» и «ноги». На шасси (раме) крепятся все детали. Два ведущих колеса надеты на валы моторов. Третья точка опоры – опорное колесо: шарик или колёсико, которое свободно катится в любую сторону. Без него робот на двух колёсах клевал бы носом.

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

Датчик сообщает контроллеру, что видит. Контроллер решает и отдаёт команду драйверу. Драйвер берёт энергию у батареи и отдаёт её мотору столько, сколько велел контроллер. Обрати внимание на толстую оранжевую стрелку: к моторам энергия идёт мимо контроллера.

1.3. Как робот едет и поворачивает

Колёса крутятся одинаково – робот едет прямо. Одно отстаёт – робот сворачивает в его сторону. Колёса крутятся в разные стороны – робот вертится на месте.

У нашего робота нет руля. Каждое ведущее колесо крутит свой мотор, и контроллер управляет ими по отдельности. Такой способ называют дифференциальным приводом (от слова «разница»: робот поворачивает за счёт разницы в скоростях колёс). Так же поворачивают танк и трактор на гусеницах.

• Оба колеса вперёд с одной скоростью – робот едет прямо вперёд. Оба назад – прямо назад.
• Одно колесо вперёд, другое стоит – робот поворачивает вокруг стоящего колеса. Левое едет, правое стоит – поворот направо.
• Одно колесо быстрее другого – робот едет по дуге в сторону медленного колеса.
• Колёса крутятся в разные стороны с одной скоростью – разворот на месте вокруг середины между колёсами. Левое вперёд, правое назад – робот крутится направо, по часовой стрелке, если смотреть сверху.

Бывает и по-другому – как у автомобиля. Один мотор крутит задние колёса, а сервомотор поворачивает передние, как руль. Такого робота тоже можно собрать в Tinkercad. Но в курсе сферы главный – дифференциальный привод: он проще и умеет разворачиваться на месте.

1.4. Зубчатая передача и передаточное число

У маленькой 12 зубьев, у большой 36 – втрое больше. Поэтому маленькая крутится втрое быстрее. Зато большая крутится сильнее.

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

Почему у шестерён разная скорость? Посмотри на место, где они встречаются. Зубья проходят через него по одному: один зуб маленькой шестерни толкнул один зуб большой. Значит, сколько зубьев прошло у ведущей, столько же прошло и у ведомой. Ведущая с 12 зубьями за один свой оборот протолкнёт 12 зубьев. У ведомой их 36 – она повернётся только на 12 из 36, то есть на треть оборота. Чтобы большая сделала полный оборот, маленькой придётся обернуться три раза.

Передаточное число показывает, во сколько раз ведомая шестерня крутится медленнее ведущей. Словами: передаточное число равно числу зубьев ведомой шестерни, делённому на число зубьев ведущей. Буквами:

$$i = \frac{z_2}{z_1},$$

где $i$ – передаточное число, $z_1$ – число зубьев ведущей шестерни, $z_2$ – ведомой. Чтобы узнать скорость ведомой, скорость ведущей делят на передаточное число:

$$n_2 = \frac{n_1}{i} = n_1 \cdot \frac{z_1}{z_2}.$$

Здесь $n_1$ и $n_2$ – скорости вращения ведущей и ведомой шестерён. Скорость вращения меряют оборотами в минуту (об/мин) или оборотами в секунду (об/с). В минуте 60 секунд, поэтому 120 об/мин – это $120 : 60 = 2$ об/с.

Пример. На моторе шестерня с 12 зубьями, на колесе – с 36. $i = 36 / 12 = 3$. Мотор делает 90 об/мин, колесо – $90 / 3 = 30$ об/мин.

Что мы выигрываем. Шестерни не делают энергию из ничего. Если ведомая крутится в 3 раза медленнее, она крутит в 3 раза сильнее (если не считать трения в шестерёнках, которое немного съедает силу). Силу вращения – насколько сильно вал может провернуть то, что к нему приделано, – называют крутящим моментом. Правило простое: выиграл в силе – проиграл в скорости, и наоборот.

• Передаточное число больше 1 (ведомая больше ведущей) – передача понижающая: колесо крутится медленнее, но сильнее. Коробку с понижающими передачами называют редуктором. У «жёлтого моторчика» из учебных наборов передаточное число редуктора 48: вал мотора крутится в 48 раз быстрее, чем выходная ось, на которую надевают колесо. При питании 6 В колесо такого моторчика делает около 200 об/мин.
• Передаточное число меньше 1 (ведомая меньше ведущей) – передача повышающая: быстрее, но слабее. Так устроен велосипед. Спереди у педалей большая звёздочка, например на 44 зуба, сзади маленькая, на 11 зубьев. За один оборот педалей заднее колесо делает $44 / 11 = 4$ оборота. Звёздочки соединены цепью, а не зацеплены напрямую, но зубья считаются так же.

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

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

Несколько ступеней. Если одной пары шестерён мало, ставят несколько пар подряд – это ступени редуктора. Две шестерни разного размера сидят на одном валу и крутятся вместе, как одно целое. Большая из них принимает вращение от предыдущей ступени, маленькая передаёт следующей. Передаточное число всего редуктора равно произведению передаточных чисел ступеней. Две ступени по 3 дают $3 \cdot 3 = 9$, а не $3 + 3 = 6$. Так редуктор маленького моторчика и набирает свои 48.

1.5. Рычаг

Ребёнок легче взрослого в 2 раза, но сидит в 2 раза дальше от середины. Качели в равновесии.

Рычаг – твёрдая палка или планка, которая может поворачиваться вокруг одной точки – опоры. Качели во дворе, ножницы, открывашка, лом, которым отковыривают лёд с крыльца, – всё это рычаги.

Плечо – расстояние от опоры до места, где на рычаг давят. У качелей два плеча: от середины до взрослого и от середины до ребёнка.

Правило равновесия рычага: сила, умноженная на плечо, с одной стороны равна силе, умноженной на плечо, с другой. Буквами:

$$F_1 \cdot l_1 = F_2 \cdot l_2,$$

где $F_1$, $F_2$ – силы, которые давят на рычаг с двух сторон, а $l_1$, $l_2$ – их плечи. Сила – то, с чем одно тело толкает или тянет другое. Её измеряют в ньютонах (Н). Груз массой 1 кг давит на ладонь с силой около 10 Н. Если на рычаг давят только подвешенные грузы, можно не переводить в ньютоны: вместо сил подставляй массы. Проверим качели с картинки: $60 \cdot 1 = 30 \cdot 2$, то есть $60 = 60$ – равновесие.

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

Даром это не даётся: длинный конец проходит больший путь. Чтобы приподнять камень на 1 см ломом с плечами 10 см и 50 см, дальний конец придётся опустить на 5 см. Выиграли в силе в 5 раз – проиграли в пути в 5 раз. С шестерёнками было то же самое, только там вместо пути – скорость.

Рычаги в роботе. Клешня захвата – это два рычага на общей оси. Качалка на валу сервомотора – тоже рычаг: чем она длиннее, тем дальше отводит тягу, но тем слабее давит. Стрела подъёмного крана или погрузчика – рычаг с опорой на башне. Чтобы кран не опрокинулся, на другом конце стрелы висит противовес – тяжёлый груз, который уравновешивает поднимаемый.

1.6. Разбираем задачи

В задачах с выбором ответ – строка из цифр выбранных пунктов, например «246». Удобнее записывать цифры по возрастанию, а как нужно на отборе – всегда написано в условии задачи.

Задача 1.4 Редуктор из двух ступеней

двухступенчатый редуктор, передаточное число, перевод единиц

Моторчик марсохода-макета делает 6000 об/мин – слишком быстро и слабо. Между мотором и колесом поставили двухступенчатый редуктор (рисунок ниже). На валу мотора шестерня с 10 зубьями. Она крутит шестерню с 40 зубьями. На одном валу с ней сидит шестерня с 12 зубьями, она крутит шестерню с 60 зубьями на оси колеса. Сколько оборотов в секунду делает колесо? Крутится оно в ту же сторону, что вал мотора, или в обратную?

Дано: $n_{\text{м}} = 6000$ об/мин; ступень 1: $10 \to 40$ зубьев; ступень 2: $12 \to 60$ зубьев.
Найти: скорость колеса в об/с; направление.

Шаг 1. Разбираем редуктор на ступени. В первой ступени ведущая – шестерня мотора (10 зубьев), ведомая – 40 зубьев. Во второй ведущая – шестерня с 12 зубьями, ведомая – с 60. Шестерня с 12 зубьями сидит на одном валу с шестерней на 40 зубьев и крутится вместе с ней.

Шаг 2. Передаточное число первой ступени. $i_1 = 40 / 10 = 4$.

Шаг 3. Передаточное число второй ступени. $i_2 = 60 / 12 = 5$.

Шаг 4. Весь редуктор. Ступени перемножаем: $i = i_1 \cdot i_2 = 4 \cdot 5 = 20$.

Шаг 5. Скорость колеса в об/мин. $n_{\text{к}} = 6000 / 20 = 300$ об/мин.

Шаг 6. Переводим в обороты в секунду. В минуте 60 секунд: $300 / 60 = 5$ об/с.

Шаг 7. Направление. Зацеплений два: 10 с 40 и 12 с 60. Первое поворачивает направление в обратную сторону, второе – ещё раз, обратно. Колесо крутится в ту же сторону, что и вал мотора.

Можно проверить по шагам, без общего передаточного числа: вал с шестернями 40 и 12 крутится со скоростью $6000 / 4 = 1500$ об/мин, колесо – $1500 / 5 = 300$ об/мин. Пять оборотов колеса в секунду – бойкий робот, но глаз за колесом ещё успевает, в отличие от вала мотора со ста оборотами в секунду.

Типичная ошибка. Сложить передаточные числа: $4 + 5 = 9$, и получить $6000 / 9 = 667$ об/мин. Ступени работают одна за другой: первая замедлила в 4 раза, вторая замедляет уже замедленное ещё в 5 раз – это умножение. И второе – забыть перевести минуты в секунды и ввести 300: в условии просили обороты в секунду.

Ответ: 5 об/с, в ту же сторону, что и вал мотора.

Своя задача по программе сферы, модуль 6

Задача 1.5 Кран с противовесом

рычаг, правило равновесия, противовес

На макете лунной базы работает робот-кран. Его стрела – рычаг с опорой на башне. На коротком конце стрелы, в 25 см от опоры, закреплён противовес массой 12 кг. На длинном конце висит крюк, его можно передвигать вдоль стрелы. а) На каком расстоянии от опоры надо повесить на крюк ящик массой 5 кг, чтобы стрела была в равновесии? б) Потом нужно поднять ящик массой 8 кг. Куда передвинуть крюк? Массой самой стрелы и крюка пренебреги. Ответы – в сантиметрах.

Дано: $m_1 = 12$ кг, $l_1 = 25$ см; а) $m_2 = 5$ кг; б) $m_2 = 8$ кг.
Найти: $l_2$ – ? в обоих случаях.

Шаг 1. Правило рычага. На стрелу давят только подвешенные грузы, поэтому вместо сил можно подставлять массы: $m_1 \cdot l_1 = m_2 \cdot l_2$.

Шаг 2. Левая сторона. Противовес и его плечо не меняются: $12 \cdot 25 = 300$ (кг·см). Это число должно получиться и справа.

Шаг 3. Ящик 5 кг. $5 \cdot l_2 = 300$, значит, $l_2 = 300 / 5 = 60$ см.

Шаг 4. Ящик 8 кг. $8 \cdot l_2 = 300$, $l_2 = 300 / 8 = 37{,}5$ см. Ящик тяжелее – крюк нужно придвинуть к опоре.

Проверка. а) $5 \cdot 60 = 300$; б) $8 \cdot 37{,}5 = 300$. Обе стороны дают по 300. Кстати, на настоящей Луне всё весит примерно в 6 раз меньше, чем на Земле. Но и противовес полегчает во столько же раз, поэтому точки равновесия останутся на тех же местах.

Типичная ошибка. Решить «наоборот»: раз ящик тяжелее, отодвинуть его дальше. Но дальше от опоры груз сильнее тянет стрелу вниз – тяжёлый ящик вешают ближе к опоре. Ещё ошибаются, когда плечо меряют от края стрелы или от противовеса, а не от опоры.

Ответ: а) 60 см; б) 37,5 см.

Своя задача по программе сферы, модуль 9

Задача 1.6^* Настоящий размер колеса

передаточное число, путь за оборот колеса, калибровка

Робот ездит на «жёлтых моторчиках»: передаточное число редуктора 48. На валу мотора стоит счётчик оборотов – он считает обороты вала мотора, а не колеса. По паспорту диаметр колеса 65 мм. Но шина мягкая и немного проминается под весом робота, поэтому катится колесо как будто меньшего диаметра.

Чтобы узнать настоящий диаметр, робота пустили прямо по коридору. Счётчик показал 960 оборотов мотора, а по рулетке робот проехал 4,02 м. Число $\pi$ считай равным 3,14.

а) Каков настоящий диаметр колеса? Округли до целых миллиметров. б) Сколько оборотов мотора надо задать в программе, чтобы робот проехал 2,5 м? Округли до целых. В ответ введи число из пункта б.

Дано: $i = 48$; $N_{\text{м}} = 960$ оборотов мотора; путь $S = 4{,}02$ м; паспортный диаметр 65 мм; $\pi = 3{,}14$.
Найти: а) настоящий диаметр $D$; б) число оборотов мотора для пути 2,5 м.

Шаг 1. Что происходит. Мотор крутится, редуктор замедляет вращение в 48 раз, колесо катится. За один оборот колесо проходит путь, равный длине своей окружности, – как если бы обод размотали и положили на пол. Длина окружности равна $\pi \cdot D$ (подробнее о пути за оборот – в главе 2). Цепочка такая: обороты мотора → обороты колеса → путь за один оборот → диаметр.

Шаг 2. Обороты колеса. Колесо крутится в 48 раз медленнее мотора: $960 / 48 = 20$ оборотов.

Шаг 3. Путь в миллиметрах. Диаметр нужен в мм, поэтому путь тоже переводим: $4{,}02$ м $= 4{,}02 \cdot 1000 = 4020$ мм.

Шаг 4. Путь за один оборот колеса. $4020 / 20 = 201$ мм.

Шаг 5. Диаметр. $\pi \cdot D = 201$ мм, значит, $D = 201 / 3{,}14 = 64{,}01$ мм $\approx 64$ мм. Шина промялась на миллиметр по сравнению с паспортом – мелочь, но сейчас увидим, во что она обходится.

Шаг 6. Обороты колеса на 2,5 м. $2{,}5$ м $= 2500$ мм. За оборот колесо проходит $3{,}14 \cdot 64 = 200{,}96$ мм. Оборотов колеса: $2500 / 200{,}96 = 12{,}44$.

Шаг 7. Обороты мотора. Мотор крутится в 48 раз быстрее колеса: $12{,}44 \cdot 48 = 597{,}1 \approx 597$ оборотов.

Пункт б можно решить и без $\pi$: путь за оборот мы уже измерили в шаге 4, это 201 мм. Тогда $2500 / 201 \cdot 48 = 597{,}0$ – те же 597.

А если поверить паспорту? Для колеса 65 мм вышло бы $2500 / (3{,}14 \cdot 65) \cdot 48 = 587{,}9 \approx 588$ оборотов. С такой программой робот проедет $588 / 48 \cdot 201 = 2462$ мм и не дотянет до цели почти 4 см. На соревнованиях этого хватит, чтобы промахнуться мимо клетки финиша. Поэтому колёса и проверяют заездом, а не по надписи на коробке.

Типичная ошибка. Забыть про редуктор и считать, что колесо сделало все 960 оборотов, – тогда колесо выйдет диаметром около 1,3 мм, со спичечную головку. Такой ответ сам себя выдаёт. Вторая – поделить на $\pi$ весь путь 4020 мм, забыв разделить его на 20 оборотов: выйдет колесо диаметром 1280 мм, ростом с первоклассника. Третья – подставить в пункт б паспортные 65 мм и ввести 588.

Ответ: а) 64 мм; б) 597 оборотов мотора.

По мотивам задачи первого отборочного этапа НТО 2024/25, профиль «Интеллектуальные робототехнические системы», инженерный тур, «Калибровка одометрии»

2.1. Скорость, путь и время

Скорость – сколько робот проезжает за одну секунду. Прошло 5 секунд – значит, пять раз по 20 см.

Когда робот едет без рывков, каждую секунду он проезжает одно и то же расстояние. Это расстояние за одну секунду называют скоростью. У робота на картинке скорость 20 сантиметров в секунду, коротко – 20 см/с. Косая черта читается как «в»: «сантиметров в секунду». Движение, при котором скорость не меняется, называют равномерным.

Путь – сколько робот проехал, время – сколько длилась поездка. Для равномерного движения правило такое: путь равен скорости, умноженной на время. Буквами:

$$s = v \cdot t,$$

где $s$ – путь, $v$ – скорость, $t$ – время. Из этой формулы получаются ещё две. Нужно время – путь делим на скорость. Нужна скорость – путь делим на время:

$$t = \frac{s}{v}, \qquad v = \frac{s}{t}.$$

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

Три примера для робота со скоростью 20 см/с:

• за 5 с он проедет $20 \cdot 5 = 100$ см;
• на 1,5 м ему нужно: сначала переводим $1{,}5$ м $= 150$ см, потом $150 : 20 = 7{,}5$ с;
• другой робот проехал 90 см за 6 с – его скорость $90 : 6 = 15$ см/с.

Средняя скорость. Всю дорогу с одной скоростью робот едет редко: он разгоняется, сбрасывает скорость перед поворотом, ждёт на перекрёстке. Тогда считают среднюю скорость – весь путь делят на всё время, вместе с остановками:

$$v_{\text{ср}} = \frac{\text{весь путь}}{\text{всё время}}.$$

Пример. Робот проехал 120 см за 6 с (это 20 см/с), 2 с стоял у перекрёстка, потом проехал 80 см за 2 с (это 40 см/с). Весь путь $120 + 80 = 200$ см, всё время $6 + 2 + 2 = 10$ с, средняя скорость $200 : 10 = 20$ см/с. Рука так и тянется сложить 20 и 40 и поделить пополам. Получится 30 см/с – неверно: медленно робот ехал втрое дольше, чем быстро, да ещё и стоял.

Два робота. Если роботы едут навстречу друг другу, каждую секунду расстояние между ними уменьшается на сумму их скоростей: роботы со скоростями 20 см/с и 30 см/с сближаются на 50 см за секунду. Если один догоняет другого, расстояние сокращается на разность: $30 - 20 = 10$ см за секунду. Стоят такие роботы в 2 м друг от друга и едут навстречу – встретятся через $200 : 50 = 4$ с. А если медленный уехал вперёд на 2 м, быстрый догонит его за $200 : 10 = 20$ с.

2.2. Единицы скорости и их перевод

Робот, который за секунду проезжает метр, за минуту проедет 60 м, а за час – 3600 м, то есть 3,6 км. Поэтому 1 м/с – то же самое, что 3,6 км/ч.

У автобуса на спидометре скорость в километрах в час (км/ч), у робота в задаче – в сантиметрах в секунду (см/с), а у мотора в паспорте – в оборотах в минуту (об/мин). Переводить можно по шагам или готовыми множителями.

По шагам. Отдельно переводим путь, отдельно время. Возьмём 30 см/с. Путь: 30 см = 0,3 м, значит, это 0,3 м/с. А сколько это километров в час? За час, то есть за 3600 с, робот проедет $0{,}3 \cdot 3600 = 1080$ м $= 1{,}08$ км. Значит, 1,08 км/ч.

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

• 1 м/с = 100 см/с = 1000 мм/с;
• 1 м/с = 3,6 км/ч: из м/с в км/ч – умножаем на 3,6, из км/ч в м/с – делим на 3,6;
• 1 об/с = 60 об/мин: из оборотов в минуту в обороты в секунду – делим на 60;
• 1 с = 1000 мс (миллисекунд): в Arduino команда delay(1000) ждёт одну секунду, delay(250) – четверть секунды.

Сравним скорости из жизни. Пешеход идёт со скоростью около 5 км/ч – это $5 : 3{,}6 \approx 1{,}4$ м/с. Школьный автобус на трассе едет 60 км/ч, то есть $60 : 3{,}6 \approx 16{,}7$ м/с. Учебный робот со своими 30 см/с (1,08 км/ч) медленнее пешехода больше чем в четыре раза. Ему и не надо спешить: на поле размером с комнату дороже точность.

Со временем осторожнее: в минуте 60 секунд, а не 100. Поэтому 1,5 мин – это 90 с, и никак не 150 с. 2 мин 15 с – это $2 \cdot 60 + 15 = 135$ с.

2.3. Колесо: путь за один оборот

Капля снова коснулась пола, когда колесо прокатилось на длину своей окружности. Столько колесо проезжает за каждый оборот: π · D.

Спидометра у робота нет. Зато он может считать обороты колёс – для этого на колесо или на вал мотора ставят датчик оборотов, энкодер. А программа знает, с какой скоростью крутится мотор. Остаётся связать обороты с путём.

Обод – это край колеса, та часть, что касается пола. Если колесо катится без проскальзывания, точки обода по очереди прикладываются к полу, и за один оборот весь обод как будто размотался и лёг на пол ленточкой. Длина этой ленточки – длина окружности колеса:

$$C = \pi \cdot D,$$

где $C$ – путь за один оборот (длина окружности), $D$ – диаметр колеса (от края до края через центр), а $\pi \approx 3{,}14$ – число «пи», оно одинаково для любого круга. Точнее его даёт кнопка $\pi$ на калькуляторе. Если в условии дан радиус $r$ – расстояние от центра до края, – то $D = 2r$ и $C = 2 \pi r$.

Колесо диаметром 65 мм за оборот проезжает $3{,}14159 \cdot 65 = 204{,}2$ мм, то есть примерно 20,4 см – длину короткой школьной линейки. Дальше всё считается умножением и делением:

$$s = n \cdot \pi D, \qquad n = \frac{s}{\pi D},$$

где $n$ – число оборотов. За 5 оборотов колесо 65 мм проедет $5 \cdot 20{,}42 = 102{,}1$ см. А чтобы проехать 1 м, ему нужно $100 : 20{,}42 = 4{,}9$ оборота.

От оборотов в минуту к скорости робота. Как быстро крутится колесо, говорят в оборотах в минуту или в секунду. Колесо делает 2 оборота в секунду – значит, за секунду робот проедет путь двух оборотов:

$$v = (\text{оборотов в секунду}) \cdot \pi D.$$

Пример. Колесо 65 мм крутится со скоростью 120 об/мин. В секунду это $120 : 60 = 2$ об/с. Скорость робота $2 \cdot 20{,}42 = 40{,}8$ см/с.

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

2.4. График «путь – время»

Чем круче поднимается линия, тем быстрее ехал робот. Ровная полочка – робот стоял: время идёт, а путь не растёт.

График – рисунок, на котором видно, как одна величина меняется вместе с другой. На графике «путь – время» по горизонтальной оси откладывают время, по вертикальной – путь, который робот проехал с начала. Каждая точка линии говорит: «к такой-то секунде робот проехал столько-то сантиметров».

Что можно узнать по такому графику?

• Путь к моменту времени. Находишь нужную секунду внизу, поднимаешься до линии и смотришь влево, на шкалу пути. К 2-й секунде робот проехал 40 см, к 7-й – 120 см.
• Скорость на участке. Путь, набранный на участке, делим на время этого участка. С 0 до 4 с робот проехал 80 см, его скорость $80 : 4 = 20$ см/с. С 6 до 8 с – тоже 80 см, но всего за 2 с: $80 : 2 = 40$ см/с. Линия здесь вдвое круче.
• Стоянки. С 4 до 6 с путь не меняется, 80 см и 80 см, – робот стоял.

Средняя скорость по графику – тот же весь путь, делённый на всё время: $160 : 8 = 20$ см/с.

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

2.5. Разгон, торможение и инерция

Моторы уже не тянут, а робот ещё катится – его несёт инерция. Расстояние от команды до остановки называют тормозным путём.

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

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

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

Как посчитать тормозной путь. Часто скорость при торможении падает равномерно – за каждую долю секунды на одно и то же число см/с. Такое торможение на графике скорости выглядит как прямая линия вниз.

Робот ехал 40 см/с и остановился за 0,5 с. В начале торможения его скорость 40 см/с, в конце – ноль, а в середине, через 0,25 с, – 20 см/с. Насколько в начале торможения робот едет быстрее 20 см/с, настолько же в конце он едет медленнее. Так что в среднем он ехал 20 см/с – вдвое медленнее, чем до команды. Тормозной путь:

$$s_{\text{торм}} = \frac{v}{2} \cdot t_{\text{торм}} = \frac{40}{2} \cdot 0{,}5 = 20 \cdot 0{,}5 = 10 \text{ см}.$$

Словами: при равномерном торможении средняя скорость – половина начальной, а тормозной путь – эта половина, умноженная на время торможения. С разгоном так же: если робот равномерно разгоняется от нуля до 40 см/с, в среднем он едет 20 см/с. Правило годится только для равномерного изменения скорости – в условии так и напишут: «скорость уменьшается равномерно» или «линейно».

Для программы вывод простой: если робот должен встать у линии, команду «стоп» даём раньше – за тормозной путь до неё.

2.6. Трение: почему колёса буксуют

На ковре колесо цепляется за ворс и отталкивает пол назад – робот едет вперёд. На льду зацепиться не за что: колесо крутится, а робот стоит на месте.

Сначала одно новое слово. Сила – это толчок или тяга: то, что может сдвинуть предмет, остановить его или изменить его скорость. Силу измеряют в ньютонах (Н). Чтобы почувствовать 1 Н, положи на ладонь яблоко массой 100 г – примерно с такой силой оно давит на руку.

Сила трения появляется, когда одна поверхность скользит по другой или пытается скользить, и всегда мешает этому скольжению. Попробуй сдвинуть по полу коробку с книгами. Толкаешь слабо – коробка стоит: трение её держит. Толкаешь сильнее – поехала, но трение всё время тормозит, и стоит перестать толкать, как коробка остановится. Сила трения зависит от двух вещей:

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

Трение помогает ехать. Без трения робот никуда бы не уехал. Колесо, вращаясь, упирается в пол и толкает его назад. Трение не даёт колесу проскользнуть, и робот отталкивается от пола вперёд – так же, как ты отталкиваешься ногой при ходьбе. На льду нога проскальзывает, и идти трудно; колесу на скользком полу так же трудно.

Пробуксовка. Если мотор крутит колесо сильнее, чем трение может удержать, колесо проскальзывает по полу – буксует. Так бывает на резком старте, на гладком или пыльном полу, у лёгкого робота, у колёс с твёрдыми пластиковыми шинами. Для расчётов это значит: колесо сделало обороты, а робот за каждый оборот проехал меньше $\pi D$. Энкодер честно считает обороты, но путь по ним получается больше настоящего. Пример: по оборотам робот должен был проехать 200 см, а по рулетке проехал 190 см. Он недоехал 10 см – это $10 : 200 \cdot 100 = 5$ % от расчётного пути.

Что с этим делать? Разгон делают плавным: программа поднимает скорость ступеньками, и колёса не срываются в пробуксовку. А путь по оборотам проверяют заездом с рулеткой на том полу, где роботу выступать, – как в задаче 1.6.

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

Для любопытных: вдвое быстрее – вчетверо дальше. Как тормозной путь зависит от скорости, подробно проходят в физике 9 класса, но понять это можно и сейчас. Возьмём робота на скользком полу: с 20 см/с он тормозит полсекунды и прокатывается 5 см. Пол и робот те же – значит, трение за каждую секунду отнимает у скорости одно и то же число см/с. С 40 см/с робот будет тормозить вдвое дольше, целую секунду, и едет он при этом в среднем вдвое быстрее: 20 см/с, а не 10. Время вдвое больше и скорость вдвое больше – путь вырастает в $2 \cdot 2 = 4$ раза: $20 \cdot 1 = 20$ см. Скорость втрое больше – тормозной путь в $3 \cdot 3 = 9$ раз длиннее. Поэтому в гололёд водители и едут медленно: лишние 10 км/ч удлиняют тормозной путь намного сильнее, чем кажется.

2.7. Разбираем задачи

Задача 2.3 Скорость по оборотам мотора

обороты в минуту, редуктор, скорость робота, перевод единиц

Вал мотора робота крутится со скоростью 7200 об/мин. Между мотором и колесом стоит редуктор с передаточным числом 48. Диаметр колеса 65 мм. За сколько секунд робот проедет 3 м? Разгон не учитывай, колёса не проскальзывают. Округли до десятых.

Дано: $n_{\text{м}} = 7200$ об/мин; $i = 48$; $D = 65$ мм; $s = 3$ м.
Найти: $t$ – ?

Шаг 1. Строим цепочку. Время найдём, если знаем скорость робота. Скорость – по оборотам колеса в секунду и пути за оборот. Обороты колеса – по оборотам мотора и редуктору. Получается так:

Шаг 2. Обороты колеса. Редуктор замедляет вращение в 48 раз: $7200 : 48 = 150$ об/мин.

Шаг 3. Обороты в секунду. В минуте 60 секунд: $150 : 60 = 2{,}5$ об/с.

Шаг 4. Путь за оборот. Скорость удобно получить сразу в см/с, поэтому диаметр переводим в сантиметры: $65$ мм $= 6{,}5$ см. Путь за оборот $\pi D = 3{,}14159 \cdot 6{,}5 = 20{,}42$ см.

Шаг 5. Скорость робота. За секунду колесо делает 2,5 оборота: $v = 2{,}5 \cdot 20{,}42 = 51{,}05$ см/с.

Шаг 6. Время. $3$ м $= 300$ см. $t = 300 : 51{,}05 = 5{,}88 \approx 5{,}9$ с.

Полметра в секунду – бодрый учебный робот, и три метра для него – дело шести секунд.

Типичная ошибка. Забыть про редуктор. Тогда колесо будто бы делает $7200 : 60 = 120$ об/с, а робот мчится $120 \cdot 20{,}42 = 2450$ см/с – это 24,5 м/с, почти 90 км/ч. Так же выдаёт себя пропущенное деление на 60: $150 \cdot 20{,}42 = 3063$ см/с. Если скорость робота вышла больше пары метров в секунду, ищи пропущенный шаг.

Ответ: 5,9 с.

Своя задача по программе сферы, модули 2 и 6

Задача 2.4 Читаем график поездки

график путь–время, скорость на участке, средняя скорость

На графике показано, как робот проехал по полигону. а) Сколько секунд робот стоял? б) С какой самой большой скоростью он ехал? в) Какова средняя скорость робота за всю поездку? В ответ введи среднюю скорость в сантиметрах в секунду.

Дано: график «путь – время».
Найти: время стоянки; самую большую скорость; $v_{\text{ср}}$ – ?

Шаг 1. Цена клетки. По горизонтали соседние линии – через 1 с. По вертикали подписаны 0, 40, 80…, а между подписанными линиями есть ещё одна. Значит, клетка по вертикали – 20 см.

Шаг 2. Разбиваем на участки. Линия ломается в точках: (0 с; 0 см), (4 с; 80 см), (7 с; 80 см), (11 с; 240 см), (15 с; 300 см). Получилось четыре участка.

Шаг 3. Стоянка. С 4-й по 7-ю секунду путь не меняется – 80 см. Робот стоял $7 - 4 = 3$ с.

Шаг 4. Скорости на участках. На каждом участке путь участка делим на его время:

• с 0 до 4 с: $80 : 4 = 20$ см/с;
• с 7 до 11 с: $(240 - 80) : (11 - 7) = 160 : 4 = 40$ см/с;
• с 11 до 15 с: $(300 - 240) : (15 - 11) = 60 : 4 = 15$ см/с.

Самая большая – 40 см/с, на самом крутом участке.

Шаг 5. Средняя скорость. Весь путь 300 см, всё время – 15 с, вместе со стоянкой: $300 : 15 = 20$ см/с.

Средняя вышла вдвое меньше самой большой скорости: робот три секунды стоял, а в конце еле полз.

Типичная ошибка. Сложить скорости участков и поделить на их число: $(20 + 40 + 15) : 3 = 25$ см/с или, со стоянкой, $(20 + 0 + 40 + 15) : 4 = 18{,}75$ см/с. Так нельзя: участки длились разное время, а среднее «по скоростям» считается, только когда время на каждой скорости одинаковое. Вторая ловушка – принять клетку по вертикали за 40 см и получить все пути вдвое больше.

Ответ: а) 3 с; б) 40 см/с; в) 20 см/с.

Своя задача по программе сферы, модуль 6

Задача 2.7^* Разгон по секундам

плавный разгон, пошаговая модель движения, таблица, цикл

Чтобы колёса не буксовали на старте, робот разгоняется плавно. Программа устроена так: в начале каждой секунды она прибавляет к скорости 10 см/с, пока скорость не станет 40 см/с, а дальше робот едет с 40 см/с. Считаем, что внутри секунды скорость не меняется: какой её поставили в начале секунды, с такой робот и едет до конца этой секунды. Робот стартует с места. За сколько секунд он проедет 3 м? Ответ – целое число секунд.

Дано: прибавка скорости 10 см/с в начале каждой секунды; наибольшая скорость 40 см/с; путь 3 м.
Найти: $t$ – ?

Шаг 1. Модель. Движение считаем по шагам, секунда за секундой. На каждом шаге сначала меняется скорость, потом к пути прибавляется то, что робот проехал за эту секунду, – столько сантиметров, сколько сейчас его скорость в см/с.

Шаг 2. Разгон по секундам. Выпишем первые секунды в таблицу:

Таблица 2.2

Секунда	Скорость, см/с	Проехал за секунду, см	Путь с начала, см
1-я	10	10	10
2-я	20	20	30
3-я	30	30	60
4-я	40	40	100

С 4-й секунды скорость больше не растёт. За 4 с робот проехал 100 см.

Шаг 3. Остаток пути. 3 м = 300 см. Осталось $300 - 100 = 200$ см со скоростью 40 см/с: $200 : 40 = 5$ с.

Шаг 4. Всё время. $4 + 5 = 9$ с.

Проверка кодом. Одинаковые шаги – работа для цикла. Вот та же модель на Python:

v = 0                 # скорость, см/с: робот стоит
s = 0                 # путь с начала, см
t = 0                 # сколько секунд прошло
while s < 300:        # повторяем, пока не проехали 3 м
    if v < 40:        # ещё не разогнались?
        v = v + 10    # в начале секунды прибавляем скорость
    s = s + v         # за эту секунду проехали v сантиметров
    t = t + 1         # прошла ещё одна секунда
print(t, s)           # 9 300

Первые три строки заводят переменные – ячейки памяти с именами v, s и t, в которых лежат числа. Всё, что после знака #, – комментарий для человека, компьютер его пропускает. Слово while значит «пока»: строки с отступом под ним повторяются, пока верно условие s < 300. if значит «если»: скорость растёт, только пока она меньше 40. print выводит на экран число секунд и путь – 9 и 300.

Без разгона робот проехал бы 3 м за $300 : 40 = 7{,}5$ с. Плавный старт обошёлся в полторы секунды – зато без пробуксовки.

Типичная ошибка. Не заметить, когда прибавляется скорость. Если бы прибавка шла в конце секунды, в 1-ю секунду робот стоял бы на месте, и ответ вышел бы 10 с. Слова «в начале» и «в конце» в таких условиях перечитай дважды. Другая ошибка – забыть про разгон и ответить 7,5 или 8 с.

Ответ: 9 с.

По мотивам задачи первого отборочного этапа НТО 2024/25, профиль «Интеллектуальные робототехнические системы», предметный тур по информатике, «Ускорение ускорения»

3.1. Координаты на поле

От угла поля сначала отсчитываем шаги вправо, потом вверх. Точка (4; 3) – четыре шага вправо и три вверх.

Полигон для роботов в сфере «Роботех» – это белое поле, по которому нарисованы чёрные линии. Линии пересекаются и образуют сетку, как в тетради в клетку. Места, где линии пересекаются, называют перекрёстками. Робот едет по линии, считает перекрёстки и на нужном останавливается или поворачивает.

Чтобы сказать роботу, куда ехать, перекрёстки нумеруют. В кинотеатре место задают двумя числами: ряд и кресло. В «Морском бое» – буквой и цифрой: «Б-5, ранил». На поле – двумя числами: сколько шагов от угла вправо и сколько вверх. Эти два числа называют координатами точки. Угол, от которого считаем, – начало отсчёта, у него координаты (0; 0).

• Первое число – x («икс»): сколько шагов вправо. Вдоль него идёт горизонтальная ось x.
• Второе число – y («игрек»): сколько шагов вверх. Вдоль него идёт вертикальная ось y.

Записывают так: (4; 3). Между числами ставим точку с запятой, потому что запятая у нас нужна для дробей: точка (2,5; 1) – это два с половиной шага вправо и один вверх. Порядок менять нельзя. Точки (4; 3) и (3; 4) – разные перекрёстки, и робот, перепутавший их, приедет не туда.

Шаг здесь – расстояние между соседними линиями, сторона клетки. На полигоне она может быть 20 см, 30 см, 50 см – в условии задачи это всегда сказано. Координаты при этом считают в клетках, а в сантиметры переводят в самом конце.

Осторожно с подсчётом. От линии 0 до линии 4 – четыре шага, хотя линий по дороге пять (0, 1, 2, 3, 4). С забором то же самое: у пяти столбиков четыре пролёта. Считай промежутки, а не линии.

Вернись к рисунку в начале раздела. Оранжевая стрелка кончается в точке (4; 0): четыре шага вправо и ноль вверх, точка лежит прямо на оси x. Самый верхний перекрёсток левого края – (0; 4): вправо идти не нужно, только вверх. А правый верхний угол нарисованного поля – (6; 4).

Иногда начало отсчёта ставят в середину поля. Тогда у точек левее середины x получается с минусом, у точек ниже – y с минусом: (−2; 3) – два шага влево и три вверх. А в программах, которые работают с картинками с камеры, ось y часто смотрит вниз, и отсчёт идёт от левого верхнего угла. Поэтому, прежде чем считать, посмотри на рисунок: где ноль и куда смотрят стрелки осей.

3.2. Направление и углы поворота

Робот смотрит вниз – и его «направо» на карте показывает влево. Повороты всегда считаем от носа робота.

Угол поворота меряют в градусах. Полный оборот вокруг себя – 360°. Остальное получается из него:

• 180° – половина оборота, разворот назад;
• 90° – четверть оборота, прямой угол: так робот сворачивает на перекрёстке;
• 45° – половина прямого угла: так смотрит диагональ клетки, из одного её угла в противоположный.

Для тренировки глаза посмотри на часы. Минутная стрелка за час делает полный оборот, 360°. За 15 минут – четверть, 90°. За одну минуту – 6°.

Слов для направлений у нас два набора. Перепутаешь их – робот уедет в другую сторону. «Вверх», «вниз», «вправо», «влево» – это направления на карте, как север, юг, восток и запад. Они от робота не зависят. А «направо», «налево», «вперёд», «назад» – это направления от робота. Смотрит робот вверх – его «направо» совпадает с «вправо» на карте. Развернулся и смотрит вниз – его «направо» на карте уже слева (рисунок выше).

Куда смотрит робот, удобно записывать одним числом – курсом. Курс – угол от направления «вверх» по часовой стрелке, как у компаса: 0° – вверх, 90° – вправо, 180° – вниз, 270° – влево. Посередине – диагонали: 45°, 135°, 225°, 315°.

Когда робот едет вперёд вдоль линии, у него меняется только одна координата:

Как считать курс после поворотов. Поворот направо – прибавляем угол, налево – вычитаем:

• направо на $\alpha$: новый курс = курс + $\alpha$;
• налево на $\alpha$: новый курс = курс − $\alpha$.

Буквой $\alpha$ («альфа») обозначаем угол поворота. Если получилось 360° или больше, вычитаем 360°: целый оборот ничего не меняет. Если получилось меньше нуля, прибавляем 360°. Пример: робот смотрит влево (270°) и поворачивает направо на 135°: $270 + 135 = 405$, $405 - 360 = 45°$ – теперь он смотрит по диагонали вверх-вправо. Другой пример: курс 0°, налево на 90°: $0 - 90 = -90$, $-90 + 360 = 270°$, робот смотрит влево.

На какой угол повернуть. Робот смотрит с курсом $A$, а ехать нужно с курсом $B$. Поворот направо – на $B - A$ (если вышло меньше нуля, прибавь 360°). Поворот налево – на то, что осталось до полного оборота: 360° минус угол поворота направо. Из двух выбирают меньший, он всегда не больше 180°. Пример: робот смотрит вправо (90°), а ехать надо вниз-влево (225°). Направо – на $225 - 90 = 135°$, налево – на $360 - 135 = 225°$. Короче направо, на 135°.

Если цель лежит на диагонали от робота – сдвиги по x и по y одинаковые, – курс на неё 45°, 135°, 225° или 315°. Например, из (1; 1) в (4; 4) сдвиг 3 вправо и 3 вверх – курс 45°. Из (5; 5) в (2; 2) – 3 влево и 3 вниз, курс 225°.

Робот рисует фигуру. Допустим, робот обходит квадрат: едет, поворачивает направо на 90°, едет, снова поворачивает… После четырёх поворотов он вернулся в начало и смотрит туда же, куда смотрел на старте. Значит, все повороты вместе дали полный оборот: $4 \cdot 90° = 360°$. Так с любой правильной фигурой – у которой все стороны равны и все углы равны. Если у неё $n$ сторон, то в каждой вершине робот поворачивает на

$$\text{угол поворота} = \frac{360°}{n}.$$

Для квадрата $360 : 4 = 90°$, для правильного шестиугольника $360 : 6 = 60°$, для восьмиугольника – 45°.

С треугольником ошибаются больше всего. Угол правильного треугольника – 60°, и рука сама пишет «поворот на 60°». Но робот поворачивает не на угол фигуры, а на угол между тем, куда он ехал, и тем, куда поедет дальше (оранжевая дуга на рисунке). Это $360 : 3 = 120°$. Проверка: угол фигуры и угол поворота вместе дают 180°, ведь робот, не повернув, поехал бы прямо дальше по пунктиру: $60 + 120 = 180$. У квадрата оба угла по 90°, поэтому там их и не путают.

3.3. Программа движения: где окажется робот

Робот выполняет команды по одной, сверху вниз. На поворотах он крутится на месте, как фигурист, – колёсами никуда не уезжает.

Робот – исполнитель: он умеет выполнять несколько простых команд, и из них собирают программу. Для езды по полю хватает таких:

• вперёд N – проехать вперёд N клеток (или N сантиметров – скажут в условии);
• направо и налево – повернуть на месте на 90°, если не сказано другое;
• развернуться – повернуть на месте на 180°;
• иногда ещё назад N – откатиться на N клеток, не поворачиваясь.

Чтобы узнать, где робот закончит программу, заведи таблицу, как бортовой журнал. В ней четыре столбца: команда, курс, x, y. Первая строка – старт. Дальше на каждую команду – новая строка: поворот меняет только курс, «вперёд» – только одну из координат, а какую – смотри по таблице из раздела 3.2.

Так выглядит журнал для программы с рисунка. Робот стартует в точке (0; 0) и смотрит вверх.

Робот закончил в точке (2; 4) и снова смотрит вверх. Можно проверить на глаз: вверх он проехал $3 + 1 = 4$ клетки, вправо – 2 клетки. Раз начал он из (0; 0), эти числа и дают его координаты.

Журнал удобен и тем, что его легко превратить в программу для компьютера. Код ниже на языке Python делает то же, что мы сделали в таблице. Его можно пропустить – о программах подробно рассказывают главы 4 и 6. Но если хочешь проверять себя на компьютере, вот как он устроен.

# на сколько меняются x и y за одну клетку вперёд при каждом курсе
shag = {0: (0, 1), 90: (1, 0), 180: (0, -1), 270: (-1, 0)}

x, y, kurs = 0, 0, 0            # старт: точка (0; 0), робот смотрит вверх
programma = [("вперёд", 3), ("направо", 90), ("вперёд", 2),
             ("налево", 90), ("вперёд", 1)]

for komanda, chislo in programma:
    if komanda == "вперёд":
        dx, dy = shag[kurs]
        x = x + dx * chislo
        y = y + dy * chislo
    elif komanda == "направо":
        kurs = (kurs + chislo) % 360
    else:                            # налево
        kurs = (kurs - chislo) % 360

print(x, y, kurs)                    # 2 4 0

• Всё, что после знака #, – пояснения для человека, компьютер их пропускает.
• shag – это таблица из раздела 3.2: для каждого курса записано, на сколько меняются x и y за одну клетку. Курс 90° (вправо) даёт (1, 0): x растёт на 1, y не меняется.
• x, y, kurs = 0, 0, 0 – заводим три переменные (ячейки памяти с именами) и кладём в каждую ноль.
• programma – список команд, по порядку. Такой список в программировании называют массивом. Кстати, в курсе сферы робот так и «запоминает путь»: складывает свои команды в массив.
• for … in programma: – «для каждой команды из списка сделай то, что ниже с отступом».
• if / elif / else – «если / иначе если / иначе»: смотрим, какая пришла команда.
• % – остаток от деления. (kurs + chislo) % 360 убирает лишние полные обороты: $405 \% 360 = 45$. А $-90 \% 360$ Python считает как 270 – это то же правило «прибавь 360» из раздела 3.2.
• print выводит ответ: 2 4 0, то есть точка (2; 4), курс 0°.

3.4. Масштаб: план и настоящий полигон

План – уменьшенная копия поля. Масштаб говорит, во сколько раз уменьшили.

Полигон размером 3 м × 2 м на тетрадный лист не поместится, поэтому рисуют план – уменьшенную копию, у которой все размеры уменьшены в одно и то же число раз. Это число записывают в масштаб. Масштаб 1 : 50 («один к пятидесяти») значит: 1 см на плане – это 50 см на настоящем поле.

• С плана на поле – умножаем на 50: отрезок 7 см на плане – это $7 \cdot 50 = 350$ см = 3,5 м на поле.
• С поля на план – делим на 50: край поля 2,4 м $= 240$ см, на плане это $240 : 50 = 4{,}8$ см.

Умножив сантиметры плана на 50, получаешь тоже сантиметры – только уже настоящие. Нужен ответ в метрах – переведи отдельным шагом: 350 см $= 350 : 100 = 3{,}5$ м.

Масштаб бывает записан словами: «в 1 см – 30 см». Это то же самое, что 1 : 30. А иногда его надо найти самому. Скажем, на плане одна клетка тетради (5 мм) – одна клетка поля (30 см). Переводим в одинаковые единицы: 30 см = 300 мм. Во сколько раз клетка поля больше: $300 : 5 = 60$. Масштаб 1 : 60.

Чем меньше второе число, тем крупнее рисунок. На плане 1 : 20 поле выйдет крупнее, чем на плане 1 : 50: каждый метр поля займёт 5 см, а не 2 см.

3.5. Расстояние и маршрут: по клеткам и по прямой

Как ни петляй лесенкой вправо и вверх, по линиям выйдет те же 4 + 3 = 7 клеток. Напрямую короче, но так можно ехать только там, где нет стен и не нужны линии.

Робот, который ездит по линиям, не может срезать угол. Как пешеход в городе: между кварталами дома, и по диагонали через двор не пройдёшь. Сколько он проедет от точки $(x_1;\ y_1)$ до точки $(x_2;\ y_2)$ самым коротким путём? Нужно проехать сдвиг по x и сдвиг по y:

$$\text{путь по линиям} = |x_2 - x_1| + |y_2 - y_1|.$$

Маленькие цифры 1 и 2 внизу – номера точек: $x_1$ – x первой точки, $x_2$ – x второй. Палочки $|\ |$ значат «без минуса»: из большего числа вычитаем меньшее. Из (1; 2) в (6; 8): по x $6 - 1 = 5$, по y $8 - 2 = 6$, путь $5 + 6 = 11$ клеток. Из (6; 8) обратно в (1; 2) – те же 11: едем влево и вниз, но расстояние от этого не меняется.

Почему у всех лесенок на рисунке длина одна и та же? Все горизонтальные кусочки вместе дают сдвиг вправо на 4, все вертикальные – сдвиг вверх на 3, как их ни перемешивай. Длиннее путь станет, только если где-то поехать назад: влево или вниз.

Маршрут через несколько точек считают по кусочкам: от старта до первой точки, от первой до второй и так далее, а потом складывают. Каждый кусок – от предыдущей точки, а не от старта. Потом клетки переводят в сантиметры: умножают на сторону клетки. 11 клеток по 20 см – это $11 \cdot 20 = 220$ см.

Для любопытных: путь напрямую. Если линий нет и робот умеет ехать куда угодно, короче всего – по прямой. Длину прямой находят по теореме Пифагора – её проходят в 8 классе, а пока хватит кнопки корня на калькуляторе:

$$\text{путь напрямую} = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}.$$

Сдвиг по x возводим в квадрат (умножаем сам на себя), сдвиг по y – тоже, складываем и берём квадратный корень – число, которое при умножении само на себя даёт то, что под корнем. На рисунке сдвиги 4 и 3: $\sqrt{16 + 9} = \sqrt{25} = 5$ клеток, ведь $5 \cdot 5 = 25$. По линиям было 7. Прямая никогда не бывает длиннее пути по линиям, а равны они, только когда точки на одной линии поля – горизонтальной или вертикальной. Одна клетка по диагонали – это $\sqrt{1 + 1} \approx 1{,}41$ клетки, почти в полтора раза длиннее стороны.

3.6. Поворот на колёсах: сколько крутить колесо

Колёса – как два бегуна на круглой дорожке стадиона: робот крутится на месте, а они бегут друг за другом по кругу. Повернулся робот на 180° – каждый бегун пробежал полкруга.

На поле с линиями робот поворачивает, пока датчик снова не увидит линию. А если линий нет – при навигации по координатам, – робот поворачивает вслепую: считает, на сколько повернулись колёса. Для этого на моторе ставят энкодер – датчик, который считает обороты (похожий счётчик стоял у робота в задаче 1.6). Значит, надо уметь переводить поворот робота в поворот колеса.

Вспомни главу 1: при развороте на месте одно колесо крутится вперёд, другое назад, а робот вертится вокруг точки посередине между ними. Каждое колесо при этом едет по окружности. Её диаметр – колея $B$, расстояние между серединами левого и правого колёс.

Шаг 1. Путь колеса. Длина окружности – $\pi \cdot$ диаметр, где $\pi \approx 3{,}14$ (подробнее – в главе 2). Полный оборот робота – колесо проходит $\pi \cdot B$. Поворот на угол $\alpha$ – такую же долю окружности, какую $\alpha$ составляет от 360°:

$$\text{путь колеса} = \pi \cdot B \cdot \frac{\alpha}{360}.$$

Шаг 2. Обороты колеса. За один свой оборот колесо диаметром $D$ проезжает $\pi \cdot D$. Делим путь на это число. Число $\pi$ стоит и сверху, и снизу, поэтому сокращается:

$$\text{обороты колеса} = \frac{\pi \cdot B \cdot \alpha / 360}{\pi \cdot D} = \frac{B}{D} \cdot \frac{\alpha}{360}.$$

А если энкодер считает не обороты, а градусы, умножаем обороты на 360 и получаем совсем короткую формулу:

$$\text{угол колеса} = \alpha \cdot \frac{B}{D}.$$

Пример. Колея 12 см, колесо 6 см, поворот на 90°. Путь колеса $3{,}14 \cdot 12 \cdot 90 : 360 \approx 9{,}4$ см. Колесо за оборот проезжает $3{,}14 \cdot 6 \approx 18{,}8$ см, значит, нужно $9{,}4 : 18{,}8 = 0{,}5$ оборота – это 180°. По короткой формуле то же самое: $90 \cdot 12 : 6 = 180°$. Колея здесь вдвое больше колеса, и колесо поворачивается вдвое больше, чем робот.

Есть и второй способ повернуть – вокруг стоящего колеса: одно колесо стоит, другое едет. Тогда едущее колесо идёт по окружности вокруг стоящего, её диаметр уже $2B$, и путь выходит вдвое длиннее: для того же робота на 90° – около 18,8 см, целый оборот колеса.

Зачем такая точность? Робот, который при каждом «направо» поворачивается на 88° вместо 90°, после десяти поворотов смотрит мимо цели на 20°. Проедет он после этого метр – и уйдёт вбок примерно на 34 см, больше чем на клетку. Не веришь – начерти в тетради прямую, а от неё транспортиром луч под углом 20°. Отмерь на луче 10 см и измерь угольником, как далеко эта точка от прямой: около 3,4 см. Увеличь в 10 раз – получишь те же 34 см. Поэтому колею и колёса мерят линейкой, а потом проверяют заездом.

3.7. Разбираем задачи

Координаты в ответах книги записаны как (x; y). Как вводить их на отборе – двумя числами через пробел, одной строкой или по отдельности, – всегда сказано в условии задачи.

Задача 3.4 Три груза по порядку

маршрут по точкам, путь по линиям, повороты

Робот стоит в точке S (1; 1) и смотрит вверх. Ему нужно забрать грузы в точках A (4; 3), B (2; 5) и C (5; 1) – строго в этом порядке. Ездит он только по линиям поля и к каждой следующей точке едет так: сначала вдоль оси x, потом вдоль оси y. Поворачивает на месте на 90°. Сторона клетки – 25 см.

а) Сколько сантиметров проедет робот от S до C? б) Сколько раз он повернёт направо и сколько налево?

Дано: S (1; 1), курс 0°; A (4; 3), B (2; 5), C (5; 1); сначала по x, потом по y; клетка 25 см.
Найти: а) длину пути, см; б) число поворотов направо и налево.

Шаг 1. Длина каждого куска. Считаем по линиям: сдвиг по x плюс сдвиг по y, каждый кусок – от предыдущей точки.

• S → A: по x $4 - 1 = 3$, по y $3 - 1 = 2$, всего 5 клеток;
• A → B: по x $4 - 2 = 2$ (влево), по y $5 - 3 = 2$, всего 4 клетки;
• B → C: по x $5 - 2 = 3$, по y $5 - 1 = 4$ (вниз), всего 7 клеток.

Шаг 2. Весь путь. $5 + 4 + 7 = 16$ клеток. В сантиметрах: $16 \cdot 25 = 400$ см.

Шаг 3. Повороты. Проедем маршрут по командам и будем следить за курсом.

• Из S к A: надо вправо (90°), а робот смотрит вверх (0°) – направо. Вперёд 3 – он в (4; 1). Дальше вверх (0°): с 90° на 0° – налево. Вперёд 2 – он в A (4; 3).
• Из A к B: надо влево (270°), робот смотрит вверх – налево. Вперёд 2 – в (2; 3). Дальше вверх: с 270° на 0° – направо. Вперёд 2 – в B (2; 5).
• Из B к C: надо вправо, робот смотрит вверх – направо. Вперёд 3 – в (5; 5). Дальше вниз (180°): с 90° на 180° – направо. Вперёд 4 – в C (5; 1).

Считаем: направо – 4 раза, налево – 2 раза.

Шаг 4. Сверяем с концом маршрута. Четыре поворота направо и два налево – в сумме $4 \cdot 90 - 2 \cdot 90 = 180°$ направо. Начинал робот с курса 0°, значит, закончить должен с курсом 180°, то есть глядя вниз. Последний кусок он и правда ехал вниз.

Типичная ошибка. Считать каждый кусок от старта или от начала отсчёта: например, решить, что от A до B надо проехать 5 клеток вверх, потому что у B y = 5. Кусок считается от предыдущей точки: от y = 3 до y = 5 – две клетки. В пункте б путаница другая: «направо» определяют по карте. Из A к B робот едет влево по карте и поворачивает для этого налево, потому что смотрит вверх. А у точки (2; 3), глядя влево, он поворачивает к «вверх» уже направо.

Ответ: а) 400 см (4 м); б) направо 4 раза, налево 2 раза.

По мотивам задачи второго отборочного этапа НТО 2024/25, профиль «Интеллектуальные робототехнические системы», инженерный тур, «Планирование движения робота»

Задача 3.7^* Сколько есть коротких дорог

кратчайшие маршруты по сетке, подсчёт вариантов, обязательная точка

Робот-разведчик едет по линиям поля из точки (0; 0) в точку (4; 3) самым коротким путём. По дороге он обязан проехать через контрольную точку K (2; 1) – там его фотографирует камера. Сколько существует разных самых коротких маршрутов через K?

Дано: старт (0; 0), финиш (4; 3), обязательная точка K (2; 1); путь – самый короткий, по линиям.
Найти: число маршрутов.

Шаг 1. Какие маршруты самые короткие. По линиям от (0; 0) до (4; 3) самый короткий путь – $4 + 3 = 7$ клеток. Такой путь получается, только если робот едет вправо и вверх и ни разу не сворачивает влево или вниз. Каждый шаг влево или вниз потом пришлось бы отыгрывать, и путь бы удлинился.

Шаг 2. Сколькими способами попасть в перекрёсток. В каждый перекрёсток робот въезжает последним шагом либо слева, либо снизу. Значит, число способов попасть в перекрёсток = способы попасть в соседа слева + способы попасть в соседа снизу. На нижней линии и на левой – по одному способу: туда можно только ехать прямо, не сворачивая.

Шаг 3. Считаем до K. До K (2; 1) робот не может заехать выше y = 1 и правее x = 2 – иначе в K ему пришлось бы ехать вниз или влево. Нижняя линия: 1, 1, 1. Перекрёсток (1; 1): $1 + 1 = 2$. Перекрёсток K (2; 1): слева 2, снизу 1, итого $2 + 1 = 3$ способа.

Шаг 4. Считаем от K до финиша. Дальше робот едет только правее K и выше K. Все маршруты проходят через K, поэтому в K ставим 3 и считаем тем же правилом:

• правее K по линии y = 1: 3 и 3; выше K по линии x = 2: 3 и 3;
• (3; 2): $3 + 3 = 6$; (4; 2): $6 + 3 = 9$;
• (3; 3): $3 + 6 = 9$; (4; 3): $9 + 9 = 18$.

Шаг 5. Короче – умножением. От старта до K – 3 маршрута. От K до финиша (2 вправо и 2 вверх) – тем же правилом выходит 6. Любой из трёх первых кусков можно продолжить любым из шести вторых: $3 \cdot 6 = 18$. Если убрать камеру и посчитать тем же правилом всю сетку, в финише выйдет 35 – обязательная точка отсекла почти половину путей.

Типичная ошибка. Сложить маршруты двух половин, $3 + 6 = 9$, вместо того чтобы умножить. Каждый маршрут до K соединяется с каждым маршрутом после K, поэтому их 3 раза по 6. Другая ловушка – в таблице прибавить к перекрёсткам выше K те маршруты, что обходят K стороной (например, через (1; 2)). Их брать нельзя: такие пути мимо камеры.

Ответ: 18 маршрутов.

По мотивам задачи первого отборочного этапа НТО 2024/25, профиль «Интеллектуальные робототехнические системы», предметный тур по информатике, «Ладья и обязательная клетка»

4.1. Исполнитель и его команды

Робот берёт карточки по одной, сверху вниз, и делает то, что на них написано. Сам он ничего не придумывает.

Исполнитель – тот, кто выполняет команды. Это может быть робот на полигоне, черепашка на экране компьютера или твой младший брат, которому ты объясняешь дорогу до остановки. У каждого исполнителя свой набор команд, который он понимает. Этот набор называют системой команд исполнителя (коротко СКИ). Команду не из своего списка исполнитель выполнить не может, даже если человеку она кажется простой.

Алгоритм – точный порядок действий, который приводит к цели. Записанный командами исполнителя, он становится программой. Главное слово тут – «точный». «Иди куда-нибудь направо» – пожелание, исполнитель с ним ничего не сделает. «Вперёд 3, направо, вперёд 2» – алгоритм.

Наш исполнитель на всю главу – робот на клетчатом поле. Поле расчерчено на клетки, робот всегда стоит в центре какой-то клетки и смотрит в одну из четырёх сторон: вверх, вправо, вниз или влево (по листу). Клетку записываем двумя числами: сначала номер столбца (считаем слева направо), потом номер строки (снизу вверх). Клетка (4; 3) – четвёртый столбец, третья строка. В главе 3 точки отмечались на пересечениях линий, здесь робот стоит внутри клеток, но порядок чисел тот же: сначала «вправо», потом «вверх».

Система команд робота:

• вперёд N – проехать N клеток в ту сторону, куда робот смотрит; вперёд 1 – на одну клетку;
• направо – повернуться на месте на четверть оборота по часовой стрелке (на 90°);
• налево – повернуться на месте на четверть оборота против часовой стрелки.

Поворот не сдвигает робота из клетки, он меняет только направление взгляда. Край поля и стены – препятствие. Команду вперёд N робот выполняет клетка за клеткой. Если по дороге встретилась стена или край поля, он доезжает до препятствия, врезается – и программа останавливается с ошибкой. Команды после этой уже не выполняются.

Направо – с точки зрения робота, а не листа. Робот смотрит вверх – его «направо» совпадает с правой стороной листа. Но если робот смотрит вниз, его «направо» – это левая сторона листа, а «налево» – правая. Подробно про это в главе 3. Если запутался, поверни тетрадь так, чтобы робот смотрел от тебя, или встань и повернись вместе с ним.

Линейный алгоритм – команды выполняются одна за другой, по одному разу, без пропусков и повторов. Так устроена программа на картинке выше: вперёд 2, направо, вперёд 3. Робот из клетки (1; 1), смотревший вверх, приедет в клетку (4; 3) и будет смотреть вправо.

Сколько команд нужно, чтобы доехать. Если нужна самая короткая программа, считай так: каждый прямой отрезок пути – одна команда вперёд N, каждый поворот на 90° – одна команда, разворот на месте – две (направо, направо). Чтобы попасть из (1; 1) в (4; 3), надо сдвинуться и вправо, и вверх. Значит, прямых отрезков нужно хотя бы два, и между ними – поворот. Получается 3 команды – меньше нельзя.

4.2. Циклы: «повтори» и «пока»

Учитель физкультуры не говорит «присядь, присядь, присядь…» двадцать раз. Он говорит «двадцать приседаний». Цикл – то же самое для робота.

Чтобы робот объехал квадрат со стороной в 3 шага, можно написать восемь команд подряд: вперёд 3, направо, вперёд 3, направо и так ещё два раза. Длинно, и легко сбиться со счёта. Удобнее сказать роботу: «повтори четыре раза: вперёд 3, направо». Такая конструкция называется циклом.

повтори 4:
    вперёд 3
    направо

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

Сколько команд в программе и сколько робот выполнит – разные вещи. В записи выше 3 строки: сам повтори 4 и две команды тела. А выполнит робот $4 \cdot 2 = 8$ команд движения и поворота. В задачах про это спрашивают по-разному, поэтому договоримся для всей главы:

• длина программы – число строк-команд в записи; повтори N: – тоже команда, тело считаем один раз;
• выполненные команды – сколько раз робот сделал вперёд, направо или налево; вперёд 3 – одна команда, хотя клеток три. Сама строка повтори роботом «не делается», её не считаем.

Как считать, пишут в условии задачи. Прочитай это место до того, как начнёшь считать, а не после.

Как сократить программу циклом. Ищи кусок, который повторяется подряд несколько раз без изменений. Например, вперёд 1, направо, вперёд 1, налево, вперёд 1, направо, вперёд 1, налево – это дважды один и тот же кусок из четырёх команд, то есть повтори 2: и четыре команды в теле. Если после повторов остался хвостик – часть куска, – его пишут отдельно после цикла. Число повторов – сколько раз кусок встретился целиком.

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

пока впереди свободно:
    вперёд 1

Перед каждым повтором робот смотрит датчиком вперёд. Свободно – делает шаг и снова проверяет. Стена – цикл заканчивается, и робот идёт к следующей строке. Если впереди стена с самого начала, тело не выполнится ни разу. Условия, которые понимает наш робот: «впереди свободно», «справа свободно», «слева свободно» и обратные к ним «впереди стена», «справа стена», «слева стена».

4.3. Ветвление: «если – иначе»

Как ты утром смотришь в окно: идёт дождь – берёшь зонт, нет – не берёшь. Робот тоже выбирает одну из двух дорог по ответу датчика.

Ветвление – место в программе, где робот выбирает, что делать, в зависимости от условия. Условие – вопрос, на который ответ «да» или «нет»: «впереди стена?», «справа свободно?». Запись такая:

если впереди стена:
    направо
иначе:
    вперёд 1

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

Бывает, что вариантов больше двух. Тогда проверки ставят цепочкой: если …, иначе если …, иначе если …, иначе. Робот проверяет условия сверху вниз и выполняет ветку первого верного, остальные даже не смотрит. Поэтому порядок проверок меняет поведение робота – на этом держится правило правой руки из раздела 4.5.

Ветвление почти всегда живёт внутри цикла. Одна проверка – это один выбор на одном перекрёстке. А чтобы робот принимал решение на каждом шаге, проверку кладут в тело цикла пока.

4.4. Подпрограммы

В рецепте пишут «приготовь тесто», а как его готовить – описано один раз на другой странице. Подпрограмма – такая же страница для робота.

Подпрограмма – кусок программы, которому дали имя. Её описывают один раз, а потом вызывают – пишут имя в том месте, где нужны эти команды. Встретив имя, робот выполняет все команды подпрограммы по порядку и возвращается к строке, которая идёт после вызова.

подпрограмма ступенька:
    вперёд 1
    направо
    вперёд 1
    налево

ступенька
ступенька
ступенька

Описание подпрограммы (первые пять строк) робот сам по себе не выполняет – это как рецепт на полке. Работа начинается с первого вызова. Здесь их три, и робот из (1; 1), смотревший вверх, поднимется по трём ступенькам в (4; 4) – как на картинке.

Зачем это нужно? Программу проще читать: «ступенька, ступенька, ступенька» понятнее двенадцати строк. Ошибку исправляешь в одном месте, а не в двенадцати. И подпрограмму можно вызывать внутри цикла и даже внутри другой подпрограммы. В языке C++ для Arduino подпрограммы называют функциями – с ними ты встретишься в главе 6.

Сколько команд выполнит робот? Каждый вызов – это все команды подпрограммы. Ступенька – 4 команды, три вызова – $3 \cdot 4 = 12$. Вызов внутри цикла умножается на число повторов.

4.5. Лабиринт и правило правой руки

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

Лабиринт на поле – это клетки со стенами между некоторыми из них. Карты у робота нет, он видит только стены рядом с собой: датчики смотрят вперёд, вправо и влево. Нужен алгоритм, который выводит к выходу, даже если лабиринт видишь впервые. Самый известный – правило правой руки: двигаться так, будто правая рука всё время касается стены.

В каждой клетке робот проверяет стороны строго по порядку:

1. справа свободно – повернуть направо и шагнуть;
2. иначе впереди свободно – шагнуть прямо;
3. иначе слева свободно – повернуть налево и шагнуть;
4. иначе (кругом стены, это тупик) – развернуться и шагнуть обратно.

На языке нашего робота:

пока не вышел:
    если справа свободно:
        направо
        вперёд 1
    иначе если впереди свободно:
        вперёд 1
    иначе если слева свободно:
        налево
        вперёд 1
    иначе:
        направо
        направо
        вперёд 1

Заметь: после каждого поворота стоит вперёд 1. Без него робот, повернув направо, на следующей проверке снова найдёт справа свободное место – хотя бы то, откуда пришёл, – и повернётся ещё раз. Вместо того чтобы идти вдоль стены, он закружится на месте или поедет назад. Забытый шаг после поворота ломает всё правило.

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

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

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

4.6. Трассировка и поиск ошибок

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

Трассировка – выполнение программы «вручную», на бумаге, строка за строкой. Удобнее всего таблица из четырёх колонок: номер шага, команда, клетка робота, куда он смотрит. После каждой команды – новая строка таблицы. Даже если «и так понятно», не перепрыгивай через шаги: ошибки прячутся на поворотах.

Цикл в трассировке разворачивай полностью: при повтори 3 тело пишешь три раза, строка за строкой. Подпрограмму тоже раскрывай – вместо имени вписывай её команды. Позже, когда набьёшь руку, заметишь закономерность («за один круг робот сдвигается на 2 клетки вправо») и сможешь считать сразу. Но первые задачи честно трассируй до конца.

Поиск ошибки в программе (программисты говорят «отладка») – та же трассировка, только ты сравниваешь, что должно быть после каждой строки и что получилось. Первая строка, где разошлось, – подозреваемая. Самые частые ошибки в программах для робота на поле:

• перепутаны направо и налево – чаще когда робот смотрит вниз или влево и хочется повернуть «по листу»;
• ошибка заборчика – в ряду из 6 клеток между первой и последней всего 5 шагов, а не 6: столбиков забора на один больше, чем пролётов;
• не то число повторов – на один больше или меньше, чем нужно;
• команда не на своём месте – поворот попал в тело цикла, хотя должен стоять после него, или наоборот;
• забыт шаг после поворота в правиле руки.

Для любопытных: трассировку может сделать компьютер. Этот кусок можно пропустить – все задачи главы решаются карандашом. В главе 3 была программа на Python, которая ведёт журнал робота по таблице курсов. Здесь – её родственница: поворот она делает без таблицы и вдобавок следит за краем поля. Если Python ты видишь впервые, читай медленно, со строкой кода перед глазами, – разбор ниже идёт по порядку. Зато потом подставляешь свою программу и проверяешь ответ.

W, H = 6, 5              # поле: 6 столбцов, 5 строк
x, y = 2, 1              # клетка робота: столбец 2, строка 1
dx, dy = 0, 1            # куда смотрит: вверх
program = ["вперёд 3", "направо", "вперёд 3", "направо",
           "вперёд 2", "налево", "вперёд 2"]
crash = False
for i, cmd in enumerate(program, start=1):
    if cmd == "направо":
        dx, dy = dy, -dx
    elif cmd == "налево":
        dx, dy = -dy, dx
    else:
        n = int(cmd.split()[1])        # число после слова «вперёд»
        for step in range(n):          # едем по одной клетке
            if not (1 <= x + dx <= W and 1 <= y + dy <= H):
                crash = True           # следующая клетка – за краем поля
                break
            x, y = x + dx, y + dy
    print(i, cmd, "->", x, y)
    if crash:
        print("врезался в край поля")
        break

Разберём по строкам. Всё, что после #, – комментарий для человека, компьютер его пропускает. W, H = 6, 5 и x, y = 2, 1 кладут числа в переменные – ячейки памяти с именами: размер поля и клетку робота (2; 1). Направление хранится двумя числами: dx – на сколько меняется столбец за один шаг, dy – на сколько меняется строка. Вверх – это (0; 1), вправо – (1; 0), вниз – (0; −1), влево – (−1; 0). program – список команд в квадратных скобках. for i, cmd in enumerate(program, start=1): – цикл «для каждой команды из списка»: в cmd по очереди попадает очередная команда, а в i – её номер, начиная с 1. Дальше ветвление: if – «если», elif – «иначе если», else – «иначе».

Самая хитрая строка – поворот направо, dx, dy = dy, -dx. Компьютер сначала вычисляет оба числа справа от = по старым значениям и только потом раскладывает их: первое – в dx, второе – в dy. Проверь на примере: робот смотрел вверх, (0; 1). Справа получается 1, 0 – теперь он смотрит вправо. Ещё раз: из (1; 0) выйдет 0, -1, то есть вниз. А если записать то же двумя строками, dx = dy и потом dy = -dx, вторая строка возьмёт уже новое dx. Из «вверх» получится (1; −1) – робот смотрит наискосок, такого направления у нас нет. Налево – та же строка с минусом у другого числа: dx, dy = -dy, dx.

Команду вперёд N программа выполняет по одной клетке. Сначала cmd.split() режет текст «вперёд 3» по пробелу на два куска, [1] берёт второй кусок – «3», а int превращает текст «3» в число 3. Перед каждым шагом программа проверяет, не за краем ли следующая клетка: 1 <= x + dx <= W значит «новый столбец от 1 до W», и так же для строки. Если за краем – запоминает аварию в crash и командой break прерывает внутренний цикл. print выводит номер команды, её саму и клетку робота. Второй break, после сообщения об аварии, останавливает и внешний цикл: врезавшийся робот дальше не едет. Для этой программы последние строки вывода – 7 вперёд 2 -> 6 2 и врезался в край поля. Это задача 4.1 – сейчас решим её руками.

4.7. Когда робот ходит по кругу

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

Бывает исполнитель совсем простой. Робот-погрузчик ездит по дорожке из пронумерованных клеток, а на каждой клетке стоит табличка с номером: «→ 5» значит «переезжай на клетку 5». Робот читает табличку, переезжает, читает следующую. Своей головы у него нет, только таблички.

Допустим, робот вернулся на клетку, где уже был. Таблички не поменялись, значит, дальше он поедет точно так же, как в прошлый раз, – и снова вернётся сюда же. Робот попал в бесконечный круг. Это называют зацикливанием. Для трассировки вывод простой: как только клетка повторилась, дальше писать таблицу бессмысленно, всё уже известно.

Возьмём дорожку с рисунка: робот начинает на клетке 1 и едет 1 → 5 → 2 → 7 → 4 → 3 → 2 → … Клетка 2 повторилась. До неё робот ехал 2 переезда – это подъезд. Круг 2 → 7 → 4 → 3 → 2 занимает 4 переезда, это длина круга.

Где робот будет через много переездов. Спросим: где он окажется после 31 переезда? Выписывать 31 строку долго, и легко ошибиться. Считаем иначе.

• Отнимаем подъезд: $31 - 2 = 29$. Столько переездов робот сделал уже по кругу, начав с клетки 2.
• Делим на длину круга с остатком: $29 = 4 \cdot 7 + 1$. Семь полных кругов вернули робота на клетку 2.
• Остаток 1 – ещё один переезд по кругу от клетки 2: робот на клетке 7.

Прежде чем верить такому счёту, проверь его на маленьком числе, которое легко протрассировать руками. Три переезда: $3 - 2 = 1$, кругов ноль, остаток 1 – клетка 7. По дорожке: 1 → 5 → 2 → 7. Совпало, значит, подъезд и длину круга ты нашёл правильно.

4.8. Разбираем задачи

Задача 4.1 Доедет или врежется

разминка · линейный алгоритм, трассировка, повороты относительно робота, край поля

Поле 6 × 5 клеток, стен внутри нет. Робот стоит в клетке (2; 1) и смотрит вверх. Он выполняет программу:

вперёд 3
направо
вперёд 3
направо
вперёд 2
налево
вперёд 2

Выполнит ли робот программу до конца? Если да – в какой клетке он окажется. Если нет – на какой по счёту команде он врежется и в какой клетке будет стоять в этот момент.

Дано: поле 6 × 5; старт (2; 1), смотрит вверх; 7 команд.
Найти: доедет ли; клетку в конце или в момент аварии.

Шаг 1. Готовим таблицу. Записываем начальное положение, а потом по строке на каждую команду. вперёд меняет клетку, повороты меняют только направление. Держим в голове размер поля: столбцы от 1 до 6, строки от 1 до 5.

Шаг 2. Трассировка.

Таблица 4.1

Шаг	Команда	Клетка	Смотрит
старт	–	(2; 1)	вверх
1	вперёд 3	(2; 4)	вверх
2	направо	(2; 4)	вправо
3	вперёд 3	(5; 4)	вправо
4	направо	(5; 4)	вниз
5	вперёд 2	(5; 2)	вниз
6	налево	(5; 2)	вправо
7	вперёд 2	(6; 2), дальше край	вправо

Шаг 3. Самое опасное место – шаг 6. Робот смотрит вниз. Поверни тетрадь вверх ногами: теперь робот смотрит от тебя, и его «налево» совпадает с твоим левым. Верни тетрадь обратно – эта сторона оказалась справа по листу. Налево от робота, который смотрит вниз, – это вправо по листу.

Шаг 4. Последняя команда. Робот в (5; 2) смотрит вправо, ему нужно проехать 2 клетки. Первая – в (6; 2), это последний столбец поля. Вторая клетка была бы в седьмом столбце, а его нет: робот врезается в край. Он стоит в (6; 2), программа остановилась на 7-й команде.

Проверить себя можно программой на Python из раздела 4.6 – это та же задача, и она печатает то же самое.

Типичная ошибка. На шаге 6 повернуть «налево по листу» – влево. Тогда робот спокойно проедет 2 клетки влево, в (3; 2), и покажется, что программа выполнилась до конца. Одна неверно понятая команда поменяла не только клетку, но и сам ответ «доедет – не доедет». Вторая ошибка поменьше: решить, что робот при аварии остаётся в (5; 2). По нашему правилу он проезжает, сколько может, и останавливается у края.

Ответ: не доедет: робот врежется на 7-й команде, стоя в клетке (6; 2).

Своя задача по программе сферы, модуль 10

вперёд 1
направо
вперёд 1
налево
вперёд 1
направо
вперёд 1
налево
вперёд 1
направо
вперёд 1
налево
вперёд 1
направо

повтори 3:
    вперёд 1
    направо
    вперёд 1
    налево
вперёд 1
направо

повтори 5:
    вперёд 1
    направо
    вперёд 1
    налево

повтори 3:
    вперёд 2
    налево
    вперёд 1
    ???

повтори 4:
    вперёд 3
    ???

пока впереди свободно:
    вперёд 1
???
пока впереди свободно:
    вперёд 1

Задача 4.4 Гребёнка из подпрограмм

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

Робот рисует на полу маркером «гребёнку». Он стоит в клетке (1; 1) поля 8 × 3 и смотрит вверх. Программа:

подпрограмма зубец:
    вперёд 2
    направо
    вперёд 1
    направо
    вперёд 2
    налево
    вперёд 1
    налево

повтори 3:
    зубец

Сколько команд движения и поворота выполнит робот? В какой клетке он окажется и куда будет смотреть?

Дано: подпрограмма из 8 команд; вызов в цикле 3 раза; старт (1; 1), смотрит вверх.
Найти: число выполненных команд; конечную клетку и направление.

Шаг 1. Что делает один зубец. Трассируем подпрограмму один раз, от (1; 1) лицом вверх:

Таблица 4.2

Команда	Клетка	Смотрит
вперёд 2	(1; 3)	вверх
направо	(1; 3)	вправо
вперёд 1	(2; 3)	вправо
направо	(2; 3)	вниз
вперёд 2	(2; 1)	вниз
налево	(2; 1)	вправо
вперёд 1	(3; 1)	вправо
налево	(3; 1)	вверх

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

Шаг 2. Три зубца. Столбец растёт на 2 за каждый вызов: $1 + 3 \cdot 2 = 7$. Строка в конце зубца снова первая. Робот в (7; 1) и смотрит вверх.

Шаг 3. Считаем команды. В подпрограмме 8 команд, вызывается она 3 раза: $8 \cdot 3 = 24$. Сами строки повтори 3: и зубец мы не считаем – по ним робот не двигается, они только говорят, что и сколько раз делать.

Проверка по полю. Поле 8 × 3: строки от 1 до 3, зубец поднимается до третьей и в край не упирается. Последний зубец заканчивается в столбце 7, восьмой остаётся свободным.

Типичная ошибка. Посчитать строчки в записи: 8 строк подпрограммы + 2 строки основной программы = 10. Это длина программы, а спрашивают, сколько робот выполнил. Другая ошибка – решить, что каждый вызов начинается из клетки (1; 1). Подпрограмма продолжает с того места, где робот сейчас стоит.

Ответ: 24 команды; клетка (7; 1), смотрит вверх.

Своя задача по программе сферы, модуль 1

подпрограмма уголок:
    вперёд 1
    направо

подпрограмма квадрат:
    повтори 4:
        уголок

повтори 3:
    квадрат
    вперёд 2

Задача 4.5 Выход из лабиринта

лабиринт, правило правой руки, ветвление в цикле, трассировка

Робот стоит в клетке (1; 1) лабиринта 5 × 5 и смотрит вверх. Вход за ним закрылся. Выход – в верхней стене над клеткой (5; 5). Робот идёт по правилу правой руки (программа – в разделе 4.5). Сколько раз он выполнит команду вперёд 1, пока не выйдет из лабиринта? Шаг через выход наружу тоже считается.

Дано: лабиринт на рисунке; старт (1; 1), смотрит вверх; правило правой руки.
Найти: число команд вперёд 1.

Шаг 1. Порядок проверок. В каждой клетке спрашиваем: справа свободно? Если да – поворот направо и шаг. Если нет: впереди свободно? – шаг прямо. Если нет: слева? – поворот налево и шаг. Если и слева стена – разворот и шаг. Шаг в каждой клетке один, поэтому число команд вперёд 1 – это число строк в таблице.

Шаг 2. Трассировка. «Справа / впереди / слева» – что видит робот: «с» – свободно, «ст» – стена.

Таблица 4.3

Шаг	Робот стоит, смотрит	Справа / впереди / слева	Что делает	Куда пришёл
1	(1; 1), вверх	ст / с / ст	прямо	(1; 2)
2	(1; 2), вверх	с / ст / ст	направо	(2; 2)
3	(2; 2), вправо	ст / ст / с	налево	(2; 3)
4	(2; 3), вверх	с / ст / с	направо	(3; 3)
5	(3; 3), вправо	с / ст / с	направо	(3; 2)
6	(3; 2), вниз	ст / с / ст	прямо	(3; 1)
7	(3; 1), вниз	с / ст / с	направо	(2; 1)
8	(2; 1), влево	ст / ст / ст	разворот	(3; 1)
9	(3; 1), вправо	ст / с / с	прямо	(4; 1)
10	(4; 1), вправо	ст / с / с	прямо	(5; 1)
11	(5; 1), вправо	ст / ст / ст	разворот	(4; 1)
12	(4; 1), влево	с / с / ст	направо	(4; 2)
13	(4; 2), вверх	с / ст / ст	направо	(5; 2)
14	(5; 2), вправо	ст / ст / с	налево	(5; 3)
15	(5; 3), вверх	ст / с / с	прямо	(5; 4)
16	(5; 4), вверх	ст / с / с	прямо	(5; 5)
17	(5; 5), вверх	ст / с / с	прямо	наружу

Посмотри на шаги 7 и 10. Из клетки (3; 1) справа от робота открыт проход в тупик (2; 1) – и робот туда послушно сворачивает, хотя выход совсем в другой стороне. На шаге 10 рука заводит его во второй тупик, (5; 1). В тупиках (шаги 8 и 11) робот разворачивается и выходит обратно.

Шаг 3. Любопытная деталь – шаг 12. Робот стоит в (4; 1), смотрит влево, и впереди свободно. Но справа – проход вверх, а правое по правилу проверяется первым. Поэтому он поворачивает направо и уходит вверх, в (4; 2).

Прикинем. Кратчайший путь от (1; 1) до выхода – 11 шагов. У нас 17: лишние шесть ушли на два тупика, в каждом – заезд и выезд. Так платит за дорогу любой, кто идёт без карты. Зато стены здесь соединены с внешней, и к выходу рука приведёт наверняка.

Типичная ошибка. Посчитать кратчайший путь (11 шагов) – ведь «робот же умный». Робот без карты кратчайшего пути не знает, он честно следует правилу. Вторая ошибка – поменять порядок проверок и сначала смотреть вперёд: на шаге 12 робот поедет прямо, в (3; 1), и путь станет совсем другим.

Ответ: 17.

Своя задача по программе сферы, модуль 8

Задача 4.6 Найди ошибку

поиск ошибки, трассировка, цикл

На поле 8 × 6 клетки (2; 2) и (3; 2) заняты клумбой. Робот стоит в клетке (1; 1) и смотрит вверх. Он должен объехать клумбу по соседним клеткам по часовой стрелке – (1; 1) → (1; 3) → (4; 3) → (4; 1) → (1; 1) – и вернуться в (1; 1) лицом вверх. Программист написал:

1  повтори 2:
2      вперёд 2
3      направо
4      вперёд 3
5      налево

Робот уехал куда-то не туда. В какой строке ошибка и что там должно стоять? В ответ запиши номер строки.

Дано: программа из 5 строк; задуманный маршрут; старт (1; 1), смотрит вверх.
Найти: номер строки с ошибкой и исправление.

Шаг 1. Что должно быть. Задуманный путь – прямоугольник из четырёх отрезков: вверх 2, вправо 3, вниз 2, влево 3. Он складывается из двух одинаковых половинок: «вверх 2, вправо 3» и «вниз 2, влево 3». Поэтому цикл повтори 2 здесь к месту. После каждого отрезка робот поворачивает по часовой стрелке – то есть направо.

Шаг 2. Трассируем, что получилось.

Таблица 4.4

Строка	Команда	Клетка	Смотрит	Должно быть
2	вперёд 2	(1; 3)	вверх	(1; 3) – да
3	направо	(1; 3)	вправо	вправо – да
4	вперёд 3	(4; 3)	вправо	(4; 3) – да
5	налево	(4; 3)	вверх	смотреть вниз – нет

Первое расхождение – строка 5. Робот должен повернуть вниз, к клетке (4; 1), а повернул вверх.

Шаг 3. Что будет дальше с ошибкой. Второй круг: вперёд 2 – вверх в (4; 5), направо – вправо, вперёд 3 – в (7; 5), налево – вверх. Робот закончит в (7; 5), далеко от клумбы. Красная линия на рисунке.

Шаг 4. Исправляем и проверяем. В строке 5 ставим направо. Первый круг: (1; 3), вправо, (4; 3), вниз. Второй: вперёд 2 – (4; 1), направо – смотрит влево, вперёд 3 – (1; 1), направо – смотрит вверх. Робот на месте и смотрит как в начале.

А нельзя ли исправить иначе, например в строке 3 поставить налево и объехать клумбу против часовой? Нельзя: робот стоит в левом нижнем углу поля, и первый же вперёд 3 влево врежет его в край. Значит, ошибка только в строке 5.

Типичная ошибка. Начать «исправлять» числа: заменить вперёд 3 на вперёд 4 или вперёд 2 на вперёд 3, потому что клумба «вроде бы шире». Числа в программе верные – это видно по таблице: до строки 5 робот идёт по задуманному пути. Сначала найди первую строку, где разошлось, и только потом думай, что менять.

Ответ: строка 5, вместо налево должно быть направо.

Своя задача по программе сферы, модуль 1

1  подпрограмма ступенька:
2      вперёд 1
3      направо
4      вперёд 1
5      направо
6  повтори 4:
7      ступенька

Задача 4.7^* Таблички на клетках

трассировка, зацикливание, таблица переходов

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

а) Таблички такие, как на рисунке. Сколько переездов сделает робот до финиша?

б) Таблички переставили: 1 → 3, 2 → 6, 3 → 5, 4 → 9, 5 → 8, 6 → 4, 7 → 2, 8 → 3. Сколько переездов теперь? Если робот никогда не доедет до финиша, в ответ запиши −1.

в) Робота из пункта б) никто не выключил, и он продолжает ездить по табличкам. На какой клетке он будет после 20 переездов?

Дано: 9 клеток; таблички для а) – на рисунке, для б) и в) – в условии; старт – клетка 1, финиш – клетка 9.
Найти: а), б) число переездов или −1; в) клетку после 20 переездов.

Шаг 1. Пункт а) – трассировка. Табличка на клетке – это команда «переехать на клетку №…». Ведём робота:

Таблица 4.5

Переезд	Откуда	Табличка	Куда
1	1	→ 4	4
2	4	→ 7	7
3	7	→ 3	3
4	3	→ 6	6
5	6	→ 5	5
6	5	→ 2	2
7	2	→ 9	9 – финиш

Робот на финише после 7 переездов. На клетке 8 он так и не побывал: на неё не указывает ни одна табличка.

Шаг 2. Пункт б) – та же трассировка. 1 → 3 → 5 → 8 → 3. Стоп: на клетке 3 робот уже был – после первого переезда.

Шаг 3. Почему дальше можно не считать. Это зацикливание из раздела 4.7. С клетки 3 робот в прошлый раз поехал на 5, потом на 8, потом снова на 3 – и сейчас поедет так же. Круг 3 → 5 → 8 → 3 будет крутиться вечно, финиша робот не увидит.

А клетка 4, с которой есть переезд на финиш? До неё можно добраться только с клетки 6, до 6 – только с 2, до 2 – только с 7, а на 7 не указывает ни одна табличка. Робот с клетки 1 в эту цепочку не попадёт никогда.

Шаг 4. Сколько строк таблицы может понадобиться. Клеток с табличками – восемь. Пусть робот сделал 8 переездов и не доехал до финиша. Считая старт, это 9 остановок, а разных клеток с табличками всего 8 – значит, одна повторилась, и робот уже на круге. Больше 8 строк в такой таблице не бывает никогда.

Шаг 5. Пункт в) – где робот после 20 переездов. Считаем, как в разделе 4.7. Подъезд: 1 → 3 – один переезд, дальше робот на круге. Длина круга 3 → 5 → 8 → 3 – три переезда. Отнимаем подъезд: $20 - 1 = 19$. Делим на длину круга с остатком: $19 = 3 \cdot 6 + 1$. Шесть полных кругов возвращают робота на клетку 3, остаток 1 – ещё один переезд, на клетку 5.

Сверим на малом числе. После 4 переездов счёт даёт $4 - 1 = 3 = 3 \cdot 1 + 0$, остаток 0 – робот на клетке 3. По трассировке из шага 2 после четвёртого переезда он как раз вернулся на 3.

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

tabl = {1: 3, 2: 6, 3: 5, 4: 9, 5: 8, 6: 4, 7: 2, 8: 3}   # пункт б)
pos = 1           # где робот
moves = 0         # сколько переездов сделано
visited = set()   # на каких клетках уже был
while pos != 9 and pos not in visited:
    visited.add(pos)
    pos = tabl[pos]
    moves = moves + 1
print(moves if pos == 9 else -1)   # -1

tabl – словарь: по номеру клетки он выдаёт номер с таблички. visited – множество клеток, где робот уже побывал. Цикл while («пока») идёт, пока робот не на финише и не вернулся на старую клетку. moves if pos == 9 else -1 значит «напечатай число переездов, если робот на финише, а иначе −1». Подставь таблички из пункта а) – и программа напечатает 7.

Типичная ошибка. В пункте б) увидеть табличку «4 → 9» и решить, что робот через клетку 4 доедет до финиша, – и начать подгонять ответ. Смотреть надо на путь этого робота с клетки 1, а не на все таблички подряд. Вторая ошибка – долго считать переезды по кругу 3 → 5 → 8, надеясь, что «когда-нибудь выйдет». Повтор клетки – это уже ответ. В пункте в) легко забыть про подъезд и разделить на 3 сразу все 20 переездов: $20 = 3 \cdot 6 + 2$, два шага по кругу от клетки 3 – и выходит неверная клетка 8.

Ответ: а) 7; б) −1; в) клетка 5.

По мотивам задачи заключительного этапа НТО 2024/25, профиль «Интеллектуальные робототехнические системы», предметный тур по информатике, «Робот-манипулятор»

5.1. Цепь: ток, напряжение, сопротивление

Батарейка – насос, который создаёт напор. Мотор – колесо, которое крутит поток. Узкая труба мешает воде – это сопротивление.

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

У любого источника два вывода: плюс (+) и минус (–). Условились считать, что снаружи источника ток идёт от плюса к минусу. На плате Arduino плюс подписан 5V, минус – GND (от английского ground – «земля»). Все выводы GND на схеме соединены между собой, это общий минус.

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

• Напряжение $U$ – напор, с которым насос гонит воду. Чем больше напряжение, тем сильнее оно толкает ток. Измеряют в вольтах (В). Пальчиковая батарейка даёт 1,5 В, плата Arduino – 5 В, батарейка «Крона» – 9 В. В розетке 220 В – это смертельно опасно, с розеткой не экспериментируем никогда.
• Сила тока $I$, или просто ток, – сколько воды протекает по трубе за секунду. Измеряют в амперах (А). Токи в роботе маленькие, поэтому чаще пишут миллиамперы: 1 А = 1000 мА. Через светодиод пускают до 20 мА, моторчик робота берёт сотни миллиампер.
• Сопротивление $R$ – насколько узкая труба. Измеряют в омах (Ом), 1 кОм (килоом) = 1000 Ом. Деталь, вся работа которой – мешать току, называется резистор.

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

Батарейки в отсеке робота стоят последовательно: плюс одной упирается в минус следующей. Напряжения при этом складываются. Четыре батарейки по 1,5 В дают $4 \cdot 1{,}5 = 6$ В – самое частое питание учебного робота. Поставь одну батарейку задом наперёд, и она «вычтется»: вместо 6 В останется $1{,}5 + 1{,}5 + 1{,}5 - 1{,}5 = 3$ В.

5.2. Закон Ома и резистор для светодиода

Подняли бак вдвое выше – воды течёт вдвое больше. Сузили трубу вдвое – вдвое меньше. С током то же самое: он растёт вместе с напряжением и падает, когда растёт сопротивление.

Эту связь в 1827 году описал немецкий учитель физики Георг Ом, и с тех пор её называют законом Ома. Словами: сила тока равна напряжению, делённому на сопротивление. Буквами:

$$I = \frac{U}{R},$$

где $I$ – ток в амперах, $U$ – напряжение в вольтах, $R$ – сопротивление в омах. Из этой формулы получаются ещё две: напряжение равно току, умноженному на сопротивление, а сопротивление – напряжению, делённому на ток:

$$U = I \cdot R, \qquad R = \frac{U}{I}.$$

Пример. Резистор 250 Ом подключили к 5 В. Ток $I = 5 : 250 = 0{,}02$ А. В миллиамперах это $0{,}02 \cdot 1000 = 20$ мА.

Единицы в этой формуле строгие: вольты, амперы, омы. Дан ток 15 мА – сначала переведи: $15 : 1000 = 0{,}015$ А. Если подставить в формулу число 15, сопротивление выйдет в 1000 раз меньше настоящего. Есть и короткий путь для тех, кто любит килоомы: вольты, делённые на килоомы, дают сразу миллиамперы. 5 В на резисторе 2 кОм – это $5 : 2 = 2{,}5$ мА.

Если на пути тока стоят два резистора подряд (последовательно), их сопротивления складываются: 100 Ом и 220 Ом вместе мешают току, как один резистор на 320 Ом. Это как труба с двумя узкими местами.

Светодиод и резистор к нему. Светодиод – маленькая лампочка, которая светится, когда через неё идёт ток. Ток он пропускает только в одну сторону: длинная ножка (анод) – к плюсу, короткая (катод) – к минусу. Без резистора светодиод почти не мешает току, ток получается огромным, и светодиод сгорает – в Tinkercad это видно прямо на экране. Поэтому последовательно с ним всегда ставят резистор.

На горящем светодиоде «оседает» почти постоянное напряжение: у красного, жёлтого и зелёного – около 2 В, у синего и белого – около 3 В. Остальное напряжение приходится на резистор. Поэтому сопротивление считают по оставшемуся напряжению:

$$R = \frac{U_{\text{пит}} - U_{\text{св}}}{I},$$

где $U_{\text{пит}}$ – напряжение питания, $U_{\text{св}}$ – напряжение на светодиоде, $I$ – ток, который мы хотим пустить. Пример: красный светодиод от вывода Arduino, ток 20 мА. $R = (5 - 2) : 0{,}02 = 150$ Ом.

Резисторы не продают любого номинала: есть стандартный ряд, в учебных наборах чаще всего 100, 150, 220, 330, 470 Ом, 1 кОм, 10 кОм. Если нужного нет, берут ближайший больший. Ток станет чуть меньше, светодиод – чуть тусклее, зато он не перегреется. Меньший резистор пустит ток больше допустимого.

5.3. Мотор и драйвер: почему мотор нельзя прямо к плате

Контроллер не носит ток к мотору сам. Он только поворачивает ручку крана, а сильный ток бежит к мотору от батареи.

Внутри мотора постоянного тока (DC-мотора, ты знаешь его по главе 1) – катушка из тонкой проволоки и магниты. Пошёл ток через катушку – вал закрутился. Поменяй провода местами – вал закрутится в обратную сторону. Подними напряжение – закрутится быстрее.

Почему же мотор не подключают прямо к выводу Arduino? Вывод платы отдаёт самое большее около 40 мА – это предел, на все выводы вместе до 200 мА. Безопасно держаться около 20 мА: этого хватает на светодиод, и только. Катушка мотора – это просто кусок проволоки, сопротивление у неё маленькое, несколько омов или десяток. По закону Ома при 5 В и 10 Ом получится $5 : 10 = 0{,}5$ А, то есть 500 мА – в 25 раз больше безопасных 20 мА (и в 12,5 раза больше предельных 40 мА). Пока вал крутится, ток немного меньше, а вот в момент трогания с места он как раз такой. Вывод сгорит, а может, и вся плата. Вдобавок мотор при включении и выключении даёт скачки напряжения, и плата от них сбоит.

Поэтому между контроллером и мотором ставят драйвер моторов. В курсе сферы это микросхема L293D. Она управляет двумя моторами и отдаёт каждому до 600 мА. Для каждого мотора у неё три входа:

• IN1 и IN2 – направление вращения;
• EN (от английского enable – «разрешить») – можно ли мотору крутиться и насколько быстро.

Сами моторы питаются от батареи через ножку 8 микросхемы (VS). Сигналы с выводов Arduino к мотору не идут – они только «открывают кран». А ещё минус батареи и GND платы обязательно соединяют: без общего минуса драйвер не поймёт сигналов контроллера.

Сигнал на выводе бывает двух видов: HIGH («высокий», 5 В) и LOW («низкий», 0 В). Что делает мотор при разных сигналах на IN1 и IN2, если на EN подано HIGH, – в таблице:

Какую из двух сторон считать «вперёд», зависит от того, как припаяны провода мотора; в задаче это всегда сказано. Если на EN подано LOW, мотор стоит при любых IN.

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

const int EN1 = 5;   // вывод 5 – скорость мотора
const int IN1 = 2;   // выводы 2 и 4 – направление
const int IN2 = 4;

void setup() {
  pinMode(EN1, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
}

void loop() {
  digitalWrite(IN1, HIGH);  // едем вперёд
  digitalWrite(IN2, LOW);
  analogWrite(EN1, 200);    // скорость 200 из 255
  delay(2000);              // 2000 мс = 2 с
  digitalWrite(IN1, LOW);   // стоп
  digitalWrite(IN2, LOW);
  delay(1000);
}

• const int EN1 = 5; – даём выводу 5 имя EN1, чтобы в программе не путаться в номерах. Всё, что после //, – комментарий для человека, плата его не читает.
• setup выполняется один раз при включении. pinMode(…, OUTPUT) говорит: «этот вывод будет выдавать сигнал».
• loop повторяется по кругу, пока есть питание.
• digitalWrite(IN1, HIGH) подаёт на вывод 5 В, LOW – 0 В.
• analogWrite(EN1, 200) задаёт скорость – как это работает, расскажет следующий раздел.
• delay(2000) – подождать 2000 миллисекунд. В одной секунде 1000 мс, значит, это 2 с.

5.4. ШИМ: как ехать не на полной скорости

Выводу Arduino доступны только «5 В» и «0 В». Если щёлкать между ними очень быстро, мотор почувствует среднее и закрутится медленнее.

Цифровой вывод знает два состояния: HIGH и LOW. Для мотора это «полный ход» и «стоп». А как же ехать вполсилы? Похоже на велосипед: крутишь педали полоборота, полоборота отдыхаешь – и едешь медленнее, но не останавливаешься, потому что велосипед катится по инерции.

Контроллер делает так же, только намного быстрее. Вывод включается и выключается около 500 раз в секунду (на выводах 5 и 6 – около 1000 раз). Вал мотора тяжёлый и за такое короткое время остановиться не успевает, поэтому крутится с какой-то средней скоростью. Этот приём называют ШИМ – широтно-импульсная модуляция. «Импульс» – короткое включение, «широтно» – потому что меняют его ширину, то есть сколько времени вывод включён.

Значение ШИМ задаёт команда analogWrite(вывод, значение), где значение – целое число от 0 до 255:

• 0 – вывод всё время выключен, мотор стоит;
• 255 – всё время включён, полная скорость;
• 128 – включён примерно половину времени.

Доля времени, когда вывод включён, равна значению, делённому на 255. Отсюда две формулы:

$$\text{доля} = \frac{\text{значение}}{255}, \qquad \text{значение} = \text{доля} \cdot 255.$$

Чтобы вывод был включён 40 % времени, нужно $0{,}4 \cdot 255 = 102$. Значение analogWrite бывает только целым, поэтому дробный результат округляют до целого. Среднее напряжение на моторе – та же доля от напряжения питания моторов. От батареи 6 В при значении 128 мотор получит в среднем $6 \cdot 128 : 255 \approx 3$ В.

ШИМ умеют не все выводы Arduino Uno, а только помеченные значком ~: 3, 5, 6, 9, 10, 11. Поэтому вход EN драйвера подключают к одному из них – на схеме в разделе 5.3 это вывод 5.

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

5.5. Батарея: на сколько хватит заряда

Ёмкость – сколько «воды» в бочке. Чем сильнее открыт кран, тем быстрее бочка опустеет.

На аккумуляторе пишут его ёмкость – в миллиампер-часах (мА·ч). Надпись 2000 мА·ч значит: аккумулятор может отдавать ток 2000 мА в течение часа. Или 1000 мА два часа. Или 200 мА десять часов. Произведение тока на время всегда одно и то же – это запас заряда. У пауэрбанка для телефона бывает 10 000 мА·ч, у пальчикового аккумулятора – около 2000 мА·ч.

Отсюда формула: время работы равно ёмкости, делённой на ток:

$$t = \frac{\text{ёмкость}}{I}.$$

Если ёмкость в мА·ч, а ток в мА, время получится в часах. Минуты – умножаем на 60. Осторожно с дробями часов: 1,6 ч – это 1 ч 36 мин ($0{,}6 \cdot 60 = 36$), а вовсе не 1 ч 60 мин.

Ток всего робота. От одной батареи питаются сразу моторы, плата и датчики. Все они подключены к батарее рядом, как ветки к стволу, – такое соединение называют параллельным. Каждая ветка берёт свой ток, а батарея отдаёт их сумму. Два мотора по 250 мА, плата 50 мА, датчики 20 мА: $2 \cdot 250 + 50 + 20 = 570$ мА. Больше всего, конечно, берут моторы, поэтому робот, который стоит на месте, почти не тратит заряд.

Запас. Аккумулятор не разряжают до нуля: под конец напряжение проседает, робот начинает ехать медленнее и сбиваться с линии. Поэтому в задачах часто пишут, сколько ёмкости можно использовать, например 80 %. Тогда сначала находим полезную ёмкость: $0{,}8 \cdot 2000 = 1600$ мА·ч, и уже её делим на ток.

Несколько батареек. Последовательно (как в отсеке робота) – напряжения складываются, а ёмкость остаётся как у одной батарейки: через них всех идёт один и тот же ток, и садятся они одновременно. Четыре батарейки по 1,5 В и 2000 мА·ч дают 6 В и те же 2000 мА·ч. А если соединить батарейки параллельно, плюс к плюсу и минус к минусу, напряжение останется как у одной, зато ёмкости сложатся.

5.6. analogRead: как контроллер измеряет напряжение

Контроллер меряет напряжение линейкой с делениями от 0 до 1023. 0 В – это 0, 5 В – это 1023, одно деление – около 5 милливольт, то есть 5 тысячных вольта.

Кнопка отвечает «да» или «нет». Но многим датчикам этого мало: датчик линии, датчик освещённости, ИК-дальномер, крутилка-потенциометр выдают напряжение от 0 до 5 В, и оно меняется вместе с тем, что датчик измеряет: светом, расстоянием, поворотом ручки. Такие датчики подключают к аналоговым входам платы – A0, A1, …, A5.

Команда analogRead(A0) измеряет напряжение на входе A0 и возвращает целое число от 0 до 1023. Это номер деления на воображаемой линейке, где 0 В – деление 0, а 5 В – деление 1023. Почему 1023? Делений вместе с нулевым 1024, это число удобно для компьютера ($2 \cdot 2 \cdot \ldots \cdot 2$, десять двоек).

Перевод туда и обратно – обычная пропорция. Какую долю от 5 В составляет напряжение, такую же долю от 1023 составляет число:

$$U = N \cdot \frac{5}{1023}, \qquad N = \frac{U}{5} \cdot 1023,$$

где $N$ – число, которое вернул analogRead, $U$ – напряжение в вольтах. Число $N$ всегда целое: контроллер отбрасывает дробную часть (в этой книге считаем так).

• $U = 2{,}5$ В: $N = 2{,}5 : 5 \cdot 1023 = 511{,}5$, дробную часть отбрасываем – 511.
• $N = 614$: $U = 614 \cdot 5 : 1023 = 3{,}0$ В.

В некоторых задачах делят не на 1023, а на 1024 – разница крошечная, но ответ может не совпасть в последней цифре. Считай так, как сказано в условии.

Как посмотреть показания своими глазами? Плата умеет посылать числа на компьютер, а Arduino IDE показывает их в окне «Монитор порта»:

void setup() {
  Serial.begin(9600);          // включаем связь с компьютером
}

void loop() {
  int n = analogRead(A0);      // число от 0 до 1023
  float u = n * 5.0 / 1023;    // переводим в вольты
  Serial.println(u);           // печатаем в «Монитор порта»
  delay(500);                  // и так два раза в секунду
}

int – целое число, float – число с дробной частью. Зачем 5.0, а не просто 5? Если написать n * 5 / 1023, программа поделит целое на целое и выбросит дробную часть ещё до того, как число попадёт в u. Вместо 2.49 в мониторе появится 2.00.

5.7. Датчик линии: белое и чёрное

Датчик светит вниз и ловит отражённый свет. Белое поле возвращает много света, чёрная линия почти весь свет «съедает».

Датчик линии висит под днищем робота в нескольких миллиметрах от поля. В нём две детали. ИК-светодиод светит вниз инфракрасным светом – невидимым для глаза, как у пульта от телевизора. Фототранзистор рядом с ним – приёмник: чем больше света на него падает, тем больше тока он пропускает. От этого меняется напряжение на выходе датчика, и analogRead превращает его в число.

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

Чтобы робот решал «линия или не линия», в программу записывают порог – число посередине между показаниями на белом и на чёрном:

$$\text{порог} = \frac{\text{показание на белом} + \text{показание на чёрном}}{2}.$$

Над белым 850, над чёрным 120: порог $(850 + 120) : 2 = 485$. Показание меньше порога – датчик ближе к «чёрному» числу, значит, под ним линия. Больше – поле.

int n = analogRead(A0);
if (n < 485) {
  // под датчиком линия
} else {
  // под датчиком белое поле
}

if значит «если»: если условие в скобках верно, выполняется то, что в первых фигурных скобках, а иначе (else) – во вторых. Подробно об этом – в главе 6, а как по двум датчикам удерживать робота на линии – в главе 7.

Показания для порога меряют на том самом поле и на той высоте, где поедет робот. Подними датчик на пару сантиметров – и разница между белым и чёрным станет гораздо меньше. Солнце из окна тоже подсвечивает поле невидимыми лучами, и числа уплывают. Бывают и модули попроще: на плате стоит маленький винтик-регулятор, им заранее задают порог, и модуль выдаёт только «0» или «1». В Tinkercad готового датчика линии нет, его изображают фоторезистором – деталью, сопротивление которой меняется от света.

5.8. Дальномеры: ультразвук и инфракрасный свет

Звук успел долететь до стены и вернуться. Значит, до стены – половина пути, который он пролетел.

Звук – это дрожание воздуха, которое бежит от источника во все стороны. Сколько раз в секунду воздух дрожит, называют частотой и измеряют в герцах (Гц): 1 Гц – одно колебание в секунду, 1 кГц = 1000 Гц. Человек слышит звуки примерно от 20 до 20 000 Гц. Всё, что выше, – ультразвук: его слышат летучие мыши и дельфины, а мы – нет.

Звук летит не мгновенно. Скорость звука в воздухе – около 340 м/с: за секунду он пролетает треть километра. Поэтому гром доходит позже молнии, а крик в пустом спортзале возвращается эхом. От температуры скорость немного зависит: в мороз звук летит медленнее, в жару – быстрее. В задачах этой книги берём 340 м/с, если в условии не сказано другое.