Программирование ПЛК110 [М02] для задач реального времени

[Владимир Ситников]

Сделал ещё "1 процент": эмулятор PRU процессора.
Останется его скрестить со средой разработки PRU программ, и можно без ПЛК отлаживаться.

https://github.com/vlsi/pru-emulator...rTest.java#L50

[Newcomer]

Появилась минутка, сделал блок на ST.
Получается, для генерации следующей пачки импульсов нужно передёрнуть вход enable (сделать enable==false, дождаться пока ready перейдёт в false, потом передать enable=true и тогда пойдёт вторая пачка). Это то, что ожидалось?

По поводу изменения частоты импульсов: текущий подход к программированию PRU предполагает, что PRU выполняется своим циклом, поэтому тут я сделал "переключение сигнала out при каждом цикле PRU". Норм? Или делитель какой-то нужен?
Или с такой стороны: нормально ли, если для изменения частоты меандра нужно перезаливать PRU программу?
Нужны ли меандры разной частоты по разным выходам?

FUNCTION_BLOCK PRU_GENER_BURST
VAR_INPUT
  enable : BOOL;
  quantity : WORD;
END_VAR
VAR_OUTPUT
  out : BOOL;
  ready : BOOL;
END_VAR
VAR
  qtyLeft : WORD;
END_VAR
  IF enable THEN
    IF qtyLeft > 0 THEN
      (* Идёт генерация *)
      qtyLeft := qtyLeft - 1;
    ELSIF ready THEN
      (* Всё сгенерировали, ждём пока передёрнут enable для следующего включения *)
    ELSE
      (* Поступила команда на включение *)
      qtyLeft := quantity * 2;
    END_IF;
  ELSE
    (* Выключаемся *)
    qtyLeft := 0;
  END_IF;
  ready := qtyLeft = 0;
  (* Если всё сделали, то out выключится. Если пачка ещё генерируется, то младший бит и есть меандр *)
  out := qtyLeft.0;
  
END_FUNCTION_BLOCK

Кажется скоро появится первый приличный ФБ для управления ШД. Если все получится, то следующим шагом, по моему, должно быть разработка более продвинутого ФБ. Я имею ввиду ФБ, в котором осуществляется плавный разгон и торможение ШД. Это реализовано во всех буржуйских ПЛК, которые управляют ШД. Вот ссылка на статью, в которой изложен этот вопрос: http://electroprivod.ru/akseleration.htm

[Newcomer]

Скоро vladimirisitnikov закончит разработку ФБ для управления ШД. Было бы не плохо если фирма "ОВЕН" профинансирует изготовления стенда для натурных испытаний системы управления ШД на базе ПЛК110 М02. Кроме ПЛК понадобятся ШД, драйвер ШД, источник питания на 36 или 48 вольт. Затраты небольшие. Схему электрическую принципиальную + перечень элементов могу представить.

[Владимир Ситников]

Посмотрел-покрутил имеющиеся PRU блоки, и сделал свой компилятор.
В имеющихся блоках мне не понравилось то, что для одного только сложения нужна куча _разных_ блоков: "сложение BYTE+BYTE, WORD+BYTE, WORD+WORD". Но это ещё не всё, ведь, для сложения двух переменных и сложения переменной с константой тоже разные блоки нужны. На мой взгляд, это слишком сложно. Если сложение, то должен быть просто блок сложения.

Описывать в своей среде разновидности "PRU_ADD", "PRU_ADD_CONST", "PRU_ADD_BYTE_CONST" и правила выбора это была бы та ещё песня.

Понятно, что какие-то блоки всё равно проще на ассемблере писать (например, чтение входов-выходов, работа с host), поэтому сделал ассемблерные вставки в ST.

Всё нижеупомянутое получается одной кнопкой, без привлечения bat файлов, exe файлов и т.п.

Собственно, до сборки финального PRU0.prg (файла, который заливается в ПЛК) осталось сделать обработку ассемблерных инструкций работы с памятью: LBCO/SBCO и LBBO/SBBO. Там ничего сложного нет, просто нужно немного времени.

Пример программы:
s1_asm_test.png

Вот промежуточный ассемблер.
Тут особенность, что команда QBLT label, src, 42 означает "branch to label if 42 < src" (по крайней мере, так говорится в документации на процессор)

se_asm_test_intermediate.png

