Datenübertragung mit MODBUS Protokoll. Serielle Kommunikation und über TCP/IP. MODBUS RTU ASCII Modus. Modbus Bibliothek mit Master, Slave, Client.
Modbus über serielle. Modbus über TCP/IP, RTU über TCP. Bridge RTU over IP Gateway. RTU over TCP, Modbus Kommunikation Bibliothek, C++, C#, Visual Basic, Delphi, LabView. Komponenten und Bibliotheken für Automation und Steuerungen. MODBUS Protokoll mit LabVIEW Beispiele. Modbus Master Protokoll Bibliothek. Modbus bridging seriell zu TCP/IP. Serielle MODBUS Bibliothek. MODBUS Bibliothek mit Siemens S7.
MODBUS RTU ASCII Modus. Serielle Kommunikation und über TCP/IP. Datenübertragung mit MODBUS Protokoll. Modbus Library.
SuperCom - MODBUS Protokoll Bibliothek
SuperCom - MODBUS Protokoll Bibliothek
MODBUS ist ein Protokoll für die Kontrolle von SPS Steuerungen über serielle Leitungen (serielles Kommunikation Protokoll für RS-232, RS-422, RS-485) und über TCP/IP Verbindungen.
Die SuperCom MODBUS Protokoll Bibliothek enthält die notwendigen Funktionen um einfach und schnell eine stabile MODBUS Anwendung zu entwickeln. Die SuperCom MODBUS Kommunikation Bibliothek kapselt das komplexe MODBUS Protokoll in ein einfach zu nutzendes Set von Funktionen, die auf gleicher Weise über serielle und TCP/IP Verbindungen genutzt werden. Dadurch wird eine qualitative Anwendung in weniger Zeit und mit Kostenersparnis produziert.
Die SuperCom MODBUS Protokoll Bibliothek unterstützt die Datenkommunikation zwischen Geräten an seriellen Schnittstellen, am Bus oder Netzwerk gemäß der MODBUS Spezifikation. Das Protokol Modul unterstützt sowohl den ASCII als auch den RTU (*Modbus Remote Terminal Unit) Übertragungsmodus. Im ASCII Modus werden die Daten als ASCII Codes übertragen und im RTU Modus als binäre Byte-Folge (binär Modus).
Unabhängig vom Verbindungstyp (seriell, TCP/IP, ISDN) oder Übertragungsmodus (Modbus ASCII, Modbus RTU, Modbus TCP) werden immer dieselben Funktionen und Parameter genutzt.
Die Protokoll Funktionen erlauben den einfachen Zugriff auf Register und Variablen der SPS. Eine transparente Datenkommunikation für Benutzerspezifische Funktion-Codes und Datenpakete ist auch enthalten. Damit können maschinespezifische Erweiterungen der Automation einfach behandelt werden.
Einfache Handhabung
In den meisten Fällen wird nur eine kleine Menge an Funktionen genutzt um Daten mit einer SPS auszutauschen. Ein bestehendes Projekt wird schnell erweitert. Weitere Funktionen sind enthalten um die unterschiedlichsten Anforderungen zu bewältigen.
- Gleichzeitige Ausführung von mehreren Modbus Master.
- Gleichzeitige Verbindung von MODBUS RTU oder MODBUS ASCII Master zu Modbus Slaves.
- Abhängig von der genutzten SuperCom Software kann das SuperCom MODBUS Protokoll Modul serielle und/oder TCP/IP Verbindungen kontrollieren.
- Das SuperCom MODBUS Protokoll Modul kann gleichzeitig mehrere Verbindungen verwalten. Die gleichzeitige Abfrage von mehreren SPS is möglich.
- Empfangen von Modbus Datenpaketen und Simulation von Modbus Slaves oder Protokoll Gateway.
- Erzeugung des eigenen Modbus Gateway oder Bridge um Daten zwischen seriellen Schnittstellen und TCP/IP Netzwerk zu leiten z.B. ein MODBUS TCP zu MODBUS RTU Gateway.
- Mit SuperCom Modbus bridging (z.B. seriell zu TCP/IP).
- Erzeugung eines Protokoll Gateway unter Nutzung der, mit SuperCom angebotenen, Industrie Protokollen (SPS Protokolle) oder auch mit eigenen.
- Einfache Nutzung mit SPS von SIEMENS, Allen Bradley, u.a. Ein vorinstalliertes MODBUS Protokoll Modul auf SPS vorausgesetzt.
Die SuperCom MODBUS Protokoll Bibliothek nutzt den SuperCom Communication Layer, der ein solides Fundament für die Datenkommunikation bietet, um ohne Kopfzerbrechen stabile Datenkommunikationssoftware schnell zu entwickeln. Dabei macht es für den Programmierer keinen Unterschied ob das MODBUS Protokoll über TCP/IP oder über serielle Leitung (RS-232, RS-422, RS-485, Modem, TAPI) genutzt wird.
Beispiele - MODBUS Protocol API:
1. Ein Ausgangs-Bit ("coil") auslesen
C/C++
#define SLAVE_ID 1
BYTE Com = COM_2; // Use serial port COM2
ComInit (Com);
ComSetState (Com, 9600, ...);
:
RS_MBSetConfig(Com,,SuperCom.MODBUS.MODBUS_MODE_RTU,,);
if (RS_MBReadCoil (Com,
SLAVE_ID,
wCoil,
&Buffer))
{
printf("Coil[%d] = %s ", wCoil, Buffer?"TRUE":"FALSE");
}
else
{
int ErrorCode = RS_MBGetLastError(Com);
if (ErrorCode == MB_ERR_EXCEPTION)
printf("Exception %02X reported from slave ", RS_MBGetException(Com));
else
printf("Error %d", ErrorCode);
}
ComReset (Com);
Delphi
Const SLAVE_ID = 1;
Com = COM_2; // Use serial port COM2
Var ErrorCode:Integer;
ComInit (Com);
ComSetState (Com, 9600, ...);
:
RS_MBSetConfig(Com,,SuperCom.MODBUS.MODBUS_MODE_RTU,,);
If (RS_MBReadCoil (Com,
SLAVE_ID,
wCoil,
Buffer)) Then
Write('Coil[', wCoil, '] =', Buffer)
Else
Begin
ErrorCode = RS_MBGetLastError(Com);
If (ErrorCode = MB_ERR_EXCEPTION) Then
Write('Exception ', RS_MBGetException(Com), ' reported from slave ')
Else
Write('Error %d', ErrorCode);
End;
ComReset (Com);
C# mit TSCom Klasse (ActiveX API)
SCom = new MYSCOM(Com, frm1);
SCom.Settings = "9600,N,8,1";
SCom.PortOpen = true;
:
SuperCom.MODBUS.RS_MBSetConfig(Com,,SuperCom.MODBUS.MODBUS_MODE_RTU,,);
if (SuperCom.MODBUS.RS_MBReadCoil (Com,
SLAVE_ID,
wCoil,
Buffer))
WriteLine("Coil[{0}] = {0}", wCoil, Buffer);
else
{
int ErrorCode = SuperCom.MODBUS.RS_MBGetLastError(Com);
if (ErrorCode = MB_ERR_EXCEPTION) Then
{
WriteLine("Exception {0} reported from slave", SuperCom.MODBUS.RS_MBGetException(Com));
}
else
{
WriteLine("Error {0}", ErrorCode);
}
}
SCom.PortOpen = false;
Visual Basic
Const SLAVE_ID = 1
Const Com = COM_2 ' Use serial port COM2
Dim ErrorCode As Integer
Call ComInit (Com)
Call ComSetState (Com, 9600, ...)
:
Call RS_MBSetConfig(Com,,SuperCom.MODBUS.MODBUS_MODE_RTU,,)
If (RS_MBReadCoils(Com, _
SLAVE_ID, _
wFromCoil, _
wCount, _
cBuffer(0))) Then
WriteLine ("Response (" & Format(wCount) & " bits), Coil:" & Format(wFromCoil) & vbCrLf)
Else
ErrorCode = RS_MBGetLastError(Com)
If (ErrorCode = MB_ERR_EXCEPTION) Then
WriteLine ("Exception " & Format(RS_MBGetException(Com)) & " reported from slave " & vbCrLf)
End If
End If
Call ComReset (Com);
|
2. Lesen/Schreiben auf Register
C/C++
#define SLAVE_ID 1
BYTE Com = COM_2; // Using serial port COM2
WORD Buffer [10];
WORD wStart=0x0000;
WORD wCount=1;
WORD wValue=0x0020;
:
ComInit (Com);
ComSetState (Com, 9600, ...);
:
RS_MBSetConfig(Com,,SuperCom.MODBUS.MODBUS_MODE_RTU,,);
if (RS_MBWriteRegister(Com, SLAVE_ID, wStart, wValue))
printf ("Read Success.\n");
else
printf ("Error: %d\n", RS_MBGetLastError(Com));
if (RS_MBReadHoldingRegisters(Com,
SLAVE_ID,
wStart,
&wCount,
Buffer))
{
printf("Read %d Register:", wCount);
for (int i=0; i<wCount; i++) printf ("%4X",Buffer[i]);
}
else
printf ("Error: %d\n", RS_MBGetLastError(Com));
ComReset (Com);
Delphi
Const SLAVE_ID = 1;
Com = COM_2; // Use serial port COM2
Var ErrorCode:Integer;
Buffer:Array [0..9] Of Word;
wStart:WORD=$0000;
wCount:WORD=1;
wValue:WORD=0x0020;
:
ComInit (Com);
ComSetState (Com, 9600, ...);
:
RS_MBSetConfig(Com,,SuperCom.MODBUS.MODBUS_MODE_RTU,,);
If (RS_MBWriteRegister(Com, SLAVE_ID, wStart, wValue)) Then
WriteLn('Read Success.')
Else
WriteLn('Error: ', RS_MBGetLastError(Com));
If (RS_MBReadHoldingRegisters(Com,
SLAVE_ID,
wStart,
&wCount,
Buffer)) Then
Begin
Write('Read ', wCount, ' Register:');
For I:=0 To wCount-1 Do Write(Hex(Buffer[i]));
End
Else
WriteLn('Error: ', RS_MBGetLastError(Com));
ComReset (Com);
C# mit TSCom Klasse (ActiveX API)
int ErrorCode
int Buffer=new int[10];
int wStart ,wCount, wValue;
wStart = 0x0000; wCount = 1; wValue = 0x0020;
:
SCom = new MYSCOM(Com, frm1);
SCom.Settings = "9600,N,8,1";
SCom.PortOpen = true;
:
SuperCom.MODBUS.RS_MBSetConfig(Com,,SuperCom.MODBUS.MODBUS_MODE_RTU,,);
if (SuperCom.MODBUS.RS_MBWriteRegister(Com, SLAVE_ID, wStart, wValue))
WriteLine ("Read Success.\n");
else
WriteLine("Error: {0}", RS_MBGetLastError(Com));
if (RS_MBReadHoldingRegisters(Com,
SLAVE_ID,
wStart,
ref wCount,
ref Buffer))
{
WriteLine("Read {0} Register:", wCount);
for (int i=0; i<wCount; i++)
WriteLine("{0:x4}",Buffer[i]);
}
else
printf ("Error: {0}\n", RS_MBGetLastError(Com));
SCom.PortOpen = false;
Visual Basic
Const SLAVE_ID = 1
Const Com = COM_2 ' Use serial port COM2
Dim ErrorCode As Integer
Dim Buffer(10) As Integer
Dim wStart ,wCount, wValue As Integer
wStart = &H0000 : wCount = 1 : wValue = &H0020
:
Call ComInit (Com)
Call ComSetState (Com, 9600, ...)
:
Call RS_MBSetConfig(Com,,SuperCom.MODBUS.MODBUS_MODE_RTU,,)
If (RS_MBWriteRegister(Com, SLAVE_ID, wStart, wValue)) Then
WriteLine("Read Success.")
Else
WriteLine("Error: " & Format(RS_MBGetLastError(Com)));
If (RS_MBReadHoldingRegisters(Com,
SLAVE_ID,
wStart,
&wCount,
Buffer(0))) Then
WriteLine("Read " & Format(wCount) & " Register:" &vbCrLf);
For I=0 To wCount-1 Do WriteLine(Hex(Buffer[i]));
Else
WriteLine("Error: " & Format(RS_MBGetLastError(Com)));
EndIf
Call ComReset (Com);
|
Datenüberwachung, Weiterleitung - MODBUS Slave oder Gateway Funktionen
Die Datenüberwachung und Weiterleitung von MODBUS Datenpaketen wird unterstützt. Empfangen von Datenpaketen und senden von Antworten (Slave Funktionalität) wird unterstützt. Die Entwicklung eines Protokoll-Konverters oder Gateway von MODBUS in ein anderes Protokoll wird unterstützt. Die Simulation eines MODBUS Slave kann u.a. auch während der Anwendungsentwicklung von Nutzem sein.
Lizenzbedingung
Ausführbare Anwendungen (.EXE) können frei weitergegeben werden.
Unterstützte Compiler
C++, C#, Delphi, Visual C++, Visual Basic, Visual Basic NET, C++ Builder, Borland C/C++, Microsoft C/C++, Borland Pascal, VBA, LabVIEW, PowerBuilder und andere Windows Entwicklungsumgebungen (MS .NET ?).
Beispiele
für C/C++, C#, Visual C++, C++ Builder, Pascal/Delphi, Visual Basic, Visual Basic NET (VB .NET), LabVIEW.
Unterstützte Protokolle
Die SuperCom MODBUS Protokoll Bibliothek implementiert das standard MODBUS Protokoll für serielle und TCP/IP Verbindungen* basierend auf der offiziellen Spezifikation der MODBUS Organisation. Das bedeutet MODBUS ASCII und MODBUS RTU Protokolle über serielle Schnittstellen (RS-232, RS-422, RS-485) und MODBUS TCP/IP (MODBUS/TCP) und Open MODBUS TCP über das TCP/IP Netzwerk.
*Eine entsprechende SuperCom Lizenz vorausgesetzt (Seriell und/oder TCP/IP).
Eine nicht ofizielle Variante, RTU over IP (MODBUS RTU/IP, MODBUS RTU over TCP), wird auch unterstützt. Das RTU over IP ermöglicht die SuperCom Anwendung mit OMTS Geräte (OMTS = Out of the MODBUS TCP/IP specification) zu kommunizieren. Da keine offizielle Spezifikation können andere Namen und Variationen existieren.
Wie einsetzen ?
Die SuperCom MODBUS Protokoll Bibliothek kann über jeden Verbindungstyp genutzt werden, die von SuperCom unterstützt wird (aktuell Seriell (RS-232, RS-422, RS-485), TCP/IP, ISDN). Eine Liste von SuperCom Paketen wo MODBUS Protokoll enthalten ist, finden Sie in der folgenden Tabele.
Auch hier gilt: Ein gemeinsames API für Seriell, TCP/IP oder ISDN (ein SuperCom ActiveX API und / oder DLL API).
Was bestellen ?
Viele günstigen Kombinations-Pakete mit MODBUS lieferbar (z.B. SuperCom Serial inkl. MODBUS, SuperCom für TCP/IP inkl. MODBUS, SuperCom Protocol Engine, SuperCom Suite).
Die Artikelnummern 638 bzw. 638400 sind nur dann notwendig, wenn das MODBUS Protokoll später zu einem SuperCom zugekauft wird.
Home
Back
Modified at:
|
|
It Simply Works!
|
|
|
ADONTEC Computer Systems GmbH, Hölderlinstr. 32, D-75433 Maulbronn,
Tel: 07043/9000-20, Fax: 07043/9000-21
|
ADONTEC's Kommunikationslösungen
32 Bit und 64 Bit Versionen verfügbar!