
С3: примеры программ на Lua
Готовые программы на Lua для контроллера С3: вход → выход, кнопки и реле, датчики 0–5 В, Modbus TCP, мост TCP ↔ RS485, microSD, OSC и считыватели ODRFID-RS485.
Каждый пример — законченная основная программа. Откройте раздел «Редактор» веб-интерфейса, вставьте код и нажмите «Записать». Или скачайте файл и загрузите его командой:
curl -X PUT --data-binary @input-to-output.lua http://192.168.1.50/lfs/main.lua
Параметры — адреса, порты, номера клемм — вынесены в начало программы. Сообщения
print() выводятся в USB-консоль.
Как устроены программы, объяснено на странице «Программирование на
Lua».
| Пример | Что нужно |
|---|---|
| Вход управляет выходами | модуль выходов или реле, сигнал на IO7 |
| Кнопки управляют реле | модули кнопок и реле |
| Датчики 0–5 В | модуль АЦП, датчики с выходом по напряжению |
| Экран состояния | дисплей |
| Модуль ввода-вывода Modbus TCP | сеть, при желании — модуль выходов или реле |
| Шлюз Modbus TCP → RTU | сеть и прибор Modbus RTU на RS485 |
| Мост TCP ↔ RS485 | сеть и прибор на RS485 |
| Отчёты на HTTP-сервер | сеть и HTTP-сервер |
| Журнал на microSD | карта microSD, доступ к NTP-серверу |
| Счётчик импульсов | сигнал на IO7 |
| События входов по OSC | сеть и программа, принимающая OSC |
| Адресная лента | лента WS2812B и блок питания для неё |
| Доступ на несколько считывателей | считыватели ODRFID-RS485 на одной линии RS485, модуль реле |
Вход управляет выходами
Сигнал на клемме IO7 управляет модулем транзисторных выходов или реле: каждый переход 0 → 1 переключает канал 1, а канал 2 повторяет уровень входа. Светодиод LED0 на плате показывает состояние канала 1. Модуль программа находит сама, в любом слоте.
Подайте на IO7 логический сигнал 0 / 3,3–5 В относительно GND, например выход датчика. Обработчик срабатывает, если новый уровень держится не меньше 30 мс: дребезг и короткие помехи не переключают выход.
-- Вход IO7 управляет модулем транзисторных выходов или реле.
-- Каждый фронт 0 → 1 на IO7 переключает канал 1, канал 2 повторяет уровень
-- входа, LED0 показывает состояние канала 1.
local io = require("odkit.io")
local unit = require("odkit.unit")
local task = require("zephyr.task")
local INPUT_IO = 7 -- клемма с логическим сигналом 0 / 3,3–5 В
local DEBOUNCE_MS = 30 -- игнорировать дребезг короче 30 мс
-- Модуль выходов или реле в любом слоте.
local outputs = assert(unit.find("outputs", "relay"), "нет модуля выходов или реле")
print("Модуль выходов в слоте " .. outputs.slot)
local input = assert(io.open(INPUT_IO)) -- open() уже настраивает вход
local latched = false
outputs:set(1, false)
outputs:set(2, input:read())
assert(input:on_change("both", function(level)
outputs:set(2, level) -- уровень 0 / 1 передаётся как есть
if level == 1 then
latched = not latched
outputs:set(1, latched)
odkit.led_set(odkit.LED0, latched)
end
print("IO" .. INPUT_IO .. " = " .. level .. ", канал 1: " .. tostring(latched))
end, DEBOUNCE_MS))
-- Основная задача должна продолжать работу: при её завершении
-- дескриптор входа будет закрыт и подписка снята.
while true do
task.sleep(1000)
end
Кнопки управляют реле
Кнопка 1 модуля кнопок переключает реле 1, кнопка 2 — реле 2, кнопка 5 выключает оба. Светодиод модуля кнопок коротко мигает при каждом нажатии. Вместо модуля реле можно установить модуль транзисторных выходов.
Модуль кнопок сам подавляет дребезг и запоминает нажатия. Функция
on_press опрашивает его каждые 30 мс, поэтому короткое нажатие не теряется.
Основного цикла в программе нет: подписка на нажатия работает и после
завершения программы.
-- Модуль кнопок управляет модулем реле (или транзисторных выходов).
-- Кнопка 1 переключает канал 1, кнопка 2 — канал 2, кнопка 5 выключает оба.
local unit = require("odkit.unit")
local buttons = assert(unit.find("buttons"), "нет модуля кнопок")
local outputs = assert(unit.find("relay", "outputs"), "нет модуля реле или выходов")
outputs:set_all(false)
-- Модуль кнопок сам подавляет дребезг и запоминает нажатия. on_press опрашивает
-- его каждые 30 мс и вызывает функцию для каждого нажатия; нажатия до запуска
-- программы не учитываются.
assert(buttons:on_press(function(button)
if button == 1 or button == 2 then
outputs:toggle(button)
elseif button == 5 then
outputs:set_all(false)
end
buttons:blink(100, 1) -- короткая вспышка светодиода модуля подтверждает нажатие
end))
-- Подписка работает и после завершения основной программы.
Датчики 0–5 В
Модуль АЦП измеряет напряжение датчиков на четырёх каналах. Программа усредняет 10 измерений, пересчитывает милливольты в единицы датчика и раз в 5 секунд выводит значения. Если давление на канале 1 выше 8 бар, включается канал 1 модуля выходов или реле; выключается он ниже 7,5 бар, чтобы выход не переключался на границе.
| Канал | Датчик в примере | Шкала |
|---|---|---|
| 1 | давление | 0,5–4,5 В = 0–10 бар |
| 2 | уровень | 0–5 В = 0–100 % |
Шкалу своего датчика впишите в таблицу SENSORS: напряжение и значение в
начале и в конце диапазона. При первом запуске программа переводит каналы
модуля в режим аналогового входа и перезапускает модуль.
-- Датчики 0–5 В на модуле АЦП: пересчёт в единицы измерения, усреднение
-- и сигнализация. Пример: датчик давления 0,5–4,5 В = 0–10 бар на канале 1.
-- Превышение 8 бар включает канал 1 модуля выходов или реле.
local unit = require("odkit.unit")
local sys = require("zephyr.sys")
local task = require("zephyr.task")
local SENSORS = {
-- канал, название, напряжение и значение в начале и конце шкалы, единица
{channel = 1, name = "Давление", mv0 = 500, v0 = 0, mv1 = 4500, v1 = 10, unit = "бар"},
{channel = 2, name = "Уровень", mv0 = 0, v0 = 0, mv1 = 5000, v1 = 100, unit = "%"},
}
local ALARM_SENSOR, ALARM_ON, ALARM_OFF = 1, 8.0, 7.5 -- гистерезис 0,5 бар
local SAMPLES = 10 -- измерений в среднем
local adc = assert(unit.find("adc"), "нет модуля АЦП")
local outputs = unit.find("outputs", "relay") -- необязателен
-- Каналы датчиков — аналоговые входы. Модуль хранит режим сам: если режим
-- меняется, set_mode сохраняет его и перезапускает модуль (меньше секунды).
local channels = {}
for i, sensor in ipairs(SENSORS) do channels[i] = sensor.channel end
assert(adc:set_mode("analog", table.unpack(channels)))
local function scale(sensor, mv)
return sensor.v0 + (mv - sensor.mv0) * (sensor.v1 - sensor.v0) / (sensor.mv1 - sensor.mv0)
end
local alarm = false
if outputs then outputs:set(1, false) end
local function set_alarm(on)
if on == alarm then return end
alarm = on
if outputs then outputs:set(1, on) end
print(on and "Тревога: давление выше нормы" or "Давление в норме")
end
local sums, count, last_print = {}, 0, 0
while true do
for i, sensor in ipairs(SENSORS) do
sums[i] = (sums[i] or 0) + assert(adc:read(sensor.channel)) -- милливольты
end
count = count + 1
if count == SAMPLES then
local report = {}
for i, sensor in ipairs(SENSORS) do
local mv = sums[i] / SAMPLES
local value = scale(sensor, mv)
sensor.value = value
report[#report + 1] = string.format("%s %.2f %s (%d мВ)", sensor.name, value,
sensor.unit, math.floor(mv + 0.5))
sums[i] = 0
end
count = 0
local pressure = SENSORS[ALARM_SENSOR].value
if pressure > ALARM_ON then set_alarm(true)
elseif pressure < ALARM_OFF then set_alarm(false) end
local now = sys.uptime().sec
if now - last_print >= 5 then
print(table.concat(report, "; "))
last_print = now
end
end
task.sleep(50)
end
Экран состояния
Дисплей показывает IP-адрес, время работы, уровни всех входов IO и занятую память Lua; данные обновляются раз в секунду. Перед запуском назначьте слоту дисплея тип «Дисплей» в настройках и перезапустите контроллер — см. «Модули расширения».
-- Экран состояния на дисплее 128×64: IP-адрес, время работы,
-- уровни входов и занятая память Lua.
-- Слоту с дисплеем назначьте «Дисплей» в настройках и перезапустите С3.
local net = require("net")
local sys = require("zephyr.sys")
local io = require("odkit.io")
local task = require("zephyr.task")
-- Все доступные клеммы открываем как входы.
local inputs = {}
for _, index in ipairs(io.list()) do
inputs[#inputs + 1] = {index = index, pin = assert(io.open(index))}
end
local function address()
for _, interface in ipairs(net.stat(true)) do
if interface.interface == "en" and interface.connected then
return interface.ip
end
end
return "нет сети"
end
local function uptime()
local s = sys.uptime().sec
return string.format("%dд %02d:%02d", s // 86400, s // 3600 % 24, s // 60 % 60)
end
local function levels()
local text = ""
for _, input in ipairs(inputs) do
text = text .. (input.pin:read() and "1" or "0")
end
return text
end
odkit.display_contrast(160)
while true do
-- В строке 12 знакомест: адрес переносим после второй точки.
local ip = address()
local head, tail = ip:match("^(%d+%.%d+%.)(.+)$")
local memory = sys.memory()
odkit.display_fill(false)
odkit.display_text(head or ip, 0, 0) -- строки идут через 16 пикселей
odkit.display_text(tail or "", 0, 16)
odkit.display_text(uptime(), 0, 32)
odkit.display_text(string.format("%s %dK", levels(), memory.current // 1024), 0, 48)
odkit.display_show() -- передать кадр на экран
task.sleep(1000)
end
Модуль ввода-вывода Modbus TCP
С3 работает модулем ввода-вывода для SCADA, ПЛК или OPC-сервера. Клиент Modbus TCP читает входы IO и время работы, а записью в coils включает каналы модуля выходов или реле.
| Таблица Modbus | Адреса | Содержимое |
|---|---|---|
| Coils, функции 1, 5, 15 | 0–1 | каналы 1–2 модуля выходов или реле |
| Discrete inputs, функция 2 | 0–3 или 0–7 | уровни IO5–IO8 или IO1–IO8 по порядку |
| Input registers, функция 4 | 0–1 | время работы в секундах, старшее слово первым |
Сервер слушает порт 502 и отвечает на любой Unit ID. Одновременно обслуживаются два клиента. Адреса считаются от нуля.
-- Modbus TCP-сервер ввода-вывода на порту 502 (Unit ID любой).
-- Coils 0–1 → каналы 1–2 модуля выходов или реле
-- Discrete inputs 0–N ← уровни входов IO (IO5–IO8 или IO1–IO8)
-- Input registers 0–1 ← время работы в секундах, старшее слово первым
local modbus = require("modbus")
local io = require("odkit.io")
local unit = require("odkit.unit")
local sys = require("zephyr.sys")
local task = require("zephyr.task")
local outputs = unit.find("outputs", "relay") -- необязателен
local terminals = io.list()
local server = assert(modbus.tcp_slave{
port = 502,
coils = 2,
discrete = #terminals,
input = 2,
})
-- Запись клиента в coils сразу передаём модулю.
server:on_write(function(kind, address, count)
if kind ~= "coils" or not outputs then return end
for coil = address, address + count - 1 do
outputs:set(coil + 1, server:get("coils", coil))
end
end)
-- Входы: начальное состояние и подписка на изменения.
local inputs = {}
for position, index in ipairs(terminals) do
local pin = assert(io.open(index))
local address = position - 1
server:set("discrete", address, pin:read())
assert(pin:on_change("both", function(level)
server:set("discrete", address, level == 1)
end, 20))
inputs[#inputs + 1] = pin
end
print("Modbus TCP: порт 502, входов " .. #terminals ..
(outputs and (", выходы в слоте " .. outputs.slot) or ", модуль выходов не найден"))
-- Сервер обслуживает запросы в фоне; здесь обновляем время работы.
while true do
local seconds = sys.uptime().sec
server:set("input", 0, {seconds >> 16 & 0xFFFF, seconds & 0xFFFF})
task.sleep(1000)
end
Проверить обмен можно любой программой Modbus TCP, например mbpoll:
mbpoll -m tcp -0 -1 -t 0 -r 0 -c 2 192.168.1.50 # прочитать coils 0–1
mbpoll -m tcp -0 -t 0 -r 0 192.168.1.50 1 # включить канал 1
mbpoll -m tcp -0 -1 -t 1 -r 0 -c 4 192.168.1.50 # прочитать входы
mbpoll -m tcp -0 -1 -t 3 -r 0 -c 2 192.168.1.50 # время работы
Ключ -0 включает адресацию с нуля, как в таблице выше, -1 выполняет один
опрос вместо непрерывного.
Шлюз Modbus TCP → RTU
С3 опрашивает прибор Modbus RTU на линии RS485 и отдаёт его регистры по Modbus TCP. В отличие от готового шлюза, программа может проверять, пересчитывать и объединять значения нескольких приборов, а запись из сети пропускать только в разрешённые регистры.
| Таблица Modbus TCP | Адреса | Содержимое |
|---|---|---|
| Input registers | 0–9 | holding-регистры 0–9 прибора, обновляются каждые 500 мс |
| Holding registers | 0–9 | запись клиента передаётся в прибор |
| Discrete input | 0 | 1, если прибор ответил на последний опрос |
Прибор — адрес 1, 9600 бит/с, 8N1. Если у вашего прибора другие параметры,
измените DEVICE, baudrate и число регистров COUNT в начале программы.
-- Шлюз Modbus TCP → RTU для одного прибора на RS485 (адрес 1, 9600 8N1).
-- Input registers 0–9 (TCP) ← holding-регистры 0–9 прибора, опрос раз в 500 мс
-- Holding registers 0–9 (TCP) → записываются в прибор, когда их меняет клиент
-- Discrete input 0 (TCP) ← прибор ответил на последний опрос
-- TCP-сервер слушает порт 502. Значения можно проверять и пересчитывать в Lua.
local modbus = require("modbus")
local task = require("zephyr.task")
local DEVICE, COUNT = 1, 10
local rtu = assert(modbus.rtu_master{baudrate = 9600, timeout = 300})
local tcp = assert(modbus.tcp_slave{port = 502, holding = COUNT, input = COUNT, discrete = 1})
local writes = {}
-- Здесь только ставим запись в очередь: линией RS485 владеет задача опроса.
tcp:on_write(function(kind, address, count)
if kind == "holding" then
writes[#writes + 1] = {address, count}
end
end)
while true do
while #writes > 0 do
local address, count = table.unpack(table.remove(writes, 1))
local ok, _, message = rtu:write_registers(DEVICE, address,
tcp:get("holding", address, count))
if not ok then
print("Запись в прибор:", message)
end
end
local values, _, message = rtu:read_holding(DEVICE, 0, COUNT)
tcp:set("discrete", 0, values ~= nil)
if values then
tcp:set("input", 0, values)
else
print("Опрос прибора:", message)
end
task.sleep(500)
end
Запрос Modbus master приостанавливает остальные задачи до ответа прибора или тайм-аута, поэтому тайм-аут 300 мс выбран коротким. Если на линии несколько приборов, опрашивайте их по очереди в том же цикле.
Мост TCP ↔ RS485
Прозрачный мост для приборов со своим протоколом: данные, которые клиент присылает на TCP-порт 4001, передаются в линию RS485, а ответ прибора возвращается этому клиенту. Ответ считается законченным, когда в линии 30 мс нет данных.
Мост рассчитан на обмен «запрос — ответ»: данные, которые прибор передаёт сам, без запроса, клиенту не пересылаются. Одновременно подключаются два клиента; неактивное соединение закрывается через 5 минут.
-- Мост TCP ↔ RS485 для обмена «запрос — ответ».
-- Данные клиента с TCP-порта 4001 передаются в линию RS485, ответ прибора
-- возвращается тому же клиенту. Одновременно обслуживаются два клиента.
local net = require("net")
local uart = require("zephyr.uart")
local task = require("zephyr.task")
local PORT = 4001
local BAUDRATE, PARITY = 9600, "none" -- 8 бит данных, 1 стоп-бит
local FIRST_BYTE_MS = 500 -- сколько ждать начала ответа
local GAP_MS = 30 -- пауза, после которой ответ закончен
local rs485 = assert(uart.open("rs485"))
assert(rs485:configure(BAUDRATE, PARITY))
local function send_to_line(data)
for offset = 1, #data, 256 do -- за один вызов — до 256 байт
local ok, _, message = rs485:write(data:sub(offset, offset + 255), 1000)
if not ok then return nil, message end
end
return true
end
local function read_reply()
local parts = {}
local chunk, _, message = rs485:read(256, FIRST_BYTE_MS)
while chunk and #chunk > 0 do
parts[#parts + 1] = chunk
chunk, _, message = rs485:read(256, GAP_MS)
end
if not chunk then print("RS485:", message) end
return table.concat(parts)
end
assert(net.tcpserv.start(PORT, function(ip, data)
rs485:read(256, 0) -- сбросить случайные байты из линии
local ok, message = send_to_line(data)
if not ok then
print("RS485:", message)
return
end
local reply = read_reply()
if #reply > 0 then
net.tcpserv.send(reply, 1000)
end
end, 300)) -- закрыть соединение после 5 минут простоя
print("Мост TCP " .. PORT .. " ↔ RS485 " .. BAUDRATE)
while true do
task.sleep(1000)
end
Подключитесь к мосту программой, которая работает с прибором через TCP или
виртуальный COM-порт поверх TCP, указав адрес С3 и порт 4001. Для проверки
подойдёт nc 192.168.1.50 4001.
Отчёты на HTTP-сервер
Каждые 10 секунд и сразу при изменении любого входа С3 отправляет POST-запрос с JSON:
{"device":"02:83:28:c2:ee:43","uptime":340,"inputs":[0,1,0,1],"lua_memory":16539}
device — MAC-адрес контроллера, uptime — время работы в секундах, inputs
— уровни входов IO по порядку. Если сервер не ответил кодом 200, светится
LED1, а причина выводится в консоль. Адрес сервера задаётся IPv4-адресом:
DNS-имена и HTTPS контроллер не поддерживает.
-- Периодический отчёт на HTTP-сервер: POST с JSON каждые 10 секунд,
-- а также сразу при изменении любого входа.
-- Адрес сервера — только IPv4: DNS и HTTPS в С3 не поддерживаются.
local net = require("net")
local io = require("odkit.io")
local sys = require("zephyr.sys")
local task = require("zephyr.task")
local SERVER, PORT, PATH = "192.168.1.10", 8080, "/c3/report"
local PERIOD_S = 10
local function mac_address()
for _, interface in ipairs(net.stat(true)) do
if interface.interface == "en" then return interface.mac end
end
return "unknown"
end
local device = mac_address()
local inputs, changed = {}, true
for _, index in ipairs(io.list()) do
local pin = assert(io.open(index))
assert(pin:on_change("both", function() changed = true end, 20))
inputs[#inputs + 1] = pin
end
local function report()
local levels = {}
for i, pin in ipairs(inputs) do levels[i] = pin:read() and 1 or 0 end
local body = string.format(
'{"device":"%s","uptime":%d,"inputs":[%s],"lua_memory":%d}',
device, sys.uptime().sec, table.concat(levels, ","), sys.memory().current)
local code, errno, message = net.http.post(SERVER, PATH, "application/json",
nil, body, false, PORT, 3000)
odkit.led_set(odkit.LED1, code ~= 200) -- LED1 светится при ошибке
if code ~= 200 then
print("Отчёт не принят:", code or message)
end
end
-- Расписание в секундах: миллисекунды в 32-битном целом переполнятся через 24 дня.
local next_report = 0
while true do
local now = sys.uptime().sec
if changed or now >= next_report then
changed = false
if net.connected() then report() end
next_report = now + PERIOD_S
end
task.sleep(100)
end
Простой приёмник для проверки на компьютере с Python:
from http.server import BaseHTTPRequestHandler, HTTPServer
class Handler(BaseHTTPRequestHandler):
def do_POST(self):
body = self.rfile.read(int(self.headers["Content-Length"]))
print(self.path, body.decode())
self.send_response(200)
self.end_headers()
HTTPServer(("0.0.0.0", 8080), Handler).serve_forever()
Журнал на microSD
Каждое изменение входов IO записывается в CSV-файл на карте microSD, раз в
минуту добавляется отметка «контроллер работает». Время берётся по SNTP; файлы
разделены по дням, например /SD:/logs/2026-10-30.csv. До синхронизации
времени записи попадают в unsynced.csv с временем от включения.
2026-10-30T10:27:32Z,alive,18620
2026-10-30T10:28:05Z,IO7,1
2026-10-30T10:28:06Z,IO7,0
Время в журнале — UTC. Карту отформатируйте в FAT32 на компьютере. Чтобы забрать журнал, выключите контроллер и прочитайте карту на компьютере.
-- Журнал изменений входов на microSD в CSV-файлах по дням.
-- Время берётся по SNTP; до синхронизации строки помечаются временем работы.
local net = require("net")
local io = require("odkit.io")
local fs = require("zephyr.fs")
local sd = require("zephyr.sd")
local sys = require("zephyr.sys")
local task = require("zephyr.task")
local NTP = {"162.159.200.1", "216.239.35.0"} -- только IPv4-адреса
local DIR = "/SD:/logs"
assert(sd.mount()) -- повторное подключение безопасно
if not fs.stat(DIR) then assert(fs.mkdir(DIR)) end
net.service.sntp.start(table.unpack(NTP))
local function timestamp()
if net.service.sntp.synced() then
return os.date("!%Y-%m-%dT%H:%M:%SZ"), os.date("!%Y-%m-%d")
end
return "uptime+" .. sys.uptime().sec, "unsynced"
end
local queue = {} -- callback только ставит строку в очередь
local function write_queue()
if #queue == 0 then return end
local _, day = timestamp()
local file <close> = assert(fs.open(DIR .. "/" .. day .. ".csv", "a"))
for _, line in ipairs(queue) do
assert(file:write(line .. "\n"))
end
assert(file:sync())
queue = {}
end
local inputs = {}
for _, index in ipairs(io.list()) do
local pin = assert(io.open(index))
assert(pin:on_change("both", function(level)
queue[#queue + 1] = string.format("%s,IO%d,%d", timestamp(), index, level)
end, 20))
inputs[#inputs + 1] = pin
end
queue[#queue + 1] = timestamp() .. ",start,0"
local heartbeat = 0
while true do
heartbeat = heartbeat + 1
if heartbeat >= 600 then -- раз в минуту отметка «контроллер работает»
heartbeat = 0
queue[#queue + 1] = timestamp() .. ",alive," .. sys.memory().current
end
write_queue()
task.sleep(100)
end
Обработчик входа только ставит строку в очередь, а основной цикл записывает её на карту: запись в файл приостанавливает остальные задачи, поэтому её выполняют в одном месте и пачкой.
Счётчик импульсов
Программа считает импульсы на IO7 — от счётчика воды, электроэнергии или датчика оборотов с логическим выходом — и сохраняет значение во встроенной памяти. После выключения питания счёт продолжается с сохранённого значения.
Значение записывается в FlashDB раз в 10 секунд и только если оно изменилось: частая запись изнашивает память и задерживает другие задачи. При внезапном отключении питания теряются импульсы за последние 10 секунд. Первый запуск занимает несколько секунд: контроллер создаёт базу.
-- Счётчик импульсов на IO7, который сохраняется после выключения питания.
-- Значение пишется в FlashDB не на каждый импульс, а раз в 10 секунд,
-- если счётчик изменился: так память не изнашивается частой записью.
local flashdb = require("flashdb")
local io = require("odkit.io")
local task = require("zephyr.task")
local INPUT_IO = 7
local SAVE_PERIOD_MS = 10000
local db = assert(flashdb.open_kv("counter", "/lfs/db/counter", 16384))
local stored = db:get("pulses")
local pulses = stored and string.unpack("<i4", stored) or 0
local saved = pulses
print("Импульсов сохранено: " .. pulses)
local input = assert(io.open(INPUT_IO))
assert(input:on_change("rising", function()
pulses = pulses + 1
end, 5)) -- импульсы короче 5 мс считаются помехой
while true do
task.sleep(SAVE_PERIOD_MS)
if pulses ~= saved then
local ok, message = db:set("pulses", string.pack("<i4", pulses))
if ok then
saved = pulses
print("Импульсов: " .. pulses)
else
print("FlashDB:", message)
end
end
end
Входы опрашиваются примерно каждые 2 мс, поэтому пример подходит для импульсов длительностью от 5 мс и частотой до нескольких десятков герц.
События входов по OSC
Изменение любого входа IO отправляется сообщением Open Sound Control по UDP:
адрес /c3/io/7, целый аргумент 1 или 0. Раз в 5 секунд приходит сообщение
/c3/alive. Так кнопки и датчики подключаются к TouchDesigner, Resolume, QLab,
Max/MSP и другим программам для шоу и инсталляций.
-- Изменения входов IO отправляются по OSC (UDP) в медиасервер или
-- программу управления шоу: адрес /c3/io/<номер>, аргумент — уровень 0 или 1.
local net = require("net")
local osc = require("osc")
local io = require("odkit.io")
local task = require("zephyr.task")
local HOST, PORT = "192.168.1.20", 8000 -- только IPv4-адрес получателя
local inputs = {}
for _, index in ipairs(io.list()) do
local pin = assert(io.open(index))
assert(pin:on_change("both", function(level)
net.udp.sendto(HOST, PORT, osc.make("/c3/io/" .. index, "i", level))
end, 20))
inputs[#inputs + 1] = pin
end
-- Раз в 5 секунд — сообщение о том, что контроллер на связи.
while true do
net.udp.sendto(HOST, PORT, osc.make("/c3/alive", "T"))
task.sleep(5000)
end
UDP не подтверждает доставку. Если получатель должен знать текущее состояние после своего перезапуска, добавьте в периодическое сообщение уровни всех входов.
Адресная лента
Бегущая радуга на ленте WS2812B из 30 светодиодов, подключённой к IO5. Яркость ограничена 20 %, чтобы снизить ток ленты.
Подключите вход ленты DIN к IO5, а землю ленты — к GND контроллера. Ленту питайте от отдельного источника подходящего напряжения. Для длинного провода от контроллера до ленты нужен внешний буфер сигнала.
-- Бегущая радуга на адресной ленте WS2812B, подключённой к IO5.
-- Ленту питайте от отдельного источника и объедините её землю с GND С3.
local neopixel = require("neopixel")
local task = require("zephyr.task")
local IO, PIXELS = 5, 30
local strip = assert(neopixel.attach(neopixel.WS2812B, IO, PIXELS))
assert(strip:setBrightness(0.2)) -- 20 % яркости: меньше ток ленты
for i = 0, PIXELS - 1 do
local r, g, b = neopixel.hsvToRgb(i / PIXELS, 1, 1)
assert(strip:setPixel(i, r, g, b))
end
assert(strip:update())
while true do
assert(strip:shift(true, true)) -- сдвиг на один пиксель и вывод кадра
task.sleep(50)
end
Для ленты WS2811 замените тип на neopixel.WS2811; если цвета перепутаны,
передайте порядок четвёртым аргументом, например "GRB". Все функции —
в справочнике neopixel.
Доступ на несколько считывателей ODRFID-RS485
С3 опрашивает несколько считывателей ODRFID-RS485 на одной линии RS485 и работает контроллером доступа: проверяет UID по списку разрешённых, включает на 3 секунды реле нужной двери и отправляет каждое касание на сервер по UDP. Считыватель, у которого нет своего канала реле, только регистрирует проходы.
{"door":"Вход","uid":"04A1B2C3","allowed":true}
Подготовка:
- Задайте каждому считывателю уникальный адрес Modbus командой
AT+[— см. инструкцию ODRFID-RS485. По умолчанию у всех считывателей адрес0x5Fи скорость 115200 бит/с. - Соедините считыватели и С3 одной линией RS485 и установите оконечные резисторы на концах линии.
- Загрузите библиотеку в раздел «Файлы»:
odrfid.lua — в каталог
/lfs/lua, at.lua — в/lfs/lua/odrfid. - Впишите в программу адреса считывателей в
DOORS, разрешённые UID вALLOWEDи адрес сервера.
-- Контроллер доступа на несколько считывателей ODRFID-RS485 на одной линии RS485.
-- Разрешённая метка у любой двери включает реле этой двери на 3 секунды.
-- Каждое касание отправляется на сервер по UDP строкой JSON.
-- Нужны библиотеки /lfs/lua/odrfid.lua и /lfs/lua/odrfid/at.lua,
-- у каждого считывателя — свой адрес Modbus.
local modbus = require("modbus")
local odrfid = require("odrfid")
local net = require("net")
local unit = require("odkit.unit")
local timer = require("zephyr.timer")
local task = require("zephyr.task")
local SERVER, PORT = "192.168.1.10", 9000 -- получатель событий, только IPv4
local OPEN_MS = 3000
local DOORS = {
{unit = 1, name = "Вход", channel = 1},
{unit = 2, name = "Склад", channel = 2},
{unit = 3, name = "Выход", channel = nil}, -- только регистрация
}
-- Разрешённые UID. Для большой базы используйте FlashDB.
local ALLOWED = {
["04A1B2C3"] = "Иванов",
["2B7F10E4"] = "Петрова",
}
local relay = unit.find("relay", "outputs") -- реле или транзисторные выходы
-- Один master на всю линию. Короткий тайм-аут: пока считыватель не ответил,
-- остальные задачи ждут.
local bus = assert(modbus.rtu_master{baudrate = 115200, timeout = 100})
local function open_door(door)
if not (relay and door.channel) then return end
relay:set(door.channel, true)
timer.after(OPEN_MS, function()
relay:set(door.channel, false)
end)
end
local function report(door, uid, person)
local event = string.format('{"door":"%s","uid":"%s","allowed":%s}',
door.name, uid, person and "true" or "false")
net.udp.sendto(SERVER, PORT, event)
end
local at = require("odrfid.at")
for _, door in ipairs(DOORS) do
local reader = assert(odrfid.open{master = bus, unit = door.unit, retries = 0})
-- Автоматическое сканирование до перезагрузки считывателя (AT+P сохраняет).
if not at(reader, "AT+SCAN1") then
print(door.name .. ": считыватель не отвечает")
end
local failed = false
reader:watch{
interval = 100,
on_tag = function(uid)
failed = false
local person = ALLOWED[uid]
print(door.name, uid, person or "нет доступа")
if person then open_door(door) end
report(door, uid, person)
end,
on_error = function(_, message)
if not failed then print(door.name .. ": " .. message) end
failed = true
end,
}
door.reader = reader
end
package.loaded["odrfid.at"] = nil -- AT-команды больше не нужны
at = nil
while true do
task.sleep(60000)
end
Все считыватели опрашиваются через один Modbus master. Пока считыватель не
ответил, остальные задачи ждут, поэтому тайм-аут ответа выбран коротким —
100 мс; исправный ODRFID-RS485 отвечает быстрее. Неисправный или отключённый
считыватель замедляет опрос остальных: следите за сообщениями об ошибках в
консоли. Для большого списка пропусков храните UID в
FlashDB, а не в таблице программы.
Функции библиотеки описаны в справочнике odrfid.