Руководство по протоколу modbus

Из данной статьи вы узнаете о протоколе Modbus RTU, который широко применяется в АСУ ТП. Англоязычная версия статьи доступна на сайте ipc2u.com. Описание протокола Modbus TCP можно найти в статье.

Оглавление:

• Описание протокола Modbus RTU
• Какие бывают команды Modbus RTU?
• Как послать команду Modbus RTU на чтение дискретного вывода? Команда 0x01
• Как послать команду Modbus RTU на чтение дискретного ввода? Команда 0x02
• Как послать команду Modbus RTU на чтение аналогового вывода? Команда 0x03
• Как послать команду Modbus RTU на чтение аналогового ввода? Команда 0x04
• Как послать команду Modbus RTU на запись дискретного вывода? Команда 0x05
• Как послать команду Modbus RTU на запись аналогового вывода? Команда 0x06
• Как послать команду Modbus RTU на запись нескольких дискретных выводов? Команда 0x0F
• Как послать команду Modbus RTU на запись нескольких аналоговых выводов? Команда 0x10
• Какие бывают ошибки запроса Modbus?
• Программы для работы с протоколом Modbus RTU

Описание протокола Modbus RTU

Modbus — коммуникационный протокол, основан на архитектуре ведущий-ведомый (master-slave). Использует для передачи данных интерфейсы RS-485, RS-422, RS-232, а также Ethernet сети TCP/IP (протокол Modbus TCP).

Сообщение Modbus RTU состоит из адреса устройства SlaveID, кода функции, специальных данных в зависимости от кода функции и CRC контрольной суммы.

Если отбросить SlaveID адрес и CRC контрольную сумму, то получится PDU, Protocol Data Unit.

SlaveID – это адрес устройства, может принимать значение от 0 до 247, адреса с 248 до 255 зарезервированы.

Данные в модуле хранятся в 4 таблицах.

Две таблицы доступны только для чтения и две для чтения-записи.

В каждой таблице помещается 9999 значений.

В сообщении Modbus используется адрес регистра.

Например, первый регистр AO Holding Register, имеет номер 40001, но его адрес равен 0000.

Разница между этими двумя величинами есть смещение offset.

Каждая таблица имеет свое смещение, соответственно: 1, 10001, 30001 и 40001.

Ниже приведен пример запроса Modbus RTU для получения значения AO аналогового выхода (holding registers) из регистров от #40108 до 40110 с адресом устройства 17.

11 03 006B 0003 7687

В ответе от Modbus RTU Slave устройства мы получим:

11 03 06 AE41 5652 4340 49AD

Где:

Регистр аналогового выхода AO0 имеет значение AE 41 HEX или 44609 в десятичной системе.

Регистр аналогового выхода AO1 имеет значение 56 52 HEX или 22098 в десятичной системе.

Регистр аналогового выхода AO2 имеет значение 43 40 HEX или 17216 в десятичной системе.

Значение AE 41 HEX — это 16 бит 1010 1110 0100 0001, может принимать различное значение, в зависимости от типа представления.

Значение регистра 40108 при комбинации с регистром 40109 дает 32 бит значение.

Пример представления.

Наверх к оглавлению

Какие бывают команды Modbus RTU?

Приведем таблицу с кодами функций чтения и записи регистров Modbus RTU.

Наверх к оглавлению

Как послать команду Modbus RTU на чтение дискретного вывода? Команда 0x01

Эта команда используется для чтения значений дискретных выходов DO.

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

Значения DO в ответе находятся в одном байте и соответствуют значению битов.

Значения битов определяются как 1 = ON и 0 = OFF.

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

Если запрашивалось меньше восьми значений DO, то оставшиеся биты в ответе будут заполнены нулями (в направлении от младшего к старшему байту). Поле Byte Count Количество байт далее указывает количество полных байтов данных в ответе.

Пример запроса DO с 20 по 56 для SlaveID адреса устройства 17. Адрес первого регистра будет 0013 hex = 19, т.к. счет ведется с 0 адреса (0014 hex = 20, -1 смещение нуля = получаем 0013 hex = 19).

Состояния выходов DO 27-20 показаны как значения байта CD hex, или в двоичной системе 1100 1101.

В регистре DO 56-52 5 битов справа были запрошены, а остальные биты заполнены нулями до полного байта (0001 1011).

Модули с дискретным выводом: M-7065, ioLogik R1214, ADAM-4056S

Наверх к оглавлению

Как послать команду Modbus RTU на чтение дискретного ввода? Команда 0x02

Эта команда используется для чтения значений дискретных входов DI.

Пример запроса DI с регистров от #10197 до 10218 для SlaveID адреса устройства 17. Адрес первого регистра будет 00C4 hex = 196, т.к. счет ведется с 0 адреса.

Модули с дискретным вводом: M-7053, ioLogik R1210, ADAM-4051

Наверх к оглавлению

Как послать команду Modbus RTU на чтение аналогового вывода? Команда 0x03

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

Пример запроса AO с регистров от #40108 до 40110 для SlaveID адреса устройства 17. Адрес первого регистра будет 006B hex = 107, т.к. счет ведется с 0 адреса.

Модули с аналоговым выводом: M-7024, ioLogik R1241, ADAM-4024

Наверх к оглавлению

Как послать команду Modbus RTU на чтение аналогового ввода? Команда 0x04

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

Пример запроса AI с регистра #30009 для SlaveID адреса устройства 17. Адрес первого регистра будет 0008 hex = 8, т.к. счет ведется с 0 адреса.

Модули с аналоговым вводом: M-7017, ioLogik R1240, ADAM-4017+

Наверх к оглавлению

Как послать команду Modbus RTU на запись дискретного вывода? Команда 0x05

Эта команда используется для записи одного значения дискретного выхода DO.

Значение FF 00 hex устанавливает выход в значение включен ON.

Значение 00 00 hex устанавливает выход в значение выключен OFF.

Все остальные значения недопустимы и не будут влиять значение на выходе.

Нормальный ответ на такой запрос — это эхо (повтор запроса в ответе), возвращается после того, как состояние DO было изменено.

Пример записи в DO с регистром #173 для SlaveID адреса устройства 17. Адрес регистра будет 00AC hex = 172, т.к. счет ведется с 0 адреса.

Состояние выхода DO173 поменялось с выключен OFF на включен ON.

Модули с дискретным выводом: M-7053, ioLogik R1210, ADAM-4051

Наверх к оглавлению

Как послать команду Modbus RTU на запись аналогового вывода? Команда 0x06

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

Пример записи в AO с регистром #40002 для SlaveID адреса устройства 17. Адрес первого регистра будет 0001 hex = 1, т.к. счет ведется с 0 адреса.

Модули с аналоговым выводом: M-7024, ioLogik R1241, ADAM-4024

Наверх к оглавлению

Как послать команду Modbus RTU на запись нескольких дискретных выводов? Команда 0x0F

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

Пример записи в несколько DO с регистрами от #20 до #29 для SlaveID адреса устройства 17. Адрес регистра будет 0013 hex = 19, т.к. счет ведется с 0 адреса.

В ответе возвращается количество записанных регистров.

Модули с дискретным выводом: M-7053, ioLogik R1210, ADAM-4051

Наверх к оглавлению

Как послать команду Modbus RTU на запись нескольких аналоговых выводов? Команда 0x10

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

Пример записи в несколько AO с регистрами #40002 и #40003 для SlaveID адреса устройства 17. Адрес первого регистра будет 0001 hex = 1, т.к. счет ведется с 0 адреса.

Модули с аналоговым выводом: M-7024, ioLogik R1241, ADAM-4024

Наверх к оглавлению

Какие бывают ошибки запроса Modbus?

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

Ответ будет содержать измененный Функциональный код, старший бит будет равен 1.

Пример:

Пример запроса и ответ с ошибкой:

Расшифровка кодов ошибок

Наверх к оглавлению

Программы для работы с протоколом Modbus RTU

Ниже перечислены программы, которые облегчают работу с Modbus.

DCON Utility Pro с поддержкой Modbus RTU, ASCII, DCON. Скачать

Modbus Master Tool с поддержкой Modbus RTU, ASCII, TCP. Скачать

Modbus TCP client с поддержкой Modbus TCP. Скачать

Наверх к оглавлению

Время на прочтение
7 мин

Количество просмотров 217K

Протокол Modbus — самый распространенный промышленный протокол для M2M-взаимодействия. Является стандартом де-факто и поддерживается почти всеми производителями промышленного оборудования.

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

В статье разберем реализации протокола Modbus, форматы данных, программное обеспечение для работы с протоколом. Попробуем на практике прочитать данные из устройства.

История Modbus

Modbus был представлен в 1979 году компанией Modicon (ныне Schneider Electric). Это был открытый стандарт, работающий по интерфейсу RS-232. Позже появилась реализации протокола для интерфейсов RS-485 и Modbus TCP. Протокол быстро набрал популярность, и многие производители стали внедрять его в своих устройствах.

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

В описании стандарта Modbus используются терминология, унаследованная от языков релейной логики. Так, например, некоторые регистры называются катушками (англ. coil).

Физический уровень

• RS-232/422/485 — последовательные интерфейсы, широко распространенные в промышленности. Интерфейсы RS-422/485 обеспечивают дальность сигнала до 1200 метров. Используются протоколы Modbus RTU/ASCII
• Сети TCP/IP — физическим каналом передачи данных могут любые ethernet-интерфейсы. Используется протокол Modbus TCP

Логический уровень

Различия протоколов Modbus

Modbus ASCII

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

