1

Bausatz I2C-Master mit Arduino UNO und LAN Option

24,90 €
inkl. MwSt. zzgl. Versand
Lieferzeit: Lieferzeit 3-5 Arbeitstage Deutschland / ca. 10 Tage Europa
I2ARL-Bk
4260404260967

Bausatz I2C-Master mit ARDUINO-UNO und optional W5500 LAN auf DIN-Schiene

Kompakter I2C-Master mit einem "Arduino UNO" für die Hutschiene.

Mit dem Modul lassen sich eine Vielzahl von Anwendungen mit der Arduino-IDE oder mit Platform IO verwirklichen.

Zum Beispiel:

- I2C Modbus-TCP Server
- I2C MQTT Client / I2C-MQTT-Gateway

Klemmen: feste Klemmen

Beschreibung:

Mit dem I2C-Master Modul können Sie eigene Programme entwickeln und die I2C-Peripherie nutzen.
auf dem ATMEGA328P ist der Arduino Bootloader und ein kleines Demo-Programm vorinstalliert.
Das Programm kann angepasst und aufgespielt werden.

- Frei programmierbar mit Arduino-IDE
- Status-LED für SDA, SCL und INT
- Jumper zum aktivieren der Terminierung
- Blaue LED frei programmierbar. Z.B. für Status der LAN-Verbindung
- Steckplatz für WizNET W5500 LAN-Modul
- BUS-Stecker zum Anschluss weiterer I2C-Module
- Steckplatz für USB-RS232 Programmieradapter

Bitte den Programmieradapter separat bestellen!
 Micro USB to TTL UART Programmieradapter 3,3V/5V mit CP2102 

Links:

Wir werden im Blog demnächst ein paar Beispiele veröffentlichen.

Modbus-TCP-Server
- Einlesen der digitalen Eingänge und Übertragung zu einer S7-1500 SPS von SIEMENS
- Steuern von Ausgängen über Modbus-TCP
- Analogwerte lesen und schreiben

MQTT-Gateway
- Übertragen von digitalen und analogen Eingängen zu einem MQTT-Broker
- Empfangen von MQTT Nachrichten und steuern von analogen oder digitalen Ausgängen

Downloads:

Datenblatt      Schaltplan     

Stückliste:

5 Keramik-Kondensator 100 nF
2 Keramik-Kondensator 27 pF
1 Elko 10yF
1 Elko 100yF
1 Widerstandsnetzwerk 4x 1,5 kOhm 5 Pins
1 Widerstandsnetzwerk 4x 4,7 kOhm 5 Pins
1 Widerstand 47 kOhm
1 Widerstand 1 MOhm
1 ATMEGA328P DIL 28 mit Fassung
1 LS 7405 DIL 14 mit Fassung
1 LM117-3,3 SMD
1 Quarz 16 MHz
1 LED 3 mm grün 2mA
1 LED 3 mm gelb 2mA
1 LED 3 mm rot 2mA
1 LED 3 mm blau 2mA
3 Buchsenleiste 1x6pol für LAN / USB
3 Pfostenleiste 2polig + Jumper
1 Anschlussklemme 5 pol fest oder steckbar
1 Leiterplatte bleifrei verzinnt mit Lötstopmaske

Zubehör:

438-home_default.jpg 

I2ARL-Bk

Besondere Bestellnummern

ean13
4260404260967
Neu

Beispiel I2C-Modbus-TCP Server

In dem Programmbeispiel werden die Eingangssignale der digitalen I2C-SPS-Karte I2HE und die Analogwerte von der I2HAE Karte eingelesen und in die Modbus Input-Register einsortiert.

      digitale Eingänge      Input-Register 0 = 30001 in der SPS
Messwert 1 Input-Register 1 = 30002 in der SPS
Messwert 2 Input-Register 2 = 30003 in der SPS
Messwert 3 Input-Register 3 = 30004 in der SPS
Messwert 4 Input-Register 4 = 30005 in der SPS
Messwert 5 Input-Register 5 = 30006 in der SPS



Danach werden die Modbus-Holding Register, von der SPS zur digitalen SPS-Ausgangskarte I2HA und die vier Analogwerte zur Analog-Ausgangskarte I2HAA übertragen

      Holding-Register 0 = 40001 aus der SPS      Digitale Ausgänge