PRU, разумеется, с переменными работать не умеет, поэтому назначаем регистры.
sf_asm_regalloc.png

И превращаем в java код (ну, чтобы генерировать файл для заливки в ПЛК и/или запускать эмулятор PRU)
sg_asmtest_java.png


Вот, например, блок чтения 1-го входа. Описали 1 раз -- и уже можно использовать в программе.
Присмотрелся -- тут ошибка. Должно, конечно, быть LSR Q, R31.dw, 21 (регистр b0 байтовый и в нём никак 21 бит не влезет). Но сама ошибка не влияет на суть (лень картинки переделывать)
s5_pru_in1.png


Попробуем что-нибудь посложнее.

Напишем на ST PRU_CTU_WORD (ну, как в стандарте 61131 через RTRIG):
s8_ctu_dword.png

И сделаем цикл, в котором подаём IN1 на вход CTU и младшие 2 бита счётчика выводим на OUT1 и OUT2.
s9_counter_program.png

На ассемблере получается такая дичь. Компилятор подставил все-все переменные и вызовы блоков в финальную программу и превратил в ассемблер. При желании понять можно, но на ST всё-таки гораздо понятнее.
si_counter_asm_final.png

Из интересного:
1) Видно, что распределитель регистров (liveness analysis + linear scan register allocation) догадался переиспользовал регистр R1.b3 по ходу программы. Например, в самом конце где записываются OUT1 и OUT2 видно, что сам записываемый бит хранится как раз в R1.b3.

2) Особых оптимизаций сейчас нет. Например, a:=b; может приводить к выделению временного регистра для a (это видно на "бесполезной" команде в начале вызова RTRIG: ADD R2.b0, R1.b3, 0). Но если уж нужны будут оптимизации -- посмотрим потом. Как-никак, а SSA (я про Static single assignment form) за 1-2 дня не сделать.

[Филоненко Владислав]

PRU0.prg и PRU1.prg это файлы программ PRU. И да, они, по расширению, совпадают с prg 2-го КоДеСис-а.
prg отлично формируются уже представленным ПО из имеющихся или заново создаваемых ФБ.

[Владимир Ситников]

prg отлично формируются уже представленным ПО из имеющихся или заново создаваемых ФБ.

Проблема в "уже представленном ПО" в том, что для задействования "уже представленного" нужно:
1) Создать схему программы в КДС (неудобно) или в формате КДС_CFC.exp (не реализовано)
2) Очень внимательно следить за использованием ADD vs ADD_CONST vs ADD_WORD_CONST. Вот тут "представленное ПО" крайне тяжело ложится на IDE. Сделать, конечно, всё можно, но я никак не хочу делать 100500 copy-paste'ов, описывающих разновидности ADD/SUB и т.п.

Вот фрагмент моего компилятора, описывающий команды "a := b OP c", где OP это сложение, вычитание и т.п:
c1_st_assignmentcompiler.png

с3_st_simple_operand.png

И ещё пара блоков (Instruction здесь это объект, описывающий ассемблерную команду. Например, XOR, AND выше это и есть Instruction с аргументами), которые превращают "ассемблер" в нужные вызовы Java:
c2_asm_to_java.png

Тут нет никакого взрыва комбинаций "ADD vs ADD_CONST vs ADD_WORD_CONST".
Вышеупомянутый код без проблем компилирует сложение BYTE/WORD/DWORD.
Конечно, мне хотелось бы уйти от unsigned типов, но я уж лучше сначала сделаю рабочий блок ШД, а заниматься знаковыми типами и т.п. потом.



"Компилировать в формат КДС_CFC.exp" неудобно. Да и у меня нет никакого желания откладывать "обкатку блока ШД" до момента, как я научусь генерировать КДС_CFC.exp формат.

