Runtime программирование промышленного робота на RCML / Хабр

.2. Понятие типа данных

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

С такими задачами вы уже сталкивались в курсе математики. Например, решение задачи «Найдите площадь прямоугольника» можно записать так: S = a ∙ b, где переменные a и b обозначают соответственно длину и ширину прямоугольника, а S — площадь. Зная эту формулу, можно найти площадь любого прямоугольника.

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

Информацию, представленную в пригодном для обработки на компьютере виде, называют данными.

Переменная в программировании — это именованная ячейка памяти, хранящая значение переменной.

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

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

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

Для описания переменных используется команда var (сокращение от англ. variable — переменная).

Формат записи команды следующий:

var <имя переменной>: <тип>;

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

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

.3. Оператор присваивания

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

Операторприсваивания предназначен для того, чтобы:

• задавать значения переменным;
• вычислять значения арифметического выражения (результат вычисления будет записан как значение переменной).

Формат записи оператора присваивания:

(Рассмотрите пример 14.5.)

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

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

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

(Рассмотрите пример 14.6 и пример 14.7.)

.4. Ввод данных

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

Команда read( ) предназначена для ввода данных. В скобках через запятую перечисляются имена переменных, значения которых необходимо ввести.

Ввод данных происходит в нижней части окна программы PascalABC. Для этого используется окно «Ввод данных». После нажатия кнопки «Ввести» или клавиши «Enter» введенные значения переносятся в окно вывода. После завершения работы программы в этом же окне будет выведен результат (пример 14.8).

.5. Структура программы

Все программы на языке программирования Pascal имеют общую структуру.

В программе можно выделить следующие разделы:

Таким образом, в минимально возможном наборе программа состоит только из пустого тела программы: beginend. Программа, содержащая все разделы, представлена в примере 14.9.

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

1. Понятие алгоритма

Вспомним некоторые понятия, с которыми вы познакомились в 6-м классе.

Алгоритм — понятная и конечная последовательность точных действий (команд), формальное выполнение которых позволяет получить решение поставленной задачи.Исполнитель алгоритма — человек (группа людей) или техническое устройство, которые понимают команды алгоритма и умеют правильно их выполнять.Система команд исполнителя — команды, которые понимает и может выполнить исполнитель.

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

1. 1) команды, которые непосредственно выполняет исполнитель;
2. 2) команды, меняющие порядок выполнения команд исполнителя.

Компьютер является универсальным исполнителем.

Запись алгоритма в виде последовательности команд, которую может выполнить компьютер, называют программой.

Существуют следующие способы представления алгоритмов:

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

(Схематически данные способы представлены в примере 8.1.)

2. Исполнитель Чертежник

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

Чертежник имеет перо, с помощью которого он может рисовать отрезки на плоскости. Исходное положение пера исполнителя Чертежник поднято и находится над точкой (0, 0) — началом координат. После завершения рисования перо также должно быть поднято.

Напомним систему команд исполнителя Чертежник:

Пример 8.3. Составим алгоритм решения задачи.

Прямоугольный участок, длина которого в 2 раза больше ширины, огородили забором длиной 120 м. Определите длину и ширину участка. Напишите программу, выполнив которую исполнитель Чертежник построит чертеж забора этого участка. Масштаб: 1 клетка равна 10 м.

Словесное описание алгоритма:

1. Длина участка в два раза больше ширины, поэтому в сумме длина и ширина составят три одинаковых части. Забор огораживает участок по периметру. Периметр прямоугольника равен удвоенной сумме длины и ширины, следовательно, он равен шести одинаковым частям.
2. Значение ширины получим так: 120 : 6 = 20 м.
3. Длина в 2 раза больше ширины: 20 ∙ 2 = 40 м.

3. Алгоритмическая конструкция следование

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

Алгоритмическая конструкция следование — последовательность команд алгоритма, которые выполняются в том порядке, в котором они записаны.

Следование использовалось в примере 8.3, в котором описывались алгоритмы вычисления длины и ширины участка и построения прямоугольника исполнителем Чертежник.

Алгоритмическая конструкция следование представлена в примере 8.4 и примере 8.5.

4. Вспомогательные алгоритмы

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

Вспомогательныйалгоритм — алгоритм, целиком используемый в составе другого алгоритма.

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