Holding-Register 1 = 40002 aus der SPS Analogwert 1
Holding-Register 2 = 40003 aus der SPS Analogwert 2
Holding-Register 3 = 40004 aus der SPS Analogwert 3
Holding-Register 4 = 40005 aus der SPS Analogwert 4



Hardware-Aufbau

Test-Aufbau für I2C-Modbus Demo



Arduino-Programm

/*
 ==============================================
 Test I2C-Modbus TCP Server
 ==============================================
 Board Arduino UNO
 Version 1.0

 Quelle:
 Modbus-Arduino Example (Modbus IP)
 Copyright by André Sarmento Barbosa
 http://github.com/andresarmento/modbus-arduino

 ==============================================
 */

String Version = "V1.0";            // Version

#include <Wire.h>                   // I2C-Lib
#include <avr/wdt.h>                // Watchdog
#include <Modbus.h>                 // ArduinoRS485 library
#include <ModbusIP.h>               // Modbus

//ModbusIP object
ModbusIP mb;
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };  
byte ip[] =  { 192, 168, 1, 7};  

// Pins definieren
int I2C_SCL  = 19;    // PC5 = I2C-Bus SCL
int I2C_SDA  = 18;    // PC4 = I2C-Bus SDA
int I2C_INT  = 17;    // PC3 = I2C-Bus INT
int LED_BL   =  8;    // PB0 = LED Blau

// I2C-Baugruppen definieren und globale Variablen anlegen
#define I2E1_ADDR  112 >> 1   // I2C-Digital INPUT  Addresse als 7 Bit
int  I2E1_WERT=0;
bool I2E1_OK;
#define I2A1_ADDR   64 >> 1   // I2C-Digital OUTPUT Addresse als 7 Bit
int I2A1_WERT=0;
bool I2A1_OK;
#define I2AE1_ADDR  16 >> 1   // I2C-Analog  INPUT  Addresse als 7 Bit
int I2AE1_WERT[5];
bool I2AE1_OK;
#define I2AA1_ADDR 176 >> 1   // I2C-Analog  OUTPUT Addresse als 7 Bit
int I2AA1_WERT[4];
bool I2AA1_OK;

// Variablen deklarieren
byte ALTWERT;
long ts;

void setup() {

  // Pin-Modes einstellen
  // --------------------
  pinMode(I2C_INT, INPUT);
  pinMode(LED_BL, OUTPUT);

  Serial.begin(9600);                   // Serielle Schnittstelle konfigurieren
  Wire.begin();                         // I2C-Pins definieren
 
  Serial.println("Version " + Version); // Version ausgeben
 
  // setzten aller Bits der Eingabekarte auf 1
  // -----------------------------------------
  Wire.beginTransmission(I2E1_ADDR);   // Start Übertragung zum PCF8574
  Wire.write(0xFF);                      // Alle Bits sind Eingänge
  Wire.endTransmission();                // Ende

  // Blaue LED abschalten
  // --------------------
  digitalWrite(LED_BL, LOW);             // Blaue LED AUS

  // Modbus-TCP Server starten
  // -------------------------
  Serial.println("Modbus TCP Server");
  mb.config(mac, ip);

  // Input-Register anlegen (Server -> SPS)
  mb.addIreg(0);  // Input-Register 0 = 30001 in der SPS
  mb.addIreg(1);  // Input-Register 1 = 30002 in der SPS
  mb.addIreg(2);  // Input-Register 2 = 30003 in der SPS
  mb.addIreg(3);  // Input-Register 3 = 30004 in der SPS
  mb.addIreg(4);  // Input-Register 4 = 30005 in der SPS
  mb.addIreg(5);  // Input-Register 5 = 30006 in der SPS
 
  // Holding Register anlegen (SPS -> Server)
  mb.addHreg(0);  // Holding-Register 0 = 40001 in der SPS
  mb.addHreg(1);  // Holding-Register 1 = 40002 in der SPS
  mb.addHreg(2);  // Holding-Register 2 = 40003 in der SPS
  mb.addHreg(3);  // Holding-Register 3 = 40004 in der SPS
  mb.addHreg(4);  // Holding-Register 4 = 40005 in der SPS
 
}