Объективно:
1) Компилировать в бинарный формат PRU я могу уже сейчас. Как-никак, а команды, которые выполняет PRU процессор гораздо ближе к ST, чем к графическому языку
2) Компилировать графический язык в ST гораздо проще, чем наоборот. Поэтому, вариант развития "сначала сделать ST -> PRU0.prg компилятор", потом добавить "графический -> ST" выглядит более понятным и позволит не ждать 2018-го года до первого тестирования ШД.
2) Компилировать в формат КДС диаграмм (из ST или из графического языка -- не так важно) только ради того, чтобы использовать "уже представленное ПО" выглядит как отвлекающей задачей, занимающей много времени без видимого результата. Гораздо проще вызвать команду процессора "условный переход", чем превращать разные ветки в CFC.
3) Некоторые блоки становятся ненужными, если компилировать программу целиком. Например, один и тот же код блока CTU_BYTE будет работать как в случае, когда на вход поступает константа, так и в случае, когда на вход переменная. Сам компилятор выберет необходимую команду процессора, и расход регистров/памяти будет зависеть не от имени блока, а от его фактического использования.
И пользователю просто: не нужно задумываться о множестве однотипных блоков, и при написании этого множества блоков не будет copy-paste ошибок.

Поэтому, у меня возник вопрос: "а что, если PRU0.prg генерировать непосредственно из бинарного кода PRU?"

Собственно, вопрос: действительно ли "задействование уже предоставленного ПО" это единственно возможный вариант создания PRU0.prg?
Действительно ли, формат PRU0.prg засекречен, и создание его внешними инструментами недопустимо?

[Владимир Ситников]

Раз PRU0.prg нет, то будем тестировать блок ШД на эмуляторе.

"enable" будем подавать через "fast IN1", а параметры "количество импульсов" и "частоту импульсов" будем подавать через память PRU.

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

Попробую "проверенный" способ: кто-нибудь может пошевелить/поспрашивать ОВЕН на предмет возможности генерации PRU0.prg/PRU1.prg файлов из внешних программ?

Собственно, программа обрабатывающая блок ЩД:
a1_main_program.png

Ничего хитрого.
Из нового -- блок WAIT_TICK, который делает так, чтобы наш блок ШД вызывался не чаще, чем указанный интервал.
LBCO -- команды, загружающие значения из "памяти PRU" в регистр. В эмуляторе берём и "пишем напрямую в память". Возможно, HOST_TO_PRU/PRU_TO_HOST немного по-другому будут работать, но на суть это не влияет.

В самом блоке WAIT_TICK использован метод УКП (универсального коэффициента подгона):
a2_wait_tick.png

Выглядит жутковато, но тесты проходит: https://github.com/vlsi/pru-emulator...BlockTest.java

В тестах проверяется, что "полезная работа" стартует ровно раз в заданное время в комбинациях "cycleTime от 20 до 100" и "длительность тела цикла от 0 до 5".


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

a3_gener_burst.png


Начинаем с одного импульса и задержки в "35 тактов", и затем после каждой пачки увеличиваем количество импульсов на 1 и длительность тоже на 1.

Т.е. сначала должен получиться 1 импульс длины 35, затем 2 импульса по 36, затем 3 импульса по 37 и так далее.

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


Собственно, результаты теста. Тут через _/‾ и ‾\_ схематично изображены фронты out сигнала.
_/‾33‾\_ означает, что на выходе out была единица 33 такта.
‾\_36_/‾ означает, что на выходе был ноль 36 тактов.

Самая первая цифра -- это задержка от перевода enable в true до фронта out (т.е. задержка того, пока цикл PRU докрутится и запустит генерацию).
Цифра в пределах ожидаемого

cycle: 35, quantity: 1. _15_/‾33‾\_
cycle: 36, quantity: 2. _46_/‾34‾\_36_/‾36‾\_
cycle: 37, quantity: 3. _27_/‾35‾\_37_/‾37‾\_37_/‾37‾\_
cycle: 38, quantity: 4. _22_/‾36‾\_38_/‾38‾\_38_/‾38‾\_38_/‾38‾\_
cycle: 39, quantity: 5. _30_/‾37‾\_39_/‾39‾\_39_/‾39‾\_39_/‾39‾\_39_/‾39‾\_
cycle: 40, quantity: 6. _17_/‾38‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_
cycle: 41, quantity: 7. _26_/‾39‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_
cycle: 42, quantity: 8. _48_/‾40‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_
cycle: 43, quantity: 9. _50_/‾41‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_
cycle: 44, quantity: 10. _14_/‾42‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_
cycle: 45, quantity: 11. _38_/‾43‾\_45_/‾45‾\_45_/‾45‾\_45_/‾45‾\_45_/‾45‾\_45_/‾45‾\_45_/‾45‾\_45_/‾45‾\_45_/‾45‾\_45_/‾45‾\_45_/‾45‾\_
cycle: 46, quantity: 12. _20_/‾44‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_46_/‾46‾\_

