Как изменить луа скрипты

• Для быстрого поиска существующего файла в консоли введите первые символы и жмите TAB, например edit i [TAB] —> edit /init.lua
• Для удаления всей строки нажмите CTRL+DELETE

• Notepad++
  Стандарт скриптовика. Прост и легок в обращении. Плюсы — малый размер, куча плагинов и расширений. Лучшее средство для начинающего программиста Lua.
• Sublime Text
  Более продвинутый инструмент. Плюсы — расширенный интерфейс, выбор из разнообразных тем, поддержка плагинов, включая подсветку ошибок при написании кода.
  Сам пользуюсь этим редактором на компе, расширив плагинами Corona Editor, Lua Love, Sublime Linter — lua
• SciTE, Atom
  Для хипстеров. По функционалу такие же как выше.

• Пишете код в редакторе
• Вставляете его на Pastebin
• Вписываете код для запуска в игре (заменив XXXXXX на код пасты):
• pastebin get XXXXXX name

— Через облачное хранилище с прямыми ссылками:

• Сохраняйте и работайте с файлами прямо в папке облачного хранилища, с возможностью доступа по прямым ссылкам.
  Например, в дропбоксе это папка Public (в новых аккаунтах ее нет)
• Загружайте обновленные файлы на ОС компьютер через интернет-плату программой wget, получив прямую ссылку на файл, например:

  wget -f https://dl.dropboxusercontent.com/u/12345678/file.lua

• Для удобства вы можете написать короткую программу, которая при нажатии клавиши, например F5, будет выполнять такую загрузку автоматически

• ZeroBrane Studio 
  Суперлегкая (у меня занимает 17мб оперативки) и быстрая кроссплатформенная IDE. Визуальные темы, мониторинг переменных, выделение локальных и глобальных переменных, проверка на неиспользуемые переменные и прочие ништяки.
• Lua Development Tools
  Преимуществ от ZeroBrane практически нет, скорее минусы в роде отсутствие темной темы и требовательности к оперативке.
• Cloud 9
  Облачное браузерное IDE.
  По стандарту отсутствует отладка. Ее нужно устанавливать в проект самостоятельно.
  Плюс — вам не нужно ничего устанавливать на компьютер. Но самое приятное, что к каждому файлу в этой IDE можно обратиться по постоянной прямой ссылке, что крайне упрощает заливку файла в игру. Так же, вы можете раздавать ссылку на проект другим и совместно редактировать код.

Сам я использую Sublime для быстрого редактирования файлов, LDT для больших проектов на стадии написания кода, Cloud9 для совместных проектов с другими программистами, и для отладки текущих проектов в игре.
О ZeroBrane Studio узнал совсем недавно, поэтому планирую перейти на нее в ближайшее время, что и другим советую.

How to create and run as well as manage Lua scripts

Jump to:

• To run a Lua script
• To run a Lua script when launching Netfabb
• To add a Lua script to the library
• Editing a Lua script
• Using the debugger

How to create and run as well as manage Lua scripts

Jump to:

• To run a Lua script
• To run a Lua script when launching Netfabb
• To add a Lua script to the library
• Editing a Lua script
• Using the debugger

Одной из отличительных особенностей всех продуктов комплекса НЕЙРОСС и, в частности, IP-контроллеров БОРЕЙ, ЯРС v.1 (снят с производства!) и других является возможность модификации и расширения алгоритмов работы продукта посредством скриптов автоматизации. С помощью скрипта возможно, например, изменить или полностью заменить алгоритм доступа в контроллере БОРЕЙ. Или реализовать логику сопряжения со внешней информационной системой по протоколу HTTP. Или управлять исполнительными устройствами по заданному алгоритму.

В данном документе приведены общие сведения о скриптах автоматизации, их возможностях и руководство программиста по написанию таких скриптов.

Оглавление

Общие сведения

Скрипт автоматизации — текстовый сценарий, выполнение которого осуществляется программными средствами продукта.

Данный сценарий всегда один. Он может быть пустым — в таком случае скрипт не делает ничего. В скрипте могут быть команды управления — они выполняются по мере выполнения скрипта.

Скрипт автоматизации должен быть написан на языке Lua (версия 5.1). Разработчику доступны стандартные средства языка (операторы, структуры данных и др.), часть функций стандартной библиотеки (см. далее), а также наборы констант и функций, определённых в прикладных Lua-модулях продукта. Прикладные Lua-модули специально разработаны для упрощения написания скриптов и двустороннего взаимодействия с программными средствами продукта — чтобы можно было из скрипта вызывать какие-либо функции продукта или, наоборот, передавать управление в скрипт в процессе функционирования продукта.

Скрипт автоматизации выполняется в «песочнице» — защищённом окружении. Если в ходе работы скрипта возникает ошибка, то выполнение скрипта просто прерывается — нарушается работа функций, так или иначе связанных со скриптами (например, алгоритмов доступа), НО общая работоспособность продукта сохраняется, на стабильность работы программных средств поведение скрипта не влияет.

Как редактировать скрипт

Для удобство редактирования и отладки скрипта автоматизации предназначен текстовый online-редактор, доступный в наших продуктах по адресу http://[ip-address]/lua-editor/ или http://[ip-address]/internal/lua-editor/.

1. В левом блоке — текст скрипта автоматизации. Внесите в него изменения, для сохранения нажмите на кнопку «Сохранить» внизу.
2. В правом блоке можно просматривать lua-код модулей и сниппеты — примеры скриптов автоматизации. Для просмотра сниппета или модуля выберите его в раскрывающемся списке под правым блоком.
   1. Lua-код модулей обычно содержит определение констант, структур, функций, а также обеспечивает удобную для разработчика «обёртку» на доступными функциями основных программных средств.
      ЗАМЕЧАНИЕ: в списке обычно можно посмотреть Lua-код всех модулей всех продуктов, их можно подключить к скрипту автоматизации, но фактически «отсутствующий» модуль просто не будет работать.
   2. Сниппеты — блоки кода, из которых можно почерпнуть идеи при разработке скрипта. Или можно скопировать «куски» сниппета в свой скрипт. Библиотека сниппетов постоянно пополняется разработчиками с добавлением примеров создания скриптов автоматизации.
3. При сохранении скрипта автоматизации выполнение текущего скрипта будет автоматически прервано. После чего будет запущен новый скрипт.

Скриншот редактора скриптов приведён на изображении ниже.

Как отлаживать скрипт

Сообщения об ошибках в Lua-скрипте, а также отладочные сообщения, выводимые из скрипта с помощью модуля log.lua, записываются в журнал аудита. Просмотр этих сообщений в реальном времени возможен при помощи веб-приложения «Журнал аудита», доступного с веб-страницы Рабочий стол.

