Освещение - Мехническое / Автоматическое
Если есть люди знающие и уже применившие какое нибудь решение в своем быту. Интересует что-бы физический выключатель все так-же продолжал функционировать, но при этом работала точно так-же автоматизация (работа через мобильное приложение которое завязано на Raspberry Pi как система по управлению домом). То есть интересует следующего рода решение :
Физический выключатель - вкл/выкл свет физически (при этом автоматизация продолжает работать, что-бы модуль автоматизации продолжал быть под напряжением и в любой момент можно было удаленно послать к нему сигнал вкл/выкл свет)
Модуль автоматизации - вкл/выкл свет дистанционно (при этом физический выключатель если задействовать выключит или включит освещение, если на него воздействовать физически)
Так же интересно возможно ли это в приложении реализовать что-бы 2 этих действия отображались сразу - физическое воздействие вкл/выкл и дистанционное вкл/выкл.
Подскажите пожалуйста, как это правильно реализовать без покупки умных выключателей оставив обыкновенные, если это возможно. Так же интересует что будет по протяжке кабелей. Какие надо будет протягивать до куда, и какие надо будет раскидывать после.
Заранее признательно благодарен за помощь.
Автоматики пост :)
Для тех, кто заинтересовался работой автоматики SmartFarm на нашей ферме, мы решили подготовить отдельный пост. Чем больше обратной связи от вас, тем больше информации от нас ;)
Начнем по порядку:
1. Пожаробезопасность. Пожаробезопасность обеспечивается пока что полным отсутствием внутри помещения пожароопасных предметов. На эту тему размышления открыты.
2. Собственно, автоматика и что она позволяет делать.
Помещается это все дело в такую коробку - она весьма удобна в транспортировке и установке. Это не конечный результат, удобство и практичность находятся в процессе постоянной разработки.
Благодаря установленным внутри датчикам, пользователь может задавать расписание/условие включения/выключения разных реле, которые, в свою очередь, включают или выключают малый/большой свет, малый/большой вентилятор или любое другое устройство, которое понадобиться вам для агрономического процесса.
В данный момент, в секции Demo на нашем сайте (ссылка будет в первом комментарии) можно посмотреть и опробовать пример установки расписание для курятника. Каждая кнопка оснащена всплывающей подсказкой. С удовольствием примем пожелания по улучшению данной вкладки :)
Заданное вами расписание не влияет на наших куриц в реальной жизни, а просто показывает пример того, каким расписание может быть. Приносим извинения за черный экран вместо трансляции курочек, сейчас выключен на ночь свет. Но вы всегда можете навестить их днем. ;)
3. Насчет кода. На сегодняшний день код в закрытом репозитории на BitBucket, но в скором времени мы планируем открыть проект для open-source, чтобы любой желающий мог поучаствовать в разработке. Скорее всего, проект будет открыть под GNU GPLv3 license.
На подходе пост про наших несушек. :)
Домашние вкусняшки на Raspberry PI. Веб-морда робота /окончание/
Продолжение. Начало здесь. Для тех кто не читал первую часть - в ней речь шла о том, как на основе raspberry pi создать блок управления, скажем, роботом, задействуя в качестве выходных сигналов 4 дискретных выхода GPIO и с управляющим алгоритмом на языке SFC.
6. Теперь, собственно, сам веб-интерфейс.
Для начала разработки скачайте архив Inkscape и распакуйте его в любой удобной папке. Это портабельный, не требующий инсталляции редактор SVG-графики. Запускать надо файл inkscape.exe, для удобства можно сделать ярлык на рабочем столе.
Скачайте также библиотеку виджетов, при помощи которых будем оживлять нашу мнемосхему. Распакуйте в любом удобном месте.
Создайте целевую папку (назовём её web), в которой будет лежать вся веб-начинка, содержимое этой папки и будет заливаться в ПЛК в виде zip- архива. И скопируйте туда содержимое папки web из архива виджетов.
7. Запускаем inkscape:
Кнопками + и - выставляем масштаб. На экране появилось что-то несуразное. Но это только заготовка с тремя виджетами - кнопка(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 В следующем посте постараюсь изыскать и привести пример более близкий к тематике умного дома.
Домашние вкусняшки на Raspberry PI. Халявная веб-морда робота.
В предыдущем посте я писал про Raspberri PI как про перспективное средство домашней автоматизации и только вскользь упомянул про возможность создания связки softLogic+веб (под softLogic понимать программирование малины на языках MЭК). А теперь хочу раскрыть эту тему гораздо более развёрнуто и показать как построить небольшую системку управления роботом через веб и подавать ему команды вправо/влево/прямо/назад из браузера десктопа, планшета или мобильника.
Кто не читал предыдущий пост, тот может и не знать, что эту задачу можно порешать двумя путями - CodeSys-ом или Isagraf-ом. Так как на codesys халява действует только 2 часа, да и сам я являюсь адептом второго варианта, то на нём и заостряю свой мысленный взор.
Как начать и что скачать показано здесь, включая то, как потренироваться на демо-проекте. Да, загружать всё это надо конечно не в малину, а на комп разработки под windows, а уже среда разработки сама загрузит исполняемый код на ПЛК (так далее будем называть raspberry pi3).
Итак, пошагово:
1. В среде разработки ISaGRAF Workbench создаём новый проект (Файл->Новый):
По умолчанию 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 платы:
А вот плата gpio_do это самая что ни на есть настоящая плата:
На неё и приходят наши выходные сигналы.
По завершению ввода плат и привязки сигналов нужно проверить программу и избавиться от возможных ошибок.
4. Теперь откроем окно опций компилятора (окно "Программы"->Создать->"Опции компилятора") :
Вот так оно должно выглядеть.
А теперь опции выполнения (окно "Программы"->Создать->"Опции выполнения приложения"):
Здесь вводим время цикла программы в мС.
А теперь пробуем не проверить, а создать приложение (окно "Программы"->Создать->"Создать приложение").
Ошибок быть не должно.
5. Прежде чем грузить приложение в контроллер, его можно погонять на симуляторе (я нарочно поставил галочку напротив симулятора в опциях проекта п.4). Запустив симулятор и расположив окна наглядным образом можно погонять робота туда-сюда и буквально увидеть как работает программа:
Гонять робота можно открыв словарь и записывая значение переменной cmd двойным кликом по ней. Другого способа пока нет, т.к. web-морду мы пока ещё не прикрутили. Но всё равно интересно!
Продолжение следует. В следующем посте нарисуем веб-интерфейс, сконпонуем его с isagraf-проектом и зальём в малину.
Домашние вкусняшки на малине сорта raspberry pi. Дополненное.
Это тоже по сути своей комп примерно такого же размера как малина (если не считать конструктив), 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)! И не только видеть, но и управлять:
Плюс данного варианта ёщё в том, что этот таргет не боится случайного отключения. Эта проблема решена за счёт выбора ОС, там и там линукс, но в первом случае (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.
Тем более весь высокотехнологичный инструмент есть, нужно только помнить о его наличии).
Домашние вкусняшки на малине сорта raspberry pi
Этот маленький комп неспроста так быстро и широко разошёлся по всему белу свету. Маленький, достаточно шустрый, непрожорливый (потянет даже зарядка от мобильника) девайс за недорого. К тому же, слыхать, уже в наличии клоны за ещё более недорого. Я, старый автоматизатор, знаю цену таким вещам. Вот прям сейчас, далеко ходить не надо, на столе валяется процессор Beckhoff cx9020:
Это тоже по сути своей комп примерно такого же размера как малина (если не считать конструктив), 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:
Я думаю, комментарии излишни.
Энтузиаст создал Linux-систему размером с iPhone 5 на базе Raspberry Pi
Что будет, если скрестить смартфон и одноплатный компьютер Raspberry Pi Zero W за 10 долларов? Например, Zero Terminal.
Что это такое?
Zero Terminal — это проект, созданный человеком, известным под ником N-O-D-E. Он превратил Pi Zero W в компьютер размером с телефон с выдвижной QWERTY-клавиатурой и сенсорным дисплеем. Устройство работает не на мобильной ОС, а на полноценном десктопном дистрибутиве Linux, Raspbian.
Являясь полноценным компьютером, Terminal обходит фундаментальное ограничение Pi, которое заключается в необходимости использования монитора и клавиатуры для полноценного функционирования.
Такое устройство лучше всего подходит для несложных задач, например, программирования, работы с командной строкой, обработки текста или запуска старых игр в эмуляторах, а не использования веб-браузера и прочих полноценных программ.
Однако N-O-D-E обещает создать альтернативную модель Terminal, которая будет использовать более мощную, но большую по размеру плату Raspberry Pi 3 Model B.
Zero Terminal оснащён заряжаемым аккумулятором емкостью 1,500 мАч. К нему можно подключить монитор и мышку через HDMI- и USB-порты, в отличие от «голого» Pi Zero W, требующего дополнительных переходников. Корпус устройства напечатан на 3D-принтере, а выдвижная клавиатура является частью чехла для iPhone 5. Когда N-O-D-E закончит работу над корпусом, он выложит файлы для 3D-печати в открытый доступ.
Однако если вы хотите создать свою версию такого устройства, все детали можно найти в свободной продаже. Вам понадобятся дисплей Adafruit PiTFT Plus, сама плата Raspberry Pi Zero W, контроллер Adafruit Powerboost 1000c, батарея на 1500 мАч и платы для microSD. Вы можете найти более подробную информацию на страничке проекта.
Характеристики устройства:
32-разрядный 1-ядерный процессор Broadcom BCM2835 на базе ARM частотой 1 ГГц;
512 МБ ОЗУ;
Выход mini-HDMI;
1 USB-разъём;
Разъём micro-USB для зарядки;
Cлот для карт памяти формата microSD;
Экран диагональю 3,5’’ с разрешением 480×320;
Полная QWERTY-клавиатура;
802.11b/g/n Wi-Fi;
Bluetooth 4.0;
Аккумулятор емкостью 1500 мАч.
На сайте разработчика можно найти много других интересных проектов, советуем взглянуть. Кроме того, совсем недавно мы писали про систему для пополнения запасов кофе на базе Pi Zero, а в прошлом году — про игровую консоль внутри NES-контроллера. Также для всех любителей Raspberry приятной новостью будет тот факт, что компьютеры этой серии заняли третье место в списке самых продаваемых компьютеров, обойдя Commodore 64.
Источник: Tproger