Если присмотреться, то можно заметить, что длина первого импульса почему-то на 2 такта меньше, чем заданная длительность.
Можно, конечно, раскуривать ассемблер и смотреть где там стоит добавить-убрать такт, но нужно ли? Кого реально парят 2 такта?

Минимально стабильная длина цикла для этой программы составляет 33 такта.
Частота PRU где-то 150-200 МГц, т.е. за одну микросекунду PRU выполняет ~200 команд.
Иными словами, данная программа может генерировать пачки импульсов частоты до 1МГц (выходы вряд ли смогут такое, но не суть).


PS Вот так на ассемблере выглядит финальная программа (на один экран не вместилось, поэтому 3 картинки):
a4_asm1.png
a5_asm2.png
a6_asm3.png

[Владимир Ситников]

Не пойму это ваш редактор для чего, для ПЛК что ли или это альтернатива cds?

У меня как дополнение к CDS, так и альтернатива.
С одной стороны, моя среда может генерировать КДС проект (это в случае управления простыми, "медленными" выходами), а с другой, она может генерировать бинарный код для TI PRU процессора (ну, того, что используется в ПЛК110 М02) -- т.е. можно писать программы для быстрых входов/выходов.

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

Вижу, что вы пытались в ответе написать какой-то код: < spf; i++){delay_us(50);}
Можете поправить ответ, чтобы код стало видно?


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

Доступ к памяти стоит 2-3 такта, т.е. в процессе управления можно просто читать очередную задержку и всё.

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

Вот, похоже, разумные стати по теме ШД: http://www.embedded.com/design/mcus-...s-in-real-time, http://www.atmel.com/images/doc8017.pdf, https://courses.cs.washington.edu/co...Arithmetic.pdf, http://www.orientalmotor.com/product...alculation.pdf

[Владимир Ситников]

Если задержку делать непосредственно перед записью выходов, то длительности импульсов получаются вообще ровными:
a7_delay_before_outs.png

Результат:

cycle: 33, quantity: 2. _56_/‾33‾\_33_/‾33‾\_
cycle: 34, quantity: 3. _24_/‾34‾\_34_/‾34‾\_34_/‾34‾\_
cycle: 35, quantity: 4. _41_/‾35‾\_35_/‾35‾\_35_/‾35‾\_35_/‾35‾\_
cycle: 36, quantity: 5. _47_/‾36‾\_36_/‾36‾\_36_/‾36‾\_36_/‾36‾\_36_/‾36‾\_
cycle: 37, quantity: 6. _43_/‾37‾\_37_/‾37‾\_37_/‾37‾\_37_/‾37‾\_37_/‾37‾\_37_/‾37‾\_
cycle: 38, quantity: 7. _39_/‾38‾\_38_/‾38‾\_38_/‾38‾\_38_/‾38‾\_38_/‾38‾\_38_/‾38‾\_38_/‾38‾\_
cycle: 39, quantity: 8. _55_/‾39‾\_39_/‾39‾\_39_/‾39‾\_39_/‾39‾\_39_/‾39‾\_39_/‾39‾\_39_/‾39‾\_39_/‾39‾\_
cycle: 40, quantity: 9. _46_/‾40‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_40_/‾40‾\_
cycle: 41, quantity: 10. _51_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_41_/‾41‾\_
cycle: 42, quantity: 11. _54_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_42_/‾42‾\_
cycle: 43, quantity: 12. _51_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_43_/‾43‾\_
cycle: 44, quantity: 13. _52_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_44_/‾44‾\_

[Владимир Ситников]

Я имею ввиду ФБ, в котором осуществляется плавный разгон и торможение ШД

Нашёл пример Amtel'а.
Статья: http://www.atmel.com/images/doc8017.pdf (вариант на русском, который, кстати, более подробный: http://avrdoc.narod.ru/index/0-7 )
Код (MIT license == проблем нет): https://code.google.com/archive/p/st...or-controller/

Собственно, нужный код рассчёта задержек между импульсами: https://github.com/rob-smallshire/st...ntr.c#L77-L127

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

По моим прикидкам, подобные вычисления будут занимать 300 тактов, т.е. порядка 2 мкс.
Собственно, вопрос: есть ли смысл заморачиваться с памятью и предвычислением, или достаточно, если минимальный импульс будет 3-4 мкс?