Modbus RTU

В протоколе Modbus RTU данные кодируются в двоичный формат, и разделителем пакетов служит временной интервал. Этот протокол критичен к задержкам и не может работать, например, на модемных линиях. При этом, накладные расходы на передачу данных меньше, чем в Modbus ASCII, так как длина сообщений меньше.

Modbus TCP

Структура пакетов схожа с Modbus RTU, данные также кодируются в двоичный формат, и упаковываются в обычный TCP-пакет, для передачи по IP-сетям. Проверка целостности, используемая в Modbus RTU, не применяется, так как TCP уже имеет собственный механизм контроля целостности.

Формат пакета

Форматы пакета разных реализаций Modbus

Все устройства Modbus взаимодействуют, следуя модели master-slave. Запросы может инициировать только master-устройство, slave-устройства могут только отвечать на запросы, и не могут самостоятельно начинать передачу данных. В зависимости от реализации протокола, заголовки пакета различаются. Вот основные составляющие пакета, которые важно знать:

ADU (Application Data Unit) — пакет Modbus целиком, со всеми заголовками, PDU, контрольной суммой, адресом и маркерами. Отличается, в зависимости от реализации протокола.

PDU (protocol data unit) — основная часть пакета, одинаковая для всех реализаций протокола. Содержит сам payload.

Адрес устройства — адрес получателя, то есть slave-устройства. В одном сегменте Modbus-сети могут находится до 247 устройств. Только slave-устройства имеют различающиеся адреса, master-устройство не имеет адреса. Адрес «0» используется для широковещательных запросов от master, при этом, slave-устройства не могут отвечать на эти широковещательные пакеты.

Контрольная сумма — алгоритмы проверки целостности пакетов. В Мodbus RTU и ASCII используется 2 байта контрольной суммы. В Modbus RTU применяется алгоритм CRC16, в Modbus ASCII — более простой и менее надежный LRC8. В Modbus TCP контрольная сумма не добавляется в ADU, так как целостность проверяется на уровне TCP.

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

Регистры и функции Modbus

В упрощенном виде, структура запросов Modbus состоит из кода функции (чтение/запись), и данных, которые нужно считать или записать. При этом, коды функции различаются для разных типов данных. Разберем, какие бывают регистры, и функции для работы с ними.

• Discrete Inputs — дискретные входы устройства, доступны только для чтения. Диапазон адресов регистров: с 10001 по 19999. Имеют функцию «02» — чтение группы регистров
• Coils — дискретные выходы устройства, или внутренние значения. Доступны для чтения и записи. Диапазон адресов регистров: с 20001 по 29999. Имеет функции: «01» — чтения группы регистров, «05» — запись одного регистра, «15» — запись группы регистров
• Input Registers — 16-битные входы устройства. Доступны только для чтения. Диапазон адресов регистров: с 30001 по 39999. Имеют функцию: «04» — чтение группы регистров
• Holding Registers — 16-битные выходы устройства, либо внутренние значения. Доступны для чтения и записи. Диапазон адресов регистров: с 40001 по 49999. Имеют

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

Примеры работы

Для примера работы с протоколом Modbus TCP воспользуемся максимально простой консольной утилитой modbus-cli, написанной на языке Ruby. Она позволяет легко читать и писать данные в регистры Modbus.

Попробуем прочесть состояние счетчиков переданных пакетов на промышленном коммутаторе Advantech EKI-5524SSI. Для начала необходимо определить адреса регистров, хранящие нужную информацию, для этого заглянем в документацию устройства. Описание регистров находятся в разделе «Modbus Mapping Table»:

Описание значений регистров в документации коммутаторов EKI

Видно, что значение переданных пакетов для одного порта хранится в четырех регистрах, и для первого порта это регистры с 38193 по 38197. Также дано описание формата хранения данных, из которого следует, что целое число переданных пакетов хранится шестнадцатеричном формате, и значение 11223344 пакетов будет записано как 0xAB4130, справа налево.

Составим запрос:

$ modbus read 192.168.0.17 38193 4
38193   0x0000
38194   0x0000
38195   0x0000
38196   0x3459

read — команда чтения. Программа сама понимает, какую конкретно команду чтения использовать в зависимости от адреса регистра, в нашем случае будет использована команда «04», для чтения 16-битных регистров.

192.168.0.17 — IP-адрес устройства.

38193 — начальный адрес регистра.

4 — смещение относительно начального адреса. Мы читаем четыре регистра для порта 1, как следует из даташита.

Получаем ответ, содержащий значения четырех регистров. Видим, что число пакетов невелико: 0x3459, то есть 13401, — коммутатор был включен недавно.

Недостатки протокола Modbus

Справедливости ради, стоит упомянуть и о недостатках протокола. Так как он разрабатывался более 40 лет назад, когда производительность процессоров была существенно ниже и протоколы разрабатывались без учета защиты данных, он имеет рад минусов:

• Протокол не предусматривает аутентификацию и шифрование передаваемых данных. Поэтому, при использовании Modbus TCP необходимо использовать дополнительные VPN-тоннели.
• Slave-устройство не может инициировать передачу данных, поэтому master должен постоянно опрашивать ведомые устройства
• Slave-устройство не может обнаружить потерю связи с Master. Эта проблема напрямую следует из предыдущей.

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

Оборудование с поддержкой Modbus

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

ADAM-6000 и WISE-4000 — модули удаленного ввода-вывода

Модули серии ADAM-6000 и WISE-4000 позволяют удаленно управлять цифровыми и аналоговыми входами/выходами по протоколу Modbus TCP. Используются для управления периферийными устройствами и сбора данных в режиме slave. Могут работать в паре с программируемым логическим контроллером, или подключаться напрямую к SCADA-серверу.⠀⠀⠀ ⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀

EKI-1200 — Modbus-шлюзы для преобразования интерфейсов

Для преобразования протоколов Modbus RTU/ASCII в Modbus TCP, используются Modbus шлюзы. Устройства серии EKI-1200 имеют на борту до четырех последовательных интерфейсов RS-232/422/485, и два Ethernet-порта. Они позволяют объединить в одну сеть устройства с разными протоколами. Например, подключить slave устройство, поддерживающее только Modbus RTU, по интерфейсу RS-485 к сегменту сети Modbus TCP.

APAX-5000, ADAM-3600, WISE-5000 — контроллеры автоматизации

Контроллеры поддерживают функции Modbus RTU в качестве slave/master и клиента/сервера Modbus TCP.

Примеры применения

Система мониторинга теплиц

Решение Advantech для мониторинга интегрирует устройства TPC-1070H, ADAM-6024, ADAM-6050, ADAM-6060 и программное обеспечение WebAccess в машинном шкафу рядом с сельскохозяйственными угодьями. Соединяясь с различными чувствительными устройствами, модули ADAM-6000 могут в режиме реального времени получать данные об окружающей среде и контролировать переключение оборудования, чтобы гарантировать, что теплица находится в оптимальной среде для роста растений. Благодаря особой функции Advantech — графической логике условий (GCL), пользователи могут определять свои собственные правила логики управления и загружать эти правила в модули ввода / вывода Ethernet ADAM-6000, а затем модули автоматически выполняют логические правила, как автономные модули. контроллер. Еще одна особенность — Peer-to-Peer (P2P) использует наиболее открытую и гибкую сеть Ethernet, чтобы не только упростить процесс внедрения без контроллера, но и сэкономить затраты на аппаратное оборудование.

Все полученные данные затем передаются через Ethernet на компьютер с сенсорной панелью TPC-1070H. Благодаря системе охлаждения без вентилятора и передней панели, соответствующей стандарту IP65, TPC-1070H представляет собой прочную и компактную конструкцию, подходящую для изменяемой операционной среды, а его мощные вычислительные возможности способны обрабатывать большие объемы данных. Для управления устройствами Advantech WebAccess позволяет инженерам или менеджерам просматривать, контролировать и настраивать систему мониторинга через интрасеть или Интернет с помощью обычного веб-браузера с любого устройства, включая планшеты и смартфоны.

Мониторинг системы нагрева воды солнечной энергией

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

Модули Adam от Advantech предоставили заказчику решение, в котором использовались модули сбора данных, подключенные через RS485, и двухпроводная шина для передачи данных со всех датчиков. Эта системная архитектура имеет два основных преимущества: во-первых, она позволяет в любое время добавлять в систему большее количество датчиков модулей сбора данных, и, во-вторых, очень легко добавлять дополнительные метки в программное обеспечение для мониторинга и записи этих значений на ПК.

Описание протокола Modbus:

Перед тем как приступить к описанию протокола, давайте разберёмся с терминами.

Шина это нечно физическое (дорожки на плате, провода, шлейфы и т.д.). Шина определяет граничные значения скорости, максимальную дальность, напряжения логических уровней, допустимые емкости между линиями, форму сигналов на линиях и т.д.

Протокол это правила по которым осуществляется передача данных. Данные между двумя устройствами передаются по шине в соответствии с протоколом.

Интерфейс это шина + протокол + устройство или программа отвечающая за передачу данных.

Протокол Modbus разработан для шин: RS-485, RS-422, RS-232, и интерфейса Ethernet сети TCP/IP, но при желании его можно использовать для связи и по другим шинам или даже радиоканалам.

Протокол Modbus предусматривает наличие одного ведущего и до 247 ведомых устройств. Количество ведомых устройств может быть ограничено физическими возможностями шины.

