kst2002

Теперь открываем (Файл->Открыть) файл mns.svg папки web:

Кнопками + и - выставляем масштаб. На экране появилось что-то несуразное. Но это только заготовка с тремя виджетами - кнопка(button), лампочка(led) и рамка(border). Каждый из этих виджетов находится внутри своей группы, или слоя. Их три:

- слой ввода (inp) - кнопки и поля ввода;

- слой динамических элементов (dyn) - лампочки, индикаторы;

- слой статики (stat) - рамки, шкалы плюс всё что нарисуете сами в качестве заднего плана;

Чтобы эти слои сразу обозначить, начальная страница-заготовка и содержит три этих элемента/виджета, вместо которых нужно будет разместить что-то своё. Чтобы войти в нужный слой, выбираем левой кнопкой элемент, затем по правой кнопке выбираем в выпадающем меню "Войти в группу #inp, #dyn или #stat".

В правой части экрана inkscape фрейм xml-редактора. Если у вас он не появился, жмите shift+ctrl+x или поищите соотв.кнопку на правом поле экрана. Редактор показывает содержимое SVG-файла, который в xml формате. И не только показывает, но и позволяет менять свойства виджетов, так что без него никуда.

8. Итак, заходим в слой inp и размещаем кнопки управления. Кнопки берём из папки виджетов, для этого не выходя из inkscape открываем файл buttons.mns.svg (он откроется в новом окне):

Берём так - в окне buttons.mns.svg заходим в слой inp, выделяем кнопку и копируем её в буфер (ctrl+c), в окне mns.svg заходим в слой inp и пастим (ctrl+v).

После копирования кнопки можно расставить и выровнять:

Для выравнивания пользуемся вот этим инструментом:

Здесь кроме выравнивания кнопок я удалил ненужную старую кнопку и добавил четыре стрелки, которые будут светиться зелёным цветом при движении. Стрелки берутся из arrows.mns.svg аналогично кнопкам, только вставлять их нужно в слой #dyn. Для поворачивания стрелок есть соотв. команда в меню Объект, либо это можно делать изменяя свойство transform через xml-редактор:

9. Теперь подпишем кнопки, делается это так:

А самое главное - изменить у кнопок свойство click так, чтобы мы потом в javascript-е смогли идентифицировать кнопку при её нажатии:

Соответственно, остальным кнопкам также нужно задать свойства onclick:

- кнопка ВЛЕВО: buttonclick('left')

- кнопка ВПРАВО: buttonclick('right')

- кнопка НАЗАД: buttonclick('revers')

- кнопка ВПЕРЁД: buttonclick('forward')

- кнопка СТОП: buttonclick('stop')

10. Теперь второстепенные дела - вместо прежней панели берём другую (взята из panels.mns.svg и немного растянута) и передвигаем лампочку на панель. Вот что получилось:

Проверьте - динамические виджеты (стрелки и лампочки) должны находиться с слое (группе) dyn. Прописываем следующие идентификаторы (св-во id виджета) :

- лампочка - led1

- стрелка вправо - ar

- стрелка влево - al

- стрелка назад - ab

- стрелка вперёд - af

По этим id мы будем обращаться к ним из программы javascript.

11. Осталось бросить последний камень в огород визуализации - оживить полученную мнемосхему. Код javascript (js) должен отправлять команды от кнопок на ПЛК и забирать оттуда данные - булевские переменные do_left, do_right, do_up, do_down и по их состоянию зажигать соответствующие стрелки.

11.1 Откроем текстовым редактором файл index.js . Именно в нём сосредоточена логика визуализации. Этот файл дан для примера и его нужно подправить под наше ТЗ. Начнём с начала:

var PlcIP = "http://192.168.0.179:1200";

// массив структур для ajax-запроса чтения

var InBuf = [

{"name": "ana1", "rw":"r"},

{"name": "prg1.bool1", "rw":"r"},

{"name": "prg2.msg1", "rw":"r"}

];

// массив структур для ajax-запроса записи

var OutBuf = [

{"name": "ana2", "rw":"w"},

{"name": "prg2.msg2", "rw":"w"},

{"name": "prg1.bool1", "rw":"w"}

];