Пример 8.6. Напишем программу, выполнив которую исполнитель Чертежник нарисует следующий рисунок:

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

Описание основного алгоритма будет следующим:

• перемещение в начальную точку;
• рисование фигуры;
• перемещение ко второй фигуре;
• рисование фигуры;
• перемещение к третьей фигуре;
• рисование фигуры.

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

1. Роботы в жизни человека

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

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

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

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

Робот может быть материальным или виртуальным. Виртуальный робот — специальная программа, выполняющая определенные действия.

Роботы являются исполнителями. Для исполнителей обычно определяют среду обитания и систему команд.

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

2. Среда обитания и система команд исполнителя Робот

В среде программирования PascalABC, кроме исполнителя Чертежник, можно выбрать исполнителя Робот.

Средой обитания исполнителя Робот является прямоугольное клетчатое поле (пример 9.1). Размеры этого поля, как и для исполнителя Чертежник, задаются командой Field(n, m). При этом начальное положение Робота — клетка в центре поля.

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

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

Runtime программирование промышленного робота на rcml

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

Под катом описание и реальный пример того, как работает runtime программирование.

Типично программа для робота представляет собой последовательность позиций, в которые должен прийти манипулятор робота. Каждая из этих позиций характеризуются положением TCP (Tool Center Point) – точкой острия инструмента, установленного на манипуляторе. По умолчанию TCP находится в центре фланца робота, см. рисунок ниже, но её положение может быть перенастроено и чаще всего так, что TCP совпадает с острием установленного инструмента на манипуляторе робота. Поэтому обычно при программировании задается положение TCP в пространстве, а положение суставов манипулятора робот определяет сам. Далее в статье будет использоваться термин «положение TCP», или другими словами точка, в которую робот должен «прийти».
Программа для робота также может содержать примитивную управляющую логику (ветвления, циклы), простые математические операции, а также команды по управлению периферией – аналоговыми и цифровыми входами/выходами. В предлагаемом подходе runtime программирования, в качестве внешнего контроллера используется обычный ПК, на котором могут быть использованы мощные средства программирования дающие необходимый уровень абстракции (ООП и прочие парадигмы) и инструменты, обеспечивающие скорость и легкость разработки сложной логики (высокоуровневые языки программирования). На роботе же остается только логика критичная к скорости реакции, для исполнения которой нужна надежность промышленного контроллера, например, оперативная и адекватная реакция на внештатную ситуацию. Управление же периферией, подключенной к роботу, попросту «проксируется» самим роботом на ПК, позволяя ПО с ПК включать или выключать соответствующие сигналы на роботе. Это чем-то похоже на управление «ножками» на Arduino.

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

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

Еще немного теории и переходим к практике.

Описание существующих способов программирования промышленных роботов

Без учета, вводимого в данной статье подхода runtime программирования, принято выделять два способа программирования промышленных роботов. Офлайн- и онлайн-программирование.

Процесс онлайн программирования происходит при непосредственном взаимодействии программиста с роботом на месте его использования. При помощи пульта управления или физического перемещения осуществляется подвод инструмента (TCP), установленного на фланце робота, к необходимой точке пространства.

Процесс

офлайн программирования

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

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

Для написания этого текста потребовалось передать роботу более 1700 точек.

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

Если писать программу подобный образом, то это было бы минимум 1700 операторов — строк кода, по оператору на точку. А что если бы потом потребовалось изменить текст или высоту букв, или расстояние между ними? Править все 1700 точек-строк? Это противоречит духу автоматизации!

Итак, приступим к решению…

Имеем робота FANUC LR Mate 200iD с котроллером R-30i серии B cabinet. У робота предварительно настроена TCP на конце маркера и координатная система рабочего стола, поэтому мы можем отправлять координаты, напрямую не заботясь о преобразовании координат из координатной системы стола в координатную систему робота.

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

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

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

Весь код доступен в репозитории на GitHub: rct_paint_words

Рассмотрим подробнее выходной файл, исполнение начинается с функции main():

Пример выходного файла на языке RCML