void loop() {

  //Call once inside loop() - all magic here
  mb.task();  // Modbus-Task

  // Einlesen der Bits von der I2C-INPUT Karte
  // ------------------------------------------
  // 8-Bit von der Eingangkarte lesen
  I2E(I2E1_ADDR, I2E1_WERT, I2E1_OK);         // Ein Byte von der DI-Karte Adresse 112 lesen
  if (I2E1_OK == 0) {
    Serial.print("Keine Antwort vom Slave ");
    Serial.println (I2E1_ADDR);
  }

  // Wert zur SPS
  mb.Ireg(0, I2E1_WERT) ;                     // Input-Register 0 = 30001 in der SPS
 

  // Ausgeben der Bits an die I2C-OUTPUT Karte
  // ------------------------------------------  
  // Wert von der SPS umrangieren
  I2A1_WERT = mb.Hreg(0);                     // Holding-Register 0 = 40001 in der SPS
  // 8-Bit zur Ausgangskarte schicken
  I2A(I2A1_ADDR, I2A1_WERT, I2A1_OK);


  // Analogwerte einlesen und berechnen
  // ----------------------------------
  // Werte von Analogkarte lesen
  I2AE(I2AE1_ADDR, I2AE1_WERT, I2AE1_OK);
  // Werte zur SPS
  mb.Ireg(1, I2AE1_WERT[0]);  // Input-Register 1 = 30002 in der SPS
  mb.Ireg(2, I2AE1_WERT[1]);  // Input-Register 2 = 30003 in der SPS
  mb.Ireg(3, I2AE1_WERT[2]);  // Input-Register 3 = 30004 in der SPS
  mb.Ireg(4, I2AE1_WERT[3]);  // Input-Register 3 = 30005 in der SPS
  mb.Ireg(5, I2AE1_WERT[4]);  // Input-Register 3 = 30006 in der SPS


  // Analogwerte ausgeben
  // --------------------
  // Wert von der SPS
  I2AA1_WERT[0] = mb.Hreg(1);  // Holding-Register 1 = 40002 in der SPS
  I2AA1_WERT[1] = mb.Hreg(2);  // Holding-Register 2 = 40003 in der SPS
  I2AA1_WERT[2] = mb.Hreg(3);  // Holding-Register 3 = 40004 in der SPS
  I2AA1_WERT[3] = mb.Hreg(4);  // Holding-Register 4 = 40005 in der SPS
  // Werte zur Analogkarte schicken
  I2AA(I2AA1_ADDR, I2AA1_WERT, I2AA1_OK);


  // Link-Status auf blaue LED
  // -------------------------
  bool takt_1hz = (millis() / 500) & 1;     // Blinktakt 1 Hz
  auto link = Ethernet.linkStatus();
  switch (link) {
    case Unknown:
      digitalWrite(LED_BL, takt_1hz); break;
    case LinkON:
      digitalWrite(LED_BL, HIGH); break;
    case LinkOFF:
      digitalWrite(LED_BL, LOW); break;
  }



 //alle 5 Sekunden lesen für Test
  if (millis() > ts + 1000) {  
    ts = millis();
   
    // Werte von der SPS
    Serial.print(mb.Hreg(0));    // Holding-Register 0 = 40001 in der SPS
    Serial.print("\t ");
    Serial.print(mb.Hreg(1));    // Holding-Register 1 = 40002 in der SPS
    Serial.print("\t ");
    Serial.print(mb.Hreg(2));    // Holding-Register 2 = 40003 in der SPS
    Serial.print("\t ");
    Serial.print(mb.Hreg(3));    // Holding-Register 3 = 40004 in der SPS
    Serial.print("\t ");
    Serial.print(mb.Hreg(4));    // Holding-Register 4 = 40005 in der SPS
    Serial.println ();
  }
}

// =============================================================================================================
// Globale Funktionen
// =============================================================================================================

// ---------------------------------------
// 8-Bit von digitale Eingangskarte lesen
// ---------------------------------------
void I2E(int I2C_Adresse, int &Wert, bool &Slave_OK) {
  Wire.requestFrom(I2C_Adresse, 1);      // Anfrage an den I2C-Slave
  if (Wire.available()) {
    Wert = 255 - Wire.read();            // Ein Byte vom PCF8574 lesen und in invertierte Eingabe wandlen
    Slave_OK = 1;
  } else {Slave_OK = 0;}
}

// ------------------------------------------
// 8-Bit zur digitale Ausgangskarte schreiben
// ------------------------------------------
void I2A(int I2C_Adresse, int &Wert, bool &Slave_OK) {
  Wire.beginTransmission(I2C_Adresse);                      // Start Übertragung zum PCF8574
  Wire.write(255 - Wert);                                   // Wert schreiben
  byte error = Wire.endTransmission();          
  if (error == 0) { Slave_OK = 1; } else {Slave_OK = 0;}    // Fehlerauswertung
}

// ---------------------------------------
// 5 Analogwerte von der I2HAE-Karte lesen
// ---------------------------------------
void I2AE(int I2C_Adresse, int (&Wert)[5], bool &Slave_OK) {
  int Array[11];                          // Lokales Array zur Speicherung der gelesenen Daten
  Wire.requestFrom(I2C_Adresse, 11);      // Anfrage an den I2C-Slave
  if (Wire.available()) {                 // 11 Bytes von Analogkarte lesen und in das array kopieren
    Slave_OK = 1;
    for(int i=0;i<11;i++){
        int c = Wire.read();
        Array[i]=c;
    }    
    // Werte berechnen. Analogwert = Highbyte * 256 + Lowbyte
    Wert[0] = Array[ 2] * 256 + Array[1];
    Wert[1] = Array[ 4] * 256 + Array[3];
    Wert[2] = Array[ 6] * 256 + Array[5];
    Wert[3] = Array[ 8] * 256 + Array[7];
    Wert[4] = Array[10] * 256 + Array[9];  
  } else {Slave_OK = 0;}
}

// ---------------------------------------
// 4 Analogwerte zur I2HAA-Karte schreiben
// ---------------------------------------
void I2AA(int I2C_Adresse, int (&Wert)[4], bool &Slave_OK) {
  Wire.beginTransmission(I2C_Adresse);        // Start Übertragung zur ANALOG-OUT Karte
  Wire.write(0);                              // Kanal auf 0 setzen
  for(int i=0;i<4;i++){
    byte HBy = Wert[i] / 256;                 // HIGH-Byte berechnen
    Wire.write(Wert[i] - HBy * 256);          // LOW-Byte schreiben
    Wire.write(HBy);                          // HIGH-Byte schreiben
  }  
  byte error = Wire.endTransmission();          
  if (error == 0) { Slave_OK = 1; } else {Slave_OK = 0;}    // Fehlerauswertung
}



Hersteller Informationen

GPSR-Angaben 

Verantwortliche Person für die EU

Horter & Kalb
Jürgen Horter
Klinikumallee 23
)5445 Bayreuth

mail@horter.de

Vielleicht gefällt Ihnen auch

DIN-Montagerahmen

I2HR

Montagerahmen für DIN-Hutschienen komplett Satz WAGO Montagesockel für unsere I2C-Hutschienenbausätze.

Preis 3,90 €

Bausatz I2C Digital Input...

I2EOK-Bk

Digitale I2C-Eingabekarte mit Optokopplern 8-Bit 5-24V für DIN-Schiene Mit dem I2C-Eingabe-Modul können 8 digitale Signal von 2,5V bis 30V über den I2C-Bus eingelesen werden. Die Eingänge sind mit Optokopplern galvanisch getrennt

Preis 16,90 €

Bausatz I2C Digital Output...

I2AOK-Bk

Digitale I2C-Ausgabekarte mit Optokopplern 8-Bit 5-24V für DIN-Schiene Mit der I2C-Ausgabekarte können 8 digitale Verbraucher geschaltet werden.Der Ausgangstreiber TBD62783APG schaltet eine positive Spannung bis zu 30V.

Preis 16,90 €
Kommentare (0)

Bausatz I2C-Master mit...

24,90 €
Klemmen: