Arduino Ethernet Shield mit iobroker (MQTT) verbinden

[DJ-Mix]

Hallo zusammen,

ich habe einen Drucksensor der über ein Arduino Uno Board mit Ethernet Shield abgefragt wird. Dieser
liefert einen Wert, den ich gerne in IOBROKER weiter verarbeiten würde.
Auf einem Display, wird mir dieser Wert angezeigt (Sketch anbei). Nun fehlt mir noch die Übermittlung an IOBROKER. Jedoch finde ich als Anfänger im Bereich Arduino/IOBROKER leider keine verständliche Hilfe bzw. Anleitung um dies umzusetzen.
Kann mir hierbei vielleicht jemand helfen?

Vielen Dank
VG

#include "Wire.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 display(4);


void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 60);
  
}

void loop() {
int sensorVal=analogRead(A1);
display.print("Sensor Value: ");
display.print(sensorVal);

float voltage = (sensorVal*5.0)/1024.0;
    display.print("Volts: ");
    display.print(voltage);
    
  float pressure_pascal = (3.0*((float)voltage-0.47))*1000000.0;
  float pressure_bar = pressure_pascal/10e5;
  
display.clearDisplay();
display.setTextColor(WHITE);
display.setTextSize(2);
display.setCursor(10,10);
display.print(pressure_bar);
display.println(" bar");
display.display();

 delay(5000);
}


``

[mickym]

@dj-mix für arduino gibts anscheinend direkt einen mqtt Client.
Ich kann dazu nicht viel sagen, aber am Ende dieses Kapitels gibts ein Beispiel
https://www.baldengineer.com/mqtt-tutorial.html

Hier der pub/sub mqtt Client für Arduino : https://github.com/knolleary/pubsubclient
mit der entsprechenden API:
https://pubsubclient.knolleary.net/api

[DJ-Mix]

@mickym vielen Dank, schaue ich mir mal an.

[andibr]

@dj-mix

Hallo DJ-Mix hast du eine Lösung mit dem pubsubclient gefunden? Also ich habe es damit nicht hingekriegt, aber mit dem MQTTPubSubClient geht es:

#include <Ethernet.h>
#include <MQTTPubSubClient.h>
#include <Adafruit_INA260.h>
#include <Adafruit_INA219.h>

byte mac[] = {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02};
Adafruit_INA260 ina260 = Adafruit_INA260();
Adafruit_INA219 ina219 = Adafruit_INA219(0x041);


float busvoltage = 0;
float current_mA = 0;
float power_mW = 0;
float busvoltage219 = 0;
float current_mA219 = 0;

static char spannung[8];
static char current[8];
static char power[8];
static char spannung219[8];
static char current219[8];


EthernetClient client;
MQTTPubSubClient mqtt;

void setup() {
  //Serial.begin(57600);

  // setup ethernet communication using DHCP
  Ethernet.init(10);
  Ethernet.begin(mac) == 0;
  //Serial.println(F("Ethernet configured via DHCP"));
  //Serial.print("IP address: ");
  //Serial.println(Ethernet.localIP());
  //Serial.println();
    // start your network
    //WiFi.begin("your-ssid", "your-password");
    // connect to host
    client.connect("192.168.168.xx", 1884);
    // initialize mqtt client
    mqtt.begin(client);
    // connect to mqtt broker
    mqtt.connect("Topic", "UserName", "UserPswd");

    // subscribe callback which is called when every packet has come
    mqtt.subscribe([](const String& topic, const String& payload, const size_t size) {
        //Serial.println("mqtt received: " + topic + " - " + payload);
    });
    // subscribe topic and callback which is called when /hello has come
    mqtt.subscribe("/Solar", [](const String& payload, const size_t size) {
        //Serial.print("/Solar ");
        //Serial.println(payload);
    });
    
    ina260.begin();     // INA260 am I2C-Bus, Adresse 0x40
    ina219.begin();     // INA219 am I2C-Bus, Adresse 0x41
}

void loop() {
    // should be called to trigger callbacks
    mqtt.update();
    // publish message
    //mqtt.publish("/hello/hello", "hello");
    delay(5000);

    busvoltage = ina260.readBusVoltage();   
    current_mA = ina260.readCurrent(); 
    power_mW = ina260.readPower();

    busvoltage219 = ina219.getBusVoltage_V();
    current_mA219 = ina219.getCurrent_mA();

    //Serial.println(busvoltage);
    //Serial.println(current_mA);
    //Serial.println(power_mW);
    //Serial.println(current_mA219);
        
    mqtt.publish("/Solar/Panelspannung", dtostrf((busvoltage/1000), 6, 2, spannung));
    mqtt.publish("/Solar/Panelsstrom", dtostrf((current_mA/1000), 6, 3, current));
    mqtt.publish("/Solar/Panelleistung", dtostrf((power_mW/1000), 6, 3, power));

    mqtt.publish("/Solar/Lastspannung", dtostrf((busvoltage219/1), 6, 2, spannung219));
    mqtt.publish("/Solar/Laststrom", dtostrf((current_mA219/1000), 6, 3, current219));
}

