Wenn dies dein erster Besuch hier ist, lies bitte zuerst die Hilfe - Häufig gestellte Fragen durch. Du musst dich vermutlich registrieren, bevor du Beiträge verfassen kannst. Klicke oben auf 'Registrieren', um den Registrierungsprozess zu starten. Du kannst auch jetzt schon Beiträge lesen. Suche dir einfach das Forum aus, das dich am meisten interessiert.
Kann ich machen… aber blöde Frage: im KNX gibt es doch nur 16 Hauptgruppen - von 0-15.
wie kommst du auf den Gedanken eine Hauptgruppe 20 zu verwenden??
Hallo Thorsten,
danke, dass du dich trotz Urlaub meldest. Die Debugausgaben habe ich mir tatsächlich angesehen und kam somit zu dem Schluss, dass ich grundsätzlich Daten empfangen kann. Die Lösung befand sich viele Seiten vorher hier im Thread:
Das senden der Daten von ihm funktioniert auch, das Empfangen von einer Antwort (KNX_COMMAND_READ) klappt auch bis einschließlich Hauptgruppe 15.
I
Sehr schön, einige Seiten vorher im Thread stand scheinbar die Lösung meines Problems. Ich hatte die Hauptgruppe 20 verwendet. Da packe ich immer meinen Spielkram rein. Jetzt habe ich, nachdem ich etliche Seiten hier im Thread durchgearbeitet habe, das Ding mit der Hauptgruppe 15 gefunden und auf meine nächste freie Hauptgruppe, in meinem Falle die 11 gewechselt. Und siehe da, ich bekomme die Telegramme. 😀
ThorstenGehrig Könntest du das ggf. bei Zeiten in Github erwähnen, sodass Andere nicht diesen Leidensweg gehen müssen? Danke 😊
Hallo.
derzeit bin ich im Urlaub - und an der Library habe ich schon viele Jahre nicht mehr meinen Hand angelegt :-(
„irrelevant telegram“ deutet ja darauf hin das die Adresse nicht zu den Listen Adressen gehört…. Hast du dir die mal im debug ausgeben lassen?
empfangen von Telegrammen hab ich selten genutzt… vielleicht ist noch ein aktiver Nutzer online?
So, ich habe mir jetzt den gleichen Microcontroller gegönnt. Leider zeigt es das gleiche Verhalten. Ich empfange nur die Telegramme 0, 2 und 3. Das gewünschte 1er Telegramm kommt nicht. Jetzt brauche ich tatsächlich Hilfe.
EDIT:
Ich habe jetzt in der Library, genauer im "KnxTpUart.cpp" den Debug-Modus eingestellt und lausche dazu auf der seriellen Schnittstelle. Das geht, indem man in der genannten cpp-Datei folgende Zeilen oben einfügt:
Ferner habe ich das Beispiel "ReceiveKNXTelegrams" so angepasst, dass es bei mir lauffähig wird.
Folgendes wird nämlich bei neueren Microcontrollern scheinbar nicht mehr aufgerufen.
void serialEvent1() {
Jetzt muss man in der "void loop()" einen Aufruf starten.
Weiterhin habe ich die Gruppenadressen, auf die gelauscht werden soll angepasst und zwar auf jene, welche bei mir häufig erscheinen. Zumindest ist das bei "5/6/8" der Fall. Hierbei handelt es sich bei mir um einen Datentyp 5.001 (Prozentwert), welcher alle 3 Sekunden auf den Bus gesendet wird. Dennoch erhalte ich fast ausschließlich "IRRELEVANT_KNX_TELEGRAM".
Hier der angepasste Sketch:
Code:
// File: ReceiveKNXTelegrams.ino
// Author: Daniel Kleine-Albers (Since 2012)
// Modified: Thorsten Gehrig (Since 2014)
// Modified: Mag Gyver (Since 2016)
// Test constellation = ARDUINO MEGA <-> 5WG1 117-2AB12
#include <KnxTpUart.h>
// Initialize the KNX TP-UART library on the Serial1 port of ARDUINO MEGA
// and with KNX physical address 15.15.20
KnxTpUart knx(&Serial1, "15.15.20");
//#define TPUART_DEBUG
//#define TPUART_DEBUG_PORT Serial
int LED = 13;
void setup() {
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);
Serial.begin(9600);
while (!Serial);
Serial.println("TP-UART Test");
Serial1.begin(19200, SERIAL_8E1);
while (!Serial1);
Serial.print("UCSR1A: ");
Serial.println(UCSR1A, BIN);
Serial.print("UCSR1B: ");
Serial.println(UCSR1B, BIN);
Serial.print("UCSR1C: ");
Serial.println(UCSR1C, BIN);
knx.uartReset();
knx.addListenGroupAddress("20/2/0");
knx.addListenGroupAddress("20/2/1");
knx.addListenGroupAddress("20/2/2");
knx.addListenGroupAddress("5/6/8"); //5.001 8-bit unsigned
knx.addListenGroupAddress("20/2/4");
knx.addListenGroupAddress("20/2/5");
knx.addListenGroupAddress("20/2/6");
knx.addListenGroupAddress("20/2/7");
knx.addListenGroupAddress("20/2/8");
knx.addListenGroupAddress("20/2/9");
}
void maintainKnxSerial() {
if (Serial1.available() > 0) {
Serial.println(Serial1.available());
KnxTpUartSerialEventType eType = knx.serialEvent();
// Serial.println(eType);
if (eType == TPUART_RESET_INDICATION) { // eType = 0
Serial.println("Event TPUART_RESET_INDICATION");
}
else if (eType == UNKNOWN) { // eType = 3
Serial.println("Event UNKNOWN");
}
else if (eType == KNX_TELEGRAM) {
Serial.println("Event KNX_TELEGRAM");
KnxTelegram* telegram = knx.getReceivedTelegram();
// Telegrammauswertung auf KNX (bei Empfang immer notwendig)
String target =
String(0 + telegram->getTargetMainGroup()) + "/" +
String(0 + telegram->getTargetMiddleGroup()) + "/" +
String(0 + telegram->getTargetSubGroup());
// Here you have the telegram and can do whatever you want
if (telegram->getCommand() == KNX_COMMAND_WRITE) {
// Auswertung des empfangenen KNX-Telegrammes mit Schreibbefehl (Flag) -> Aktion
if (target == "20/2/0") {
int received_15_0_0 = telegram->getBool();
Serial.print("Empfangener wert");
Serial.println(received_15_0_0);
if (received_15_0_0) {
digitalWrite(LED, HIGH);
}
else {
digitalWrite(LED, LOW);
}
}
if (target == "20/2/1") {
int received_15_0_1 = telegram->get4BitIntValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_1);
}
if (target == "20/2/2") {
int received_15_0_2_0 = telegram->get4BitDirectionValue();
int received_15_0_2_1 = telegram->get4BitStepsValue();
Serial.print("Empfangener Wert:");
Serial.println("");
switch (received_15_0_2_0) {
case 0:
Serial.print("Direction: down");
break;
case 1:
Serial.print("Direction: up");
break;
}
Serial.print(" ");
switch (received_15_0_2_1) {
case 0:
Serial.print("Step: stop");
break;
case 1:
Serial.print("Step: 100%");
break;
case 2:
Serial.print("Step: 50%");
break;
case 3:
Serial.print("Step: 25%");
break;
case 4:
Serial.print("Step: 12%");
break;
case 5:
Serial.print("Step: 6%");
break;
case 6:
Serial.print("Step: 3%");
break;
case 7:
Serial.print("Step: 1%");
break;
}
Serial.println("");
}
if (target == "20/2/3") {
int received_15_0_3 = telegram->get1ByteIntValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_3);
}
if (target == "20/2/4") {
int received_15_0_4 = telegram->get2ByteIntValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_4);
}
if (target == "20/2/5") {
float received_15_0_5 = telegram->get2ByteFloatValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_5);
}
if (target == "20/2/6") {
int received_15_0_6_0 = telegram->get3ByteWeekdayValue();
int received_15_0_6_1 = telegram->get3ByteHourValue();
int received_15_0_6_2 = telegram->get3ByteMinuteValue();
int received_15_0_6_3 = telegram->get3ByteSecondValue();
Serial.print("Empfangener Wert:");
Serial.println("");
Serial.print(received_15_0_6_0);
Serial.print(" ");
Serial.print(received_15_0_6_1);
Serial.print(":");
Serial.print(received_15_0_6_2);
Serial.print(":");
Serial.print(received_15_0_6_3);
Serial.println("");
}
if (target == "20/2/7") {
int received_15_0_7_0 = telegram->get3ByteDayValue();
int received_15_0_7_1 = telegram->get3ByteMonthValue();
int received_15_0_7_2 = telegram->get3ByteYearValue();
Serial.print("Empfangener Wert:");
Serial.println("");
Serial.print(received_15_0_7_0);
Serial.print(".");
Serial.print(received_15_0_7_1);
Serial.print(".");
Serial.print(received_15_0_7_2);
Serial.println("");
}
if (target == "20/2/8") {
float received_15_0_8 = telegram->get4ByteFloatValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_8);
}
if (target == "20/2/9") {
String received_15_0_9 = telegram->get14ByteValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_9);
}
}
}
}
}
void loop() {
maintainKnxSerial();
}
Dazu dann hier ein paar Sekunden der Debug-Ausgabe:
herzlichen Glückwunsch zum Zehnjährigen. 😀
Ich möchte mich gerne auch mit deinen Librarys vergnügen und mir mit einem Microcontroller eine Serovsteuerung bauen. Da ich damit Probleme hatte, habe ich bereits einen anderen Thread eröffnet um jetzt festzustellen, dass der die Themen besser hier her gehören. @Admins: Falls ihr das hier her schieben könntet, wäre das nett.
Ich habe nun schon 2 Microcontroller getestet. Einmal einen Arduino Nano Clon und meinen bevorzugten Seeeduino Xiao (SAMD21). Bei beiden kann ich Daten senden, aber die Abfrage von vordefinierten Telegrammen (knx.addListenGroupAddress(.....) funktioniert bei mir irgendwie nicht.
Code:
#include <Arduino.h>
#include <KnxTpUart.h>
#include <KnxTelegram.h>
#include <Servo.h>
#define PHYSICAL_ADDRESS "1.0.61"
#define INPUT_GROUP_ADDRESS "20/2/0"
#define OUTPUT_GROUP_ADDRESS "20/2/1"
#define SERVOPIN 1
#define LED_OFF HIGH
#define LED_ON LOW
#define REFRESH_INTERVAL 10000
bool SERVOPOSITION = false;
static unsigned long lastRefreshTime = 0;
KnxTpUart knx(&Serial1, PHYSICAL_ADDRESS);
Servo myservo; // create servo object to control a servo
int pos = 90; // variable to store the servo position
int led = LED_BUILTIN;
void setup() {
Serial.begin(115200); // USB
Serial.println("Bla1");
Serial1.begin(19200, SERIAL_8E1); // Siemens seriell
while (!Serial); // Warten auf USB
Serial.println("Bla2");
while (!Serial1); // Warten auf Siemens
Serial.println("Bla3");
knx.uartReset();
Serial.println("Bla4");
knx.addListenGroupAddress(INPUT_GROUP_ADDRESS);
Serial.println("Bla5");
// delay(1000);
Serial.println("Bla6");
myservo.attach(SERVOPIN); // attaches the servo on pin 1 to the servo object
pinMode(led, OUTPUT);
digitalWrite(led, LED_OFF);
Serial.println("Setup done");
}
void maintainKnxSerial() {
if (Serial1.available() > 0) {
KnxTpUartSerialEventType eType = knx.serialEvent();
if (eType == KNX_TELEGRAM) {
Serial.println("Telegramm empfangen");
KnxTelegram* telegram = knx.getReceivedTelegram();
String target =
String(0 + telegram->getTargetMainGroup()) + "/" +
String(0 + telegram->getTargetMiddleGroup()) + "/" +
String(0 + telegram->getTargetSubGroup());
Serial.print("Zieladresse: ");
Serial.println(target);
if (telegram->getCommand() == KNX_COMMAND_READ) {
Serial.println("Leseanforderung erhalten");
// Antwort auf Leseanforderung
if (target == OUTPUT_GROUP_ADDRESS) {
knx.groupAnswerBool(OUTPUT_GROUP_ADDRESS, SERVOPOSITION);
}
} else if (telegram->getCommand() == KNX_COMMAND_WRITE) {
Serial.println("Schreibanforderung erhalten");
// Schreibanforderung
if (target == INPUT_GROUP_ADDRESS) {
if (telegram->getBool()) {
Serial.println("Servo auf Position 90 setzen");
SERVOPOSITION = true;
myservo.write(90);
digitalWrite(led, LED_ON);
} else {
Serial.println("Servo auf Position 180 setzen");
SERVOPOSITION = false;
myservo.write(180);
digitalWrite(led, LED_OFF);
}
}
}
} else {
Serial.print("Kein KNX-Telegramm, Event-Type: ");
Serial.println(eType);
}
}
}
/*
void serialEvent1() {
Serial.println("Aufruf");
KnxTpUartSerialEventType eType = knx.serialEvent();
if (eType == TPUART_RESET_INDICATION) {
Serial.println("Event TPUART_RESET_INDICATION");
}
else if (eType == UNKNOWN) {
Serial.println("Event UNKNOWN");
}
else if (eType == KNX_TELEGRAM) {
Serial.println("Event KNX_TELEGRAM");
KnxTelegram* telegram = knx.getReceivedTelegram();
// Telegrammauswertung auf KNX (bei Empfang immer notwendig)
String target =
String(0 + telegram->getTargetMainGroup()) + "/" +
String(0 + telegram->getTargetMiddleGroup()) + "/" +
String(0 + telegram->getTargetSubGroup());
// Here you have the telegram and can do whatever you want
if (telegram->getCommand() == KNX_COMMAND_WRITE) {
// Auswertung des empfangenen KNX-Telegrammes mit Schreibbefehl (Flag) -> Aktion
if (target == "15/0/0") {
int received_15_0_0 = telegram->getBool();
Serial.print("Empfangener wert");
Serial.println(received_15_0_0);
if (received_15_0_0) {
// digitalWrite(LED, HIGH);
}
else {
// digitalWrite(LED, LOW);
}
}
if (target == "15/0/1") {
int received_15_0_1 = telegram->get4BitIntValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_1);
}
if (target == "15/0/2") {
int received_15_0_2_0 = telegram->get4BitDirectionValue();
int received_15_0_2_1 = telegram->get4BitStepsValue();
Serial.print("Empfangener Wert:");
Serial.println("");
switch (received_15_0_2_0) {
case 0:
Serial.print("Direction: down");
break;
case 1:
Serial.print("Direction: up");
break;
}
Serial.print(" ");
switch (received_15_0_2_1) {
case 0:
Serial.print("Step: stop");
break;
case 1:
Serial.print("Step: 100%");
break;
case 2:
Serial.print("Step: 50%");
break;
case 3:
Serial.print("Step: 25%");
break;
case 4:
Serial.print("Step: 12%");
break;
case 5:
Serial.print("Step: 6%");
break;
case 6:
Serial.print("Step: 3%");
break;
case 7:
Serial.print("Step: 1%");
break;
}
Serial.println("");
}
if (target == "15/0/3") {
int received_15_0_3 = telegram->get1ByteIntValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_3);
}
if (target == "15/0/4") {
int received_15_0_4 = telegram->get2ByteIntValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_4);
}
if (target == "15/0/5") {
float received_15_0_5 = telegram->get2ByteFloatValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_5);
}
if (target == "15/0/6") {
int received_15_0_6_0 = telegram->get3ByteWeekdayValue();
int received_15_0_6_1 = telegram->get3ByteHourValue();
int received_15_0_6_2 = telegram->get3ByteMinuteValue();
int received_15_0_6_3 = telegram->get3ByteSecondValue();
Serial.print("Empfangener Wert:");
Serial.println("");
Serial.print(received_15_0_6_0);
Serial.print(" ");
Serial.print(received_15_0_6_1);
Serial.print(":");
Serial.print(received_15_0_6_2);
Serial.print(":");
Serial.print(received_15_0_6_3);
Serial.println("");
}
if (target == "15/0/7") {
int received_15_0_7_0 = telegram->get3ByteDayValue();
int received_15_0_7_1 = telegram->get3ByteMonthValue();
int received_15_0_7_2 = telegram->get3ByteYearValue();
Serial.print("Empfangener Wert:");
Serial.println("");
Serial.print(received_15_0_7_0);
Serial.print(".");
Serial.print(received_15_0_7_1);
Serial.print(".");
Serial.print(received_15_0_7_2);
Serial.println("");
}
if (target == "15/0/8") {
float received_15_0_8 = telegram->get4ByteFloatValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_8);
}
if (target == "15/0/9") {
String received_15_0_9 = telegram->get14ByteValue();
Serial.print("Empfangener Wert:");
Serial.println(received_15_0_9);
}
}
}
}
*/
void loop() {
maintainKnxSerial();
// serialEvent1();
//Das funktioniert
if (millis() - lastRefreshTime >= REFRESH_INTERVAL) {
lastRefreshTime += REFRESH_INTERVAL;
knx.groupWriteBool(OUTPUT_GROUP_ADDRESS, false);
}
}
Ich habe nun Debug-Ausgaben per USB ausgewertet und stelle ein eType von meistens 3, manchmal 2 fest.
Um diesen Befehl geht es:
Gemäß der KnxTpUart.h müsste 2 ja ein KNX_TELEGRAM sein und 3 IRRELEVANT_KNX_TELEGRAM.
Wenn ich das richtig verstehe, sollte also meine Debug-Ausgabe in Zeile 45 zünden. In Zeile 44 wird ausgewertet
if (eType == KNX_TELEGRAM) {
in 45 wird dann auf den USB-Serial "Telegramm empfangen" ausgegeben. Das passiert jedoch nicht. Gibt es irgend einen Ratschlag, wie ich da vorgehen kann? Ich denke, es müsste ja funktionieren.
EDIT:
2 sollte IRRELEVANT_KNX_TELEGRAM sein und 3 UKNOWN.
Ich habe jedenfalls in meinem Codebeispiel die Gruppenadresse 20/2/0 auf "listen" gesetzt. Ferner habe ich auf diese Gruppenadresse Boolsche Werte (mittels NodeRed) gesendet.
Hilft das bei der Fehlersuche?
EDIT2:
Ich habe mir jetzt einen Arduino Pro Micro zugelegt. Dann kann ich einmal 1 zu 1 das nachbauen, was auf https://haus-automatisierung.com/har...selbstbau.html
genannt ist. Irgendwie muss es ja funktionieren. Der Seeeduino Xiao ist ungetestet, mein Arduino Nano hat keine zweite serielle Schnittstelle, was das Debuggen ätzend macht und meinem ebenso noch vorhandenen Arduino Uno geht es genauso. Schauen wir mal, was dabei raus kommt.
Ich muss gerade mal 10-jähriges feiern :-)
Der erste post war am 09.01.2014 - also vor 10 Jahren.
Ich bin ein bisschen "baff" das dieser Thread immer noch "Lebt" - und freu mich wie weit wir mittlerweile gekommen sind (mit Ardunio, ESP, SelfKNX und co).
spontan sage ich mal, dass das delay(5000) hier etwas kontra-produktiv ist. Die Loop sollte man nie blockieren. In der Zeit können ja keine neue Nachrichten vom Bus gelesen werden.
Hallo zusammen & allen erstmal noch ein frohes neues Jahr!
Ich habe aktuell ein Problem beim Auslesen von KNX-Telegrammen auf einem Arduino Mega. Ich schaffe es nur ein Telegramm auszulesen, weitere Telegramme funktionieren nicht (also 2 oder mehr). Das Skript dient aktuell nur zu Testzwecken, um die Funktion an sich, mehrere Telegramme auszulesen, zum laufen zu bekommen. Hier sende ich aktuell 2 Messwerte über eine Siemens BCU ins KNX-System. Diese kommen dort auch korrekt an. Wenn ich diese dann allerdings über den Arduino auslesen möchte, bekomme ich nur Daten zum 1. Telegramm zurück. Ich habe bereits sehr viel probiert (ein eigener Void für das 2. Telegramm, if & else if, telegram1 & telegram2, target1 & target2, eType1 & eType2 --> siehe Code) , jedoch klappt nichts davon. Kennt sich hier vielleicht jemand damit aus und kann mir bitte weiterhelfen?
Code:
#include <KnxTpUart.h>
#include "DHT.h" //DHT Bibliothek laden
#define DHTPIN 2 //Der Sensor wird an PIN 2 angeschlossen
#define DHTTYPE DHT11 // Es handelt sich um den DHT11 Sensor
#define Temperatur_Group_Adress "1/1/24"
#define Luftfeuchtigkeit_Group_Adress "1/1/23"
#define Physical_Adress "1/1/25"
DHT dht(DHTPIN, DHTTYPE); //Der Sensor wird ab jetzt mit „dth“ angesprochen
KnxTpUart knx(&Serial1, Physical_Adress);
void setup() {
Serial.begin(9600);
Serial1.begin(19200, SERIAL_8E1);
knx.uartReset();
knx.addListenGroupAddress(Temperatur_Group_Adress);
knx.addListenGroupAddress(Luftfeuchtigkeit_Group_Adress);
knx.addListenGroupAddress(Nitrat_Group_Adress); // Nitrat Gruppenadresse
dht.begin(); //DHT11 Sensor starten
}
float Temp_from_KNX = 0;
float Hum_from_KNX = 0;
float getTemperatur() {
int Temperatur = dht.readTemperature();
return float (Temperatur);
}
float getLuftfeuchtigkeit() {
int Luftfeuchtigkeit = dht.readHumidity();
return float (Luftfeuchtigkeit);
}
void maintainSensors () {
delay(10000); //Zwei Sekunden Vorlaufzeit bis zur Messung (der Sensor ist etwas träge)
knx.groupWrite2ByteFloat(Luftfeuchtigkeit_Group_Adress, getLuftfeuchtigkeit());
knx.groupWrite2ByteFloat(Temperatur_Group_Adress, getTemperatur());
}
void loop() {
maintainSensors();
maintainKnxSerial_Temp();
//maintainKnxSerial_Hum();
delay(5000);
}
void maintainKnxSerial_Temp() {
//if (Serial1.available() > 0) {
//Serial.println("Serial1 available");
//Serial1.println("Serial1 available");
KnxTpUartSerialEventType eType1 = knx.serialEvent();
//if (eType == TPUART_RESET_INDICATION) {
//Serial.println("Event TPUART_RESET_INDICATION");
//}
//if (eType == UNKNOWN_EVENT) {
//Serial.println("Event UNKNOWN");
//}
if (eType1 == KNX_TELEGRAM) {
//Serial.println("Event KNX_TELEGRAM");
KnxTelegram* telegram = knx.getReceivedTelegram();
Serial.println(" ");
Serial.print("Telegramm erhalten --> ");
// Create the KNX String Address in the "0/0/0" format
String target =
String(0 + telegram->getTargetMainGroup()) + "/" +
String(0 + telegram->getTargetMiddleGroup()) + "/" +
String(0 + telegram->getTargetSubGroup());
// Check what has been sent on KNX and write it into variables/arrays
if (telegram->getCommand() == KNX_COMMAND_WRITE) {
if (target == Temperatur_Group_Adress) {
Temp_from_KNX = telegram->get2ByteFloatValue();
Serial.print(target);
Serial.print(" --> Temperatur: ");
Serial.print(Temp_from_KNX);
}
else if (target == Luftfeuchtigkeit_Group_Adress) {
Hum_from_KNX = telegram->get2ByteFloatValue();
Serial.println(" ");
Serial.print("Telegramm erhalten --> ");
Serial.print(target);
Serial.print(" --> Humidity: ");
Serial.print(Hum_from_KNX);
}
}
}
}
void maintainKnxSerial_Hum() {
Serial.print("Maintain Hum wird ausgeführt");
KnxTpUartSerialEventType eType2 = knx.serialEvent();
Serial.print("Initiate eType");
if (eType2 == KNX_TELEGRAM) {
Serial.println("Event KNX_TELEGRAM");
KnxTelegram* telegram2 = knx.getReceivedTelegram();
Serial.println(" ");
Serial.print("Telegramm erhalten --> ");
// Create the KNX String Address in the "0/0/0" format
String target2 =
String(0 + telegram2->getTargetMainGroup()) + "/" +
String(0 + telegram2->getTargetMiddleGroup()) + "/" +
String(0 + telegram2->getTargetSubGroup());
if (telegram2->getCommand() == KNX_COMMAND_WRITE) {
if (target2 == Luftfeuchtigkeit_Group_Adress) {
Hum_from_KNX = telegram2->get2ByteFloatValue();
Serial.println(" ");
Serial.print("Telegramm erhalten --> ");
Serial.print(target2);
Serial.print(" --> Humidity: ");
Serial.print(Hum_from_KNX);
}
}
}
}
ich glaube ich versteh einfach den Code nicht richtig.
Vlt kann jemand mal sagen, welches der Beispiele aus der Lib das richtige ist, um folgendes testweise zu realisieren:
In der ETS schreibe ich auf eine bestimmte Gruppenadresse (z.B. 3/4/152) den bool Wahr, das liest der Arduino und schaltet eine LED an, bzw. umgekehrt.
Vlt. komm ich so dem Fehler auf die Schliche...
Wir verarbeiten personenbezogene Daten über die Nutzer unserer Website mithilfe von Cookies und anderen Technologien, um unsere Dienste bereitzustellen. Weitere Informationen findest Du in unserer Datenschutzerklärung.
Indem Du unten auf "ICH stimme zu" klickst, stimmst Du unserer Datenschutzerklärung und unseren persönlichen Datenverarbeitungs- und Cookie-Praktiken zu, wie darin beschrieben. Du erkennst außerdem an, dass dieses Forum möglicherweise außerhalb Deines Landes gehostet wird und bist damit einverstanden, dass Deine Daten in dem Land, in dem dieses Forum gehostet wird, gesammelt, gespeichert und verarbeitet werden.
Einen Kommentar schreiben: