Перейти к содержанию
С3: примеры программ на Lua

С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

Скачать input-to-output.lua

Кнопки управляют реле

Кнопка 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))

-- Подписка работает и после завершения основной программы.

Скачать buttons-relay.lua

Датчики 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

Скачать analog-sensors.lua

Экран состояния

Дисплей показывает 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

Скачать display-status.lua

Модуль ввода-вывода Modbus TCP

С3 работает модулем ввода-вывода для SCADA, ПЛК или OPC-сервера. Клиент Modbus TCP читает входы IO и время работы, а записью в coils включает каналы модуля выходов или реле.

Таблица ModbusАдресаСодержимое
Coils, функции 1, 5, 150–1каналы 1–2 модуля выходов или реле
Discrete inputs, функция 20–3 или 0–7уровни IO5–IO8 или IO1–IO8 по порядку
Input registers, функция 40–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-io.lua

Проверить обмен можно любой программой 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 registers0–9holding-регистры 0–9 прибора, обновляются каждые 500 мс
Holding registers0–9запись клиента передаётся в прибор
Discrete input01, если прибор ответил на последний опрос

Прибор — адрес 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-gateway.lua

Запрос 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-rs485-bridge.lua

Подключитесь к мосту программой, которая работает с прибором через 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

Скачать http-report.lua

Простой приёмник для проверки на компьютере с 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

Скачать sd-logger.lua

Обработчик входа только ставит строку в очередь, а основной цикл записывает её на карту: запись в файл приостанавливает остальные задачи, поэтому её выполняют в одном месте и пачкой.

Счётчик импульсов

Программа считает импульсы на 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

Скачать pulse-counter.lua

Входы опрашиваются примерно каждые 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

Скачать osc-inputs.lua

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

Скачать neopixel-rainbow.lua

Для ленты WS2811 замените тип на neopixel.WS2811; если цвета перепутаны, передайте порядок четвёртым аргументом, например "GRB". Все функции — в справочнике neopixel.

Доступ на несколько считывателей ODRFID-RS485

С3 опрашивает несколько считывателей ODRFID-RS485 на одной линии RS485 и работает контроллером доступа: проверяет UID по списку разрешённых, включает на 3 секунды реле нужной двери и отправляет каждое касание на сервер по UDP. Считыватель, у которого нет своего канала реле, только регистрирует проходы.

{"door":"Вход","uid":"04A1B2C3","allowed":true}

Подготовка:

  1. Задайте каждому считывателю уникальный адрес Modbus командой AT+[ — см. инструкцию ODRFID-RS485. По умолчанию у всех считывателей адрес 0x5F и скорость 115200 бит/с.
  2. Соедините считыватели и С3 одной линией RS485 и установите оконечные резисторы на концах линии.
  3. Загрузите библиотеку в раздел «Файлы»: odrfid.lua — в каталог /lfs/lua, at.lua — в /lfs/lua/odrfid.
  4. Впишите в программу адреса считывателей в 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

Скачать odrfid-readers.lua

Все считыватели опрашиваются через один Modbus master. Пока считыватель не ответил, остальные задачи ждут, поэтому тайм-аут ответа выбран коротким — 100 мс; исправный ODRFID-RS485 отвечает быстрее. Неисправный или отключённый считыватель замедляет опрос остальных: следите за сообщениями об ошибках в консоли. Для большого списка пропусков храните UID в FlashDB, а не в таблице программы. Функции библиотеки описаны в справочнике odrfid.