Damit geht es mit einem Arduino Uno und einem Netzwerkshield mit WS5100 richtig und der MQTT trägt die Daten in die Tabelle ein. Das ganze hat nur ein Nachteil: die MQTTPubSubClient Bibliothek braucht extrem viel Speicherplatz. Mit diesem Sketch ist der Speicher im Uno gerade voll.

Vieleicht hat da jemand noch ein Idee, wie man das ganze mit der PubSubClient.h zum laufen bringt?

[andibr]

@andibr

Ich habe es nach langem vergleichen und erweitern des ganz aktuellen PuSubClient Beispiel jetzt auch am laufen. Es funktioniert in beide Richtungen wunderbar. Nun hatt auch die verwendung der A/D Wandler inkl. der Datenaufbereitung noch Platz. So kommen im IoB gleich die richtigen Werte an.

[TBRFSEE]

@andibr Kannst du bitte deine ino Datei mit dem aktuellen PubSubClient.h teilen? 1000 Dank

[andibr]

@tbrfsee said in Arduino Ethernet Shield mit iobroker (MQTT) verbinden:

@andibr Kannst du bitte deine ino Datei mit dem aktuellen PubSubClient.h teilen? 1000 Dank

kann ich machen: (ich denke es gäbe noch tausend andere Möglichkeiten, darum nicht motzen)

/*
  20220106 / ABN Solarmessung mit MQTT
  mit IN260 Powermeter und I2C
  zusätzlich Relais Kanäle für Notstromversorgung
  
*/

#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>
#include <Adafruit_INA260.h>


// Update these with values suitable for your network.
byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };

Adafruit_INA260 ina260_A = Adafruit_INA260();
Adafruit_INA260 ina260_B = Adafruit_INA260();
Adafruit_INA260 ina260_C = Adafruit_INA260();

//Programmablauf
long unsigned int start;
long unsigned int intervallSensor = 5000;

//Variablen
float busvoltage_A = 0;
float current_mA_A = 0;
float power_mW_A = 0;

float busvoltage_B = 0;
float current_mA_B = 0;
float power_mW_B = 0;

float busvoltage_C = 0;
float current_mA_C = 0;
float power_mW_C = 0;




//Variablen für MQTT übertragung
static char spannung_A[8];
static char current_A[8];
static char power_A[8];

static char spannung_B[8];
static char current_B[8];
static char power_B[8];

static char spannung_C[8];
static char current_C[8];
static char power_C[8];


//ab hier Program
//----------------------------------------------------------------------------

void callback(char* topic, byte* payload, unsigned int length);

EthernetClient ethClient;
PubSubClient client("IP-Adresse-Broker", 1884, callback, ethClient);

void setup()
{
  Serial.begin(57600);
  Ethernet.init(10);
  Ethernet.begin(mac) == 0;
  // Note - the default maximum packet size is 128 bytes. If the
  // combined length of clientId, username and password exceed this use the
  // following to increase the buffer size:
  // client.setBufferSize(255);
  
  if (client.connect("Name-Client", "Login", "Paswd")) {
    client.publish("/Solarmessung/OUT","");
    client.publish("/Solarmessung/CMD/Kanal1","false");
    client.subscribe("/Solarmessung/CMD/Kanal1");
      }

  ina260_A.begin(0x040);     // INA260 am I2C-Bus, Adresse 0x40 A0=Off A1=OFF
  ina260_B.begin(0x041);     // INA260 am I2C-Bus, Adresse 0x41 A0=ON A1=OFF
  ina260_C.begin(0x044);     // INA260 am I2C-Bus, Adresse 0x44 A0=OFF A1=ON

// setup Hardware
  pinMode(7, OUTPUT);
  digitalWrite(7, HIGH);
  
}


void callback(char* topic, byte* payload, unsigned int length) {
  Serial.begin(57600);
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");   
  String payloadtemp;
  String stopic = String(topic);
  
  for (int i=0;i<length;i++) {
    Serial.print((char)payload[i]);
    payloadtemp += (char)payload[i];
  }
  Serial.println();
 
  
  if (stopic == "/Solarmessung/CMD/Kanal1") {
    if (payloadtemp == "true") {
      Serial.println("true");
      //Serial.println("Kanal 1 ein");
      //Serial.println(payloadtemp);
      digitalWrite(7, HIGH);
      client.publish("/Solarmessung/OUT/Kanal1", "true");
    }
    
    else if (payloadtemp == "false") {
      Serial.println("false");
      //Serial.println("Kanal 1 aus");
      //Serial.println(payloadtemp);
      digitalWrite(7, LOW);
      client.publish("/Solarmessung/OUT/Kanal1", "false");
    }
  }
}