Для ведущего устройства (master) в протоколе Modbus используется термин — client. Для ведомого устройства (slave) в протоколе Modbus используется термин — server. Да, это не опечатка, ведущий – клиент, ведомый – сервер. Думаю не будет ошибкой, если далее в статье мы будем пользоваться более привычными терминами: ведущий (master), ведомый (slave).

В соответствии с протоколом Modbus связь всегда начинает мастер, а ведомые устройства могут только отвечать на запросы мастера. Связь осуществляется посылкой пакета запроса (от мастера к ведомому) и посылкой ответного пакета (от ведомого к мастеру).

Типы протоколов Modbus:

• Modbus RTU:
  Данные передаются в двоичном формате, разделителем пакетов служит отсутствие данных в течении времени при котором можно передать более 3,5 байт.
  Протокол предназначен для шин: RS-485, RS-422, RS-232.
• Modbus ASCII:
  Данные передаются символами из таблицы ASCII в шестнадцатеричном формате, разделителями пакетов служат символы начала и конца пакета.
  Каждый пакет начинается символом двоеточия, в кодировке ASCII и заканчивается символами возврата каретки ‘\r’, и переноса строки ‘\n’.
  Например, для передачи адреса 10 в протоколе Modbus RTU будет передан байт 0x0A, а в протоколе Modbus ASCII будет передан байт символа ‘0’ и байт символа ‘A’, в кодировке ASCII.
  Протокол предназначен для шин: RS-485, RS-422, RS-232.
• Modbus TCP:
  Данные передаются в двоичном формате и упаковываются в обычный TCP-пакет, для передачи по IP-сетям. Отличием данного протокола является отсутствие проверки целостности (CRC-16), так как TCP уже имеет собственный механизм контроля целостности.
  Протокол предназначен для сетей TCP/IP.

Состав пакета Modbus RTU:

Состав пакета запроса от мастера к ведомому, аналогичен составу ответного пакета ведомого.

• ADU (Application Data Unit) – пакет Modbus целиком.
• PDU (Protocol Data Unit) – основная часть пакета, состоит из команды и данных.
• АДРЕС – адрес ведомого устройства которому адресован пакет запроса, или от которого отправлен пакет ответа. Ведомые устройства могут иметь адреса от 1 до 247. Пакет запроса отправленный с адресом 0 является широковещательным, он адресован всем ведомым на шине, они обязаны выполнить запрос, но не должны на него отвечать.
• КОМАНДА – указывает какие действия должен выполнить ведомый. Команда в запросе может иметь значение от 1 до 127. Этот диапазон соответствует байту у которого сброшен старший бит. Если ведомый выполнил запрос мастера, то в ответном пакете он указывает тот же номер команды, без изменений. Если ведомый обнаружил ошибку в запросе, или не может его выполнить, то в ответном пакете он указывает номер команды с установленным старшим битом. То есть номер команды будет лежать в диапазоне от 129 до 255.
• ДАННЫЕ – состав и количество данных в запросе и ответе зависят от номера команды. Если ведомый обнаружил ошибку в запросе, или не может его выполнить, то в ответном пакете, в поле данных, он указывает код ошибки.
• CRC-16 – проверка целостности пакета, два байта передаются младшим байтом вперёд.
  Для протокола Modbus значение CRC-16 рассчитывается используя реверсивный сдвиг, начальное значение равно 0xFFFF, порождающий полином равен 0xA001.

Регистры ведомых устройств:

Данные ведомых устройств хранятся в регистрах. Существует 4 типа регистров:

Данные в регистрах не обязательно связаны со значениями на входах и выходах ведомых устройств. Каждый регистр DI/DO хранит 1 бит. Каждый регистр AI/AO хранит 16 бит (2 байта).

Например, регистры AI и AO могут хранить входные данные и результаты вычислений, а регистры DI и DO флаги настроек, и биты состояний.

Команды протокола Modbus:

Все перечисленные команды (кроме работы с файлами и буфером FIFO) реализованы в библиотеке iarduino_Modbus.

Библиотека iarduino_Modbus:

Библиотека iarduino_Modbus позволяет работать с устройствами по шине RS485 используя протокол Modbus RTU или Modbus ASCII. Так как у большинства плат Arduino и ESP нет шины RS485, библиотека использует аппаратную или программную шину UART. Сигналы шины UART необходимо преобразовать в сигналы шины RS485 при помощи конвертирующего модуля UART-RS485, например, на базе микросхемы на MAX485.

Конвертер подключается к выводам TX и RX шины UART, а так же назначается вывод разрешающий работу передатчика DE.

Подключение к шине RS485:

• Для подключения конвертера к микроконтроллеру используется вывод DE и выводы UART.
• TX — вывод шины UART микроконтроллера для передачи данных к конвертеру.
• RX — вывод шины UART микроконтроллера для получения данных от конвертера.
• DI — вывод шины UART конвертера для получения данных от микроконтроллера.
• RO — вывод шины UART конвертера для передачи данных к микроконтроллеру.
• DE — вывод конвертера разрешающий работу его передатчика на шине RS485.
• ~RE — вывод конвертера разрешающий работу его приёмника на шине RS485.
• Для подключения устройств к шине RS485 используются выводы A, B и GND.
• A, B — витая пара для передачи/приёма данных.
• GND — линия шины RS485 для выравнивания потенциалов.
• Источники питания могут быть разные для каждого устройства, или один на все, если напряжение питания устройств совпадают.

Подключение к программной шине Piranha UNO:

Вместо выводов 2, 8 и 9 платы Piranha UNO можно использовать любые выводы, указав их номера в скетче.

SoftwareSerial  rs485(8, 9);      // Создаём объект для работы с программной шиной UART указывая выводы RX, TX.
   ModbusClient modbus(rs485, 2); // Создаём объект для работы по протоколу Modbus указав объект программной шины UART и номер вывода DE конвертера UART-RS485.
// ModbusClient modbus(rs485);    // Если вывод DE не используется, то он и не указывается.

Подключение к аппаратной шине Piranha ULTRA:

В примере используется аппаратная шина UART1 использующая выводы 8 и 9. Вместо вывода 2 можно использовать любой вывод платы Piranha ULTRA, указав его номер в скетче. Если вывод DE конвертера не используется, то он и не указывается в скетче.

   ModbusClient modbus(Serial1, 2); // Создаём объект для работы по протоколу Modbus указав класс Serial1 и номер вывода DE конвертера UART-RS485.
// ModbusClient modbus(Serial1);    // Если вывод DE не используется, то он и не указывается.

Подключение к аппаратной шине Piranha ESP32:

В примере используется аппаратная шина UART2 работающая на выводах 16 и 17. Вместо вывода 22 можно использовать любой вывод платы Piranha ESP32, указав его номер в скетче. Если вывод DE конвертера не используется, то он и не указывается в скетче.

   ModbusClient modbus(Serial2, 22); // Создаём объект для работы по протоколу Modbus указав класс Serial2 и номер вывода DE конвертера UART-RS485.
// ModbusClient modbus(Serial2);     // Если вывод DE не используется, то он и не указывается.

Описание функций библиотеки:

В данном разделе описаны функции библиотеки iarduino_Modbus для работы с шиной RS485 по протоколу Modbus.

Синтаксис функций библиотеки iarduino_Modbus совместим с библиотекой ArduinoModbus.

Подключение библиотеки:

В примерах вход DE конвертера подключён к выводу D2 Arduino. Вместо вывода D2 можно использовать любой выход Arduino. Если конвертер не имеет вывода DE, или он не подключён к Arduino, то номер вывода DE не указывается при создании объекта.

• Если используется аппаратная шина UART:

#include <iarduino_Modbus.h>       // Подключаем библиотеку для работы по протоколу Modbus.
   ModbusClient modbus(Serial, 2); // Создаём объект для работы по протоколу Modbus указав класс Serial и номер вывода DE конвертера UART-RS485.
// ModbusClient modbus(Serial);    // Если вывод DE не используется, то создаём объект не указывая его.

Если используется аппаратная шина UART-1, то вместо класса Serial указываем Serial1, для шины UART2 указываем Serial2 и т.д.

• Если используется программная реализация шины UART:

#include <SoftwareSerial.h>       // Подключаем библиотеку для работы с программной шиной UART.
#include <iarduino_Modbus.h>      // Подключаем библиотеку для работы по протоколу Modbus.
                                  //
   SoftwareSerial rs485(8, 9);    // Создаём объект для работы с программной шиной UART указывая выводы RX, TX.
   ModbusClient modbus(rs485, 2); // Создаём объект для работы по протоколу Modbus указав объект программной шины UART и номер вывода DE конвертера UART-RS485.
// ModbusClient modbus(rs485);    // Если вывод DE не используется, то создаём объект не указывая его.

Для программной реализации шины UART необходимо указать выводы которые будут использоваться как RX и TX, в примере указаны выводы 8, и 9 соответственно. При создании объекта modbus указывается не класс Serial, а объект для работы с программной шиной UART.

• Если используются две и более шины:

#include <iarduino_Modbus.h>       // Подключаем библиотеку для работы по протоколу Modbus.
ModbusClient modbus1(Serial1, 2);  // Создаём объект для работы по протоколу Modbus указав класс Serial1 и номер вывода DE конвертера UART1-RS485_1.
ModbusClient modbus2(Serial2, 3);  // Создаём объект для работы по протоколу Modbus указав класс Serial2 и номер вывода DE конвертера UART2-RS485_2.
ModbusClient modbus3(Serial3);     // Создаём объект для работы по протоколу Modbus указав класс Serial3, вывод DE не используется.

