мини PLC. Опции

[Jenya7]

я хочу програмировать задачи - состояния на выходе в зависимости от условий на входе. этакий мини Programmable Logic Controller.
для примера код

Код

// условие на входе
If (temp > 30 && hum > 80 || input1 ==1)
{
    // условие на выходе
    output2 = 1;
}

Где temp, hum - глобальные переменные но задаваемые пользователем через теринал.
пользователь програмирует такое условие следующим образом.

Код

task 1 param 1 temp > 30 AND
task 1 param 2 hum > 80 OR
task 1 in 1 1
task 1 out 2 1

или так

Код

task 1 param 1 temp > 30
task 1 param 2 hum > 80
task 1 in 1 1
task 1 param 1 AND param 2 OR in 1
task 1 out 2 1

и я это сохраняю и потом проверяю и если условие выполняется - включаю\выключаю нужные выходы. вопрос есть ли какие то готовые библиотеки а-ля-PLC?

Сообщение отредактировал Jenya7 - Jan 27 2016, 08:18

[=AK=]

я хочу програмировать задачи - состояния на выходе в зависимости от условий на входе. этакий мини Programmable Logic Controller.
...
и я это сохраняю и потом проверяю и если условие выполняется - включаю\выключаю нужные выходы. вопрос есть ли какие то готовые библиотеки а-ля-PLC?

Ваша задача не имеет никакого отношения к PLC, это полная чушь.

То, что вы тут накалякали, в принципе может быть реализовано путем создания некого скриптового языка. Тем не менее для грамотного решения , вам придется озаботиться и БНФ, и парсингом, и интерпретатором. Однако поскольку вы демонстрируете чрезвычайно низкий уровень знаний и очень много гонора, то шансы на то, что вы сподобитесь решить эту задачу "в общем виде", исчезающе малы.

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

[Jenya7]

Ваша задача не имеет никакого отношения к PLC, это полная чушь.

То, что вы тут накалякали, в принципе может быть реализовано путем создания некого скриптового языка. Тем не менее для грамотного решения , вам придется озаботиться и БНФ, и парсингом, и интерпретатором. Однако поскольку вы демонстрируете чрезвычайно низкий уровень знаний и очень много гонора, то шансы на то, что вы сподобитесь решить эту задачу "в общем виде", исчезающе малы.

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

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

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

Код

char *expr; //Указатель на обрабатываемую строку
char token[80]; //Лексема

Там в статье всё расписано + приведён полностью рабочий код. Вам достаточно в нем заменить пару функций на свои.

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

Можно сделать не компилятор, и интерпретатор. Тогда ничего "хранить" не надо выполнение делается при обработке строк... Правда это "медленнее", чем если сначала откомпилировать, а потом исполнять "переваренный" код... Но зато проще сделать программу обработки.
Вообще если сделать два вида исходных строк, то дело будет значительно проще реализовать.
1. "Арифметические строки" - введите "внутренние переменные", где "входы" или "внутренние переменные" проверяются на "больше-меньше" или "+/-" и результат этих действий превращается в битовые переменные
2. "Логические строки" в которых обрабатываются "битовые переменные"

Ну и Форт-система это тоже вариант....

извините но - тоже пачками.

[Herz]

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

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

извините но - тоже пачками.

Автор! Попробуйте прислушаться к советам и не хамить. Я совершенно не понимаю, откуда возьмётся желание искать приемлемое для Вас решение, разжёвывать и класть в рот при такой "благодарности".

[Jenya7]

Автор! Попробуйте прислушаться к советам и не хамить. Я совершенно не понимаю, откуда возьмётся желание искать приемлемое для Вас решение, разжёвывать и класть в рот при такой "благодарности".

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

Ей бо глухой...
Вы же почему-то сваливаете в одну кучу компиляцию исходников и исполняемую программу. На самом деле Вам надо сделать 2 программы. Одну - для превращения сложной командной строки исходника в более простой набор команд. Что-то вроде "RISC", когда каждая простейшая команда выполняет только одно действие. Либо устанавливает переменную или таймер, либо логически обрабатывает переменную. Ну и вторая часть - будет в контроллере, она и будет выполнять эти простейшие действия. И парсер там будет примитивный...
Вы посмотрите мои статьи о битовом контроллере...

а почему так нельзя?

Код

for (int i = 0; i < sizeof(dailyTask[task_num].taskParams); i++)
    {
        if (dailyTask[task_num].taskParams[i].enable)
        {
            dailyTask[task_num].taskCondition[dailyTask[task_num].condIdx].result = TASKER_EvaluateParamCondition(dailyTask[task_num].taskParams[i].variable,
                                                                                                                                  dailyTask[task_num].taskParams[i].limit,
                                                                  dailyTask[task_num].taskParams[i].compare);
            dailyTask[task_num].taskCondition[dailyTask[task_num].condIdx].logic = dailyTask[task_num].taskParams[i].logicGate;
            dailyTask[task_num].condIdx++;
        }
    }

uint32_t TASKER_EvaluateParamCondition(float *val, float val_lim, uint32_t compare)
{
    switch (compare)
    {
        case 0: return (*val == val_lim); break;
        case 1: return (*val > val_lim);  break;
        case 2: return (*val < val_lim);  break;
        case 3: return (*val >= val_lim); break;
        case 4: return (*val <= val_lim); break;
        case 5: return (*val != val_lim); break;
        default : return 2;
    }
}

что я могу сказать. работает. быстро. четко. конечно интенсивный дебагинг я еще не делал но...
элементарная структура. 10 строк кода.

Сообщение отредактировал Jenya7 - Jan 27 2016, 14:34

[arhiv6]

а почему так нельзя?

Можно, но такой вариант сложно масштабируем. Если делать в таком виде, то как Вы представляете себе решение для вашего же примера: (param1 && input1) || (param2 && (input2 || input3)) ?

[Jenya7]

Можно, но такой вариант сложно масштабируем. Если делать в таком виде, то как Вы представляете себе решение для вашего же примера: (param1 && input1) || (param2 && (input2 || input3)) ?

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

Код

struct sGroupResults
{
    uint8_t result;
    uint8_t resLogic;

};
struct sConditionGroup
{
    struct sGroupResults groupResults[10];
    uint8_t groupLogic;

};

struct sTaskCondition
{
    struct sConditionGroup condGroup[MAX_COND_GROUPS];
};

и тогда условие

Код

(param1 && input1) || (param2 && (input2 || input3))

расположиться так

Код

sTaskCondition.condGroup[0].groupResults[0].result = param 1;
sTaskCondition.condGroup[0].groupResults[0].resLogic = AND;
sTaskCondition.condGroup[0].groupResults[1].result = input 1;
sTaskCondition.condGroup[0].groupResults[1].resLogic = NONE;
sTaskCondition.condGroup[0].groupLogic = OR;

sTaskCondition.condGroup[1].groupResults[0].result = param 2;
sTaskCondition.condGroup[1].groupResults[0].resLogic = NONE;
sTaskCondition.condGroup[1].groupLogic = AND;

sTaskCondition.condGroup[2].groupResults[0].result = input 2;
sTaskCondition.condGroup[2].groupResults[0].resLogic = OR;
sTaskCondition.condGroup[2].groupResults[1].result = input 3;
sTaskCondition.condGroup[2].groupResults[1].resLogic = NONE;
sTaskCondition.condGroup[2].groupLogic= NONE;

вопрос как в проверке условий объяснить что sTaskCondition.condGroup[0]. groupResults[0].result это param 1

Сообщение отредактировал Jenya7 - Jan 27 2016, 15:27

[adnega]

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

При разработке своего контроллера я подумал побольше и сделал так.
Любая логическая функция из N переменных описывается таблицей истинности из 2^N строк.
Если переменные пронумерованы, то и на результат можно ссылаться числом.
Например, для 5 переменных имеем 32 результата.
Зная значения всех 5 переменных, мы можем получить номер бита в 32-битном хранилище результата.

В байткодах это выгладит так:

TABLE5(result_value)
VAR0
VAR1
VAR2
VAR3
VAR4
GETRESULT

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

[Jenya7]

честно говоря я мало что понял.

Сообщение отредактировал Herz - Jan 28 2016, 22:34

Причина редактирования: Избыточное цитирование

[adnega]

честно говоря я мало что понял.

Утверждается, что (param1 && input1) || (param2 && (input2 || input3)) соответствует таблица истинности из вложенного файла.
Из значений переменных собираем индекс:
n = (param1 << 4) + (param2 << 3) + (input1 << 2) + (input 2 << 1) + (input3 << 0);
Затем получаем результат:
((0xFEF0EE00) >> n) & 1
Т.е. для вычисления (param1 && input1) || (param2 && (input2 || input3)) нам достаточно знать одно волшебное 32-битное число 0xFEF0EE00.
Причем, для меня важным моментом было время вычисления логической функции любой сложности из максимум 5 переменных.
При таком подходе оно фиксировано и минимально (не зависит от вида функции и от значений переменных).
А самое главное, легко описывается байт-кодом и элементарно вычисляется.

Теперь понятно?

Эскизы прикрепленных изображений

 

[=AK=]

Из значений переменных собираем индекс:
n = (param1 << 4) + (param2 << 3) + (input1 << 2) + (input 2 << 1) + (input3 << 0);
Затем получаем результат:
((0xFEF0EE00) >> n) & 1
Т.е. для вычисления (param1 && input1) || (param2 && (input2 || input3)) нам достаточно знать одно волшебное 32-битное число 0xFEF0EE00.

А теперь немножко расширим подход. Запланируем "таблицу" в 256 значений, соответственно, "волшебное число" будет состоять не из 4-битных полей, а из 8-битных, т.е из байт. "Bолшебное число" не будем ограничивать размерами, а запишем в байтовый массив произвольной длины. А в самой таблице будем держать адреса функций, которые будут выполняться, когда в массиве встретится соответствующий байт. В результате мы получим заготовку для простейшей Форт-машины, а байтовый массив будет содержать то, что называется "программой из байт-кодов".

Для того, чтобы окончательно оформить Форт-машину, сначала зададимся вопросом; а как функции, вызываемые по своим байт-кодам, будут обмениваться информацией друг с другом? И придем к выводу, что проще всего использовать стек, откуда функции будут брать исходные данные для вычислений, и куда они будут класть результаты. Затем задумаемся, а хорошо ли, что наши программы выполняются линейно, в порядке расположения байт-кодов в массиве? Нехорошо, надо бы предусмотреть возможность изменения порядка выполнения байт-кодов при помощи самих байт-кодов. Заведем байт-коды для условной и безусловной передачи управления в произвольное место программы, а также вызовы подпрограмм, состоящих из байт-кодов, и возврата из подпрограмм. Для хранения адресов возврата заведем еще один стек, назовем его "стек возвратов".

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

Окончательно эта Форт-машина превратится в настоящий Форт после того, как (при помощи программ, написанных в байт-кодах) будет добавлен ввод-вывод, написан транслятор из исходного текста (или клавиатурного ввода) в байт-код, добавлены средства для организации и вызова программ в виде словарей.

[Kopa]

Окончательно эта Форт-машина превратится в настоящий Форт после того, как (при помощи программ, написанных в байт-кодах) будет добавлен ввод-вывод, написан транслятор из исходного текста (или клавиатурного ввода) в байт-код, добавлены средства для организации и вызова программ в виде словарей.

"Скелет" этого варианта?
Кросс Форт на C: FVM factory

Сообщение отредактировал Kopa - Jan 28 2016, 21:36

[=AK=]

Кросс Форт на C: FVM factory

Ну да. Жаль, автор давно забросил этот проект. Был бы он в нормальной форме, то задача создания встроенного интерпретатора решалась бы за 5 минут. А так его полдня чистить и править надо, прежде чем заработает, скажем, под CodeBlocks.

[Kopa]

Ну да. Жаль, автор давно забросил этот проект. Был бы он в нормальной форме, то задача создания встроенного интерпретатора решалась бы за 5 минут. А так его полдня чистить и править надо, прежде чем заработает, скажем, под CodeBlocks.

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

P.S. На sourceforge мне был интересен из Форт с С в связке F-- проект.

Сообщение отредактировал Kopa - Jan 28 2016, 22:59

[Огурцов]

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