include "chars.rcml"
function main(){
  try {
//Задействование робота
    @fr = robot_fanuc;
    system.echo("Start move programn");
//Предварительная настройка окружения робота, координатная система, нагрузка, скорость
    @fr->set_real_di("speed", SPEED);
    @fr->set_real_di("cnt", CNT);
    @fr->startProgram(UFRAME, UTOOL, PAYLOAD);

    system.echo("preparen");
    @fr->prepare();
    system.echo("start drawn");
//Сгенерированный, на Python, участок
    @fr->draw_r_P(0, 0);
    @fr->draw_P(1, 0);
    @fr->draw_r_I(2, 0);
    @fr->draw_B(3, 0);
    @fr->draw_E(4, 0);
    @fr->draw_T(5, 0);
    @fr->draw_Comm(6, 0);

    @fr->draw_r_L(8, 0);
    @fr->draw_r_Yu(9, 0);
    @fr->draw_r_D(10, 0);
    @fr->draw_r_I(11, 0);
    @fr->draw_Exclamation(12, 0);

    @fr->draw_H(14, 0);
    @fr->draw_A(15, 0);
    @fr->draw_M(16, 0);

    @fr->draw_H(18, 0);
    @fr->draw_r_U(19, 0);
    @fr->draw_r_Je(20, 0);
    @fr->draw_E(21, 0);
    @fr->draw_H(22, 0);

    @fr->draw_P(0, 1);
    @fr->draw_A(1, 1);
    @fr->draw_r_Z(2, 1);
    @fr->draw_P(3, 1);
    @fr->draw_A(4, 1);
    @fr->draw_r_B(5, 1);
    @fr->draw_O(6, 1);
    @fr->draw_T(7, 1);
    @fr->draw_r_Che(8, 1);
    @fr->draw_r_I(9, 1);
    @fr->draw_K(10, 1);
    @fr->draw_Dot(11, 1);
    @fr->draw_r_D(12, 1);
    @fr->draw_r_L(13, 1);
    @fr->draw_r_Ya(14, 1);

    @fr->draw_C(16, 1);
    @fr->draw_O(17, 1);
    @fr->draw_r_Z(18, 1);
    @fr->draw_r_D(19, 1);
    @fr->draw_A(20, 1);
    @fr->draw_H(21, 1);
    @fr->draw_r_I(22, 1);
    @fr->draw_r_Ya(23, 1);

    @fr->draw_B(25, 1);
    @fr->draw_E(26, 1);
    @fr->draw_r_B(27, 1);

    @fr->draw_r_I(0, 2);
    @fr->draw_H(1, 2);
    @fr->draw_T(2, 2);
    @fr->draw_E(3, 2);
    @fr->draw_P(4, 2);
    @fr->draw_r_F(5, 2);
    @fr->draw_E(6, 2);
    @fr->draw_r_Ii(7, 2);
    @fr->draw_C(8, 2);
    @fr->draw_A(9, 2);

    @fr->draw_C(11, 2);
    @fr->draw_r_I(12, 2);
    @fr->draw_C(13, 2);
    @fr->draw_T(14, 2);
    @fr->draw_E(15, 2);
    @fr->draw_M(16, 2);
    @fr->draw_r_y(17, 2);

    @fr->draw_H(19, 2);
    @fr->draw_A(20, 2);
    @fr->draw_r_Sha(21, 2);
    @fr->draw_r_I(22, 2);
    @fr->draw_X(23, 2);

    @fr->draw_r_Z(0, 3);
    @fr->draw_H(1, 3);
    @fr->draw_A(2, 3);
    @fr->draw_H(3, 3);
    @fr->draw_r_I(4, 3);
    @fr->draw_r_Ii(5, 3);
    @fr->draw_Dot(6, 3);

    @fr->draw_T(8, 3);
    @fr->draw_A(9, 3);
    @fr->draw_K(10, 3);

    @fr->draw_M(12, 3);
    @fr->draw_r_y(13, 3);

    @fr->draw_C(15, 3);
    @fr->draw_M(16, 3);
    @fr->draw_O(17, 3);
    @fr->draw_r_Je(18, 3);
    @fr->draw_E(19, 3);
    @fr->draw_M(20, 3);

    @fr->draw_r_P(22, 3);
    @fr->draw_E(23, 3);
    @fr->draw_P(24, 3);
    @fr->draw_E(25, 3);
    @fr->draw_H(26, 3);
    @fr->draw_r_Ya(27, 3);
    @fr->draw_T(28, 3);
    @fr->draw_soft_sign(29, 3);

    @fr->draw_O(0, 4);
    @fr->draw_T(1, 4);

    @fr->draw_B(3, 4);
    @fr->draw_A(4, 4);
    @fr->draw_C(5, 4);

    @fr->draw_r_Ge(7, 4);
    @fr->draw_r_U(8, 4);
    @fr->draw_M(9, 4);
    @fr->draw_A(10, 4);
    @fr->draw_H(11, 4);
    @fr->draw_O(12, 4);
    @fr->draw_r_Ii(13, 4);
    @fr->draw_r_D(14, 4);
    @fr->draw_O(15, 4);
    @fr->draw_B(16, 4);

    @fr->draw_r_Z(18, 4);
    @fr->draw_H(19, 4);
    @fr->draw_A(20, 4);
    @fr->draw_H(21, 4);
    @fr->draw_r_I(22, 4);
    @fr->draw_r_Ya(23, 4);
    @fr->draw_Dot(24, 4);

//Изменение ориентации маркера, чтобы роботу было проще дотянуться до края стола
    @fr->set_real_di("speed", 10); 
    @fr->rotateMarker();
    @fr->set_real_di("speed", SPEED); 

    @fr->draw_r_I(0, 6);

    @fr->draw_H(2, 6);
    @fr->draw_A(3, 6);
    @fr->draw_K(4, 6);
    @fr->draw_O(5, 6);
    @fr->draw_H(6, 6);
    @fr->draw_E(7, 6);
    @fr->draw_r_Ce(8, 6);
    @fr->draw_Minus(9, 6);
    @fr->draw_T(10, 6);
    @fr->draw_O(11, 6);

    @fr->draw_M(13, 6);
    @fr->draw_r_y(14, 6);

    @fr->draw_C(16, 6);
    @fr->draw_M(17, 6);
    @fr->draw_O(18, 6);
    @fr->draw_r_Je(19, 6);
    @fr->draw_E(20, 6);
    @fr->draw_M(21, 6);

    @fr->draw_r_Z(0, 7);
    @fr->draw_A(1, 7);
    @fr->draw_X(2, 7);
    @fr->draw_B(3, 7);
    @fr->draw_A(4, 7);
    @fr->draw_T(5, 7);
    @fr->draw_r_I(6, 7);
    @fr->draw_T(7, 7);
    @fr->draw_soft_sign(8, 7);

    @fr->draw_r_U(10, 7);
    @fr->draw_r_L(11, 7);
    @fr->draw_r_U(12, 7);
    @fr->draw_r_Che(13, 7);
    @fr->draw_r_Sha(14, 7);
    @fr->draw_r_I(15, 7);
    @fr->draw_T(16, 7);
    @fr->draw_soft_sign(17, 7);

    @fr->draw_r_aE(19, 7);
    @fr->draw_T(20, 7);
    @fr->draw_O(21, 7);
    @fr->draw_T(22, 7);

    @fr->draw_M(24, 7);
    @fr->draw_r_I(25, 7);
    @fr->draw_P(26, 7);

    @fr->draw_r_P(0, 9);
    @fr->draw_O(1, 9);
    @fr->draw_r_D(2, 9);
    @fr->draw_P(3, 9);
    @fr->draw_O(4, 9);
    @fr->draw_r_B(5, 9);
    @fr->draw_H(6, 9);
    @fr->draw_E(7, 9);
    @fr->draw_E(8, 9);
    @fr->draw_two_dots(9, 9);

    @fr->draw_H(11, 9);
    @fr->draw_T(12, 9);
    @fr->draw_T(13, 9);
    @fr->draw_P(14, 9);
    @fr->draw_two_dots(15, 9);
    @fr->draw_Slash(16, 9);
    @fr->draw_Slash(17, 9);
    @fr->draw_R(18, 9);
    @fr->draw_O(19, 9);
    @fr->draw_B(20, 9);
    @fr->draw_O(21, 9);
    @fr->draw_T(22, 9);
    @fr->draw_C(23, 9);
    @fr->draw_T(24, 9);
    @fr->draw_Dot(25, 9);
    @fr->draw_C(26, 9);
    @fr->draw_O(27, 9);
    @fr->draw_M(28, 9);
    @fr->draw_Slash(29, 9);
    @fr->draw_H(30, 9);
    @fr->draw_I(31, 9);

    @fr->draw_r_I(2, 10);
    @fr->draw_C(3, 10);
    @fr->draw_K(4, 10);
    @fr->draw_P(5, 10);
    @fr->draw_E(6, 10);
    @fr->draw_H(7, 10);
    @fr->draw_H(8, 10);
    @fr->draw_E(9, 10);

    @fr->draw_B(11, 10);
    @fr->draw_A(12, 10);
    @fr->draw_r_Sha(13, 10);

    @fr->draw_S(15, 10);
    @fr->draw_K(16, 10);
    @fr->draw_Y(17, 10);
    @fr->draw_N(18, 10);
    @fr->draw_E(19, 10);
    @fr->draw_T(20, 10);

    @fr->draw_Equal(22, 10);
    @fr->draw_Roof(23, 10);
    @fr->draw_Minus(24, 10);
    @fr->draw_Roof(25, 10);
    @fr->draw_Equal(26, 10);
// Конец сгенерированного участка
    @fr->stopProgram();
    @fr->go_home();
  } catch(E){
    system.echo("Exception catched!");
    return E;
  }
  return 0;
}

