Contrôler 65 280 relais avec Arduino : solutions d'extension IO et relais

Composants et fournitures

Composant	Quantité	Notes
Arduino Nano R3	1
Extenseur IO (IO Expander)	1	Extenseur IO
Extenseur Relais (Relay Expander)	1
Extenseur IO (IO Extender)	1
Carte relais 16 canaux Arduino	1

Applications et services en ligne

• Arduino IDE

À propos du projet

Utilisez l'Extenseur IO et l'Extenseur Relais pour contrôler jusqu'à 65 280 relais.

Besoin d'ajouter beaucoup de relais à votre projet ? Alors vous avez besoin de l'Extenseur IO avec des Externseurs Relais. Chaque Externseur IO peut contrôler jusqu'à 16 Externseurs Relais en chaîne pour un total de 256 relais. En connectant 255 Externseurs IO ensemble, vous pouvez contrôler sélectivement jusqu'à 65 280 relais.

Contrôler des relais avec un seul Externseur IO

Liste des fonctionnalités

• Utilise des cartes relais Arduino 16 canaux bon marché (< 15 $).
• Commandes de contrôle de relais simples à utiliser.
• Contrôle d'un relais individuel ou d'une banque à la fois.
• Aucun pilote requis. Économise de l'espace code.
• Aucun espace de données pour maintenir l'état des relais.
• Aucune alimentation supplémentaire nécessaire.

Pièces nécessaires pour construire une banque de relais

• Extenseur IO
• Extenseur IO (IO Extender)
• Extenseur Relais
• Carte relais 16 canaux Arduino

Schéma de câblage

Note : Dans le schéma ci-dessus, l'Extenseur IO et l'Arduino Nano sont alimentés par la première carte relais. Tous les Externseurs Relais sont alimentés par la carte relais à laquelle ils sont connectés.

Code : Contrôler 64 relais avec un seul Externseur

/* IO Expander
 * Contrôler 64 Relais
 */
#include <SoftwareSerial.h>
#include "IOExpander.h"
#include <avr/wdt.h>
//#define SERIAL_DEBUG
#define MAX_RELAYS 64

#ifdef SERIAL_DEBUG
SoftwareSerial swSerial(8,7);
#endif

char cmd[10];

void setup() {
  Serial.begin(115200);
  #ifdef SERIAL_DEBUG
  swSerial.begin(115200);
  swSerialEcho = &swSerial;
  #endif
  wdt_enable(WDTO_8S);
  sprintf(cmd, "eb%d", MAX_RELAYS / 16);
  SerialCmdDone(cmd);
}

void loop() {
  static int i = 1;
  sprintf(cmd, "e%df", i);
  SerialCmdDone(cmd);
  if (i++ >= MAX_RELAYS) i = 1;
  sprintf(cmd, "e%do", i);
  SerialCmdDone(cmd);
  delay(100);
  wdt_reset();
}

Plusieurs Externseurs IO contrôlant des relais

Une autre façon de contrôler des relais est d'utiliser plusieurs Externseurs IO. Cela permet de distribuer capteurs et relais vers un réseau central ou en étoile, mais d'interconnecter tous les Externseurs IO sur un bus série unique. Si vous devez séparer les Externseurs IO jusqu'à 1200 m (4000 ft), utilisez les Externseurs IO (IO Extenders) comme montré ci-dessous avec du câble réseau Cat5 standard.

Schéma de câblage

Note : Dans le schéma ci-dessus, tous les Externseurs IO et l'Arduino Nano sont alimentés par la première carte relais via le bus série. Tous les Externseurs Relais sont alimentés par la carte relais à laquelle ils sont connectés.

Code : Contrôler 64 relais avec plusieurs Externseurs

/* IO Expander
 * Relay Bonnaza with IO Expanders!
 */
#include <HardwareSerial9Bit.h>
#include "IOExpander9Bit.h"
#include <avr/wdt.h>
#define MAX_BOARDS 4

char cmd[10];

void setup() {
  Serial9Bit.begin(115200, SERIAL_9N1);
  Serial9Bit.write(0); // Set IO Expanders to 9-bit
  wdt_enable(WDTO_8S);
  for (int board = 1; board <= 4; board++)
    SerialCmdDone(board, "eb1");
}

void loop() {
  static int board = 1;
  static int relay = 1;
  sprintf(cmd, "e%df", relay);
  SerialCmdDone(board, cmd);
  if (++relay > 16) {
    relay = 1;
    if (++board > MAX_BOARDS) board = 1;
  }
  sprintf(cmd, "e%do", relay);
  SerialCmdDone(board, cmd);
  delay(100);
  wdt_reset();
}

Alors pourquoi ai-je besoin de contrôler autant de relais ?

Une telle application est l'aquaponie ou l'hydroponie. Beaucoup de capteurs et dispositifs doivent être automatisés jusqu'à chaque bac de culture ou plante individuelle. Cela nécessite une entrée/sortie extrême et l'Extenseur IO la fournit.

Procurez-vous votre Externseur IO aujourd'hui et construisez votre système !

Code

Contrôler 64 relais avec un seul Externseur (C/C++)

/* IO Expander * * Control 64 Relays * */
#include <SoftwareSerial.h>
#include "IOExpander.h"
#include <avr/wdt.h>
//#define SERIAL_DEBUG
#define MAX_RELAYS 64
#ifdef SERIAL_DEBUG
SoftwareSerial swSerial(8,7);
#endif
char cmd[10];
void setup() {
  Serial.begin(115200);
  #ifdef SERIAL_DEBUG
  swSerial.begin(115200);
  swSerialEcho = &swSerial;
  #endif
  wdt_enable(WDTO_8S);
  sprintf(cmd, "eb%d", MAX_RELAYS / 16);
  SerialCmdDone(cmd);
}
void loop() {
  static int i = 1;
  sprintf(cmd, "e%df", i);
  SerialCmdDone(cmd);
  if (i++ >= MAX_RELAYS) i = 1;
  sprintf(cmd, "e%do", i);
  SerialCmdDone(cmd);
  delay(100);
  wdt_reset();
}

Contrôler 64 relais avec plusieurs Externseurs (C/C++)

/* IO Expander * * Relay Bonnaza with IO Expanders! * */
#include <HardwareSerial9Bit.h>
#include "IOExpander9Bit.h"
#include <avr/wdt.h>
#define MAX_BOARDS 4
char cmd[10];
void setup() {
  Serial9Bit.begin(115200, SERIAL_9N1);
  Serial9Bit.write(0); // Set IO Expanders to 9-bit
  wdt_enable(WDTO_8S);
  for (int board = 1; board <= 4; board++)
    SerialCmdDone(board, "eb1");
}
void loop() {
  static int board = 1;
  static int relay = 1;
  sprintf(cmd, "e%df", relay);
  SerialCmdDone(board, cmd);
  if (++relay > 16) {
    relay = 1;
    if (++board > MAX_BOARDS) board = 1;
  }
  sprintf(cmd, "e%do", relay);
  SerialCmdDone(board, cmd);
  delay(100);
  wdt_reset();
}

Schémas