Hallo, ich habe einen Sketch mit einem YUN zum senden von Temperaturen zu einem MQTT Broker. Der YUN sendet nach dem Start einen Temperaturwert, dann wars das. Der serielle Monitor zeigt weiterhin alle Werte an, nach dem Publish.
Mit einem Mega läuft alles tadellos.
Ich würde aber lieber den YUN verwenden, da ich diesen über VPN programieren kann.
//#include <Bridge.h>
#include <BridgeClient.h>
#include <BridgeServer.h>
//#include <BridgeSSLClient.h>
//#include <BridgeUdp.h>
//#include <Console.h>
//#include <FileIO.h>
//#include <HttpClient.h>
//#include <Mailbox.h>
//#include <Process.h>
//#include <YunClient.h>
//#include <YunServer.h>
//#include <HID.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
//#include <YunClient.h>
#include <Ethernet.h>
#include <PubSubClient.h> // http://knolleary.net/arduino-client-for-mqtt/
//#define maxX 127//159 //Each maximum value is one less than the stated value to account for position 0,0
//#define maxY 63 //127 //Thus, position 127 is actually the 128th pixel.
#define ONE_WIRE_BUS 6
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors0(&oneWire);
DeviceAddress S1MO = { 0x28, 0xFF, 0xD6, 0x71, 0xA4, 0x16, 0x04, 0xE2 };//Testadressen
DeviceAddress S1MU = { 0x28, 0xFF, 0xF1, 0x77, 0xA4, 0x16, 0x04, 0x42 };//Testadressen
//DeviceAddress S1MO = { 0x28, 0xCC, 0xF8, 0x84, 0x1E, 0x13, 0x01, 0xEA };
//DeviceAddress S1MU = { 0x28, 0xA6, 0x9B, 0x7C, 0x1E, 0x13, 0x01, 0xD4 };
DeviceAddress S2MO = { 0x28, 0xAA, 0x6D, 0xA0, 0x16, 0x13, 0x02, 0x47 };
DeviceAddress S2MU = { 0x28, 0x1A, 0x97, 0x81, 0x1E, 0x13, 0x01, 0x63 };
DeviceAddress S2HU = { 0x28, 0x28, 0xF1, 0x9D, 0x1E, 0x13, 0x01, 0x47 };
DeviceAddress S3MO = { 0x28, 0xDA, 0x03, 0x65, 0x1E, 0x13, 0x01, 0x13 };
DeviceAddress S3MU = { 0x28, 0xAA, 0xCB, 0x94, 0x16, 0x13, 0x02, 0xAE };
DeviceAddress S1HU = { 0x28, 0x30, 0xBB, 0x9A, 0x1E, 0x13, 0x01, 0x6F };
DeviceAddress S3HU = { 0x28, 0x35, 0x15, 0x87, 0x1E, 0x13, 0x01, 0xB0 };
// Konstante Variablen
//const int chipSelect = 4; //Chip Pin für die SD Karte(bei UNO 4,bei MEGA 53)
// ===========================================================
// Callback Funktion von MQTT. Die Funktion wird aufgerufen
// wenn ein Wert empfangen wurde.
// ===========================================================
void callback(char* topic, byte* payload, unsigned int length) {
// Zähler
int i = 0;
// Hilfsvariablen für die Convertierung der Nachricht in ein String
char message_buff[100];
Serial.println("Message arrived: topic: " + String(topic));
Serial.println("Length: " + String(length,DEC));
// Kopieren der Nachricht und erstellen eines Bytes mit abschließender \0
for(i=0; i<length; i++) {
message_buff[i] = payload[i];
}
message_buff[i] = '\0';
// Konvertierung der nachricht in ein String
String msgString = String(message_buff);
Serial.println("Payload: " + msgString);
}
// MAC Adresse des Ethernet Shields
byte mac[] = { 0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
// IP des MQTT Servers
byte server[] = { 192, 168, 2, 67 };
//byte server[] = { 192, 168, 178, 62 };
// Ethernet Client zur Kommunikation des MQTT Clients
EthernetClient ethClient;
//BridgeClient yun;
// MQTT Client zur Kommunikation mit dem Server
// Server - Variable des Types byte mit Serveradresse
// 1883 - Ist der Standard TCP Port
// callback - Function wird aufgerufen wen MQTT Nachrichten eintreffen. Am ende des Sketches
// ethClient - Angabe des Ethernet Clients
PubSubClient mqttClient(server, 1883, callback, ethClient);
//PubSubClient mqttClient(server, 1883, callback, yun); // mqtt client
// ===========================================================
// Einrichten des OneWire Bus um die Daten der Temperaturfühler abzurufen
// OneWire oneWire(ONE_WIRE_BUS);
// Bindung der Sensoren an den OneWire Bus
// DallasTemperature sensors0(&oneWire);
// Variablen für die Temperatur
float tempC;
// Hilfsvariablen für die Convertierung der Temperatur in ein String
char tempBuffer[100];
// sensors0.requestTemperatures();
float T_S2HU = sensors0.getTempC(S2HU);
float T_S3HU = sensors0.getTempC(S3HU);
float T_S2MU = sensors0.getTempC(S2MU);
float T_S2MO = sensors0.getTempC(S2MO);
float T_S3MU = sensors0.getTempC(S3MU);
float T_S3MO = sensors0.getTempC(S3MO);
float T_S1HU = sensors0.getTempC(S1HU);
float T_S1MO = sensors0.getTempC(S1MO);
float T_S1MU = sensors0.getTempC(S1MU);
char tempT_S2HU[100];
char tempT_S3HU[100];
char tempT_S2MU[100];
char tempT_S2MO[100];
char tempT_S3MU[100];
char tempT_S3MO[100];
char tempT_S1HU[100];
char tempT_S1MO[100];
char tempT_S1MU[100];
// Variablen
void setup() {
// Initialisierung der Seriellen Schnittstelle
// zur Ausgabe der empfangenen Nachrichten
// for debugging, wait until a serial console is connected
Serial.begin(9600);
delay(4000);
while(!Serial);
Serial.print("Initializing the bridge...");
Bridge.begin();
Serial.println("Done");
//Ethernet.begin(mac);
// Initialisierung der Temperaur Sensoren
sensors0.begin();//MQTT
// Initialisiere I2C
Wire.begin();
//Initialisiere Temperatursensoren
sensors0.begin();
sensors0.setResolution(S2HU, 10);
sensors0.setResolution(S3HU, 10);
sensors0.setResolution(S2MU, 10);
sensors0.setResolution(S2MO, 10);
sensors0.setResolution(S3MU, 10);
sensors0.setResolution(S3MO, 10);
sensors0.setResolution(S1HU, 10);
sensors0.setResolution(S1MO, 10);
sensors0.setResolution(S1MU, 10);
}
//schreibt die Temperaturen in die serielle Schnittstelle
void printTemperature0(DeviceAddress deviceAddress0)
{
float tempC = sensors0.getTempC(deviceAddress0);
//C(deviceAddress1);
if (tempC == -127.00) {
Serial.print("Error getting temperature");
} else {
Serial.print("C: ");
Serial.print(tempC);
}
}
void loop()
{
/*
float T_S2HU = sensors0.getTempC(S2HU);
float T_S3HU = sensors0.getTempC(S3HU);
float T_S2MU = sensors0.getTempC(S2MU);
float T_S2MO = sensors0.getTempC(S2MO);
float T_S3MU = sensors0.getTempC(S3MU);
float T_S3MO = sensors0.getTempC(S3MO);
float T_S1HU = sensors0.getTempC(S1HU);
float T_S1MO = sensors0.getTempC(S1MO);
float T_S1MU = sensors0.getTempC(S1MU);
*/
// Aufbau der Verbindung mit MQTT falls diese nicht offen ist.
if (!mqttClient.connected()) {
mqttClient.connect("arduinoclient");
// Abonieren von Nachrichten mit dem angegebenen Topic
mqttClient.subscribe("/Silo/Temperatur/#");
}
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S1MO != sensors0.getTempC(S1MO) ) {
T_S1MO = sensors0.getTempC(S1MO);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S1MO",dtostrf(T_S1MO, 1, 2, tempT_S1MO));
Serial.print("MQTT-T_S1MO= "); Serial.println(tempT_S1MO);Serial.print(T_S1MO);
}
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S1MU != sensors0.getTempC(S1MU) ) {
T_S1MU = sensors0.getTempC(S1MU);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S1MU",dtostrf(T_S1MU, 1, 2, tempT_S1MU));
Serial.print("MQTT-T_S1MU= "); Serial.println(tempT_S1MU);Serial.print(T_S1MU);
}
/*
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S1HU != sensors0.getTempC(S1HU) ) {
T_S1HU = sensors0.getTempC(S1HU);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S1HU",dtostrf(T_S1HU, 1, 2, tempT_S1HU));
Serial.print("MQTT-T_S1HU= "); Serial.println(tempT_S1HU);
}
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S2MO != sensors0.getTempC(S2MO) ) {
T_S2MO = sensors0.getTempC(S2MO);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S2MO",dtostrf(T_S2MO, 1, 2, tempT_S2MO));
Serial.print("MQTT-T_S2MO= "); Serial.println(tempT_S2MO);
}
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S2MU != sensors0.getTempC(S2MU) ) {
T_S2MU = sensors0.getTempC(S2MU);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S2MU",dtostrf(T_S2MU, 1, 2, tempT_S2MU));
Serial.print("MQTT-T_S2MU= "); Serial.println(tempT_S2MU);
}
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S2HU != sensors0.getTempC(S2HU) ) {
T_S2HU = sensors0.getTempC(S2HU);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S2HU",dtostrf(T_S2HU, 1, 2, tempT_S2HU));
Serial.print("MQTT-T_S2HU= "); Serial.println(tempT_S2HU);
}
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S3MO != sensors0.getTempC(S3MO) ) {
T_S3MO = sensors0.getTempC(S3MO);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S3MO",dtostrf(T_S3MO, 1, 2, tempT_S3MO));
Serial.print("MQTT-T_S3MO= "); Serial.println(tempT_S3MO);
}
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S3MU != sensors0.getTempC(S3MU) ) {
T_S3MU = sensors0.getTempC(S3MU);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S3MU",dtostrf(T_S3MU, 1, 2, tempT_S3MU));
Serial.print("MQTT-T_S3MU= "); Serial.println(tempT_S3MU);
}
// Auslesen der Temperatur
sensors0.requestTemperatures();
// Bei Änderungen zum vorherigen Wert Publizieren
if (T_S3HU != sensors0.getTempC(S3HU) ) {
T_S3HU = sensors0.getTempC(S3HU);
// Publizierung des Wertes. Vorher Converierung von float zu String.
mqttClient.publish("/Silo/Temperatur/S3HU",dtostrf(T_S3HU, 1, 2, tempT_S3HU));
Serial.print("MQTT-T_S3HU= "); Serial.println(tempT_S3HU);
}
*/
}