void loop(){
   if (millis() - start >= intervallSensor) {
      sensors();
      start = millis();
      }
   
  
  client.loop();

   if (!client.connected()) {
      client.connect("Name", "Login", "Paswd");
      }
}


void sensors ()
{
// Bus Sensoren
    busvoltage_A = ina260_A.readBusVoltage();   
    current_mA_A = ina260_A.readCurrent(); 
    power_mW_A = ina260_A.readPower();
    
    busvoltage_B = ina260_B.readBusVoltage();   
    current_mA_B = ina260_B.readCurrent(); 
    power_mW_B = ina260_B.readPower();

    busvoltage_C = ina260_C.readBusVoltage();   
    current_mA_C = ina260_C.readCurrent(); 
    power_mW_C = ina260_C.readPower();

        
    client.publish("/Solarmessung/OUT/Panelspannung", dtostrf((busvoltage_A/1000), 6, 2, spannung_A));
    client.publish("/Solarmessung/OUT/Panelsstrom", dtostrf((current_mA_A/1000), 6, 3, current_A));
    client.publish("/Solarmessung/OUT/Panelleistung", dtostrf((power_mW_A/1000), 6, 3, power_A));

    client.publish("/Solarmessung/OUT/Batteriespannung", dtostrf((busvoltage_B/1000), 6, 2, spannung_B));
    client.publish("/Solarmessung/OUT/Batteriestrom", dtostrf((current_mA_B/1000), 6, 3, current_B));
    client.publish("/Solarmessung/OUT/Batterieleistung", dtostrf((power_mW_B/1000), 6, 3, power_B));

    client.publish("/Solarmessung/OUT/Lastspannung", dtostrf((busvoltage_C/1000), 6, 2, spannung_C));
    client.publish("/Solarmessung/OUT/Laststrom", dtostrf((current_mA_C/1000), 6, 3, current_C));
    client.publish("/Solarmessung/OUT/Lastleistung", dtostrf((power_mW_C/1000), 6, 3, power_C));

}

Dazu habe ich mir via Bibliotheksverwaltung die aktuelle PubSubClient.h (Version 2.8.0) von Nick O'Leary herunter geladen. Mit diesem Sketch und dem Adapter "MQTT Broker/Client V2.4.0 bekomme ich die Werte in die Iobroker Datentabelle geliefert.

Am "senden zum Arduino" arbeite ich noch, denn da komme ich aktuell gerade nicht weiter als so. Das Empfangen und Ausgeben auf der Konsole geht, aber das aktive Schalten eine GPIO geht nicht, da habe ich noch irgendwo in den "if / else if" Schlaufen eine Chaos.

[andibr]

Hallo zusammen

Ich brauche etwas Hilfe, denn meine INA260 haben sich nach dem Einbau gleich in Rauch aufgelöst, einzig der für die Batterie geht noch (Messung entspricht aber nicht der Anzeige auf dem Laderegler (sehr weit dabneben)), leider verstehe ich noch nicht so ganz wieso.

link INA260

Ja, bevor die Frage kommt, mein Laderegler hat einen gemeinsamen Plupol und desshalb verwende ich die INA260 als Low-Side Messung mit aufgetrennten Kreisen. Sprich ich habe die Brücke aufgeschnitten und bringe die 5V mit dem I2C als 4 Draht Leitung. Auf dem Arbeitstisch hatte ich alle 3stk zusammen gehängt und ohne Probleme mit dem Arduino die Daten auslesen und an den Iobroker senden können. Dann habe ich die genommen ohne was zu ändern (Litzen blieben drin) und bei meiner Solarverteilung eingebaut (am Abend ohne Sonne). Danach gabe es Rauch und seither keine Lebenszeichen mehr.

Kann man diese Dinger nicht gebrauchen? Ich habe diese Messung bei einem 130W PV Modul machen wollen das an einem 12V System hängt, also sollte es doch kein Problem sein? Gibt es eine alternative Möglichkeit mit der man auch grössere Ströme messen könnte? Was ich bereits getestet habe sind die Allegro ACS712 (Hall-Sensor), da ist der Aufwand für eine Magnetische Abschirmung so hoch, das ich mir das nicht an tun werde (hätte noch ein paar Abzugeben).

link ACS712

Vieleicht gibt es jemanden der eine ähnliche Idee hatte und mir ein paar Tips geben kann?
Vielen Dank
Andi