RS485 Modbus per Libmodbus im Raspberry PI auslesen

[Peter B. (mallert)]

Hallo,

ich bin zurzeit an der Auswertung eines Smart Meters per Raspberry PI. 
Leider beruhen meine C + Bus Kentnisse eher im Tryn Error Bereich.

Der Smartmeter (Janitza UMG104) soll per RS485 Modbus ausgelesen werden.
Dazu habe ich ein biliigen RS485-USB Umsetzer am Pi. Als Software habe 
ich die Bibilothek Libmodbus dazugezogen (www.libmodbus.org bzw die 
Dokumentation unter http://libmodbus.org/docs/v3.0.6/)

Die Anbindung - connect scheinen soweit zu funktionieren (bei 
abgezogegen USB erhalte ich die entsprechenden Fehlermeldungen)

Bei dem eigentlichen auslesen als Master komme ich leider nicht weiter.

Fragen:
-Wie muss das auslesen mit dem Aufruf modbus_mapping_new() korrekt 
entstehen? Ich komme mit der Dokumentation nicht weiter- Als Beispiel 
würde ich gerne das Register 19000 auslesen (das ist die Spannung - 
müsste also um die 230 liegen)

-Sollte als Anfänger eher eine andere Bibilothek/ andereren Weg genommen 
werden?

Danke!

p.S: Ziel des Projektes sind die Daten in den Volkszähler (Server 
bereits aktiv) zu laden.

Aktueller Code - while Schleife zurzeit auskommentiert:

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>

#include "modbus.h"

using namespace std;

int main(void)
{
  
int test=-1;            //Variable zur Testabfrage
modbus_mapping_t *mb_mapping;


cout << "Modbus Master Programm startet..." << endl;
cout << "libmodbus Version:" LIBMODBUS_VERSION_STRING << endl;

modbus_t *ctx;

  ctx = modbus_new_rtu ("/dev/ttyUSB0", 9600, 'N', 8, 2);
    if (ctx == NULL) 
    {
    cout<<"Fehler ABBRUCH \n";
    return -1;
    }
    else
    {
    cout<<"Parameter der Verbindung:\n";
    cout<<"BAUD:      9600\n";
    cout<<"Parity:      none\n";
    cout<<"Bits:       8\n";
    cout<<"Stop-Bit:    2\n";
    cout<<"Stop-Bit:    1\n\n";
    }
    
modbus_set_slave(ctx , 1);
cout<<"Slave Adresse:  1\n";

test = modbus_connect(ctx);
  if (test == -1) 
  {
  cout<<"Verbindung inaktiv ABBRUCH \n";
  return -1;
  }
  else
  {
  cout<<"Verbindung aktiv\n";
  }

/*
while(1)
{

mb_mapping = modbus_mapping_new(0,0,0,0); 
//(int nb_bits, int nb_input_bits, int nb_registers, int nb_input_registers);*

  if (mb_mapping == NULL)
  {
  cout<<"Verbindung inaktiv ABBRUCH \n";
  return -1;
  }
  else
  {
  cout<<"Verbindung aktiv\n";
  }

}    
*/

  cout<<"Ausserhalb der Schleife, Verbindungen werden geschlossen";  
  
  modbus_close(ctx);
  modbus_free(ctx);
  
  return 0;
}

[Stephan (Gast)]

Hi,
ich bin nicht sicher ob ich verstanden habe was du willst aber ich 
versuchs mal:

>Sollte als Anfänger eher eine andere Bibilothek/ andereren Weg genommen
>werden?
Das passt schon. :-)
Was ich dir noch mitgeben kann, such dir einen MB-Monitor, damit kannst 
du die Kommunikation testen. Es gibt viele freie im Netz.
z.B.: http://www.chipkin.com hat einen. (es gibt mehrere Versionen, such 
die neuste)

>Bei dem eigentlichen auslesen als Master komme ich leider nicht weiter.
Master stellt nur Daten zur Verfügung!
Also der Janitza UMG104 ist der Master, du (dein PC) ist der Slave, der 
muß arbeiten und die Daten abholen!(abfragen)

>Wie muss das auslesen mit dem Aufruf modbus_mapping_new() korrekt
>entstehen? Ich komme mit der Dokumentation nicht weiter- Als Beispiel
>würde ich gerne das Register 19000 auslesen (das ist die Spannung -
>müsste also um die 230 liegen)
modbus_mapping_new ist für die Erstellung eines Masters!
Hier generierst du den Platzhalter für die Register(Informationen) die 
von Außen gelesen werden können(auch write möglich).

mb_mapping = modbus_mapping_new(
0, // keine Bits (Coils (RW))
0, // keine Input-Coils (nur Read-Only)
0, // keine Holding-Register (RW)
0  // keine Inputregister (nur Read-Only)
); 
// irgendwas mußte aber erstellen
mb_mapping = modbus_mapping_new(
0, // keine Bits (Coils (RW))
0, // keine Input-Coils (nur Read-Only)
REGISTERS_ADDRESS + 100, // 100 Holding-Register (RW)
0  // keine Inputregister (nur Read-Only)
);

Im 2 Fall könnte jetzt einer deine 100 H-Register lesen.
Schau bitte im Code nach was der Wert für REGISTERS_ADDRESS ist, den 
konnte ich nicht in der Doku finden.

Dieser Satz in der Doku ist für MB wichtig:

/* The fist value of each array is accessible from the 0 address. */

leider konnte ich in der Doku zum UMG104 nichts finden!!!
Also im Zweifel die Registeradressen um +- 1 verändern!

Eigentlich willst du doch deinen UMG104 auslesen, oder?
Dazu kannst du das aus der Doku verwenden:

modbus_t *ctx;
uint16_t tab_reg[64];  // <- hier die Registerwerte reinschreiben
int rc;
int i;
int MyMBStartAdr= 19000;
int MyMBAdrLen= 6; // alle Spannungen von L1 L2 L3

rc = modbus_read_registers(ctx, MyMBStartAdr, MyMBAdrLen, tab_reg);
if (rc == -1) {
    fprintf(stderr, "%s\n", modbus_strerror(errno));
    return -1;
}

for (i=0; i < rc; i++) {
    printf("reg[%d]=%d (0x%X)\n", i, tab_reg[i], tab_reg[i]);
}

Zum Anfang mehr als 1 Register lesen, wegen den Offset von 1!!!
Hat mir immer sehr geholfen :-)

[Peter B. (mallert)]

Hallo Stephan,

erstmal Danke für die Antwort- ich probiere es gleich mal den Vorschlag 
mit modbus_read_registers.

Aber gleich mal eine Verständnisfrage:
Der Modbus Master ist mein PC (in dem Fall ein RPI) der die Slaves 
(Umg104 Adresse 1) nach den Registern fragt?
Siehe http://de.wikipedia.org/wiki/Modbus und der Zeichnung anbei
Oder habe ich hier ein gernelles Verständnisproblem?
Weil der Befehl modbus_read_registers liegt bei der Dokumentation unter 
clients (slaves)

Danke

Gruß
Peter

[Stephan (Gast)]

Hi,
hab nochmal nach gesehen:
http://www.modbus.org/docs/Modbus_Application_Protocol_V1_1b3.pdf
Seite 4: (auch 2 Bilder)

The MODBUS application data unit is built by the client that initiates a MODBUS transaction.
The function indicates to the server what kind of action to perform. 
The MODBUS application protocol establishes the format of a request initiated by a client.

Für mich ist der Master(Server), der der die Daten hat.
Der Slave(Client) muß für sein Geld arbeiten, die Daten abholen.

Das Master / Slave kommt eigentlich von der Kundenseite.
Als ich das diesen Erklärt habe, hab ich es auch so rum erzählt.
Ist einfacher zu verstehen. Der Master fragt die Werte an und der Slave 
hat zu antworten.

Wenn du dir aber heute, Web Seiten anschaust, die Daten liegen auf dem 
Server und die Clients holen sie sich ab!
Vielleicht sollte man(n) heute nur noch von 'MB-Clients' und 'MB-Server' 
reden. (neu modischer ;-) )

Ist es besser?

PS: Besser als wiki ist
http://www.modbus.org/specs.php

[Stephan (Gast)]

Master / Slave

schau mal hier:
http://www.modbus.org/docs/Modbus_over_serial_line_V1_02.pdf

Seite 7 (Bilder mit Master / Slave)

The MODBUS Serial Line protocol is a Master-Slaves protocol. Only one master (at the same time) is connected 
to the bus, and one or several (247 maximum number) slaves nodes are also connected to the same serial bus. 
A MODBUS communication is always initiated by the master. The slave nodes will never transmit data without 
receiving a request from the master node. The slave nodes will never 
communicate with each other. The master node initiates only one MODBUS transaction at the same time.

Das Master / Slave bezieht sich mehr auf die Übertragung.

Aber aus Modbus-Daten Sicht....(andersherum)
Ist halt schwer zu erklären. Sorry.

[Peter B. (mallert)]

Hallo,

nach ein bisschen probieren (lezendlich hat ein Abschlussiwderstand 
gefehlt -bei 30cm Kabel.. naja) habe ich eine Ausgabe :)

Modbus Master Programm startet...
libmodbus Version:3.0.3
Parameter der Verbindung:
BAUD:      9600
Parity:      none
Bits:       8
Stop-Bit:    2
Slave Adresse:    200
Verbindung aktiv
weiter mit 00
in der Schleife
Register gelesen
017258
146344
217258
355525
417258
58426
Ausserhalb der Schleife, Verbindungen werden geschlossen

------------------
(program exited with code: 0)
Press return to continue

Was ich da überhaupt ausgelesen habe und was die Zahlen sagen forsche 
ich morgen bei einem Kaffe nach :)

Vielen Dank Stephan mit dem richtigen Hinweis!

Gruß
Peter

[Mathias O. (m-obi)]

Ich weiß der letzte Post ist schon ein 3/4 Jahr her. Aber bevor Andere 
über diesen Thread stolpern, möchte ich gerne was richtigstellen.

Zu einem Server kann man auch Slave sagen. Er stellt Daten bereit und 
antwortet auf Anfragen vom Client bzw. Master. Der Client/Master hat die 
Oberhand, deswegen auch Master. Bzw. auch Client, da ein Client Anfragen 
stellt und Daten haben möchte.

Und das ist nicht nur bei Modbus so.