// переменные для чтения из ПЛК

var glob_ana, prg1_bool, prg2_msg;

Скорректируем это под нашу задачу, переименовав фиктивные переменные в реальные:

var PlcIP = "http://192.168.0.179:1200";

// массив структур для ajax-запроса чтения

var InBuf = [

{"name": "do_left", "rw":"r"},

{"name": "do_right", "rw":"r"},

{"name": "do_down", "rw":"r"},

{"name": "do_up", "rw":"r"}

];

// массив структур для ajax-запроса записи

var OutBuf = [

{"name": "main.cmd", "rw":"w"}

];

// переменные для чтения из ПЛК

var do_up, do_down, do_left, do_right;

Как видите, доступ к локальным переменным изаграфа тоже возможен, только нужно указать имя программы main. IP-адрес ПЛК нужно будет поставить реальный, не изменяя порт 1200.

11.2 Далее:

// считывает ответ ПЛК

// эту функцию следует указать как аргумент f_ok для PlcIO()

function on_plc_read(data) {

InBuf = data; // не удаляйте эту строку, это сохранит кэш низкоуровневых адресов тэгов и

// ускорит их поиск на стороне ПЛК

glob_ana = data[0]["value"];

prg1_bool = data[1]["value"];

prg2_msg = data[2]["value"];

}

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

function on_plc_read(data) {

InBuf = data; // не удаляйте эту строку, это сохранит кэш низкоуровневых адресов тэгов и

// ускорит их поиск на стороне ПЛК

do_left = data[0]["value"];

do_right = data[1]["value"];

do_down = data[2]["value"];

do_up = data[3]["value"];

}

11.3 Вот этот код необходимо пояснить:

// точка входа программы

$(function() {

Mns.setup({

onRdy: init,

onBtnClick: click, // обработчик ввода от кнопок

onInput: input // обработчик ввода от InputText

});

});

// запускается из mns.js при завершении загрузки mns.svg

function init() {

setInterval(function() {cycle();}, 1000);

}

// срабатывает по нажатию кнопки

function click(id) {

alert("You press button " + id);

}

// срабатывает по вводу в inputText

function input(id) {

alert("You input '" + Mns.inp[id].get() + "' into " + id);

}

// рабочий чикл программы, настраивается в init()

function cycle() {

// опросить ПЛК

PlcIO(PlcIP, InBuf, on_plc_read, f_error);

// записать в ПЛК

OutBuf[0]["value"] = 123;

OutBuf[1]["value"] = "ok";

OutBuf[2]["value"] = true;

PlcIO(PlcIP, OutBuf, on_plc_write, f_error);

}

Строка $(function() {}) это точка входа в данный скрипт и отсюда всё начинает крутиться: вызывается библиотечная функция Mns.setup(), та вызывает init(), init() создаёт нить, запускающую функцию cycle() с интервалом 1000мС.

Немного модифицируем этот код, начиная с init():

// запускается из mns.js при завершении загрузки mns.svg

function init() {

setInterval(function() {cycle();}, 100);

}

// срабатывает по нажатию кнопки

function click(id) {

var cmd;

switch(id) {

case 'stop':

cmd = 0;

break;

case 'left':

cmd = 3;

break;

case 'right':

cmd = 4;

break;

case 'forward':

cmd = 2;

break;

case 'revers':

cmd = 1;

break;

default:

return;

}

OutBuf[0]["value"] = cmd;

PlcIO(PlcIP, OutBuf, on_plc_write, f_error);

}

// срабатывает по вводу в inputText

function input(id) {

alert("You input '" + Mns.inp[id].get() + "' into " + id);

}

// рабочий чикл программы, настраивается в init()

function cycle() {

// опросить ПЛК

PlcIO(PlcIP, InBuf, on_plc_read, f_error);

}