В примере созданы три объекта для работы по трём аппаратным шинам UART. К двум первым шинам подключены конвертеры с выводом DE и в примере указаны номера выводов Arduino которые управляют этими выводами, а для третьей шины вывод DE не указан, значит этого вывода нет у конвертера третьей шины. Количество создаваемых объектов ограничено количеством шин и памятью микроконтроллера. Можно добавить еще и программную шину, подключив библиотеку SoftwareSerial как в примере выше.

Скорость передачи данных по шине Modbus равна скорости шины UART.

Функция begin();

• Назначение: Инициализация работы по протоколу Modbus.
• Синтаксис: begin();
• Параметры: Нет.
• Возвращаемое значение: Нет.
• Примечание:
• Протокол будет инициирован на той шине UART, которая указана при создании объекта.
• Функцию достаточно вызвать 1 раз в коде Setup(), до обращения к остальным функциям библиотеки.
• Пример:

modbus.begin(); // Инициируем работу по протоколу Modbus.

Функция setTypeMB();

• Назначение: Указание типа протокола Modbus.
• Синтаксис: setTypeMB( ТИП );
• Параметр: ТИП — может принимать значение MODBUS_RTU или MODBUS_ASCII.
• Возвращаемое значение: Нет.
• Примечание: Тип протокола по умолчанию MODBUS_RTU.
• Пример:

modbus.setTypeMB( MODBUS_RTU ); // Указываем тип протокола Modbus: MODBUS_RTU (по умолчанию), или MODBUS_ASCII.

Функция setTimeout();

• Назначение: Указание максимального времени ожидания ответа от ведомых устройств.
• Синтаксис: setTimeout( ВРЕМЯ );
• Параметр: ВРЕМЯ uint32_t — количество миллисекунд.
• Возвращаемое значение: Нет.
• Примечание:
• Максимальное время ожидания устанавливается, как для типа RTU, так и для ASCII.
• Максимальное время ожидания по умолчанию 10 мс.
• Библиотека не ждёт завершение времени ожидания, если модуль ответил раньше.
• Пример:

modbus.setTimeout( 15 ); // Указываем жать ответ от модулей не более 15 мс.

Функция setDelay();

• Назначение: Указание паузы до отправки сообщения.
• Синтаксис: setDelay( ВРЕМЯ );
• Параметр: ВРЕМЯ uint32_t — количество миллисекунд.
• Возвращаемое значение: Нет.
• Примечание:
• Пауза до отправки сообщения устанавливается только для протокола Modbus RTU.
• Пауза до отправки сообщения по умолчанию 3 мс.
• Пауза устанавливается между пакетами. Если после получения/отправки последнего пакета прошло больше времени, то новый пакет будет отправлен без паузы.
• Пример:

modbus.setDelay( 5 ); // Указываем выдерживать паузу между пакетами в 5 мс.

Функция coilRead();

• Назначение: Чтение одного регистра «Coil» (он же «Discrete Output»).
• Синтаксис: coilRead( [ АДРЕС_МОДУЛЯ ] , АДРЕС_РЕГИСТРА );
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• АДРЕС_РЕГИСТРА: uint16_t — значение от 0 до 9999.
• Возвращаемое значение: int8_t — прочитанное значение (0/1), или -1 при неудаче.
• Примечание: Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Пример без проверки чтения:

bool i = modbus.coilRead(9, 0); // Читаем из модуля с адресом 9, значение регистра "Coil" с адресом 0.

• Пример с проверкой:

bool i;
int8_t j = modbus.coilRead(9, 0);      // Читаем из модуля с адресом 9, значение регистра "Coil" с адресом 0.
if( j>=0 ){ i=j; }                     // Сохраняем прочитанное значение в переменную i.
else      { Serial.println("Error"); } // Выводим сообщение о ошибке чтения.

Функция discreteInputRead();

• Назначение: Чтение одного регистра «Discrete Input».
• Синтаксис: discreteInputRead( [ АДРЕС_МОДУЛЯ ] , АДРЕС_РЕГИСТРА );
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• АДРЕС_РЕГИСТРА: uint16_t — значение от 0 до 9999.
• Возвращаемое значение: int8_t — прочитанное значение (0/1), или -1 при неудаче.
• Примечание: Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Пример без проверки чтения:

bool i = modbus.discreteInputRead(9, 0); // Читаем из модуля с адресом 9, значение регистра "Discrete Input" с адресом 0.

• Пример с проверкой:

bool i;
int8_t j = modbus.discreteInputRead(9, 0); // Читаем из модуля с адресом 9, значение регистра "Discrete Input" с адресом 0.
if( j>=0 ){ i=j; }                         // Сохраняем прочитанное значение в переменную i.
else      { Serial.println("Error"); }     // Выводим сообщение о ошибке чтения.

Функция holdingRegisterRead();

• Назначение: Чтение одного регистра «Holding Register» (он же «Analog Output»).
• Синтаксис: holdingRegisterRead( [ АДРЕС_МОДУЛЯ ] , АДРЕС_РЕГИСТРА );
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• АДРЕС_РЕГИСТРА: uint16_t — значение от 0 до 9999.
• Возвращаемое значение: int32_t — прочитанное значение (0…65535), или -1 при неудаче.
• Примечание: Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Пример без проверки чтения:

uint16_t i = modbus.holdingRegisterRead(9, 0); // Читаем из модуля с адресом 9, значение регистра "Holding Register" с адресом 0.

• Пример с проверкой:

uint16_t i;
int32_t j = modbus.holdingRegisterRead(9, 0); // Читаем из модуля с адресом 9, значение регистра "Holding Register" с адресом 0.
if( j>=0 ){ i=j; }                            // Сохраняем прочитанное значение в переменную i.
else      { Serial.println("Error"); }        // Выводим сообщение о ошибке чтения.

Функция inputRegisterRead();

• Назначение: Чтение одного регистра «Input Register» (он же «Analog Input»).
• Синтаксис: inputRegisterRead( [ АДРЕС_МОДУЛЯ ] , АДРЕС_РЕГИСТРА );
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• АДРЕС_РЕГИСТРА: uint16_t — значение от 0 до 9999.
• Возвращаемое значение: int32_t — прочитанное значение (0…65535), или -1 при неудаче.
• Примечание: Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Пример без проверки чтения:

uint16_t i = modbus.inputRegisterRead(9, 0); // Читаем из модуля с адресом 9, значение регистра "Input Register" с адресом 0.

• Пример с проверкой:

uint16_t i;
int32_t j = modbus.inputRegisterRead(9, 0); // Читаем из модуля с адресом 9, значение регистра "Input Register" с адресом 0.
if( j>=0 ){ i=j; }                          // Сохраняем прочитанное значение в переменную i.
else      { Serial.println("Error"); }      // Выводим сообщение о ошибке чтения.

Функция coilWrite();

• Назначение: Запись в один регистр «Coil» (он же «Discrete Output»).
• Синтаксис: coilWrite( [ АДРЕС_МОДУЛЯ ] , АДРЕС_РЕГИСТРА , ДАННЫЕ );
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• АДРЕС_РЕГИСТРА: uint16_t — значение от 0 до 9999.
• ДАННЫЕ: bool — значение для записи 0 или 1.
• Возвращаемое значение: bool — результат записи значения в регистр (true или false).
• Примечание: Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Пример без проверки записи:

modbus.coilWrite(9, 0, 1); // Для модуля с адресом 9, в регистр "Coil" с адресом 0, записываем значение 1.

• Пример с проверкой:

bool i = modbus.coilWrite(9, 0, 1); // Для модуля с адресом 9, в регистр "Coil" с адресом 0, записываем значение 1.
if(i){ Serial.println( "Ok"  ); }   // Выводим сообщение о успешной записи.
else { Serial.println("Error"); }   // Выводим сообщение о ошибке записи.

Функция holdingRegisterWrite();

• Назначение: Запись в один регистр «Holding Register» (он же «Analog Output»).
• Синтаксис: holdingRegisterWrite( [ АДРЕС_МОДУЛЯ ] , АДРЕС_РЕГИСТРА , ДАННЫЕ );
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• АДРЕС_РЕГИСТРА: uint16_t — значение от 0 до 9999.
• ДАННЫЕ: uint16_t — значение для записи от 0 до 65535.
• Возвращаемое значение: bool — результат записи значения в регистр (true или false).
• Примечание: Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Пример без проверки записи:

modbus.holdingRegisterWrite(9, 0, 1000); // Для модуля с адресом 9, в регистр "Holding Register" с адресом 0, записываем значение 1000.

• Пример с проверкой:

bool i = modbus.holdingRegisterWrite(9, 0, 1000); // Для модуля с адресом 9, в регистр "Holding Register" с адресом 0, записываем значение 1000.
if(i){ Serial.println( "Ok"  ); }                 // Выводим сообщение о успешной записи.
else { Serial.println("Error"); }                 // Выводим сообщение о ошибке записи.

Функция registerMaskWrite();

• Назначение: Запись масок в один регистр «Holding Register» (он же «Analog Output»).
• Синтаксис: registerMaskWrite( [ АДРЕС_МОДУЛЯ ] , АДРЕС_РЕГИСТРА , AND , OR );
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• АДРЕС_РЕГИСТРА: uint16_t — значение от 0 до 9999.
• AND: uint16_t — значение маски AND от 0 до 65535.
• OR: uint16_t — значение маски OR от 0 до 65535.
• Возвращаемое значение: bool — результат записи масок в регистр (true или false).
• Примечание:
• Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Результат записи вычисляется по формуле: REG = ( REG & AND ) | ( OR & ~AND ).
• Каждый бит маски AND запрещает менять значение того же бита в регистре.
• Маска OR содержит биты для записи в регистр, если это не запрещено маской AND.
• Пример:
• Допустим сейчас значение регистра = ( 0101 0101 0101 0101 )₂.
• Если маска AND = ( 0000 0000 1111 1111 )₂, то она запрещает менять 8 младших битов.
• Для маски OR возьмем значение = ( 0111 0111 0111 0111 )₂.
• После записи, значение регистра будет = ( 0111 0111 0101 0101 )₂.
• 8 старших битов взяли значение из OR, а 8 младших остались без изменений.
• Так можно менять отдельные биты, без предварительного чтения регистра.
• Пример без проверки записи:

modbus.registerMaskWrite(9, 0, 0x00FF, 0x7777); // Для модуля с адресом 9, в регистр "Holding Register" с адресом 0, записываем маски AND=0x00FF и OR=0x7777.

• Пример с проверкой:

bool i = modbus.registerMaskWrite(9, 0, 0x00FF, 0x7777); // Для модуля с адресом 9, в регистр "Holding Register" с адресом 0, записываем маски AND=0x00FF и OR=0x7777.
if(i){ Serial.println( "Ok"  ); }                        // Выводим сообщение о успешной записи.
else { Serial.println("Error"); }                        // Выводим сообщение о ошибке записи.

Функция beginTransmission();

• Назначение: Инициализация записи в несколько регистров «Coils» или «Holding Registers».
• Синтаксис: beginTransmission( [ АДРЕС_МОДУЛЯ ], ТИП, АДРЕС_РЕГИСТРА, КОЛИЧЕСТВО);
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• ТИП — может принимать значение COILS или HOLDING_REGISTERS.
• АДРЕС_РЕГИСТРА: uint16_t — адрес первого регистра для записи от 0 до 9999.
• КОЛИЧЕСТВО: uint16_t — количество записываемых регистров.
• Возвращаемое значение: bool — результат инициализации записи (true или false).
• Примечание:
• Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Если задан некорректный диапазон адресов регистров, не будет записан ни один регистр.
• Данные для записи необходимо ставить в очередь функцией write().
• Запись данных поставленных в очередь осуществляется функцией endTransmission().
• Пример для функций beginTransmission(), write() и endTransmission(), указан ниже.

Функция write();

• Назначение: Постановка значения в очередь на запись, после beginTransmission().
• Синтаксис: write( ДАННЫЕ );
• Параметр: ДАННЫЕ uint16_t — значение 0/1 для «Coils», или 0…65535 для «Holding Registers».
• Возвращаемое значение: bool — результат постановки значения в очередь (true или false).
• Пример для функций beginTransmission(), write() и endTransmission(), указан ниже.

Функция endTransmission();

• Назначение: Выполнение инициированной ранее записи.
• Синтаксис: endTransmission();
• Параметр: Нет.
• Возвращаемое значение: bool — результат записи (true или false).
• Пример без проверки записи:

modbus.beginTransmission(9, COILS, 0, 3);             // Инициируем запись для модуля с адресом 9, в регистры "Coils", начиная с адреса 0, всего 3 значения (3 регистра).
modbus.write( 0 );                                    // Ставим значение в очередь на запись. Это значение будет записано в регистр, адрес которого был указан в modbus.beginTransmission().
modbus.write( 1 );                                    // Ставим значение в очередь на запись. Это значение будет записано в следующий регистр по порядку.
modbus.write( 0 );                                    // Ставим значение в очередь на запись. Это значение будет записано в следующий регистр по порядку.
modbus.endTransmission();                             // Выполняем запись.
                                                      //
modbus.beginTransmission(9, HOLDING_REGISTERS, 5, 2); // Инициируем запись для модуля с адресом 9, в регистры "Holding Registers", начиная с адреса 5, всего 2 значения (2 регистра).
modbus.write( 11111 );                                // Ставим значение в очередь на запись. Это значение будет записано в регистр, адрес которого был указан в modbus.beginTransmission().
modbus.write( 22222 );                                // Ставим значение в очередь на запись. Это значение будет записано в следующий регистр по порядку.
modbus.endTransmission();                             // Выполняем запись.

• Пример с проверкой:

modbus.beginTransmission(9, HOLDING_REGISTERS, 5, 2); // Инициируем запись для модуля с адресом 9, в регистры "Holding Registers", начиная с адреса 5, всего 2 значения (2 регистра).
modbus.write( 11111 );                                // Ставим значение в очередь на запись. Это значение будет записано в регистр, адрес которого был указан в modbus.beginTransmission().
modbus.write( 22222 );                                // Ставим значение в очередь на запись. Это значение будет записано в следующий регистр по порядку.
bool i = modbus.endTransmission();                    // Выполняем запись.
if(i){ Serial.println( "Ok"  ); }                     // Выводим сообщение о успешной записи.
else { Serial.println("Error"); }                     // Выводим сообщение о ошибке записи.

Функция requestFrom();

• Назначение: Чтение из нескольких регистров указанного типа.
• Синтаксис: requestFrom( [ АДРЕС_МОДУЛЯ ], ТИП, АДРЕС_РЕГИСТРА, КОЛИЧЕСТВО);
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• ТИП: COILS, или DISCRETE_INPUTS, или HOLDING_REGISTERS, или INPUT_REGISTERS.
• АДРЕС_РЕГИСТРА: uint16_t — адрес первого читаемого регистра от 0 до 9999.
• КОЛИЧЕСТВО: uint16_t — количество читаемых регистров.
• Возвращаемое значение: uint16_t — количество прочитанных регистров, или 0 при неудаче.
• Примечание:
• Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Если задан некорректный диапазон адресов регистров, не будет прочитан ни один регистр.
• Для получения прочитанных данных нужно обращаться к функции read().
• Количество оставшихся доступных данных можно узнать функцией available().
• Пример для функций requestFrom(), available() и read(), указан ниже.

Функция available();

• Назначение: Получение количества значений, доступных для чтения функцией read().
• Синтаксис: available();
• Параметры: Нет.
• Возвращаемое значение: uint16_t — количество значений доступных для чтения read().
• Примечание: При обращении к любой функции библиотеки кроме available() и read(), буфер доступных значений будет очищен или перезаписан.
• Пример для функций requestFrom(), available() и read(), указан ниже.

Функция read();

• Назначение: Получение очередного прочитанного значения.
• Синтаксис: read();
• Параметры: Нет.
• Возвращаемое значение: int32_t — очередное прочитанное значение, или -1 при неудаче.
• Примечание: При обращении к любой функции библиотеки кроме available() и read(), буфер доступных значений будет очищен или перезаписан.
• Пример без проверки чтения:

modbus.requestFrom(9, COILS, 0, 3);             // Читаем из модуля с адресом 9, регистры "Coils", начиная с адреса 0, всего 3 значения (3 регистра).
while( modbus.available() ){                    // Пока есть значения доступные для функции read()...
    Serial.println( modbus.read() );            // Выводим очередное прочитанное значение.
}                                               // 
                                                //
modbus.requestFrom(9, HOLDING_REGISTERS, 5, 2); // Читаем из модуля с адресом 9, регистры "Holding Registers", начиная с адреса 5, всего 2 значения (2 регистра).
while( modbus.available() ){                    // Пока есть значения доступные для функции read()...
    Serial.println( modbus.read() );            // Выводим очередное прочитанное значение.
}                                               // 

• Пример с проверкой:

if( modbus.requestFrom(9, HOLDING_REGISTERS, 5, 2) ){ // Читаем из модуля с адресом 9, регистры "Holding Registers", начиная с адреса 5, всего 2 значения (2 регистра).
    while( modbus.available() ){                      // Пока есть значения доступные для функции read()...
        Serial.println( modbus.read() );              // Выводим очередное прочитанное значение.
    }                                                 //
}else{ Serial.println("Error"); }                     // Не удалось прочитать ни одного регистра.

Функция end();

• Назначение: Функция для совместимости с библиотекой ArduinoModbus.
• Синтаксис: end();
• Параметры: Нет
• Возвращаемое значение: Нет.
• Примечание: Функция позволяет перенести код написанный для библиотеки ArduinoModbus в скетч с библиотекой iarduino_Modbus, без сообщений об ошибках, но сама ничего не делает.
• Пример:

modbus.end(); // Пустая функция.
Serial.end(); // Отключение шины. Функцию можно применять как к аппаратным шинам UART, так и к программной.

Функция exceptionStatusRead();

• Назначение: Чтение состояния 8 статусных выходов.
• Синтаксис: exceptionStatusRead( [ АДРЕС_МОДУЛЯ ] );
• Параметр: АДРЕС_МОДУЛЯ uint8_t — значение от 1 до 247.
• Возвращаемое значение: int16_t — байт битов, или -1 при неудаче.
• Примечание: Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Пример без проверки чтения:

uint8_t i = modbus.exceptionStatusRead(9); // Читаем статусные выходы устройства с адресом 9.
bool pin1 = bitRead(i, 0);                 // Получаем состояние 1 статусного выхода.
bool pin2 = bitRead(i, 1);                 // Получаем состояние 2 статусного выхода.
bool pin8 = bitRead(i, 7);                 // Получаем состояние 8 статусного выхода.

• Пример с проверкой:

int16_t i = modbus.exceptionStatusRead(9); // Читаем статусные выходы устройства с адресом 9.
if( i<0 ){                                 // Если чтение не выполнено ...
    Serial.println( "Error"  ); }          // Выводим сообщение о ошибке чтения.
}else{                                     // Если чтение выполнено ...
    bool pin1 = bitRead(i, 0);             // Получаем состояние 1 статусного выхода.
    bool pin2 = bitRead(i, 1);             // Получаем состояние 2 статусного выхода.
    bool pin8 = bitRead(i, 7);             // Получаем состояние 8 статусного выхода.
}                                          //