1. Авторизуйтесь в веб-интерфейсе и перейдите на Рабочий стол.
2. Перейдите в веб-приложение «Журнал аудита».
3. На второй вкладке «Фильтры» выберите в списке логгер web.
4. В настройках фильтрации укажите следующие строки (первая строка:
   1. * — OFF
   2. LuaManager — DEBUG
   3. lua_scall — DEBUG
   4. neyross::LogLuaModule — DEBUG
5. Пример корректно настроенного логгера:
   
6. Перейдите на третью вкладку «Живой журнал».
7. Установите флаги DEBUG, INFO, WARN, ERROR для вывода сообщений всех возможностей уровней тревожности.
   
8. При выполнении Lua-скрипта на странице будут появляться соответствующие сообщения. Более свежие сообщения выводятся сверху.
   

Руководство разработчика

Общие сведения о Lua

Скрипт автоматизации должен быть написан на языке Lua версии 5.1.

Официальный сайт языка Lua (на английском языке) — http://www.lua.org/

Официальная документация по языку Lua версии 5.1 — http://www.lua.org/manual/5.1/ (английский язык)

Перевод документации по языку Lua версии 5.1 на русский язык: http://www.lua.ru/doc/

Также можно ознакомиться с документацией на русском языке для последней актуальной версии Lua (5.3 на момент написания статьи) по ссылке http://lua.org.ru/contents_ru.html. Большая часть содержимого также актуальна и для версии 5.1, поддерживаемой продуктами НЕЙРОСС.

Ограничения стандартной библиотеки

В скриптах автоматизации доступны следующие разделы стандартной библиотеки:

• Basic Functions
• Coroutine Manipulation
• Modules
• String Manipulation
• Table Manipulation
• Mathematical Functions

Следующие разделы недоступны (не могут быть использованы) в скрипте автоматизации:

• Input and Output Facilities
• Operating System Facilities

Прикладные Lua-модули

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

Подключение прикладного Lua-модуля осуществляется функцией require. Рекомендуемая форма использования:

local log = require("log")

Вызвать функцию Lua-модуля в таком случае можно следующим образом, например:

local logger = log.get_logger("MyLogger")

alarm.lua

Описание временно недоступно.

common.lua

Данный модуль предоставляет общесистемные функции. Перечень функций приведён в таблице ниже.

deviceio.lua

Описание временно недоступно.

fec.lua

Данный модуль позволяет управлять выходами (на плате контроллера БОРЕЙ, ЯРС, а также на модулях расширения АМ-06) и световой / звуковой индикацией подключенных к контроллеру считывателей.

В перечислении fec.TYPE описаны различные типы периферии. Для управления пригодны типы fec.TYPE.RELE (выход на плате контроллера) и fec.TYPE.SART_RELE (выход на модуле расширения). Для управления выходами следует использовать функцию set_value(тип периферии, ID элемента, состояние), где в первый параметр необходимо передать одно из значений перечисления fec.TYPE, во второй параметр — идентификатор (адрес) элемента для управления, в третий параметр — требуемое состояние (для выходов это 0 = Выключено, 1 = Включено). Например:

local fec = require("fec")
fec.set_value(fec.TYPE.RELE, 1, 1)

В этом примере выполняется включение первого реле на плате контроллера.

Нумерация выходов начинается с 1. Адрес выхода на модуле расширения определяется его адресом на шине.

К контроллеру БОРЕЙ (и ЯРС) можно подключить два считывателя, на плате есть выходы для управления красным, зелёным светодиодами и звуковой индикацией. Управлять светодиодами и бипером можно также с помощью функции set_value. Возможные режимы индикации светодиода определены в перечислении fec.DIOD. Доступно некоторое количество предустановленных режимов различной частоты и скважности. Звуковую индикацию можно только либо включить, либо выключить (см. перичесление fec.BEEPER).

Поскольку управление светодиодной / звуковой индикацией на считывателях осуществляется в рамках алгоритмов доступа и состояние красного, зелёного светодиодов и звука взаимосвязано (если красный светодиод горит, то зелёный погашен и др.) — для удобства управления всей индикацией реализована функция-обёртка fec.set_reader(ID считывателя, зелёный светодиод, красный светодиод, звук). Пример использования функции приведён ниже:

local fec = require("fec")
fec.set_reader(1, fec.DIOD.MODE_OFF, fec.DIOD.MODE_025_025, fec.BEEPER.MODE_OFF)

http.lua

Модуль позволяет отправлять HTTP-запросы прямо из Lua-скрипта, а также асинхронно обрабатывать ответы на отправленные ранее запросы.

Для отправки запроса и обработки ответа необходимо:

1. Определить объект-обработчик ответа (Lua-таблицу) с методом on_http_response(данные ответа).
2. Создать объект-запрос посредством вызова функции-фабрики http.with(объект-обработчик). Функция возвращает создаёт и возвращает объект-запрос.
3. Вызывать на объекте-запросе метод transmit(параметры запроса). Запрос будет отправлен в соответствии с заданными параметрами запроса. По мере получения ответа (или если запрос не удастся) будет асинхронно вызван метод on_http_response у созданного на первом шаге объекта-обработчика.

Ниже приведён пример использования модуля HTTP для отправки GET-запроса на IP-адрес веб-сайта http://example.com.

local log = require("log")
local http = require("http")
local logger = log.get_logger("script.lua")

-- обработчик ответа на HTTP-запрос
local example_handler = {}

-- этот метод обработчика будет вызван при получении ответа на запрос
function example_handler:on_http_response(response_data)
  if response_data == nil then
    logger:error("connection has failed; no response received")
  else
    logger:debug("response received; status="..response_data.status..", type(body)="..type(response_data.body))
  end
end
 
-- параметры запроса
local http_request = {
  url = "http://93.184.216.34",  -- адрес http://example.com
  method = http.METHOD.GET,
  version = http.VERSION.HTTP10,
  timeout = 5000
}

-- отправка HTTP-запроса
logger:debug("querying http://example.com")
http.with(example_handler):transmit(http_request)

В параметрах запроса можно указать следующие данные:

• method — используемый HTTP-метод, значение из перечисления http.METHOD; значение по умолчанию http.METHOD.GET;
• version — используемая версия протокола HTTP, значение из перечисления http.VERSION; значение по умолчанию http.VERSION.HTTP11;
• url — целевой адрес / URL запрашиваемого ресурса, обязательный параметр;
• timeout — таймаут ожидания ответа / сетевого соединения, в миллисекундах; по умолчанию 13000 (13 секунд);
• header — таблица HTTP-заголовков (см. далее);
• body — тело запроса (см. далее).

Заголовки HTTP-запроса

Можно указать произвольные заголовки HTTP-запроса в форме Lua-таблицы со строковыми парами типа «ключ = значение». При этом «ключ» будет выступать в роли имени HTTP-заголовка, а «значение» — в роли значения HTTP-заголовка.

Пример:

-- параметры запроса
local http_request = {
  url = "http://93.184.216.34",
  method = http.METHOD.GET,
  version = http.VERSION.HTTP10,
  timeout = 5000
}
 
http_request.header = {}
http_request.header["X-Extra-Header"] = "my extra header value"

Тело HTTP-запроса

Модуль позволяет отправлять в HTTP-запросах (PUT или POST) данные в форме текста или JSON.

Для передачи запроса с телом в форме текста достаточно присвоить параметру запроса body соответствующее строковое значение. Например:

local http_request = {
  url = "http://10.1.30.3:8080/myservice",
  method = http.METHOD.POST,
  body = "<a>hello XML</a>"
}
http_request.header = {}
http_request.header["Content-Type"] = "text/xml; charset=UTF-8"

Модуль также позволяет передавать запрос с телом в форме JSON-документа, который автоматически формируется из Lua-таблицы. Например:

local http_request = {
  url = "http://10.1.30.3:8080/myservice",
  method = http.METHOD.POST
}
http_request.body = {
  myParam = "A",
  wowThisIsSubTable = {}
}
http_request.body["ohNumberHere"] = 42
http_request.body.wowThisIsSubTable["robot"] = "kill all human"

При отправке запроса с такими параметрами HTTP-заголовок Content-Type будет автоматически установлен в application/json, а тело запроса будет содержать следующий JSON-документ:

{
  "myParam": "A",
  "ohNumberHere": 42,
  "wowThisIsSubTable": { "robot": "kill all human" }
}

Обработка ответа

При поступлении ответа или сбое при отправке запроса асинхронно вызывается метод on_http_response(response_data) на объекте-обработчике. Параметр метода — это Lua-таблица, содержащая следующие данные:

• status — код HTTP-ответа, число в соответствии со спецификацией [https://ru.wikipedia.org/wiki/Список_кодов_состояния_HTTP];
• header — HTTP-заголовки ответа в форме Lua-таблицы (аналогично HTTP-заголовкам запроса);
• body — тело ответа.

Если отправка запроса не удалась и ответ не был получен, то аргумент метода равен nil.

Тело ответа в зависимости от Content-Type может быть либо Lua-таблицей (если Content-Type ответа равен application/json — тело автоматически преобразуется в Lua-таблицу), либо текстом / строкой (в остальных случаях).

ignis.lua

Описание временно недоступно.

log.lua

Модуль позволяет выводить текстовые сообщения в журнал аудита.

Для вывода сообщений разработчику необходимо:

1. Подключить модуль log.lua в скрипт автоматизации командой require.
2. Создать объект-логгер с заданным именем, вызвав функцию log.get_logger(имя-логгера).
3. В требуемом месте скрипта вывести сообщение в журнал аудита с заданным уровнем «тревожности», вызвав один из методов trace, debug, info, warn или error у объекта-логгера.

Пример приведён ниже:

local log = require("log")
local logger = log.get_logger("MyLogger")
 
local answer = 42
logger:debug("The answer is "..tostring(answer))

Обратите внимание:

1. В журнал аудита сообщения выводятся от имени компонента программных средств neyross::LogLuaModule, а потому в настройки журнала аудита следует добавить соответствующий фильтр, например: neyross::LogLuaModule | DEBUG.
2. Имя объекта-логгера также выводится в журнале аудита перед заданным текстовым сообщением. В скрипте автоматизации можно создать и использовать любое количество объектов-логгеров с разными именами. Это позволяет различить сообщения в журнале аудита от разных логических разделов скрипта автоматизации.
3. В журнале аудита для каждой записи также выводится имя функции (если таковая есть), в которой вызван объект-логгер и номер соответствующей строки в скрипте, что ещё более упрощает понимание — к какой части скрипта относится соответствующее сообщение в журнале аудита.
4. Различные методы объекта-логгера выводят в журнал сообщения с разным уровнем «тревожности». Доступны следующие методы и уровни по приоритетам (от низкого / неважного до высокого / тревожного):
   1. trace (только для отладочного режима, в журнал не попадают никогда);
   2. debug (отладочные сообщения);
   3. info (информационные сообщения);
   4. warn (сообщения-предупреждения);
   5. error (сообщения об ошибках).
5. Методы объекта-логгера принимают на вход один строковой параметр. Для формирования строки из нескольких параметров используйте оператор конкатенации строк .. и функцию приведения нестроковых типов к строке tostring из стандартной библиотеки.

longate.lua

Описание временно недоступно.

loninput.lua

Модуль предоставляет API для мониторинга состояния входов (зон) на модулях расширения ЯРС.

loninput.lua позволяет «подписаться» на изменения состояния входов. Для управления «подписчиками» в модуле доступны следующие функции:

Каждый объект-подписчик должен быть представлен Lua-таблицей с функцией on_loninput_input_state_changed(device_address, input_index, raw_state, logical_state).

Данная функция будет вызвана:

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

В функцию on_loninput_input_state_changed передаются следующие параметры:

Логическое состояние входа может быть следующим:

• 0 (LOGICAL_INPUT_STATE.UNKNOWN) — значение не известно;
• 1 (LOGICAL_INPUT_STATE.OFF) — вход выключен, нормальное состояние (логический 0);
• 2 (LOGICAL_INPUT_STATE.ON) — вход включен, тревожное состояние (логическая 1).

lonpacs.lua

Модуль предоставляет API для интеграции с подсистемой доступа модулей расширения ЯРС, таких как МДС и М2. Модуль позволяет модифицировать стандартные алгоритмы доступа.

Получить список точек доступа с их идентификаторами можно через поле lonpacs.ap_instance, которое заполняется при инициализации модуля и виртуальной Lua-машины (до того, как будет выполняться пользовательский Lua-скрипт). Поле lonpacs.ap_instance содержит Lua-таблицу, в которой ключами являются токены точек доступа, а значениями — Lua-таблицы с системными параметрами точек доступа. Структура таблицы представлена в коде ниже:

lonpacs.ap = {
  "токен первой точки доступа" = {
    ...
  },
  "токен второй точки доступа" = {
    ...
  },
  ... -- и так далее
}

Каждая точка доступа в списке — это либо точка доступа модуля расширения МДС, либо одна из точек доступа М2.

Управление точкой доступа

Для управления точками доступа на модулях расширения доступна функция transmit_status(token, status), которая позволяет отправлять модулям команды управления. Функция принимает следующие параметры:

Для управления точкам доступа доступны следующие команды (значения параметра status):

Состояние точки доступа

Модуль lonpacs.lua позволяет «подписаться» на события изменения состояния точек доступа, мониторинга связи с точками доступа, изменения состояния прохода (фазы алгоритма прохода). Для управления «подписчиками» в модуле доступны следующие функции:

Каждый объект-подписчик должен быть представлен Lua-таблицей со следующими функциями:

Параметр ap_status может принимать одно из следующих значений:

ap_status определяет интегральное состояние составляющих точку доступа элементов (замок, дверной контакт). Для получения состояния этих элементов нужно использовать функцию lonpacs.parse_ap_status(ap_status). 

Функция parse_ap_status возвращает Lua-таблицу следующего вида:

{
  door_state = ..
  lock_state = ..
  mode = ..
  alarm = ..
}

где значение полей таблицы следующее:

Значение кода состояния алгоритма прохода (фазы прохода) status, полученного в функции lonpacs_on_pass_status_changed(token, status, notify_key), может принимать одно из следующих значений:

pacs.lua

Модуль предоставляет API для интеграции с подсистемой доступа (только для контроллеров БОРЕЙ и ЯРС). Модуль позволяет либо модифицировать стандартные алгоритмы доступа, либо реализовать собственный алгоритм.

Общие сведения

Подсистема доступа в контроллерах БОРЕЙ, ЯРС поддерживает две точки доступа (поддержка дополнительных точек доступа на модулях расширения ЯРС осуществляется в Lua-модуле lonpacs.lua). Соответственно, первый считыватель относится к первой точке доступа, а второй — ко второй. У каждой точки доступа есть строковой уникальный идентификатор, называемый токеном.

Получить список точек доступа с их идентификаторами можно через поле pacs.ap, которое заполняется при инициализации модуля и виртуальной Lua-машины (до того, как будет выполняться пользовательский Lua-скрипт). Поле pacs.ap содержит Lua-таблицу, в которой ключами являются токены точек доступа, а значениями — Lua-таблицы с системными параметрами точек доступа. Структура таблицы представлена в коде ниже:

pacs.ap = {
  "токен первой точки доступа" = {
    "#" = 0,
    ...
  },
  "токен второй точки доступа" = {
    "#" = 1,
    ...
  }
}

Соответственно, для перебора точек доступа (например, чтобы для каждой точки доступа проинциализировать свой алгоритм) удобно использовать следующий код:

for key,item in pairs(pacs.ap) do
  if item["#"] == 0 or item["#"] == 1 then
    -- код обработки точки доступа с токеном = key
  else
    logger:error("unexpected access point number; #="..item["#"].."; token="..key)
  end
end

В контроллере БОРЕЙ точек доступа всегда ровно две, с номерами 0 и 1. Точка доступа с номером 0 (у которой значение свойства pacs.ap["токен"]["#"] равно 0 — это первая точка доступа), точка доступа с номером 1 — вторая.

В настройках доступа у контроллера можно выбрать «Режим работы» — «Две односторонние», «Одна двусторонняя», «Пользовательский». В стандартных режимах работы «Две односторонние» и «Одна двусторонняя» программные средства самостоятельно реализуют алгоритм доступа, таблицы параметров (pacs.ap["токен"]) содержат параметры, которые пользователь может изменить через веб-приложение. В режиме «Пользовательский» таблицы параметров по умолчанию обычно пусты.

Управление состоянием точки доступа, а также режимом её работы (начало транзакции доступа, завершение транзакции и так далее) осуществляется из Lua-скрипта. Соответствующие функции описаны в разделе «Управление точкой доступа».

В каждый момент времени состояние точки доступа описывается N-мерным вектором:

Точки доступа поддерживают внешние команды управления блокировки, разблокировки, восстановления режима, включения / отключения, разрешения и подтверждения доступа. При обработке таких команд программные средства передают управление в Lua-скрипт. Также при предъявлении идентификатора, изменении состояния периферии (входов), выполенении внешних команд над точками доступа и т.д. подсистема доступа передаёт управление в Lua-скрипт. Пользователь может запрограммировать реакцию на соответствующие события с помощью функций-обработчиков (см. раздел «Функции-обработчики»).

Через каждую точку доступа в один момент времени может осуществляться одна транзакция доступа. Транзакция доступа — это процесс, который начинается с момента идентификации доступа, и завершается при возврате точки доступа в начальное состояние. В случае удержания двери транзакция доступа продолжается.

Транзакция доступа начинается либо вызовом pacs.authenticate в случае разрешения доступа, либо по вызову pacs_grant (для случая анонимного доступа). Завершается транзакция по вызову pacs_reset. Соответствующие функции описаны в разделе «Управление точкой доступа».

В процессе транзакции сохраняются идентификационные признаки посетителя и прочая информация, эти данные подставляются во все извещения, формируемые контроллером.

Часть извещений (в основном о запрещении доступа) формируются программными средствами. Пользователь также может в любой момент времени отправить извещение из Lua-скрипта с помощью функции pacs_notify, с указанием кода извещения. Для отправки доступно более полусотни извещений. Полный список доступных для отправки извещений приведён в документации на HTTP-API контроллера в части СКУД.

Изменение системных параметров

В режиме доступа «Пользовательский» для реализации алгоритма может потребоваться задать из Lua-скрипта для каждой точки доступа системные параметры. Для указания параметров из Lua-скрипта предназначена функция pacs.set_configuration(token, {...}), в первом аргументе необходимо передать токен точки доступа, во втором аргументе — Lua-таблицу с параметрами. Например:

for key,item in pairs(pacs.ap) do
  local configuration = {}
  configuration["input.mode"] = "card"
  pacs.set_configuration(key, configuration)
end

Ниже приведены основные системные параметры, которые можно / нужно настраивать:

Функции-обработчики

Модуль позволяет разработчику определить глобальные Lua-функции с заданными именами. Такие функции-обработчики будут вызваны программными средствами контроллера по мере выполнения функций доступа.

function pacs_reader_input(token, data)
  -- тело функции
end

local pacs_reader_input = function(token, data)
  -- функция не будет вызвана
end

Ниже приведён список доступных для определения функций-обработчиков:

{
  "facility_code" = "123",
  "card_number" = "12345",
  "pincode" = "12345"
}

{
  "use_extended_time" = true,
  "access_time_duration" = число (unix-timestamp),
  "open_too_long_time_duration" = число (unix-timestamp),
  "pre_alarm_time_duration" = число (unix-timestamp)
}

Изменение состояния периферии

При изменении состояния какого-либо элемента периферии (обычно, это различные входы) вызывается функция-обработчик pacs_input. Ниже приведён Lua-код, который позволит в зависимости от типа элемента периферии получить его логическое состояние.

local fec = require("fec")
 
-- Логическое состояние элемента
local VALUE = {
	OFF     = 0,
	ON      = 1,
	SHORT   = 2,
	BROKEN  = 3
}
 
-- Получение логического состояния для элемента типа «Сухой контакт»
function get_dry_contact_value(raw, invert)
    if raw == 1 then
        if invert then
            return VALUE.OFF
        else
            return VALUE.ON
        end
    else
        if invert then
            return VALUE.ON
        else
            return VALUE.OFF
        end
    end
end
 
-- Получение логического состояния для элемента типа «Резистивный шлейф»
function get_rin_value(raw,invert)
	if raw <= 17 then -- эмпирический порог резистивного шлейфа
		if invert then
			return VALUE.OFF
		else
			return VALUE.ON
		end
	else
		if invert then
			return VALUE.ON
		else
			return VALUE.OFF
		end
	end
end
 
-- Получение логического состояния входов разного типа
-- Дополнительный аргумент invert позволяет обрабатывать настройку вида «нормально-открыт»
function get_input_value(raw, invert, type_)
    if (type_ == fec.TYPE.DRY_CONTACT) then
        return get_dry_contact_value(raw, invert)
    elseif (type_ == fec.TYPE.RADIAL_INPUT) then
        return get_rin_value(raw, invert)
    else
        log_error("invalid type: "..type_)
        return 0
    end
end

Управление точкой доступа

Для управления точкой доступа / транзакцией доступа по выбранной точке доступа предназначены следующие функции:

{
  "facility_code" = "123",
  "card_number" = "12345",
  "pincode" = "12345",
  "transaction_uuid" = "..."
}

{
  "lock" = Unlocked,
  "door" = Open,
  "mode" = Accessed,
  "alarm" = Normal,
}

Поиск в базе данных

Описание временно недоступно.

storage.lua

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

В некоторых случаях может потребоваться сохранять состояние или параметры работы скрипта автоматизации при перезапуске продукта. Или, например, может возникнуть потребность, чтобы определённые параметры были сохранены в резервной копии и восстановлены в случае сбоя файловой системы на IP-контроллере (БОРЕЙ, ЯРС и пр.). Для работы с такими данными и предназначен модуль storage.lua.

Модуль позволяет сохранять в персистентное хранилище Lua-таблицы с данными под заданным именем, а впоследствии извлекать их из хранилища по имени. Таблица с данными может содержать только пары «ключ = значение», где «ключ» это всегда строка, а «значение» может быть строкового, числового или булевого типа.

Для помещения данных в хранилище предназначена функция storage.set(ключ, данные), для сохранения — storage.save(ключ), для извлечения — storage.get(ключ).

Пример использования модуля приведён ниже:

local storage = require("storage")
 
local my_options = storage.get("my_key")
my_options.param1 = "A"
my_options.param2 = 42
storage.save("my_key")
 
local another_options = {
  param1 = "B",
  param2 = 43
}
storage.set("my_key", another_options) -- my_options более не ссылается на объект в хранилище!
storage.save("my_key")

tenso.lua

Описание временно недоступно.

timer.lua

Данный модуль предоставляет для скрипта автоматизации две функции для выполнения отложенных во времени вычислений. Первая функция — это set_timeout. Она предназначена для разового выполнения некоторой Lua-функции спустя заданное количество времени. Вторая функция — set_interval. Она позволяет запланировать выполнение некоторой Lua-функции каждые N миллисекунд. Функция будет выполняться периодически до тех пор, пока задание на выполнение не будет явно отменено (см. clear_interval далее) или Lua-машина не будет перезапущена.

Также модуль предоставляет две функции для отмены запланированных ранее заданий: clear_timeout и clear_interval.

set_timeout

Запланировать вызов указанной Lua-функции спустя заданное количество миллисекунд.

Полная сигнатура функции: set_timeout(имя-функции, длительность, ключ), где

• имя функции — строка, имя Lua-функции для вызова;
• длительность — число, задержка выполнения функции, в миллисекундах;
• ключ — строка, ключ, по которому можно будет понять в Lua-функции, кто и когда запланировал её отложенный вызов.

При вызове set_timeout возвращает уникальный идентификатор созданного задания на отложенное выполнение. Это значение можно использовать в последующем вызове clear_timeout для отмены запланированного ранее задания.

Пример:

local log = require("log")
local logger = log.get_logger("script.lua")
 
local key1_id = set_timeout("my_timeout", 10000, "key1") -- выполнить my_timeout через 20 секунд с key1
local key2_id = set_timeout("my_timeout", 20000, "key2") -- выполнить my_timeout через 20 секунд с key2
 
function my_timeout(key)
  if key == "key1" then
    logger:debug("stopping timeout on key2")
    clear_timeout(key2_id) -- отменяем задание с key2
  elif key == "key2" then
    logger:error("this should be never invoked")
  else
    logger:error("unexpected key="..key)
  end
end

clear_timeout

Функция позволяет отменить ранее запланированное задание: clear_timeout(ID задания), где ID задания — результат выполнения функции set_timeout.

set_interval

Сигнатура налогична set_timeout: set_interval(имя-функции, длительность, ключ), где

• имя функции — строка, имя Lua-функции для вызова;
• интервал — число, период выполнения функции, в миллисекундах;
• ключ — строка, ключ, по которому можно будет понять в Lua-функции, кто и когда запланировал её отложенный вызов.

clear_interval

Аналогично clear_timeout функция позволяет отменить запланированное ранее периодическое задание: clear_interval(ID задания), где ID задания — результат выполнения функции set_interval.

terminal.lua

Описание временно недоступно.

Обратите внимание

Язык Lua различает регистр символов, поэтому abc, Abc, ABC являются различными именами.

В таблице ниже приведены слова, которые зарезервированы языком Lua и не могут использоваться в именах переменных:

and break do else elseif

end false for function if

in local nil not or

repeat return then true until

while

Кроме того, все имена, начинающиеся с символа подчеркивания, за которым идут заглавные буквы (например, _VERSION) также являются зарезервированными.

Какие переменные бывают в Lua?

Переменные в Lua могут быть глобальными и локальными. Если переменная не объявлена явно как локальная, она считается глобальной.

Глобальные переменные Lua

Глобальная переменная появляется в момент присваивания ей первого значения. До присваивания первого значения обращение к глобальной переменной даёт nil.

MsgBox(tostring (g))  —> nil

g = 1

MsgBox(tostring (g))  —> 1

Глобальная переменная существует до тех пор, пока существует среда исполнения скрипта и доступна любому Lua-коду, выполняемому в этой среде.

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

g = 1 — создаем глобальную переменную g со значением 1

…

g = nil — удаляем глобальную переменную g

MsgBox(tostring (g)) —> nil

Все глобальные переменные являются полями обычной таблицы, называемой глобальным окружением. Эта таблица доступна через глобальную переменную _G. Поскольку полями глобального окружения являются все глобальные переменные (включая саму _G), то _G._G == _G.

Локальные переменные Lua

Любые локальные переменные должны быть объявлены явно с использованием ключевого слова local. Объявить локальную переменную можно в любом месте скрипта. Объявление может включать в себя присваивание переменной начального значения. Если значение не присвоено, переменная содержит nil.

local a — объявляем локальную переменную a

local b = 1 — объявляем локальную переменную b, присваиваем ей значение 1

local c, d = 2, 3 — объявляем локальные переменные c и d, присваиваем им значения 2 и 3

Область видимости локальной переменной начинается после объявления и продолжается до конца блока.

Примечание

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

Под блоком понимается:

тело управляющей конструкции (if-then, else, for, while, repeat);

тело функции;

фрагмент кода, заключённый в ключевые слова do…end.

Если локальная переменная определена вне какого-либо блока, её область видимости распространяется до конца скрипта.

a = 5 — глобальная переменная a

local i = 1  — переменная i локальна в пределах скрипта

   while i <= a do — цикл от 1 до 5

   local a = i^2 — переменная а локальна внутри цикла while

   MsgBox(a) —> 1, 4, 9, 16, 25

   i = i + 1

end

MsgBox(a) —> 5 (здесь обращение к глобальной a)

if i > 5 then

   local a — переменная а локальна внутри then

   a = 10

   MsgBox(a) —> 10

else

   MsgBox(a) —> 5 (здесь обращение к глобальной a)

end

do

   local a = 20 — переменная а локальна внутри do-end

   MsgBox(a) —> 20

end

MsgBox(a) —> 5 (здесь обращение к глобальной a)

Обратите внимание

Когда возможно, рекомендуется использовать локальные переменные вместо глобальных. Это позволит избежать «засорения» глобального пространства имён и обеспечит лучшую производительность (поскольку доступ к локальным переменным в Lua выполняется несколько быстрее, чем к глобальным).

Типы данных Lua

Какие типы данных поддерживает язык Lua?

Lua поддерживает следующие типы данных:

1. Nil (ничего). Соответствует отсутствию у переменной значения. Этот тип представлен единственным значением — nil.

2. Boolean (логический). К данному типу относятся значения false (ложь) и true (истина).

При выполнении логических операций значение nil рассматривается как false. Все остальные значения, включая число 0 и пустую строку, рассматриваются как true.

3. Number (числовой). Служит для представления числовых значений.

В числовых константах можно указывать необязательную дробную часть и необязательный десятичный порядок, задаваемый символами «e» или «E». Целочисленные числовые константы можно задавать в шестнадцатеричной системе, используя префикс 0x.

Примеры допустимых числовых констант: 3, 3.0, 3.1415926, 314.16e-2, 0xff.

4. String (строковый). Служит для представления строк.

Строковые значения задаются в виде последовательности символов, заключённой в одинарные или двойные кавычки:

a = «это строка»

b = ‘это вторая строка’

Строки, заключённые в двойные кавычки, могут интерпретировать C-подобные управляющие последовательности (escape-последовательности), начинающиеся с символа «» (обратный слэш):

b (пробел),

n (перевод строки),

 r (возврат каретки);

t (горизонтальная табуляция),

 \ (обратный слеш);

» (двойная кавычка);

‘ (одинарная кавычка).

Обратите внимание

Символ в строке также может быть представлен своим кодом с помощью escape-последовательности:

ddd,

где ddd — последовательность из не более чем трёх цифр.

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

local a = [[Компания «Кронос»]]

Определение строки с помощью двойных квадратных скобок позволяет игнорировать все escape-последовательности, т. е. строка создаётся полностью так, как описана:

local a = [[string

string1

string2

   string3

]] — «string

       string1

       string2

          string3»

Примечание

При определении строки с помощью двойных квадратных скобок учитываются символы табуляции и переноса.

Двойные скобки могут быть вложенными. Для того чтобы их не перепутать, между скобками вставляется символ«равно» (=):

local a = [=[определение строки [[string]] в Lua]=]

— будет срока: «определение строки [[string]] в Lua»

5. Function (функция). Функции в Lua могут быть записаны в переменные, переданы как параметры в другие функции ивозвращены как результат выполнения функций.

6. Table (таблица). Таблица представляет собой набор пар «ключ» — «значение», которые называют полями илиэлементами таблицы. Как ключи, так и значения полей таблицы могут иметь любой тип, за исключением nil. Таблицы не имеют фиксированного размера: в любой момент времени в них можно добавить произвольное число элементов.

Подробнее — в статье «Создание таблиц в Lua»

7. Userdata (пользовательские данные). Является особым типом данных. Значения этого типа не могут быть созданы или изменены непосредственно в Lua-скрипте.

Userdata используется для представления новых типов, созданных в вызывающей скрипт программе или в библиотеках, написанных на языке С. Например, библиотеки расширений Lua для «CronosPRO» используют этот тип для представления таких объектов, как:

банки данных (класс Bank);

базы данных (класс Base);

записи (класс Record) и т. п.

8. Thread (поток). Соответствует потоку выполнения. Эти потоки никаким образом не связаны с операционной системой и поддерживаются исключительно средствами самого Lua.

Как в Lua задать тип переменной?

Lua не предусматривает явного задания типа переменной. Тип переменной устанавливается в момент присвоения переменной значения. Любой переменной может быть присвоено значение любого типа (вне зависимости от того, значение какого типа она содержала ранее).

a = 123 — переменная a имеет тип number

a = «123» — теперь переменная a имеет тип string

a = true — теперь переменная a имеет тип boolean

a = {} — теперь переменная a имеет тип table

Обратите внимание

Переменные типа table, function, thread и userdata не содержат самих данных, а хранят ссылки на соответствующие объекты. При присваивании, передачи в функцию в качестве аргумента и возвращении из функции в качестве результата копирования объектов не происходит, копируются только ссылки на них.

a = {} — создаем таблицу. В переменную a помещается ссылка на таблицу

b = a — переменная b ссылается на ту же таблицу, что и a

a[1] = 10 — элементу таблицы с индексом 1 присвоено значение 10

MsgBox(b[1]) —> ’10’

b[1] = 20

MsgBox(a[1]) —> ’20’

Остальные данные являются непосредственными значениями.

a = 10

b = a

a = 20

MsgBox(a) —> ’20’

MsgBox(b) —> ’10’

Как в Lua получить тип переменной?

Тип значения, сохранённого в переменной, можно выяснить при помощи стандартной функции type. Эта функция возвращает строку, содержащую название типа («nil», «number», «string», «boolean», «table», «function», «thread», «userdata»).

t = type («это строка») — t равно «string»

t = type (123) — t равно «number»

t = type (type) — t равно «function»

t = type (true) — t равно «boolean»

t = type (nil) — t равно «nil»

t = type (CroApp.GetBank()) — t равно «userdata»

Как в Lua преобразовать тип переменной?

Lua при необходимости автоматически преобразует числа в строки и наоборот. Например, если строковое значение является операндом в арифметической операции, оно преобразуется в число. Аналогично числовое значение, встретившееся в том месте, где ожидается строковое, будет преобразовано в строку.

a = «10» + 2 — a равно 12

a = «10» + 2 — a равно «10 + 2»

a = «-5.3e-10″*«2» — a равно -1.06e-09

a = «строка» + 2 — Ошибка! Невозможно преобразовать «строка» в число

Значение любого типа можно явным образом преобразовать в строку с помощью стандартной функции tostring.

a = tostring (10) — a равно «10»

a = tostring (true) — a равно «true»

a = tostring (nil) — a равно «nil»

a = tostring ({[1] = «это поле 1»}) — a равно «table: 06DB1058»

Из предыдущего примера видно, что содержимое таблиц функцией tostring не преобразуется. Выполнить такое преобразование можно с помощью функции render.

a = render (10) — a равно «10»

a = render (true) — a равно «true»

a = render (nil) — a равно «nil»

a = render ({[1] = «это поле 1»}) — a равно «{[1] = «это поле 1»}»

Для явного преобразования значения в число можно использовать стандартную функцию tonumber. Если значение является строкой, которую можно преобразовать в число (или уже является числом), функция возвращает результат преобразования, в противном случае возвращает nil.

a = tonumber («10») — a равно «10»

a = tonumber («10»..».5″) — a равно 10.5

a = tonumber (true) — a равно «nil»

a = tonumber (nil) — a равно «nil»

Расстановка комментариев в Lua

Комментарий в Lua начинается двумя знаками «минус» (—) и продолжается до конца строки.

local a = 1 — однострочный комментарий

Если непосредственно после символов «—» идут две открывающие квадратные скобки ([[), комментарий являетсямногострочным и продолжается до двух закрывающих квадратных скобок (]]).

local a = 1 — [[ многострочный

комментарий ]]

Двойные скобки в комментариях могут быть вложенными. Для того чтобы их не перепутать, между скобками вставляется знак равенства (=):

local a = [[Компания «Кронос»]] — [=[

local a = [[Компания «Кронос»]]

]=]

Количество символов «=» определяет вложенность:

local a = [=[определение некоторой строки [[string]] в языке Lua]=] —[==[

local a = [=[определение некоторой строки [[string]] в языке Lua]=]

]==]

Операции, применяемые в Lua

В выражениях, написанных на Lua, могут применяться следующие виды операций:

1. Арифметические операции.

Lua поддерживает следующие арифметические операции:

+ (сложение);

— (вычитание);

* (умножение);

/ (деление);

^ (возведение в степень);

% (остаток от деления).

Обратите внимание

Арифметические операции применимы как к числам, так и к строкам, которые в этом случае преобразуются в числа.

2. Операции сравнения.

В Lua допустимы следующие операции сравнения величин:

== (равно);

~= (не равно);

< (меньше);

> (больше);

<= (меньше или равно);

>= (больше или равно).

Обратите внимание

Операции сравнения всегда возвращают логическое значение true или false.

Правила преобразования чисел в строки (и наоборот) при сравнениях не работают, т. е. выражение «0» == 0 даёт в результате false.

3. Логические операции.

К логическим операциям относятся:

and (логическое И).

Операция and возвращает свой первый операнд, если он имеет значение false или nil. В противном случае, операция возвращает второй операнд (причём этот операнд может быть произвольного типа).

a = (nil and 5) — a равно nil

a == (false and 5) — a равно false

a == (4 and 5) — a равно 5

or (логическое ИЛИ).

Операция or возвращает первый операнд, если он не false и не nil, иначе он возвращает второй операнд.

a == (4 or 5) — a равно 4

a == (false or 5) — a равно 5

Обратите внимание

Логические операции and и or могут возвращать значения любых типов.

Логические операции and и or вычисляют значение второго операнда только в том случае, если его нужно вернуть. Если этого не требуется, второй операнд не вычисляется. Например:

a == (4 or f()) — вызова функции f() не произойдет

not (логическое НЕ).

Операция not всегда возвращает true или false.

4. Операция конкатенации.

Для конкатенации (объединения) строк служит операция… (две точки).

a = «Кронос»..»-«..«Информ» — переменная a получит значение «Кронос-Информ»

Обратите внимание

Если один или оба операнда являются числами, выполняется их преобразование в строки.

a = 0..1 — переменная a получит значение «01»

5. Операция получения длины.

В Lua определена операция длины #, которую можно использовать для получения длины строки.

a = «строка»

len = #a — len равно 6

len = #«ещё строка» — len равно 10

Обратите внимание

С помощью операции # можно также узнать максимальный индекс (или размер) массива. Подробнее — в статье «Работа с массивами в Lua» .

Приоритет операций в Lua

В языке Lua выполнение операций осуществляется в соответствии со следующим приоритетом (в порядке убывания):

1. ^

2. not # — (унарный)

3. * / %

4. + —

5. ..

6. < > <= >= ~= ==

7. and

8. or

 Вызов скриптов из форм

С каждой формой (включая вложенные формы) связан отдельный скрипт, который обычно содержит функции, выполняющие обработку событий формы и её элементов.

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

Необходимо отметить, что скрипт формы, хотя и не содержит вызова функции module, фактически является модулем. Это означает, что переменные, объявленные в скрипте формы без ключевого слова local, не выносятся в глобальное окружение и доступны только внутри этого скрипта. Если необходимо сделать какое-либо значение доступным для скриптов других форм, его следует явным образом определить в глобальной таблице _G:

_G.var = 123

Другой скрипт форм сможет прочитать это значение следующим образом:

local a = _G.var

Блоки операторов (инструкций)

К основным операторам Lua относятся:

присваивание;

условный оператор;

операторы для организации циклов.

Группа операторов может быть объединена в блок (составной оператор) при помощи конструкции do… end.

do — начало блока

   <оператор1> — тело блока

   <оператор2>

   …

   <операторN>

end — конец блока

Блок открывает новую область видимости, в которой можно определять локальные переменные.

a = 5 — глобальная переменная a

do

   local a = 20 — внутри do-end определяется локальная переменная а

   MsgBox(a) —> 20

end

MsgBox(a) —> 5 (здесь обращение уже к глобальной a)

Оператор присваивания в Lua

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

a = 1 — переменной a присвоено значение 1

a = b + c — переменной a присвоена сумма значений переменных b и с

a = f(x) — переменной a присвоено значение, возвращённое функцией f(x)

В Lua допускается так называемое множественное присваивание, когда несколько переменных, находящихся слева от оператора присваивания, получают значения нескольких выражений, записанных справа от оператора присваивания:

a, b = 1, 5*c — a равно 1; b равно 5*c

Если переменных больше чем значений, «лишним» переменным присваивается nil.

a, b, c = 1, 2 — a равно 1; b равно 2; c равно nil

Если значений больше чем переменных, «лишние» значения игнорируются.

a, b = 1, 2, 3 — a равно 1; b равно 2; значение 3 не использовано

Множественное присваивание можно использовать для обмена значениями между переменными:

a = 10; b = 20 — a равно 10, b равно 20

a, b = b, a — теперь a равно 20, b равно 10

Условный оператор (if) в Lua

Оператор if проверяет истинность заданного условия. Если условие является истинным, выполняется часть кода, следующая за ключевым словом then (секция then). В противном случае, выполняется код, следующий за ключевым словом else (секция else).

if a > b then

   return a — если a больше b, вернуть a

else

   return b — в противном случае — вернуть b

end

Секция else является необязательной.

if a < 0 then

   a = 0 — если a меньше 0, присвоить a значение 0

end

Вместо вложенных операторов if можно использовать конструкцию elseif. Например, приведенный код:

if a == 1 then

   return «Иван» — если a равно 1

else

   if a == 2 then

     return «Петр» — если a равно 2

   else

      if a == 3 then

         return «Сергей» — если a равно 3

      else

         return «Нет такого игрока» — если a — ни одно из перечисленных

      end

   end

end

будет проще для восприятия, если заменить его следующим:

if a == 1 then

   return «Иван» — если a равно 1

elseif a == 2 then

   return «Петр» — если a равно 2

elseif a == 3 then

   return «Сергей» — если a равно 3

else

   return «Нет такого игрока» — если a — ни одно из перечисленных

end

Цикл с предусловием (while) в Lua

Оператор while предназначен для организации циклов с предусловием и имеет следующий вид:

while <condition> do

   … — тело цикла

end

Перед каждой итерацией цикла проверяется условие <condition>:

если условие ложно, цикл завершается и управление передаётся первому оператору, следующему за оператором while;

если условие истинно, выполняется тело цикла, после чего все действия повторяются.

i = 10; t = {}

while i > 0 do — цикл от 10 до 1

   t[i] = «поле »..i

   i = i — 1

end

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

a = {3, 5, 8, -6, 5}

i = #a

while i > 0 do — ищем в массиве отрицательное значение

   if a[i] < 0 then break end — если найдено, прерываем цикл

   i = i — 1 — иначе переходим к следующему элементу

end

if i > 0 then

   MsgBox («Индекс отрицательного значения: »..i)

else

   MsgBox («Массив не содержит отрицательных значений»)

end

Примечание

Подробнее об особенностях использования оператора break — в статье «Операторы break и return»

Цикл с постусловием (repeat) в Lua

Оператор repeat предназначен для организации циклов с постусловием и имеет следующий вид:

repeat

   … — тело цикла

until <condition>

Тело цикла выполняется до тех пор, пока условие <condition> не станет истинным. Проверка условия осуществляется после выполнения тела цикла, поэтому в любом случае тело цикла выполнится хотя бы один раз.

— суммируем значения массива a, пока сумма не превысит 10

a = {3, 2, 5, 7, 9}

i = 0; sum = 0

repeat

   i = i + 1

   sum = sum + a[i]

until sum > 10

MsgBox («Сложено »..i..» элементов. Сумма равна «..sum)

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

Примечание

Подробнее об особенностях использования оператора break — в статье «Операторы break и return»

Циклы с оператором for в Lua

Оператор for предназначен для организации циклов и допускает две формы записи:

простую (числовой for);

расширенную (универсальный for).

Простая форма оператора for

Простая форма оператора for имеет следующий вид:

for var = exp1, exp2, exp3 do

   … — тело цикла

end

Тело цикла выполняется для каждого значения переменной цикла (счётчика) var в интервале от exp1 до exp2, с шагом exp3.

Примечание

Шаг может не задаваться. В этом случае он принимается равным 1.

for i = 1, 10 do — цикл от 1 до 10 с шагом 1

MsgBox («i равно »..i)

end

for i = 10, 1, -1 do — цикл от 10 до 1 с шагом -1

   MsgBox («i равно »..i)

end

Обратите внимание

Выражения exp1, exp2 и exp3 вычисляются всего один раз, перед началом цикла. Так, в примере ниже, функция f(x) будет вызвана для вычисления верхнего предела цикла только один раз:

for i = 1, f(x) do — цикл от 1 до значения, возвращенного функцией f()

MsgBox («i равно »..i)

end

Переменная цикла является локальной для оператора цикла и по его окончании не определена.

for i = 1, 10 do — цикл от 1 до значения, возвращенного функцией f()

   MsgBox («i равно »..i)

end

MsgBox («После выхода из цикла i равно »..i) — Неверно! i равно nil

Обратите внимание

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

Для выхода из цикла до его завершения используется оператор break.

a = {3, 5, 8, -6, 5}

for i = 1,#a do — ищем в массиве отрицательное значение

   if a[i] < 0 then — если найдено…

      index = i — сохраняем индекс найденного значения…

      break — и прерываем цикл

   end

end

MsgBox («Индекс отрицательного значения: »..index)

Примечание

Подробнее об особенностях использования оператора break — в статье «Операторы break и return»    )

нужен.