Во-первых, увеличили частоту вызова cycle(), которая производит опрос ПЛК. Во-вторых, сделали обработку нажатия кнопок. Помните свойство onclick в виджете button, мы прописали там аргументы "left","right" и т.д? Теперь эти строковые значения прилетают сюда, мы преобразовываем их в код команды и посылаем в ПЛК. Ну и в-третьих, убрали из cycle() запись данных, т.к. запись в ПЛК будет теперь производиться по факту нажатия кнопок в функции click().

11.4 Ну и осталась только функция update_screen(), которая вызывается при успешном чтении:

Чтобы в целях отладки отвязаться от ПЛК, давайте приведём функции cycle() и update_screen() к такому виду:

// рабочий чикл программы, настраивается в init()

function cycle() {

// опросить ПЛК

PlcIO(PlcIP, InBuf, on_plc_read, f_error);

/* отладка ...*/

update_screen();

do_up = (OutBuf[0]["value"]==2)? true:false;

do_down = (OutBuf[0]["value"]==1)? true:false;

do_left = (OutBuf[0]["value"]==3)? true:false;

do_right = (OutBuf[0]["value"]==4)? true:false;

/* ... отладка */

}

function update_screen() {

Mns.dyn["led1"].set({f: do_left|do_right|do_up|do_down ? "green" : "black"} );

Mns.dyn["ar"].set({f: do_right? "green" : "gray"} );

Mns.dyn["al"].set({f: do_left? "green" : "gray"} );

Mns.dyn["ab"].set({f: do_down? "green" : "gray"} );

Mns.dyn["af"].set({f: do_up? "green" : "gray"} );

}

Строки между  /* отладка */ временные, для отладки, затем их нужно будет поудалять. Отладочный код устанавливает значения переменных do_* в соответствии с нажатой кнопкой, чтобы увидеть это на мнемосхеме без подключения ПЛК.

Теперь щёлкните по файлу index.html и убедитесь в работоспособности интерфейса:

Если этого не произошло, то скорее всего по причине несовместимости браузера. Это точно не будет работать под ms explorer-ом. Я пользуюсь мозиллой, но тестировал также Opera и Chrome, всё работало. Если у вас и под ними не работает, то причиной может быть только устаревшая версия браузера. Если же и с новой версией что-то пошло не так, можно попытаться локализовать ошибку в отладчике браузера.

Теперь по содержимому update_screen().

Разработчик библиотеки все обращения к виджетам привёл к одному виду:

Mns.<слой>[].set({<свойство>: <значение>});

Свойства такие:

t - текст

v - числовое значение

f - цвет заливки

Если вам не понятны конструкции вида

do_left|do_right|do_up|do_down ? "green" : "black", то вместо таковых в своей работе можете использовать аналоги:

if(do_left==true || do_right==true || do_up==true || do_down==true ) {

Mns.dyn["led1"].set({f:"green"});

else

Mns.dyn["led1"].set({f:"black"});

}

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

12. Вот теперь веб-проект, можно сказать, готов. Уберите отладочные строки в index.js и загружайте проект изаграфа в контроллер, как это показано здесь. И не забудьте грузить в ПЛК не только tic-код, но и символы приложения, эта информация нужна html-шлюзу таргета для разрешения имён запрашиваемых тегов.

IP-адрес в index.js должен соответствовать вашему ПЛК. Кстати, таргет можно запустить и на ПК!

Если всё пошло по маслу, щёлкнув по index.html вы увидите полностью рабочий проект, пользуйтесь на здоровье!

13. Теперь осталось только запаковать папку web в zip-архив (в архиве должно быть содержимое каталога web, но не каталог web с содержимым!) и присоединить его в проекту nScada как ресурс. Делается это так:

- копируем web.zip в папку проекта nScada (например c:\IsaWin\Apl\nScada)

- открываем Создать->Ресурсы окна программ и вводим

BinaryFile 'web_zip'

BEGIN

AnyTarget

From 'web.zip'

To 'web.zip'

End

- создаём и загружаем проект в ПЛК

Ну вот и всё. Теперь набрав в браузере IP нашего ПЛК, получим то что видели в предыдущем шаге, но уже полностью размещённое в контроллере и доступное с любого другого подключенного устройства сети (включая wifi), будь то планшет или мобильник.