Рассмотрим код отрисовки буквы на примере буквы А:

function robot_fanuc::draw_A(x_cell,y_cell){
  
  //Постановка маркера в точку, координаты точки 5% по Х и 95% по Y в рамке буквы
  robot->setPoint(x_cell, y_cell, 5, 95); 
  //Ведем линию
  robot->movePoint(x_cell, y_cell, 50, 5);
  //Ведем вторую линию
  robot->movePoint(x_cell, y_cell, 95, 95);
  //Получили "крышу" /

  //Переносим маркер с отрывом от стола для отрисовки палочки
  robot->setPoint(x_cell, y_cell, 35, 50);
  //Рисуем палочку
  robot->movePoint(x_cell, y_cell, 65, 50);

  //отрываем маркер от доски для перехода к следующей букве
  robot->marker_up();
}

Функции перемещения маркера в точку с отрывом или без, тоже очень просты:

//Перемещение в точку с отрывом маркера или установка точки для начала рисования
function robot_fanuc::setPoint(x_cell, y_cell, x_percent, y_precent){
  //вычисляем абсолютные координаты
  x = calculate_absolute_coords_x(x_cell, x_percent);
  y = calculate_absolute_coords_y(y_cell, y_precent);
  
  robot->marker_up(); // отрываем маркер от стола
  robot->marker_move(x,y); // перемещаем
  robot->marker_down(); // ставим маркер на стол
}

//Перемещение в точку без отрыва маркера/рисование
function robot_fanuc::movePoint(x_cell, y_cell, x_percent, y_precent){
  x = calculate_absolute_coords_x(x_cell, x_percent);
  y = calculate_absolute_coords_y(y_cell, y_precent);
  
  // тут все понятно :)
  robot->marker_move(x,y);
}

Все константы конфигурации, в том числе размер букв, их количество в строке и пр. были вынесены в отдельный файл chars_config.rcml.

В итоге суммарно мы получили примерно 300 строк высокоуровневого кода, на проектирование и написание которого ушло не более 2 часов.

Если бы данная задача решалась «в лоб» онлайн программированием по точкам, то на это бы ушло более 9 часов (примерно по 20-25 сек на точку, с учетом того, что точек более 1700 шт.). В этом случае страдания разработчика трудно представить :), особенно когда выяснилось бы, что он забыл про отступы между буквами, или ошибся с высотой букв и текст не влез, и теперь придется начинать всё с начала.

Вывод:

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

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

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

Однако данный подход следует использовать с осторожностью

В продемонстрированной вариации (с передачей одной точки за раз) runtime подход имеет существенное ограничение – некорректное понимание роботом инструкции сглаживания перемещения (CNT) или её игнорирование, т.к. при передаче всегда одной-текущей точки робот ничего не знает о следующей и не может просчитать сглаженную траекторию обхода текущей точки.

Что же есть CNT?

При перемещении инструмента робота возможно влиять на два параметра:

Оба эти параметра влияют на конечную получаемую траекторию, что проиллюстрировано на рисунке ниже:

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

В лучшем случае робот просто игнорирует инструкцию CNT (зависит от модели).

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

Надеюсь, статья оказалась вам полезной.

С радостью отвечу на ваши вопросы.

Наборы задач для робота других авторов

На скриншоте показана одна из задач для Робота по теме «Циклы ПОКА».

Программа в текстовой форме

Программа, составленная из блоков, автоматически переводится на один из
поддерживаемых языков: Python, JavaScript, PHP, Dart, Lua. Это позволяет
интересующимся детям увидеть, как выглядят программы на «серьезных»
языках программирования.

Создание новых наборов задач

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

Цикл с условием.

При решении задачи 19 ГИА по информатике с Роботом использовать цикл со счетчиком не получится. Так как там поле, как правило, бесконечное и стены не имеют конкретной длины. Поэтому мы не сможем определить количество повторений для цикла со счетчиком. Но не беда — нам поможет цикл с условием.

Вернемся к физкультуре и изменим задачу. Ведь кто-то может и не сделать 7 приседаний, а другой способен сделать 27. Можно ли учесть это при создании цикла? Конечно. Только теперь мы будем использовать не счетчик (количество повторений), а условие. К примеру, пока не устал, делай приседания.

пока не устал

сделай приседание

конец цикла

Слова не устал в нашем случае — это условие. Когда оно истинно, цикл выполняется. Если же оно ложно (устал) тело цикла не будет выполнено. У исполнителя Робот есть несколько условий

сверху свободно

снизу свободно

слева свободно

справа свободно

сверху стена

снизу стена

слева стена

справа стена

, но в условии задачи 19 ГИА указаны только первые 4. Так что будем пользоваться только ими.

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

Давайте сначала сформулируем словесный алгоритм — т. е. опишем словами что нужно делать Роботу. Этот алгоритм будет звучать примерно так:

«Пока справа свободно делай шаг вправо и закрашивай клетку»

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

Исходный код нашей программы для Робота будет примерно такой:

использовать Робот

алг

нач

нц пока справа свободно

вправо

закрасить

кон

В результате выполнения этой программы мы увидим вот такую картину:

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

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

Решение жду в комментариях. И напоминаю, до ГИА осталось совсем немного времени, готовимся активнее.

Цикл со счетчиком.

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

Для того, чтобы написать цикл со счетчиком для исполнителя необходимо знать его синтаксис. А он такой:

нц <количество повторений> раз

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

Давайте рассмотрим это на примере.

Закрасим 7 клеток, как на рисунке. Рекомендую почитать про стартовую обстановку Робота и про его простые команды.

Изначально Робот находился в левой верхней клетке.

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

закрасить

вправо

закрасить

вправо

закрасить

вправо

закрасить

вправо

закрасить

вправо

закрасить

вправо

закрасить

вправо

кон

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

Так вот, наша программа с циклом будет выглядеть так:

использовать Робот

алг

нач

нц 7 раз

закрасить

вправо

кон

Если мы ее запустим, то увидим, что в результате получится тоже самое — 7 закрашенных клеток. Однако программа стала короче и значительно грамотней с алгоритмической точки зрения!

В качестве разминки и закрепления предлагаю самостоятельно написать программу для Робота, которая нарисует квадрат со стороной 7 клеток. Естественно, используя цикл. Жду решения в комментариях.

.1.Команда вывода

Демонстрировать работу любой программы имеет смысл только тогда, когда она выводит какую-либо информацию.

Программа на языке Pascal (тело программы) должна начинаться со слова begin, а заканчиваться словом endи точкой.

begin

write(‘Привет!’);

end.

Результат работы программы отражается в нижней части окна программы PascalABC в окне вывода (пример 14.1).

Команда write( ); предназначена для вывода данных.

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

В программе может быть несколько команд вывода. Если необходимо вывести текст, записанный в несколько строк, то используют команду writeln( ). Буквосочетание «ln» (сокращение от англ. line — линия, строка), записанное в конце команды, означает, что после вывода нужно перевести курсор в новую строку.

Пример 14.2. Выведем на экран компьютера следующий текст: «Привет! Я компьютер!!! Я умею выполнять программы! Сегодня ты написал свою первую программу, а я ее выполнил. Сейчас на экране – результат этой программы».

Используя сочетание команд write и writeln, текст можно расположить по-разному.

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

Пример 14.3. Посчитаем значение выражения 2   2 ∙ 2.

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