Физический уровень АСУ ТП: UART, RS-485 и коммуникационные модули ПЛК

Причина – в архитектурных, экономических и эксплуатационных реалиях OT:

1. Огромное наследие:

   • Оборудование живет 15-30 лет;
   • ПЛК, RTU, датчики – уже внедрены и работают;
   • Замена = остановка производства + миллионы долларов.

2. Простота и предсказуемость:

   • Modbus детерминированный и прозрачный;
   • Инженеры его идеально понимают;
   • Минимум магии, максимум контроля.

3. Ограниченные ресурсы устройств:

   • Старые устройства не тянут TLS, шифрование, сложную аутентификацию.

4. Инженерная философия OT:

   • Приоритет: availability > security;
   • Лучше “небезопасно, но работает”, чем наоборот.

Внутри процессора / микроконтроллера данные не передаются по одному биту, это слишком медленно. Внутри проложены “магистрали” – шины данных.

На картинке Data Bus – это 8 параллельных проводников внутри самого микроконтроллера. По ним за один такт передается сразу целый байт.

Грубое схематичное изображение:

UART1 и UART2 на схеме – это те самые приемопередатчики. Они берут данные, подлетающие “широким фронтом”, и выстраивают их в одну линию.

Главное правило сборки: передающая линия TX (Transmit) одного устройства подключается к принимающей линии RX (Receive) другого.

Такой способ соединения можно сравнить со связями нейронов в ЦНС:

• Дендрит нейрона принимает сигнал;
• Аксон нейрона передает сигнал дальше;
• Связь между нейронами называется синапс.

То есть сигнал идет от аксона одного нейрона → к дендритам другого:

• TX ≈ аксон (передает)
• RX ≈ дендрит (принимает)

Но есть важное различие! В нейронах связь не симметричная, и нет “обратного провода”. А в UART у нас две независимые линии: TX→RX и RX→TX.

Раньше (в 80-х и 90-х) UART действительно был отдельной микросхемой на плате. Сейчас же блок UART – это микроскопический кусок кремния, который вшит прямо внутрь микроконтроллера.

CPU не умеет “стрелять битами” с точной частотой по одному проводу – это делает UART.

Мы пишем send("A") → CPU пишет 0x41 в регистр UART → UART сам превращает это в биты с таймингами.

CPU ядро
     ↓
внутренняя шина (AXI / AHB / APB)
     ↓
[ UART controller ]
     ↓
GPIO пины (TX/RX)

В предыдущей статье мы спроектировали и собрали промышленный узел управления.

Если бы мы делали самоделку, мы бы взяли микроконтроллер (Arduino) с его встроенным UART, вывели проводки на дешевый чип-драйвер (MAX485), а от нее пустили бы провода на завод.

Но в промышленных ПЛК (как Siemens S7-1200) архитектура хитрее.

Модуль Siemens CM 1241 – это “самостоятельный мини-компьютер”.

Когда мы прищелкиваем модуль связи сбоку к ПЛК, мы соединяем их не медленными проводами RX/TX, а высокоскоростной внутренней шиной (backplane bus).

Внутри самого модуля стоит свой собственный микроконтроллер. И вот уже внутри этого микроконтроллера находится аппаратный UART, а рядом припаян драйвер RS-485.

Как идет сигнал:

1. Главный процессор ПЛК говорит: “хочу отправить пакет данных”;
2. Он мгновенно скидывает пакет по высокоскоростной внутренней шине в модуль расширения;
3. Микроконтроллер внутри модуля ловит пакет;
4. Встроенный в модуль UART начинает не спеша нарезать пакет на биты;
5. Драйвер RS-485 усиливает их и отправляет в длинную линию.

Зачем нужен посредник?

Все дело в быстродействии. Задача ПЛК – крутить логику управления станком с максимальной скоростью (например, цикл в 5 мс). UART работает медленно. Если бы UART находился прямо в главном процессоре ПЛК, процессор постоянно отвлекался бы на отправку каждого бита и дергался от прерываний.

Поэтому Siemens делегирует рутину. Главный процессор скидывает данные в модуль и забывает про них. Маленький контроллер внутри модуля берет на себя всю “грязную” работу UART: считает биты, ждет тайминги и общается с драйвером RS-485. А когда снаружи приходит ответ, модуль собирает его в готовый красивый пакет и отдает главному процессору.

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

При последовательной передаче очень важны тайминги. Но есть ли они при параллельной передаче?

Еще какие! Но они работают совершенно иначе, чем в UART.

Снаружи (в UART) интерфейс асинхронный. Устройств два, у каждого свой генератор частоты, и они просто договариваются: “читаем 9600 раз в секунду”.

Внутри процессора все синхронно. Там есть один главный “дирижер” – кварцевый резонатор (clock / тактовый генератор). Он тикает с огромной скоростью (например, 100 миллионов раз в секунду – 100 МГц).

Под этот “метроном” танцуют абсолютно все блоки внутри чипа: и ядро процессора, и память, и блок UART.

Как происходит передача байта от CPU к UART:

1. Процессор выставляет на параллельную шину данных (Data Bus) 8 бит (напряжение 1 и 0);
2. Процессор дергает специальную линию управления: “UART, я пишу данные!”;
3. Тайминг: процессору достаточно продержать это напряжение на шине всего один или два такта (миллионные доли секунды);
4. По очередному “тику” главного метронома UART мгновенно “фотографирует” состояние шины данных.

Вот тут в дело вступает “фотоаппарат”. Внутри UART есть физические элементы памяти – триггеры (flip-flops), собранные в регистры.

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

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

Как реализован тот самый backpressure (контроль потока)?

Внутри простейшего UART на самом деле не один, а два регистра (две коробки для данных):

• Transmit Data Register (TDR) / буфер: это “приемная”. Сюда процессор мгновенно закидывает байт.
• Shift Register (сдвиговый регистр): это “рабочий цех”. Отсюда биты по одному выталкиваются в провод TX.

Сценарий нормальной работы

Процессор кидает байт в TDR. Если рабочий цех (сдвиговый регистр) пуст, байт мгновенно переваливается туда и начинает медленно (со скоростью 9600 бод) уезжать в провод. При этом TDR снова становится пустым! Значит, процессор может закинуть туда еще один байт, пока предыдущий еще отправляется.

Что если процессор кинет третий байт?

Сдвиговый регистр занят отправкой первого. TDR занят ожиданием (там лежит второй). Если процессор просто запишет в TDR третий байт, он физически перезапишет (уничтожит) второй байт.

Аппаратно UART никак не бьет процессор по рукам. Данные просто потеряются.

Чтобы процессор не “перекормил” UART, железо предоставляет флаги состояния (Status Flags). Это специальные биты, которые UART выставляет для процессора:

• Флаг TXE (Transmit Empty) – буфер TDR пуст, можно кидать следующий байт.
• Флаг TC (Transmission Complete) – вообще все отправлено, линия свободна.

Есть 3 режима работы с этими флагами:

1. Простой опрос (Polling) – блокирующий режим:
   • Процессор в цикле постоянно читает флаг TXE.
   • “Свободно? Нет. Свободно? Нет. Свободно? Да!” → Пишет байт в UART.
   • Минус: Процессор тратит время впустую, ожидая медленный UART.
2. Прерывания (Interrupts) – асинхронный режим:
   • Процессор кидает первый байт и уходит управлять станком.
   • Как только UART отправляет байт и буфер пустеет, UART аппаратно “дергает” процессор (вызывает прерывание).
   • Процессор на микросекунду отвлекается, кидает следующий байт и возвращается к станку.
3. Аппаратные FIFO-буферы:
   • В современных микроконтроллерах и ПК внутри UART ставят не одну ячейку (TDR), а целую аппаратную очередь FIFO, например, на 16 или 64 байта;
   • Процессор может разом заполнить эту очередь и уйти, а UART будет сам потихоньку доставать оттуда байты и отправлять.

Но каким образом процессор может прочитать эти флаги? И как устройства на концах провода договариваются о паузах?

Здесь важно сделать ремарку: контроль потока бывает внешним (между двумя устройствами) и внутренним (между процессором и его собственным UART).

1. Внешний аппаратный контроль потока – сигналы RTS / CTS – почти не используется.

В классическом старом стандарте RS-232, помимо проводов RX, TX и GND, были еще дополнительные физические провода:

• RTS (Request To Send) – запрос на передачу;
• CTS (Clear To Send) – готов к приему.

Это называется Hardware Flow Control (аппаратное управление потоком).

Зачем это было нужно? В 80-х годах процессоры были очень медленными, а буферы памяти – крошечными. Если компьютер начинал слать данные на принтер слишком быстро, принтер не успевал их печатать.

Тогда принтер физически менял напряжение на проводе CTS (поднимал “красный флажок”). Компьютер видел это напряжение и переставал слать данные (ставил свой UART на паузу). Принтер допечатывал, опускал провод CTS (“зеленый флаг”), и передача возобновлялась.

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

Проблема переполнения на стороне приемника практически исчезла.

(Примечание: иногда встречается истинный программный контроль потока – Software Flow Control (XON/XOFF). В этом случае устройства обходятся без лишних проводов RTS/CTS, а просто шлют друг другу по линиям TX/RX специальные управляющие байты “Пауза” и “Продолжить”.)

2. Внутренний контроль (работа с регистрами UART) – флаги TXE, RXNE, TC – они есть всегда.

Те самые биты TXE и TC находятся в специальных регистрах внутри самого микроконтроллера. Без них не работает ни один UART в мире. Даже прерывания (Interrupts) и прямой доступ к памяти (DMA) аппаратно завязаны на эти же самые внутренние биты.

Но где же расположены эти флаги? Но подождите, UART – это железка, у которой есть вход – восемь битов, и выход – контакты TX/RX. Откуда здесь взялись флаги статуса?

На самом деле UART устроен сложнее. Это блок, внутри которого есть несколько отдельных регистров (ячеек памяти). Каждая ячейка состоит из 8 физических триггеров (транзисторов, хранящих логический 0 или 1).

В типичном UART есть как минимум 3 такие ячейки (регистра):

• Регистр данных (Data Register, DR). Это та самая “воронка”. Сюда процессор кладет байт, который нужно отправить.
• Регистр настроек (Control Register, CR). Сюда процессор при включении записывает настройки: “работай на скорости 9600 бод, используй 8 бит, без проверки четности”.
• Регистр статуса (Status Register, SR). Вот здесь и живут наши флаги! Это тоже аппаратная ячейка из 8 бит. Но процессор не может в нее писать, он может ее только читать.

Как процессор понимает, в какую ячейку писать/читать?

Между процессором и UART проложена не только шина данных (8 проводов, Data Bus). Там есть еще шина адреса (Address Bus).

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

• Адрес 0x4000_1000 – регистр статуса;
• Адрес 0x4000_1004 – регистр данных.

Все это происходит между процессором и UART, которые находятся на одном куске кремния. Другое устройство снаружи никогда не сможет по медным проводам прочитать эти флаги.

Но как же тогда главный процессор ПЛК узнает о переполнении на плате расширения?

Главный процессор ПЛК понятия не имеет о низкоуровневых флагах UART!

Защита от переполнения (backpressure) в Siemens реализована на разных уровнях:

1. Главный процессор ПЛК;
2. Микроконтроллер внутри платы расширения CM 1241;
3. Блок UART внутри платы расширения.

Уровень 1: ПЛК общается с платой расширения

Допустим, мы написали в TIA Portal программу, которая должна отправить 1 килобайт данных на частотный преобразователь. Главный процессор ПЛК не будет слать этот килобайт по одному байту. Он использует внутреннюю высокоскоростную шину (Backplane bus).

Но у платы расширения есть своя оперативная память (RAM) – скажем, буфер на 2 килобайта.

Как происходит контроль потока здесь? Процессор ПЛК использует специальный высокоуровневый протокол связи с модулем.

Когда мы в TIA Portal вызываем блок отправки (например, Send_PTP или Modbus_Master), у этого блока есть выходы (программные переменные):

• REQ (Request) – команда отправить.
• BUSY (Занят) – модуль сейчас переваривает данные.
• DONE (Готово) – модуль все отправил.

ПЛК по скоростной шине “заливает” весь килобайт данных в оперативную память модуля расширения разом. Модуль говорит ПЛК: “Я принял посылку, буфер полон, начинаю работу” и выставляет для ПЛК сигнал BUSY = TRUE.

ПЛК видит сигнал BUSY и понимает: “ага, пока не отправляю туда следующую пачку, чтобы не переполнить память”. Главный процессор идет спокойно выполнять остальную логику (крутить моторы, читать датчики).

Уровень 2: Плата расширения общается с UART

Вот килобайт данных лежит в оперативной памяти маленького микроконтроллера внутри модуля CM 1241. И теперь этот контроллер должен выплюнуть их наружу со скоростью 9600 бод.

Вот здесь и начинается та магия аппаратных флагов, о которой мы говорили выше!

Микропроцессор модуля берет первый байт из своей оперативки и кидает его в свой внутренний блок UART. Затем он проверяет аппаратный флаг статуса UART (тот самый TXE - буфер пуст):

• Флаг поднят? Нет. Микроконтроллер модуля ждет (или уходит в прерывание);
• Ушел первый байт? Да, UART аппаратно поднял флаг;
• Микроконтроллер модуля берет второй байт из оперативки и кидает в UART.

И так он делает 1000 раз, пока весь килобайт не улетит по проводам на завод.

Как цикл завершается?

Когда микроконтроллер модуля скормил блоку UART последний байт и увидел флаг “Передача завершена” (TC), он понимает: “Килобайт отправлен”.

Тогда этот маленький контроллер по высокоскоростной шине посылает главному процессору ПЛК сообщение: “Шеф, я все сделал!”.

Блок в TIA Portal снимает сигнал BUSY и на один такт выдает DONE = TRUE. Главный процессор ПЛК видит это и понимает: “Отлично, можно слать следующий килобайт”.

Резюме: как не происходит переполнения?

ПЛК не переполняет модуль расширения, потому что смотрит на высокоуровневый флаг BUSY (программно реализованный инженерами Siemens через высокоскоростную шину).

Модуль расширения не переполняет свой блок UART, потому что передача в UART модуля организована через прерывания по флагу TXE регистра статуса. При установке TXE=1 периферия генерирует interrupt, и обработчик загружает следующий байт в передающий регистр.

“Обработчик” в данном случае – это кусок кода прошивки (ISR, interrupt service routine), который выполняется CPU, когда железо (UART) поднимает прерывание по TXE.