Если для наглядности подключать к задействованным каналам GPIO светодиоды, то желательно делать это через ограничивающие ток резисторы номиналом 200...300 ом.

P.S. Всё вышеописанное доступно в виде похожего готового проекта "nScada", входящего в состав архива библиотеки для ISaGRAF Workbench (архив здесь, описание здесь), т.е. скачав эту библиотеку можно вытащить оттуда данный проект. Веб-составляющие файлы находятся в архиве web.zip директории проекта.

P.S.2 Данный пример ни в коем случае не претендует на какую-либо практическую завершённость, просто здесь показан в действии иструмент, позволяющий разрабатывать вполне полезные вещи на базе вполне доступного железа и софта.

P.S.3 В следующем посте постараюсь изыскать и привести пример более близкий к тематике умного дома.

2. В проекте robot создаём программу, скажем, main на языке SFC (Файл->Новый):

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

3. Теперь щёлкаем по main и открываем окно SFC-редактора:

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

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

Но где же здесь логика управления роботом? А логику надо вбить в шаги и переходы методом двойного клика по ним. При этом справа выскакивает текстовый редактор:

3.1 Вы видите текст

ACTION (P) :

do_left:=false;

do_right:=false;

do_up:=false;

do_down:=false;

END_ACTION;

который следует ввести в первый шаг (пока не надо, потом). Шаг это код на языке ST, похожем на Паскаль. Тут видно, что переменным do_* присваиваются логические нули (если не знакомы с двоичными/булевскими переменными, то лог.ноль это false (ложь), а лог. единица это true (истина)). А что такое ACTION() легко ищется в мануале изаграфа. Если коротко, действия шагов могут быть импульсными ( читай однократными, внутри ACTION (P) как у нас) или 'несохранёнными' (ACTION(N)). Я не знаю почему их назвали несохранёнными, но суть в том, что код внутри ACTION(N) будет молотить постоянно, пока шаг активен. Вернее даже не постоянно, а с частотой цикла исполнения программы. Т.е. если цикл нашей программы 10 мС, а шаг продержался активным 1 сек, то ACTION(N) успеет отработать 100 раз.

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

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

3.2 Набейте скелет программы, чтобы он выглядел так, как на предпоследнем скрине. Просто введите пустые шаги и переходы. Если программу оставить в таком виде, то она тоже будет работать, в каждом цикле переходя на следующий шаг и так по кругу, ведь все переходы по умолчанию разрешены. Там, где переходы расходятся параллельно, программа пойдёт по первому (левому) пути, т.е. будут поочерёдно исполняться шаги 1 и 2. Попробуйте проверить программу, нажав на красную галочку "Проверка программы". Должен отработать генератор кода и выдать подобное сообщение:

3.3 Теперь наберите следующее содержимое шагов и переходов:

Шаг 1:

ACTION (P) :

do_left:=false;

do_right:=false;

do_up:=false;

do_down:=false;

END_ACTION;

Переход 1:

cmd=CMD_LEFT

Переход 2:

cmd=CMD_RIGHT

Переход 3:

cmd=CMD_UP

Переход 4:

cmd=CMD_DOWN

Шаг 2:

ACTION (P) :

do_left:=true;

END_ACTION;

Шаг 3:

ACTION (P) :

do_right:=true;

END_ACTION;

Шаг 4:

ACTION (P) :

do_up:=true;

END_ACTION;

Шаг 5:

ACTION (P) :

do_down:=true;

END_ACTION;

Переход 5:

cmd<>CMD_LEFT

Переход 6:

cmd<>CMD_RIGHT

Переход 7:

cmd<>CMD_UP

Переход 8:

cmd<>CMD_DOWN

3.4 Если теперь проверить программу, то генератор выплюнет кучу ошибок. Это от того, что переменные cmd, do_left, do_right и др. не были созданы заранее. Это в php и js переменные создаются автоматом, а тут их надо явно прописать в словаре. Переменные следующие:

- cmd - переменная, в которую через веб-сервис прилетает код команды от 1 до 4. Чтобы не оперировать не этими числами, а более читаемыми наименованиями, я завёл 4 макроопределения: CMD_LEFT, CMD_RIGHT, CMD_UP, CMD_DOWN и присвоил им значения от 1 до 4 (аналог #define в С);

- do_left ... do_down - булевские переменные, каждая из которых отвечает за свой дискретный выход, управляющий соответствующим моторчиком, рулём или чем-то там ещё);

Открываем словарь и вводим макроопределения:

Затем переменную-команду:

И, наконец, выходы (эти переменные надо создавать с атрибутом 'выход'):

Обратите внимание, что переменные do_* должны быть глобальными (т.е. видными из всех программ, если бы их было несколько), иначе Isagraf не позволит привязать их к выходам GPIO.

Если теперь сделать проверку программы, то хоть все переменные созданы, но Isagraf сообщит о том, что переменные do_* объявлены как выходы, но к физическому выходу не привязаны.

Есть в isagraf-е такое понятие - плата ввода-вывода. Щёлкнем по пиктограмме "Соединения ввода/вывода" в окне программ. У вас окошко будем пустым, а я уже забил туда 2 платы:

Верхняя gpioconf это даже не плата как таковая, а средство для настройки GPIO, т.к. это ужасно универсальный разъём и входы-выходы можно компоновать как угодно. На последней картинке видно, что параметр mode0_7 (настройка для первых 8-ми ножек GPIO) содержит 4 символа 'O' в начале. Это означает, что первые четыре ноги GPIO сконфигурятся как дискретные выходы. Что означают другие символы, можно посмотреть двойным кликом по плате и затем нажав кнопку Замечание.

А вот плата gpio_do это самая что ни на есть настоящая плата:

На неё и приходят наши выходные сигналы.

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

4. Теперь откроем окно опций компилятора (окно "Программы"->Создать->"Опции компилятора") :

Вот так оно должно выглядеть.

А теперь опции выполнения (окно "Программы"->Создать->"Опции выполнения приложения"):

Здесь вводим время цикла программы в мС.

А теперь пробуем не проверить, а создать приложение (окно "Программы"->Создать->"Создать приложение").

Ошибок быть не должно.

5. Прежде чем грузить приложение в контроллер, его можно погонять на симуляторе (я нарочно поставил галочку напротив симулятора в опциях проекта п.4). Запустив симулятор и расположив окна наглядным образом можно погонять робота туда-сюда и буквально увидеть как работает программа:

Гонять робота можно открыв словарь и записывая значение переменной cmd двойным кликом по ней. Другого способа пока нет, т.к. web-морду мы пока ещё не прикрутили. Но всё равно интересно!

Продолжение следует. В следующем посте нарисуем веб-интерфейс, сконпонуем его с isagraf-проектом и зальём в малину.

Это тоже по сути своей комп примерно такого же размера как малина (если не считать конструктив), CPU ARM 600мГц, 512мБ RAM, в общем похож на старую версию R-PI. Он давно валяется и никто не помнит почём его брали. В инете у всех все цены по запросу, как сговорились. Вот [здесь](http://www.dom-intel.ru/magazin/oborudovanie/kontrollery/bec...) не постеснялись обозначить цену на похожий, но более слабый комп: без малого 110 косарей просят на момент написания поста!

Ладно, к чёрту Beckhoff, есть у меня где-то наш аналог - питерский [fastwel]l(http://www.fastwel.ru/products/fastwel-io/programmiruemye-ko...). Не поленился, нашел, вот он:

Тут тоже arm на 600мГц, памяти сколько не помню, а эзернета вообще нет, не говоря про wifi. Но всё равно будем считать где-то рядом с малинкой. В районе 40 тыр, если мне гастрит не изменяет, стоили они год назад (уточнил - 41726 с ндс). Плюс срок поставки примерно месяц, т.к. в питере только магазин, а производят их сами понимаете где. Вот так то.

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

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

Итак, ПЛК - это тот ракурс, в котором мне хотелось бы посмотреть на сей сабж в свете его технико-экономических достоинств.

Что можно сотворить из маленького шустрого ПЛК не сразу окинешь взглядом. Тут, как говорится, редкая птица до середины долетит. Можно очертить только сферически - хобби-конструирование (роботы, самолётики и тп) ну и всякая разная домашняя автоматизация. Промышленную не рассматриваю, т.к. могут полететь помидоры, зачем мне это (я хоть и сравнивал по ценам с бэкхоффом, но прекрасно понимаю, что малину как она есть в шкаф промобъекта никто не поставит, 'не положено' как в армии говорят).

А раз домашняя, то малина в двойном плюсе и вот почему. Первый плюс - малую цену - мы уже видели.

Второй плюс. Обладая высокой производительностью, мы получаем доступ к классу средств разработки для дорогих и 'настоящих' ПЛК. Я имею в виду языки программирования стандарта МЭК 61131-3 :

На картинке выше среда разработки CODESYS, в которой можно кодить как раз на таких языках.

С++ или МЭК?

Чем языки МЭК лучше С++ или питона, спросят многие. Ну, если программа простая, просто ножками подёргать для курсовой, то ничем не лучше. Но сложная программа (читай - прикладная, т.к. любой практически ценный труд неизбежно обрастает сложностями) требует от разработчика продвинутых навыков и хороших средств отладки. Матёрый программер справится и на gcc, кто бы спорил. Но если человек хочет за неделю вкурить теорию и через две уже что-то получить на выходе, то подобные инструменты ему, как говорится, доктор прописал. Т.е. если есть некий порог вхождения, то для МЭК он заметно ниже.

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

#include <gpio.h>

int main(void) {

bool led;

gpio_init(/*здесь должны быть данные инициализации ножек GPIO*/);

while(1) {

gpio_write_do(1 ,led);

led = !led;

usleep(100);

}

return 0;

}

Этот код 10 раз в секунду изменяет состояние 1-го пина GPIO. Если вы никогда не программировали на С, то тут мало что понятно. А что писать в строке gpioInit вместо комментария непонятно вообще никому, кто не ознакомился со спецификой библиотеки поддержки GPIO.

Теперь вот как это может выглядеть на мэковской FBD-диаграмме:

Ну вот, совсем другое дело. Тут три функциональных блока:

- gpio_init настраивает режимы входов-выходов GPIO;

- blink генерит мигающий (1/0) сигнал;

- gpio_do итак понятно что делает;

Всё-таки в визуальном программировании что-то есть, особенно если учесть то, что среда разработки сама позаботится о компиляции и загрузке программы в ПЛК, а хелп (подсказку) по используемым функциональным блокам (тот же gpio_init) можно получить двойным кликом тут же, не отходя от кассы. А в процессе работы это окно открывается под отладчиком и значения всех переменных видны. А кроме FBD (язык блочных диаграмм) в МЭК-овской среде можно использовать похожий на Паскаль ST (структуированный текст) и/или SFC (язык последовательных диаграмм, на котором можно делать ну очень сложные и ветвистые проги). И это ещё не все языки МЭК...

В общем, МЭК или не МЭК решайте сами.

МЭК для малины

МЭК 61131-3 он конечно один, но реализаций много. Некоторые производящие ПЛК фирмы даже разработали свои среды для программирования своих изделий. Как правило там всё ограничивается FBD. Но это к слову, т.к. для малины варианта всего 2 - либо используем CodeSys, либо что-то другое.

1. CodeSys (cds)

Фирма S3 разработала МЭК-совместимую среду программирования, по навороченности соизмеримую с MS Visual Studio. Но, в отличии от MS, раздаёт её БЕСПЛАТНО.  Хотя, это как сказать бесплатно, сам-то компилятор (интегрированная среда разработки - IDE) бесплатный, зато ПЛК платные. Производители ПЛК, если хотят сделать свой продукт программируемым в CodeSys, платят денежку S3. И, разумеется, закладывают эту денюжку с стоимость ПЛК. Но в случае с малиной схема другая. Тут уже сами S3 сделали таргет (target - среда исполнения программ на уровне ПЛК) для малины и раздают его за небесплатно (по-моему, 50 евро цена вопроса). Т.е. имея в руках малину запустить в ней CodeSys-ную прогу не получится, если перед этим не запустить на малине codesys-таргет.

На самом деле тут всё довольно просто делается, вот [здесь](http://www.asutp-volgograd.com/blog/raspberry-pi-codesys-int...) популярно об этом рассказано.

2. Что-то другое это ISaGRAF

Сразу признаюсь, статья заказная. Сам себе заказал с целью ознакомить малиноводов именно с этим вариантом. Был (и есть) такой продукт ISaGRAF. Эта среда программирования ПЛК во многом аналогична CodeSys-у, до недавнего времени этот продукт даже доминировал на рынке, но в последнее время чаша весов CodeSys, по-моему имху, перевесила. Суть в том, что разработчики ISaGRAF, строго говоря, не брали денег с производителей ПЛК за доступ к себе и вся тайная кухня для портирования таргета у них, в отличии от CDS, открыта (по крайней мере до версий 3.Х). Зато IDE (пользовательская среда разработки) платная.

В настоящее время ISaGRAFы доразвивались до 6 версии и, если не ошибаюсь, восприняли схожую с CDS стратегию на 'бесплатную' IDE.

Не одну собаку съемши на изаграфе, могу посоветовать поюзать всё-таки изаграф в его 3 версии, т.к. последующая гигантомания версий 5 и 6 (4 кривая и не в счёт) простому любителю малины вроде как ни к чему.

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

- [качаем](http://homeasutp.ru/viewtopic.php?id=9) таргет;

- пишем его SD-карточку и вставляем в малину (записать образ на SD можно [программой  Win32DiskManager](https://sourceforge.net/projects/win32diskimager) );

- покупаем изаграф 3.5 и работаем, либо [скачиваем](http://homeasutp.ru/viewtopic.php?id=9) оценочную версию и тоже вполне себе работаем;

- быстрый старт описан [здесь](http://homeasutp.ru/viewtopic.php?id=3);

Можно написать не только прогу для малины, но и сделать доступ через веб с кнопками, индикаторами и трендами. Т.е. малина работает как сервер apache (он там и есть), а вы можете обратиться к ней по ip (через wifi или провод) и увидеть что происходит в вашей суперсистеме в браузере компа, планшета или (если зрение позволит) мобильника. Графика векторная (svg)! И не только видеть, но и управлять:

Правда для этого придётся задействовать javascript.

Плюс данного варианта ёщё в том, что этот  таргет не боится случайного отключения. Эта проблема решена за счёт выбора ОС, там и там линукс, но в первом случае (CodeSys) это Raspbian, а в случае ISaGRAF это TinyCore, который целиком сидит в RAM и обращений к SD не требует.

Подключение малины к 'чем-нибудь поуправлять'.

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

Есть разъём GPIO, на который можно выдавать управляющие сигналы или снимать состояния сигналов входных. В штатном варианте это только дискретка, т.е. выдать/принять логический ноль (0 вольт) или единицу (3,5 вольт). Аналоговых сигналов как таковых на нём нет, разве что в качестве аналоговых выходов использовать 2 выходных канала ШИМ с RC-фильтром. Сигналы маломощные, выходят они прямо с ножек процессора без какой-либо защиты и гальваноразвязки. Так в серьёзных ПЛК не делают, по этому я и упоминал про то, что нельзя малину сразу в промшкаф.

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

А что делать, если нужно опросить аналоговые сигнале, например сопротивления датчиков температуры? Или если требуемое количество сигналов превышает 27 дискретных входов/выходов разъёма GPIO? Тогда самое время освоить шину АСУТП всех времён и народов modbus, благо это всего два провода интерфейса RS485. Про modbus очень много есть в сети, применительно к малине могу только дать ссылку на такие вот свистушки:

Этот порт 485-го интерфейса можно заказать на [aliexpress](https://ru.aliexpress.com/item/Free-Shipping-USB-to-RS485-48...) по цене ниже $1. Т.е. сама малина по rs485, а значит и по modbus работать не сможет, для подключения к modbus нужно вставить в USB указанный адаптер. Далее подключаем двумя проводами малину к modbus-совместимым устройствам ввода вывода. Таких устройств на одной линии может висеть много, главное чтобы все они поддерживали работу на одной и той же скорости передачи данных. Самые асутп-шные скорости это 9600 и 19200 бит в секунду. Но если к одной скорости прийти не удаётся (например одни девайсы понимают только 9600, а другие только 38400), то придётся организовывать 2 сегмента modbus и закупить 2 usb/rs485 порта.

Вот типичный представитель самой демократичной на данный момент [линейки](http://icpdas.ru/) устройств ввода-вывода для modbus:

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

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

Ну и в качестве тоста на посошок. Использовать малину в качестве ПЛК нужно и можно, но осторожно, если использовать GPIO.

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

Это тоже по сути своей комп примерно такого же размера как малина (если не считать конструктив), CPU ARM 600мГц, 512мБ RAM, в общем похож на старую версию R-PI. Он давно валяется и никто не помнит почём его брали. В инете у всех все цены по запросу, как сговорились. Вот [здесь](http://www.dom-intel.ru/magazin/oborudovanie/kontrollery/bec...) не постеснялись обозначить цену на похожий, но более слабый комп: без малого 110 косарей просят на момент написания поста!

Ладно, к чёрту Beckhoff, есть у меня где-то наш аналог - питерский fastwell. Не поленился, нашел, вот он:

Тут тоже arm на 600мГц, памяти сколько не помню, а эзернета вообще нет. Но всё равно будем считать где-то рядом с малинкой. В районе 40 тыр, если мне гастрит не изменяет, стоили они год назад (уточнил - 41726 с ндс). Плюс срок поставки примерно месяц, т.к. в питере только магазин, а производят их сами понимаете где. Вот так то.

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

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

Итак, ПЛК - это тот ракурс, в котором мне хотелось бы посмотреть на сей сабж в свете его технико-экономических достоинств.

Что можно сотворить из маленького шустрого ПЛК не сразу окинешь взглядом. Тут, как говорится, редкая птица до середины долетит. Можно очертить только сферически - хобби-конструирование (роботы, самолётики и тп) ну и всякая разная домашняя автоматизация. Промышленную не рассматриваю, т.к. могут полететь помидоры, зачем мне это (я хоть и сравнивал по ценам с бэкхоффом, но прекрасно понимаю, что малину как она есть в шкаф промобъекта никто не поставит, 'не положено' как в армии говорят).

А раз домашняя, то малина в двойном плюсе и вот почему. Первый плюс - малую цену - мы уже видели.

Второй плюс. Обладая высокой производительностью, мы получаем доступ к классу средств разработки для дорогих и 'настоящих' ПЛК. Я имею в виду языки программирования стандарта МЭК 61131-3 :

На картинке выше среда разработки CODESYS, в которой можно кодить как раз на таких языках.

С++ или МЭК?

Чем языки МЭК лучше С++ или питона, спросят многие. Ну, если программа простая, просто ножками подёргать для курсовой, то ничем не лучше. Но сложная программа (читай - прикладная, т.к. любой практически ценный труд неизбежно обрастает сложностями) требует от разработчика продвинутых навыков и хороших средств отладки. Матёрый программер справится и на gcc, кто бы спорил. Но если человек хочет за неделю вкурить теорию и через две уже что-то получить на выходе, то подобные инструменты ему, как говорится, доктор прописал. Т.е. если есть некий порог вхождения, то для МЭК он заметно ниже.

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

#include <gpio.h>

int main(void) {

bool led;

gpioInit(/*здесь должны быть данные инициализации ножек GPIO*/);

while(1) {

gpio_write_do(1 ,led);

led = !led;

usleep(100);

}

return 0;

}

Этот код 10 раз в секунду изменяет состояние 1-го пина GPIO. Если вы никогда не программировали на С, то тут мало что понятно. А что писать в строке gpioInit вместо комментария непонятно вообще никому, кто не ознакомился со спецификой библиотеки поддержки GPIO.

Теперь вот как это будет выглядеть на мэковском языке FBD:

Я думаю, комментарии излишни.