Я написал длинный пост о RS485.

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

Даже RPI кажется лишним. Другой Uno легко мог бы контролировать ваши линии RS485 и подключаться через Ethernet (через Ethernet-экран) к остальной части вашего дома или к тому, чем вы занимаетесь.

... нет никаких положений, позволяющих избежать «столкновений» при общении...

Ну, вы это встраиваете. Вы присваиваете каждому Mega адрес (например, хранящийся в EEPROM), затем «адресуете» нужный вам модуль и ждете ответа. Например, в коде с моей страницы выше:

Мастер

#include "RS485_protocol.h"
#include <SoftwareSerial.h>

const byte ENABLE_PIN = 4;
const byte LED_PIN = 13;

SoftwareSerial rs485 (2, 3);  // вывод приема, вывод передачи

// процедуры обратного вызова
  
void fWrite (const byte what)
  {
  rs485.write (what);  
  }
  
int fAvailable ()
  {
  return rs485.available ();  
  }

int fRead ()
  {
  return rs485.read ();  
  }

void setup()
{
  rs485.begin (28800);
  pinMode (ENABLE_PIN, OUTPUT);  // включение выхода драйвера
  pinMode (LED_PIN, OUTPUT);  // встроенный светодиод
}  // конец настройки
  
byte old_level = 0;

void loop()
{

  // чтение потенциометра
  byte level = analogRead (0) / 4;
  
  // нет изменений? забудьте
  if (level == old_level)
    return;
      
  // собрать сообщение
  byte msg [] = { 
     1,    // устройство 1
     2,    // включить свет
     level // до какого уровня
  };

  // отправить на подчиненное устройство
  digitalWrite (ENABLE_PIN, HIGH);  // разрешить отправку
  sendMsg (fWrite, msg, sizeof msg);
  digitalWrite (ENABLE_PIN, LOW);  // отключить отправку

  // получить ответ
  byte buf [10];
  byte received = recvMsg (fAvailable, fRead, buf, sizeof buf);
  
  digitalWrite (LED_PIN, received == 0);  // включить светодиод, если ошибка
  
  // отправлять только один раз при успешном изменении
  if (received)
    old_level = level;

}  // конец цикла

Вы настраиваете приёмопередатчик RS485 на отправку или приём. Обычно он находится в режиме приёма, а для отправки «пакета» данных переключаетесь в режим отправки. (См. «Включить отправку» выше).

Теперь адресуемое устройство переводит свой приёмопередатчик в режим отправки и отвечает. В коде в написанной мной библиотеке есть тайм-аут, поэтому, если ведомое устройство неисправно, приём прекращается. Вы можете помнить об этом на ведущем устройстве и стараться реже связываться с ним. Или же вам может быть всё равно, что тайм-аут короткий.

Раб

#include <SoftwareSerial.h>
#include "RS485_protocol.h"

SoftwareSerial rs485 (2, 3);  // вывод приема, вывод передачи
const byte ENABLE_PIN = 4;

void fWrite (const byte what)
  {
  rs485.write (what);  
  }
  
int fAvailable ()
  {
  return rs485.available ();  
  }

int fRead ()
  {
  return rs485.read ();  
  }
  
void setup()
{
  rs485.begin (28800);
  pinMode (ENABLE_PIN, OUTPUT);  // включение выхода драйвера
}

void loop()
{
  byte buf [10];
  
  byte received = recvMsg (fAvailable, fRead, buf, sizeof (buf));
  
  if (received)
    {
    if (buf [0] != 1)
      return;  // не мое устройство
      
    if (buf [1] != 2)
      return;  // неизвестная команда
    
    byte msg [] = {
       0,  // устройство 0 (главное)
       3,  // получена команда включить свет
    };
    
    delay (1);  // дать мастеру время подготовиться к приему
    digitalWrite (ENABLE_PIN, HIGH);  // разрешить отправку
    sendMsg (fWrite, msg, sizeof msg);
    digitalWrite (ENABLE_PIN, LOW);  // отключить отправку
    
    analogWrite (11, buf [2]);  // установить уровень освещенности
   }  // конец, если что-то получено
   
}  // конец цикла

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

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

Моя проводка:

Чтобы продемонстрировать идею, я установил два устройства Uno, соединив их примерно 8-метровым кабелем для звонков (даже не витой парой и уж точно не экранированным).

Один Uno запускал стандартный скетч таблицы ASCII (со скоростью 9600 бод), его вывод Tx был подключен к LTC1480, а затем выводы A/B были подключены к проводу звонка.

Другой Uno был подключен как USB-интерфейс (сброс подключен к земле), и он просто повторял все, что приходило на контакт Tx к USB.

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

Мне вообще не понадобится никакой опрос, так как с вашим подходом я могу реализовать контекст «один главный/несколько подчинённых»… но с «подвижным» главным. Правильно?

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

Я считаю свои Arduino чрезвычайно надежными при выполнении простых задач (например, отпирании двери при предъявлении RFID-карты).

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

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

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

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

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

Master: Slave 3, what is your status?
Slave 3: Lights 1 and 4 on, lights 2 and 3 off.

Мне вообще не понадобится никакой опрос, так как с вашим подходом я могу реализовать контекст «один главный/несколько подчинённых»… но с «подвижным» главным. Правильно?

Я немного поразмыслил над этим и теперь думаю, что можно создать систему, практически не требующую главного устройства. Работать это может так:

• Каждое устройство имеет свой собственный адрес, который оно получает из EEPROM (или DIP-переключателей). Например, 1, 2, 3, 4, 5 ...

• Вы выбираете диапазон адресов, которые собираетесь использовать (например, максимум 10)

• При включении устройство сначала прослушивает другие устройства, «общающиеся» на шине. Надеемся, что оно услышит хотя бы одно (если нет, см. ниже).

• Мы выбираем фиксированный «пакет сообщения», скажем, из 50 байт, включая адрес, CRC и т. д. При скорости 9600 бод отправка займет 52 мс.

• Каждое устройство получает «слот» времени и ждет своей очереди, чтобы связаться с шиной.

• По достижении своего временного интервала устройство переходит в режим вывода и рассылает пакет, содержащий его собственный адрес. Таким образом, все остальные устройства теперь могут считывать его состояние (и при необходимости выполнять соответствующие действия). Например, устройство 1 может сообщить, что выключатель 3 замкнут, что означает, что устройство 2 должно включить свет.

• В идеале вы понимаете, что ваш временной интервал наступил, потому что адрес вашего устройства на единицу больше адреса только что прослушанного вами пакета. Например, вы — устройство 3. Вы только что услышали, как устройство 2 объявило о своём статусе. Теперь ваша очередь. Конечно, вы переходите к максимальному номеру, поэтому после устройства 10 вы возвращаетесь к устройству 1.

• Если устройство отсутствует и не отвечает, вы даёте ему, скажем, половину временного интервала для ответа, а затем предполагаете, что оно неисправно, и все устройства на шине теперь предполагают, что начался следующий временной интервал. (Например, вы услышали устройство 2, устройство 3 должно ответить, после 25 мс бездействия устройство 4 теперь может ответить). Это правило даёт устройству 25 мс для ответа, чего должно быть достаточно, даже если оно обслуживает прерывание или что-то подобное.

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

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

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

В этом случае:

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

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

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

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

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

Демонстрация системы без мастера

Это была интересная задача, поэтому я собрал демо-версию, как это сделать, не имея какого-либо конкретного мастера, как описано выше.

Сначала вам нужно настроить текущий адрес устройства и количество устройств в EEPROM, поэтому запустите этот скетч, изменив myAddress для каждого Arduino:

#include <EEPROM.h>

const byte myAddress = 3;
const byte numberOfDevices = 4;

void setup ()
  {
  if (EEPROM.read (0) != myAddress)
    EEPROM.write (0, myAddress);
  if (EEPROM.read (1) != numberOfDevices)
    EEPROM.write (1, numberOfDevices);
    
  }  // end of setup

void loop () { }

Теперь загрузите это на каждое устройство:

/*
 Multi-drop RS485 device control demo.
 
 Devised and written by Nick Gammon.
 Date: 7 September 2015
 Version: 1.0
 
 Licence: Released for public use.
 
 For RS485_non_blocking library see: http://www.gammon.com.au/forum/?id=11428
 For JKISS32 see: http://forum.arduino.cc/index.php?topic=263849.0
*/

#include <RS485_non_blocking.h>
#include <SoftwareSerial.h>
#include <EEPROM.h>

// the data we broadcast to each other device
struct
  {
  byte address;
  byte switches [10];
  int  status;
  }  message;

const unsigned long BAUD_RATE = 9600;
const float TIME_PER_BYTE = 1.0 / (BAUD_RATE / 10.0);  // seconds per sending one byte
const unsigned long PACKET_LENGTH = ((sizeof (message) * 2) + 6); // 2 bytes per payload byte plus STX/ETC/CRC
const unsigned long PACKET_TIME =  TIME_PER_BYTE * PACKET_LENGTH * 1000000;  // microseconds

// software serial pins
const byte RX_PIN = 2;
const byte TX_PIN = 3;
// transmit enable
const byte XMIT_ENABLE_PIN = 4;

// debugging pins
const byte OK_PIN = 6;
const byte TIMEOUT_PIN = 7;
const byte SEND_PIN = 8;
const byte SEARCHING_PIN = 9;
const byte ERROR_PIN = 10;

// action pins (demo)
const byte LED_PIN = 13;
const byte SWITCH_PIN = A0;


// times in microseconds
const unsigned long TIME_BETWEEN_MESSAGES = 3000;  
unsigned long noMessagesTimeout;                  

byte nextAddress;
unsigned long lastMessageTime;
unsigned long lastCommsTime;
unsigned long randomTime;

SoftwareSerial rs485 (RX_PIN, TX_PIN);  // receive pin, transmit pin
  
// what state we are in
enum {
   STATE_NO_DEVICES,
   STATE_RECENT_RESPONSE,
   STATE_TIMED_OUT,
} state;

// callbacks for the non-blocking RS485 library
size_t fWrite (const byte what)
  {
  rs485.write (what);  
  }
  
int fAvailable ()
  {
  return rs485.available ();  
  }

int fRead ()
  {
  lastCommsTime = micros ();
  return rs485.read ();  
  }
  
// RS485 library instance
RS485 myChannel (fRead, fAvailable, fWrite, 20);

// from EEPROM
byte myAddress;        // who we are
byte numberOfDevices;  // maximum devices on the bus

// Initial seed for JKISS32
static unsigned long x = 123456789,
                     y = 234567891,
                     z = 345678912,
                     w = 456789123,
                     c = 0;

// Simple Random Number Generator
unsigned long JKISS32 ()
  {
  long t;
  y ^= y << 5; 
  y ^= y >> 7; 
  y ^= y << 22;
  t = z + w + c; 
  z = w; 
  c = t < 0; 
  w = t & 2147483647;
  x += 1411392427;
  return x + y + w;
  }  // end of JKISS32
  
void Seed_JKISS32 (const unsigned long newseed)
  {
  if (newseed != 0)
    {
    x = 123456789;
    y = newseed;
    z = 345678912;
    w = 456789123;
    c = 0;
    }
  }  // end of Seed_JKISS32
  
void setup ()
  {
  // debugging prints
  Serial.begin (115200);
  // software serial for talking to other devices
  rs485.begin (BAUD_RATE);
  // initialize the RS485 library
  myChannel.begin ();
  
  // debugging prints
  Serial.println ();
  Serial.println (F("Commencing"));
  myAddress = EEPROM.read (0);
  Serial.print (F("My address is "));
  Serial.println (int (myAddress));
  numberOfDevices = EEPROM.read (1);
  Serial.print (F("Max address is "));
  Serial.println (int (numberOfDevices));  

  if (myAddress >= numberOfDevices)
    Serial.print (F("** WARNING ** - device number is out of range, will not be detected."));
  
  Serial.print (F("Packet length = "));
  Serial.print (PACKET_LENGTH);  
  Serial.println (F(" bytes."));

  Serial.print (F("Packet time = "));
  Serial.print (PACKET_TIME);  
  Serial.println (F(" microseconds."));
  
  // calculate how long to assume nothing is responding
  noMessagesTimeout = (PACKET_TIME + TIME_BETWEEN_MESSAGES) * numberOfDevices * 2;

  Serial.print (F("Timeout for no messages = "));
  Serial.print (noMessagesTimeout);  
  Serial.println (F(" microseconds."));
  
  // set up various pins
  pinMode (XMIT_ENABLE_PIN, OUTPUT);
  
  // demo action pins
  pinMode (SWITCH_PIN, INPUT_PULLUP);
  pinMode (LED_PIN, OUTPUT);
  
  // debugging pins
  pinMode (OK_PIN, OUTPUT);
  pinMode (TIMEOUT_PIN, OUTPUT);
  pinMode (SEND_PIN, OUTPUT);
  pinMode (SEARCHING_PIN, OUTPUT);
  pinMode (ERROR_PIN, OUTPUT);
  
  // seed the PRNG
  Seed_JKISS32 (myAddress + 1000);
  
  state = STATE_NO_DEVICES;
  nextAddress = 0;

  randomTime = JKISS32 () % 500000;  // microseconds
  }  // end of setup

// set the next expected address, wrap around at the maximum
void setNextAddress (const byte current)
  {
  nextAddress = current;  
  if (nextAddress >= numberOfDevices)
    nextAddress = 0;
  }  // end of setNextAddress


// Here to process an incoming message
void processMessage ()
  {
  
  // we cannot receive a message from ourself
  // someone must have given two devices the same address
  if (message.address == myAddress)
    {
    digitalWrite (ERROR_PIN, HIGH);
    while (true)
      { }  // give up  
    }  // can't receive our address
    
  digitalWrite (OK_PIN, HIGH);
  
  // handle the incoming message, depending on who it is from and the data in it
  
  // make our LED match the switch of the previous device in sequence
  if (message.address == (myAddress - 1))
    digitalWrite (LED_PIN, message.switches [0]);
    
  digitalWrite (OK_PIN, LOW);
  } // end of processMessage
  
// Here to send our own message  
void sendMessage ()
  {
  digitalWrite (SEND_PIN, HIGH);
  memset (&message, 0, sizeof message);
  message.address = myAddress;
  
  // fill in other stuff here (eg. switch positions, analog reads, etc.)
  
  message.switches [0] = digitalRead (SWITCH_PIN);
  
  // now send it
  digitalWrite (XMIT_ENABLE_PIN, HIGH);  // enable sending  
  myChannel.sendMsg ((byte *) &message, sizeof message);
  digitalWrite (XMIT_ENABLE_PIN, LOW);  // disable sending
  setNextAddress (myAddress + 1);
  digitalWrite (SEND_PIN, LOW);
  
  lastCommsTime = micros ();   // we count our own send as activity
  randomTime = JKISS32 () % 500000;  // microseconds
  }  // end of sendMessage
  
void loop ()
  {
  // incoming message?
  if (myChannel.update ())
    {
    memset (&message, 0, sizeof message);
    int len = myChannel.getLength ();
    if (len > sizeof message)
      len = sizeof message;
    memcpy (&message, myChannel.getData (), len);
    lastMessageTime = micros ();
    setNextAddress (message.address + 1);
    processMessage ();
    state = STATE_RECENT_RESPONSE;
    }  // end of message completely received
   
  // switch states if too long a gap between messages
  if  (micros () - lastMessageTime > noMessagesTimeout)
    state = STATE_NO_DEVICES;
  else if  (micros () - lastCommsTime > PACKET_TIME)
    state = STATE_TIMED_OUT;
    
  switch (state)
    {
    // nothing heard for a long time? We'll take over then
    case STATE_NO_DEVICES:
      if (micros () - lastCommsTime >= (noMessagesTimeout + randomTime))
        {
        Serial.println (F("No devices."));
        digitalWrite (SEARCHING_PIN, HIGH);
        sendMessage ();
        digitalWrite (SEARCHING_PIN, LOW);
        }
      break;
      
    // we heard from another device recently
    // if it is our turn, respond
    case STATE_RECENT_RESPONSE:  
      // we allow a small gap, and if it is our turn, we send our message
      if (micros () - lastCommsTime >= TIME_BETWEEN_MESSAGES && myAddress == nextAddress)
        sendMessage ();
      break;
      
    // a device did not respond in its slot time, move onto the next one
    case STATE_TIMED_OUT:
      digitalWrite (TIMEOUT_PIN, HIGH);
      setNextAddress (nextAddress + 1);
      lastCommsTime += PACKET_TIME;
      digitalWrite (TIMEOUT_PIN, LOW);
      state = STATE_RECENT_RESPONSE;  // pretend we got the missing response
      break;
      
    }  // end of switch on state
    
  }  // end of loop
  

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

В ходе тестирования я обнаружил, что светодиод мгновенно включается и выключается.

Когда все устройства отключены, первое подключенное устройство будет «охотиться» за другими. Если у вас подключены отладочные светодиоды, как у меня, вы можете увидеть, как светодиод «поиска» загорается через случайные интервалы, пока устройство передает пакеты данных со случайно меняющимися интервалами. После подключения второго устройства они успокаиваются и просто обмениваются информацией. Я тестировал с тремя подключенными устройствами одновременно.

Возможно, с HardwareSerial было бы надёжнее — я использовал SoftwareSerial для отладки. Несколько небольших изменений помогут этого добиться.

Измененная схема

Снимки экрана кода в действии

Эти изображения показывают, как работает код. Сначала, с одним подключенным устройством:

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

Теперь мы видим блоки данных с двух устройств с примерно одинаковыми промежутками посередине. Я настроил его на четыре устройства, но присутствуют только два, поэтому мы видим два блока данных и два пробела.

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

Если вы проверяете цифры, они были получены при удвоенной скорости передачи данных в качестве теста до 19200 бод.

Испытание прокладки кабеля

Для надлежащего тестирования оборудования я подключил устройства к домашнему кабелю UTP. У меня есть кабель Cat-5, проложенный из разных комнат к центральному распределительному щитку. Если соединить два конца дома (достаточно длинный), всё работает отлично. Для начала, между Arduino и розеткой есть кабель длиной 5 метров. Плюс ещё один кабель длиной 5 метров на другом конце. Затем идут два кабеля длиной примерно по 15 метров от комнат до распределительного помещения, а внутри кабеля есть короткий соединительный кабель для их соединения.

Это было при том, что платы все еще были запрограммированы на работу со скоростью 19200 бод.