Функция getSate();

• Назначение: Чтение состояния устройства.
• Синтаксис: getSate( [ АДРЕС_МОДУЛЯ ] );
• Параметр: АДРЕС_МОДУЛЯ uint8_t — значение от 1 до 247.
• Возвращаемое значение: int8_t — состояние ( 0-свободно, 1-занято ), или -1 при неудаче.
• Примечание: Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Пример без проверки чтения:

bool i = modbus.getSate(9); // Читаем состояние устройства с адресом 9.
if(i){ Serial.println( "Устройство занято"   ); }
else { Serial.println( "Устройство свободно" ); }

• Пример с проверкой:

int8_t i = modbus.getSate(9); // Читаем состояние устройства с адресом 9.
if( i<0  ){ Serial.println( "Ошибка чтения"       ); }
if( i==0 ){ Serial.println( "Устройство свободно" ); }
if( i>0  ){ Serial.println( "Устройство занято"   ); }

Функция diagnostic();

• Назначение: Выполнение команды диагностики.
• Синтаксис: diagnostic( АДРЕС_МОДУЛЯ , НОМЕР_ФУНКЦИИ_ДИАГНОСТИКИ [ , ДАННЫЕ ] );
• Параметры:
• АДРЕС_МОДУЛЯ: uint8_t — значение от 1 до 247.
• НОМЕР_ФУНКЦИИ_ДИАГНОСТИКИ: uint16_t — значение от 0 до 65535.
• 0 — Проверка связи. Результатом диагностики будет значение аргумента ДАННЫЕ.
• 1 — Перезагрузка коммуникаций и диагностика внутренних систем устройства.
• 2 — Получить значение регистра диагностики. Каждый бит информирует о ошибке.
• 3 — Сменить символ конца пакета ASCII на значение аргумента ДАННЫЕ.
• 4 — Включить режим «Только прослушивание» (Listen Only Mode).
• 10 — Сбросить все счетчики и регистр диагностики.
• 11 — Получить значение счётчика всех запросов на шине.
• 12 — Получить значение счётчика запросов с ошибками CRC.
• 13 — Получить значение счётчика ответов об ошибках.
• 14 — Получить значение счётчика запросов адресованных устройству.
• 15 — Получить значение счётчика запросов которые остались без ответа.
• 16 — Получить значение счётчика ответов об ошибках CODE_ERR_NAK.
• 17 — Получить значение счётчика ответов о «занятости» CODE_ERR_BUSY.
• 18 — Получить значение счётчика ошибок переполнения приема символов.
• Остальные номера функций доступны в документации протокола Modbus.
• ДАННЫЕ: uint16_t — необязательное значение от 0 до 65535.
• Возвращаемое значение: int32_t — результат диагностики (0…65535), или -1 при неудаче.
• Примечание:
• Счётчик событий, это счётчик успешно выполненных запросов.
• Счётчик не реагирует на успешное выполнение команды чтения его значения.
• Пример:

uint16_t i = modbus.diagnostic(9, 0, 12345); // Проверка связи устройства с адресом 9.
if( i!=12345 ){ Serial.println("Error"); }   // Выявлена ошибка связи.

• Пример:

int32_t i = modbus.diagnostic(9, 2); // Получить значение регистра диагностики устройства с адресом 9.
if(i<0){ Serial.println( "Ошибка чтения" );                               }else
if( i ){ Serial.println( "Модуль обнаружил сбои в работе своих систем" ); }else
       { Serial.println( "Устройство работает без ошибок" );              }

Функция getEventCounter();

• Назначение: Чтение счетчика событий.
• Синтаксис: getEventCounter( [ АДРЕС_МОДУЛЯ ] );
• Параметр: АДРЕС_МОДУЛЯ uint8_t — значение от 1 до 247.
• Возвращаемое значение: int32_t — значение счётчика событий (0…65535), или -1 при неудаче.
• Примечание:
• Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Счётчик событий, это счётчик успешно выполненных запросов.
• Счётчик не реагирует на успешное выполнение команды чтения его значения.
• Пример без проверки чтения:

uint16_t i = modbus.getEventCounter(9); // Читаем счётчик событий устройства с адресом 9.
Serial.println( (String) "Устройство успешно выполнило "+i+" запросов." );

• Пример с проверкой:

int32_t i = modbus.getEventCounter(9); // Читаем счётчик событий устройства с адресом 9.
if(i<0){ Serial.println( "Ошибка чтения" ); }
else   { Serial.println( (String) "Устройство успешно выполнило "+i+" запросов." ); }

Функция getEventLog();

• Назначение: Чтение журнала событий.
• Синтаксис: getEventLog( [ АДРЕС_МОДУЛЯ ] );
• Параметр: АДРЕС_МОДУЛЯ uint8_t — значение от 1 до 247.
• Возвращаемое значение: uint8_t — количество данных, доступных для чтения функцией read().
• Примечание:
• Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Для получения прочитанных данных нужно обращаться к функции read().
• Количество оставшихся доступных данных можно узнать функцией available().
• Данные будут получены в следующем порядке:
• uint16_t — слово состояния (0x0000 — устройство свободно, 0xFFFF — устройство занято).
• uint16_t — значение счётчика событий (0…65535).
• uint16_t — значение счётчика всех сообщений на шине (0…65535).
• uint8_t — массив байтов журнала событий (не более 64 байт).
• Пример без проверки чтения:

modbus.getEventLog(9); // Читаем журнал событий устройства с адресом 9.
Serial.print( "Слово состояния   = " ); Serial.println( modbus.read() );
Serial.print( "Счётчик событий   = " ); Serial.println( modbus.read() );
Serial.print( "Счётчик сообщений = " ); Serial.println( modbus.read() );
Serial.println( "Байты журнала событий:" );
while( modbus.available() ){ Serial.println( modbus.read() ); }

• Пример с проверкой:

if( modbus.getEventLog(9) ){ // Читаем журнал событий устройства с адресом 9.
    if( modbus.available() ){ Serial.print( "Слово состояния   = " ); Serial.println( modbus.read() ); }
    if( modbus.available() ){ Serial.print( "Счётчик событий   = " ); Serial.println( modbus.read() ); }
    if( modbus.available() ){ Serial.print( "Счётчик сообщений = " ); Serial.println( modbus.read() ); }
    Serial.println( "Байты журнала событий:" );
    while( modbus.available() ){ Serial.println( modbus.read() ); }
}else{
    Serial.println("Error"); // Модуль не поддерживает чтение журнала событий.
}

Функция getInfo();

• Назначение: Чтение информации об устройстве.
• Синтаксис: getInfo( [ АДРЕС_МОДУЛЯ ] );
• Параметр: АДРЕС_МОДУЛЯ uint8_t — значение от 1 до 247.
• Возвращаемое значение: uint8_t — количество данных, доступных для чтения функцией read().
• Примечание:
• Если адрес модуля не указан, команда будет отправлена всем устройствам.
• Для получения прочитанных данных нужно обращаться к функции read().
• Количество оставшихся доступных данных можно узнать функцией available().
• Данные будут получены в следующем порядке:
• uint8_t — идентификатор линейки устройств.
• uint8_t — индикатор пуска: (0x00 — off, 0xFF — on).
• uint8_t — массив данных об устройстве (количество байт зависит от устройства).
• Пример без проверки чтения:

modbus.getInfo(9); // Читаем информацию о устройстве с адресом 9.
Serial.print( "Идентификатор линейки = "  ); Serial.println( modbus.read() );
Serial.print( "Индикатор пуска = "        ); Serial.println( modbus.read() );
Serial.println( "Остальные байты данных:" );
while( modbus.available() ){ Serial.println( modbus.read() ); }

• Пример с проверкой:

if( modbus.getInfo(9) ){ // Читаем информацию о устройстве с адресом 9.
    if( modbus.available() ){ Serial.print( "Идентификатор линейки = " ); Serial.println( modbus.read() ); }
    if( modbus.available() ){ Serial.print( "Индикатор пуска = "       ); Serial.println( modbus.read() ); }
    Serial.println( "Остальные байты данных:" );
    while( modbus.available() ){ Serial.println( modbus.read() ); }
}else{
    Serial.println("Error"); // Модуль не поддерживает чтение информации о устройстве.
}

• Пример для модулей iarduino:

if( modbus.getInfo(9) ){ // Читаем информацию о устройстве с адресом 9.
    if( modbus.available()   ){ Serial.println((String) "Идентификатор линейки "+modbus.read() ); }
    if( modbus.available()   ){ Serial.println((String) "Индикатор пуска "+modbus.read() ); }
    if( modbus.available()   ){ Serial.println((String) "Адрес модуля на шине "+modbus.read() ); }
    if( modbus.available()   ){ Serial.println((String) "Идентификатор устройства "+modbus.read() ); }
    if( modbus.available()   ){ Serial.println((String) "Версия прошивки "+modbus.read() ); }
    if( modbus.available()>=2){ Serial.println((String) "Регистр диагностики "+((modbus.read()<<8)|modbus.read()); }
    if( modbus.available()   ){ Serial.println((String) "Младший байт регистра диагностики "+modbus.read() ); }
    if( modbus.available()   ){ Serial.println((String) "Количество регистров DO "+modbus.read() ); }
    if( modbus.available()   ){ Serial.println((String) "Количество регистров DI "+modbus.read() ); }
    if( modbus.available()   ){ Serial.println((String) "Количество регистров AO "+modbus.read() ); }
    if( modbus.available()   ){ Serial.println((String) "Количество регистров AI "+modbus.read() ); }
    if( modbus.available()>=4){ Serial.println((String) "Задержка до ответа в мс"+(uint32_t)((modbus.read()<<24)|(modbus.read()<<16)|(modbus.read()<<8)|modbus.read()) ); }
    Serial.println( "Остальные байты данных:" );
    while( modbus.available() ){ Serial.println( modbus.read() ); }
}else{
    Serial.println("Error"); // Модуль не поддерживает чтение информации о устройстве.
}

Функция lastError();

• Назначение: Получение кода причины последней ошибки.
• Синтаксис: lastError();
• Параметры: Нет.
• Возвращаемое значение: uint8_t — код причины последней ошибки.
• ERROR_ILLEGAL_FUNCTION — Команда запроса не поддерживается модулем.
• ERROR_ILLEGAL_ADDRESS — У модуля отсутствует регистр с указанным адресом.
• ERROR_ILLEGAL_VALUE — Недопустимое значение в поле данных запроса.
• ERROR_DEVICE_FAILURE — Любая невосстановимая ошибка кроме первых трёх.
• ERROR_ACKNOWLEDGE — Модуль принял запрос, но на обработку требуется время.
• ERROR_DEVICE_BUSY — Ведомый занят, запрос проигнорирован.
• ERROR_MEMORY_PARITY — Ошибка чтения/записи файла.
• ERROR_GATEWAY_UNAVAILABLE — Шина перегружена данными или не настроена.
• ERROR_GATEWAY_NO_DEVICE — Ведомого устройства нет или от него нет ответа.
• ERROR_SYNTAX — Ошибка синтаксиса.
• ERROR_ADR_IARDUINO — Ошибка назначения или сортировки адресов устройств iarduino.
• ERROR_ADR_RESPONSE — Несовпадение адреса регистра в ответе.
• ERROR_VAL_RESPONSE — Несовпадение данных в ответе.
• ERROR_CRC_RESPONSE — Несовпадение CRC в принятом ответе.
• ERROR_LEN_REQUEST — Размер отправляемого запроса превышает размер буфера.
• ERROR_LEN_RESPONSE — Размер полученного ответа превышает размер буфера.
• Пример:

int8_t i = modbus.coilRead(9, 100); // Читаем из модуля с адресом 9 регистр "Coil" (DO) с адресом 100.
if( i<0 ){
    switch( modbus.lastError() ){
        case ERROR_ILLEGAL_FUNCTION:    Serial.println( F("Модуль не поддерживает команду или функцию запроса")           ); break;
        case ERROR_ILLEGAL_ADDRESS:     Serial.println( F("Запрос содержит недопустимый адрес регистра")                  ); break;
        case ERROR_ILLEGAL_VALUE:       Serial.println( F("Запрос содержит недопустимое значение в поле данных")          ); break;
        case ERROR_DEVICE_FAILURE:      Serial.println( F("Ошибка запроса не связана с командой, адресом или данными")    ); break;
        case ERROR_ACKNOWLEDGE:         Serial.println( F("Модуль сообщает что занят и обработает запрос позже")          ); break;
        case ERROR_DEVICE_BUSY:         Serial.println( F("Модуль сообщает что занят и не будет обрабатывать запрос")     ); break;
        case ERROR_MEMORY_PARITY:       Serial.println( F("Модуль сообщает что произошла ошибка чтения/записи файла")     ); break;
        case ERROR_GATEWAY_UNAVAILABLE: Serial.println( F("Шлюз неправильно настроен или перегружен запросами")           ); break;
        case ERROR_GATEWAY_NO_DEVICE:   Serial.println( F("Модуль которому адресован запрос не отвечает")                 ); break;
        case ERROR_SYNTAX:              Serial.println( F("Ошибка синтаксиса")                                            ); break;
        case ERROR_ADR_IARDUINO:        Serial.println( F("Ошибка назначения или сортировки адресов устройств iarduino")  ); break;
        case ERROR_ADR_RESPONSE:        Serial.println( F("Ответ от модуля содержит недопустимый адрес регистра")         ); break;
        case ERROR_VAL_RESPONSE:        Serial.println( F("Ответ от модуля содержит недопустимое значение в поле данных") ); break;
        case ERROR_CRC_RESPONSE:        Serial.println( F("Несовпадение CRC в ответе модуля")                             ); break;
        case ERROR_LEN_REQUEST:         Serial.println( F("Размер запроса к модулю превышает буфер обмена или ADU")       ); break;
        case ERROR_LEN_RESPONSE:        Serial.println( F("Размер ответа от модуля превышает буфер обмена")               ); break;
        default:                        Serial.println( F("Неизвестная ошибка")                                           ); break;
    }
}else{ Serial.println( F("Ошибки не обнаружены") ); }

Функции для работы с адресами:

Функции перечисленные в данном разделе предназначены для устройств iarduino.

Функция checkID();

• Назначение: Функция определения принадлежности устройства.
• Синтаксис: checkID( АДРЕС_МОДУЛЯ );
• Параметр: АДРЕС_МОДУЛЯ uint8_t — значение от 1 до 247.
• Возвращаемое значение: uint8_t — принадлежность устройства:
• DEVICE_MB_ABSENT — Устройство с указанным адресом отсутствует на шине.
• DEVICE_MB_DOUBLE — Адрес принадлежит двум и более устройствам.
• DEVICE_MB_IARDUINO — Устройство принадлежит линейке iarduino.
• DEVICE_MB_UNKNOWN — Устройство не принадлежит линейке iarduino.
• Пример:

uint8_t i = modbus.checkID(9); // Определяем принадлежность устройства с адресом 9.
Serial.print(F("Адрес 9 на шине Modbus принадлежит "));
switch(i){
    case DEVICE_MB_ABSENT:   Serial.println(F("отсутствующему устройству."  )); break;
    case DEVICE_MB_DOUBLE:   Serial.println(F("двум и более устройствам."   )); break;
    case DEVICE_MB_IARDUINO: Serial.println(F("устройству линейки iarduino.")); break;
    case DEVICE_MB_UNKNOWN:  Serial.println(F("устройству не iarduino."     )); break;
}

Функция changeID();

• Назначение: Функция изменения адреса устройства iarduino на шине.
• Синтаксис: changeID( СТАРЫЙ_АДРЕС , НОВЫЙ_АДРЕС );
• Параметры:
• СТАРЫЙ_АДРЕС: uint8_t — значение от 1 до 247.
• НОВЫЙ_АДРЕС: uint8_t — значение от 1 до 247.
• Возвращаемое значение: bool — результат изменения адреса (true или false).
• Примечание:
• Новый адрес сохраняется в энергонезависимую память устройства.
• Выполнение функции занимает более 120 мс.
• Пример без проверки:

modbus.changeID(9, 10); // Меняем адрес устройства с 9 на 10.

• Пример с проверкой:

bool i = modbus.changeID(9, 10);  // Меняем адрес устройства с 9 на 10.
if(i){ Serial.println( "Ok"  ); } // Выводим сообщение о успешной смене адреса.
else { Serial.println("Error"); } // Выводим сообщение о ошибке смены адреса.

Функция sortID();

• Назначение: Функция сортировки адресов устройств iarduino по порядку.
• Синтаксис: sortID( ПЕРВЫЙ_АДРЕС_СПИСКА );
• Параметр: ПЕРВЫЙ_АДРЕС_СПИСКА uint8_t — значение от 1 до 247.
• Возвращаемое значение: int16_t — количество изменённых адресов, или -1 при неудаче.
• Примечание:
• Функция присваивает всем устройствам iarduino новые адреса по порядку.
• Функция работает с устройствами iarduino даже если у них одинаковые адреса.
• Функция пропускает адреса принадлежащие устройствам не iarduino.
• Новые адреса сохраняются в энергонезависимую память устройств iaduino.
• Выполнение функции занимает несколько секунд.
• Пример без проверки:

modbus.sortID(10); // Меняем адреса устройств в список начинающийся с адреса 10 (например, для трёх устройств, адреса станут: 10,11,12).

• Пример с проверкой:

int i=modbus.sortID(10); // Меняем адреса устройств в список начинающийся с адреса 10 (например, для трёх устройств, адреса станут: 10,11,12).
if(i<0){Serial.println( "Не удалось отсортировать все адреса устройств" ); }
else   {Serial.println( (String) "Изменены адреса "+i+" устройств" );      }

Функция searchERR();

• Назначение: Обнаружение устройств iarduino с одинаковыми адресами.
• Синтаксис: searchERR();
• Параметры: Нет.
• Возвращаемое значение: uint8_t — количество адресов, доступных для чтения функцией read().
• Примечание:
• Для получения найденных адресов нужно обращаться к функции read().
• Количество оставшихся доступных данных можно узнать функцией available().
• Выполнение функции занимает несколько секунд.
• Пример:

uint8_t i = modbus.searchERR(); // Ищем адреса принадлежащие двум и более устройствам.
Serial.println( (String) "На шине есть "+i+" адресов принадлежащих нескольким устройствам" );
// Выводим найденные адреса:
while( modbus.available() ){ Serial.println( modbus.read() ); }

Функция findID();

• Назначение: Обнаружение всех адресов ведомых устройств на шине.
• Синтаксис: findID( [ МОДЕЛЬ ] );
• Параметр: МОДЕЛЬ uint8_t — идентификатор искомых устройств (от 1 до 255).
• Возвращаемое значение: uint8_t — количество адресов, доступных для чтения функцией read().
• Примечание:
• Для получения найденных адресов нужно обращаться к функции read().
• Количество оставшихся доступных данных можно узнать функцией available().
• Если вызвать функцию без аргумента то будут обнаружены все адреса всех устройств.
• Если вызвать функцию с идентификатором устройства, то будут найдены только те адреса, которые принадлежат устройствам iarduino указанной модели.
• Выполнение функции занимает несколько секунд.
• Пример обнаружения всех адресов:

uint8_t i = modbus.findID(); // Ищем все адреса всех устройств (даже не iarduino).
Serial.println( (String) "На шине есть "+i+" устройств с адресами:" );
// Выводим найденные адреса:
while( modbus.available() ){ Serial.println( modbus.read() ); }

• Пример обнаружения адресов принадлежащих устройствам iarduino указанной модели:

uint8_t i = modbus.findID(1); // Ищем адреса устройств iarduino с идентификатором 1.
Serial.println( (String) "На шине есть "+i+" устройств с адресами:" );
// Выводим найденные адреса:
while( modbus.available() ){ Serial.println( modbus.read() ); }

• Пример получения идентификатора (номера модели) устройства iarduino:

uint8_t i;
if( modbus.getInfo(9) ){                           // Читаем информацию о устройстве с адресом 9.
    modbus.read(); modbus.read(); modbus.read();   // Пропускаем ненужные данные.
    if( modbus.available() ){ i = modbus.read(); } // Получаем идентификатор устройства.
}

Ссылки:

• Библиотека iarduino_Modbus.

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

Modbus — самый широко распространенный промышленный протокол для организации обмена данными между различными устройствами (межмашинное взаимодействие, Machine-to-Machine, M2M). Популярность объясняется многими факторами, среди которых простота реализации, отсутствие необходимости использовать дополнительные микросхемы, и, конечно же, открытость протокола.

Основные плюсы:

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

В то же время протокол Modbus не избавлен от некоторых недостатков:

• организация обмена данными по модели ведущий-подчиненный. При этом подчиненное устройство не может само инициировать отправку данных ведущему, а должно в обязательном порядке ожидать запроса.
• отсутствует механизм для определения обрыва линии связи.
• в одном запросе можно прочитать значения только последовательных регистров. Для чтения произвольных регистров необходимо отправлять несколько запросов, что увеличивает нагрузку на сеть.

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

Как уже было упомянуто, протокол Modbus использует обмен данными по модели ведущий-подчиненный (Master — Slave). Ведущий отправляет запросы, на которые могут отвечать подчиненные. Slave-устройство не может само начать обмен данными, только по команде от master’a.

В качестве физического уровня стандарт предусматривает использование интерфейсов RS-232, RS-422 и RS-485. Также существует реализация для TCP/IP — Modbus TCP. Но этот вариант мы сегодня будем затрагивать в меньшей степени.

Сеть Modbus может состоять из нескольких slave-устройств (от 1-го до 247-ми), но master должен быть только один. Каждое из подчиненных устройств имеет свой собственный адрес, соответственно, ведущий может адресовать свое сообщение или запрос конкретному slave-устройству.

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

На адреса slave накладываются некоторые ограничения:

• диапазон допустимых адресов — 1…247. Значения адресов от 248 до 255 являются зарезервированными, а адрес 0 используется для передачи широковещательных сообщений.
• master адреса не имеет, он в сети и так один.
• два подчиненных устройства не могут иметь одинаковые адреса.

Вот как может выглядеть один из вариантов подключения устройств с использованием RS-485:

Здесь у нас присутствует один master и три slave-устройства с адресами от 0x03 до 0x05.

Переходим дальше… Различают несколько логических уровней протокола:

Сегодня, в первую очередь, будем подробно разбирать Modbus RTU и Modbus ASCII. Структура пакетов выглядит следующим образом:

В стандарте Modbus принята следующая терминология:

• ADU (Application Data Unit) — полный пакет данных.
• PDU (protocol data unit) — часть пакета, содержащая непосредственно полезные данные.

Для расчета контрольной суммы используются разные алгоритмы: для Modbus RTU — CRC16, для ASCII — LRC8. В обоих случаях под контрольную сумму задействованы два байта.

Коды функций можно разделить на три группы:

• Стандартные коды команд, описанные в Modbus-IDA.
• Задаваемые пользователем (user-defined function codes) — 65…72, 100…110. Эти коды не описаны в спецификации стандарта и могут использоваться в конкретных изделиях для собственных функций.
• Зарезервированные (reserved). В эту группу входят коды 9, 10, 13, 14, 41, 42, 90, 91, 125, 126 и 127.

Но прежде, чем перейти к рассмотрению базовых/стандартных команд, необходимо рассмотреть использующуюся модель данных. Выполнение команд протокола Modbus подразумевает чтение и запись данных в регистры устройства. И различают 4 типа регистров, организованных в 4 таблицы данных:

Дискретные входы и регистры ввода доступны только для чтения данных, а, соответственно, дискретные выходы и регистры хранения — для чтения и записи.

Доступ к регистрам таблицы осуществляется при помощи 16-ти битного адреса. Первому элементу таблицы соответствует адрес 0. Таким образом, каждая из этих 4-х таблиц может включать в себя вплоть до 65536 регистров (адреса 0…65535 — 16 бит).

Вот теперь давайте рассмотрим конкретные команды из группы стандартных:

• 0x01 (1) — чтение значений из нескольких регистров флагов — Read Coil Status.
• 0x02 (2) — чтение значений из нескольких дискретных входов — Read Discrete Inputs.
• 0x03 (3) — чтение значений из нескольких регистров хранения — Read Holding Registers.
• 0x04 (4) — чтение значений из нескольких регистров ввода — Read Input Registers.
• 0x05 (5) — запись значения одного флага — Force Single Coil.
• 0x06 (6) — запись значения в один регистр хранения — Preset Single Register.
• 0x07 (7) — чтение сигналов состояния — Read Exception Status.
• 0x08 (8) — диагностика — Diagnostic.
• 0x0B (11) — чтение счетчика событий — Get Com Event Counter.
• 0x0C (12) — чтение журнала событий — Get Com Event Log.
• 0x0F (15) — запись значений в несколько регистров флагов — Force Multiple Coils.
• 0x10 (16) — запись значений в несколько регистров хранения — Preset Multiple Registers.
• 0x11 (17) — чтение информации об устройстве — Report Slave ID.
• 0x14 (20) — чтение из файла — Read File Record.
• 0x15 (21) — запись в файл — Write File Record.
• 0x16 (22) — запись в один регистр хранения с использованием маски «И» и маски «ИЛИ» — Mask Write Register.
• 0x18 (24) — чтение данных из очереди — Read FIFO Queue.
• 0x2B (43) — Encapsulated Interface Transport.

И, конечно же, мы не можем не разобрать конкретные примеры запросов и ответов при работе по Modbus.

Первым делом займемся чтением данных — коды функций 0x01, 0x02, 0x03, 0x04. В общем виде запросы ведущего и ответы подчиненного выглядят следующим образом (здесь мы рассматриваем только часть пакета — PDU):

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

Пойдем дальше обобщенного описания формата и проанализируем команды для конкретного устройства. В качестве этого устройства я использую сервопривод серии ASDA-A2, который для обмена данными использует как раз-таки протокол Modbus, причем поддерживает и Modbus RTU, и Modbus ASCII.

Пусть нам надо прочитать данные, расположенные по адресам 0x0200 и 0x0201, slave-устройства с адресом 0x01. Запрос master’а для Modbus RTU будет таким:

Здесь у нас в запросе, указано, что мы хотим прочитать значение двух элементов (регистров). И ответ slave:

А в ответе уже видим, что прочитано 4 байта, поскольку значение одного регистра — это 2 байта (16 бит), а регистров у нас тоже 2. Таким образом, полученные значения:

• Адрес 0x0200 — 0x00B1
• Адрес 0x0201 — 0x1F40

CRC Low и CRC High — это соответственно младший и старший байты 16-ти битной контрольной суммы.

В Modbus ASCII все несколько иначе, запрос выглядит так (в кавычках указаны ASCII символы):

Ответ подчиненного:

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

При чтении битов регистров флагов или дискретных входов запрос выглядит точно также, а вот байты данных ответного сообщения иначе:

Здесь одно значение флага или дискретного входа занимает один бит. И все эти биты упакованы в байты, а если число запрошенных флагов/входов не распределяется по байтам (не кратно 8), то «лишние» биты заполняются нулями. Как в последнем байте на этой схеме.

Переходим к записи. Для записи одного значения используются команды с кодами 0x05 и 0x06. Запрос в целом похож на уже рассмотренный (при чтении данных), только вместо количества элементов для чтения передаются данные, которые будут записаны:

При записи значений флагов или дискретных входов число 0xFF00 соответствует включенному состоянию, 0x0000 — выключенному. В случае успешного выполнения запроса подчиненное устройство отправляет ведущему точную копию этого запроса.

С этим разобрались 👍 Но необходимо рассмотреть еще и случай записи нескольких значений (коды команд 0x10 и 0x0F). В общем виде формат запроса такой:

И, в обязательном порядке, рассмотрим практический пример. Пусть нам требуется записать значения 0x0BB8 и 0x0000 по адресам, начинающимся с 0x0112. Запрос и ответ Modbus RTU:

И для Modbus ASCII:

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