From 82ee9fdf8167aba4ab04b36e96db565d2b5374b9 Mon Sep 17 00:00:00 2001 From: Waldemar Porscha Date: Sat, 18 Feb 2023 18:17:08 +0100 Subject: [PATCH] Release 1.4.2 - removed unnecessary libs - updated documentation --- dependencies.txt | Bin 184 -> 164 bytes doc/Applikationsbeschreibung-Logik.md | 7 +- platformio.ini | 7 +- src/Logikmodul.h | 1005 +++++++++++++------------ src/TimerInterruptRP2040.cpp.bak | 199 ----- src/TimerInterruptSAMD.cpp.bak | 191 ----- src/main.cpp | 28 +- 7 files changed, 532 insertions(+), 905 deletions(-) delete mode 100644 src/TimerInterruptRP2040.cpp.bak delete mode 100644 src/TimerInterruptSAMD.cpp.bak diff --git a/dependencies.txt b/dependencies.txt index 8733eae775d659586a48b4731bbee46e72665143..faafadd6f2aaaa2a8af65e9d455e617dbbfae1ac 100644 GIT binary patch delta 33 lcmdnNxP);+mUtqA0fQxj83Tw;Wl&(q1+p?3@+MAI1^|H&2Xp`c delta 53 zcmZ3&xPx&*mbNK_8G|8%IYT0YF_2VX$Y&^ENM*=l$OhsH23>|UpiD9lr!b^WY*YpS DC6fyK diff --git a/doc/Applikationsbeschreibung-Logik.md b/doc/Applikationsbeschreibung-Logik.md index 8c677c2..776a887 100644 --- a/doc/Applikationsbeschreibung-Logik.md +++ b/doc/Applikationsbeschreibung-Logik.md @@ -90,6 +90,10 @@ Eine Übersicht über die verfügbaren Konfigurationsseiten und Links zur jeweil Im folgenden werden Änderungen an dem Dokument erfasst, damit man nicht immer das Gesamtdokument lesen muss, um Neuerungen zu erfahren. +18.02.2023: Firmware 1.4.2, Applikation 1.4 + +* Überflüssige Libraries entfernt, keine funktionalen Änderungen. + 09.01.2023: Firmware 1.4.1, Applikation 1.4 * NEU: Zeitschaltuhren können jetzt auch anhand des Sonnenstands (Elevation, Winkel unter/über dem Horizont) schalten. @@ -98,7 +102,7 @@ Im folgenden werden Änderungen an dem Dokument erfasst, damit man nicht immer d * FIX: Ungültige Datum- und Zeit-Telegramme werden ignoriert und stellen die Zeit nicht mehr auf unsinnige Werte * FIX: Ein Datum mit einem Jahr vor 2022 wird ignoriert, das hilft, wenn beim System-Neustart erst mal veraltete Datum-Telegramme verschickt werden -* NEU: Sommerzeit kann nicht nur über ein KO gesetzt oder intern berechnet werden (gilt nur für Deutschland), sondern auch aus einem DPT19-Telegramm ermittelt werden, sofern der KNX-Zeitgeber das unterstützt. +* NEU: Sommerzeit kann nicht nur über ein KO gesetzt oder intern berechnet werden (gilt nur für Deutschland), sondern auch aus einem DPT 19-Telegramm ermittelt werden, sofern der KNX-Zeitgeber das unterstützt. 30.12.2022: Firmware 1.2, Applikation 1.2 @@ -461,7 +465,6 @@ Erscheint nur, wenn der Datum- bzw. Zeitempfang über ein kombiniertes Datum/Zei Wenn der Datum- bzw. Zeitempfang über ein kombiniertes Datum/Zeit-KO (DPT 19) gewählt worden ist, kann dieses Zeittelegramm auch die Information enthalten, ob gerade die Sommerzeit aktiv ist. Wenn der Zeitgeber im System diese Information mit dem DPT 19-Telegramm mitschicken kann, sollte diese Option gewählt werden. -Nach bisherigen Tests ist uns nur das MDT-IP-Interface ##### **Interne Berechnung (nur für Deutschland)** Erscheint nur, wenn die Zeitzone 'Berlin' gewählt worden ist. diff --git a/platformio.ini b/platformio.ini index 5f6374d..2a31405 100644 --- a/platformio.ini +++ b/platformio.ini @@ -18,6 +18,7 @@ build_flags = ; optimize knx stack -D SMALL_GROUPOBJECT -D USE_BINSEARCH + -D LOGICAPP -D LOGICMODULE -D MASK_VERSION=0x07B0 ; use flash directly @@ -32,8 +33,8 @@ build_flags = ; debug timing in knx stack monitor_speed = 115200 lib_ldf_mode = deep+ -lib_deps = - khoih-prog/TimerInterrupt_Generic @ 1.13.0 +; lib_deps = +; khoih-prog/TimerInterrupt_Generic @ 1.13.0 ; lib_extra_dirs = ; ${PROJECT_DIR}\.. debug_tool = jlink @@ -82,7 +83,7 @@ build_flags = ; -D CRYSTALLESS ; -D WATCHDOG lib_deps = - ${env.lib_deps} + ; ${env.lib_deps} adafruit/Adafruit SleepyDog Library @ 1.4.0 ; Wire ; SPI diff --git a/src/Logikmodul.h b/src/Logikmodul.h index a69ffb2..de0f38f 100644 --- a/src/Logikmodul.h +++ b/src/Logikmodul.h @@ -1,5 +1,13 @@ #pragma once + +#define paramDelay(time) (uint32_t)( \ + (time & 0xC000) == 0xC000 ? (time & 0x3FFF) * 100 : \ + (time & 0xC000) == 0x0000 ? (time & 0x3FFF) * 1000 : \ + (time & 0xC000) == 0x4000 ? (time & 0x3FFF) * 60000 : \ + (time & 0xC000) == 0x8000 ? ((time & 0x3FFF) > 1000 ? 3600000 : \ + (time & 0x3FFF) * 3600000 ) : 0 ) + // Parameter with single occurrence @@ -173,125 +181,129 @@ #define LOG_TimezoneValueShift 0 // Anzahl verfügbarer Logikkanäle -#define ParamLOG_NumChannels (knx.paramByte(LOG_ParamBlockOffset + LOG_NumChannels)) +#define ParamLOG_NumChannels (knx.paramByte(LOG_NumChannels)) // Zeitbasis -#define ParamLOG_StartupDelayBase ((knx.paramByte(LOG_ParamBlockOffset + LOG_StartupDelayBase) & LOG_StartupDelayBaseMask) >> LOG_StartupDelayBaseShift) +#define ParamLOG_StartupDelayBase ((knx.paramByte(LOG_StartupDelayBase) & LOG_StartupDelayBaseMask) >> LOG_StartupDelayBaseShift) // Zeit -#define ParamLOG_StartupDelayTime (knx.paramWord(LOG_ParamBlockOffset + LOG_StartupDelayTime) & LOG_StartupDelayTimeMask) +#define ParamLOG_StartupDelayTime (knx.paramWord(LOG_StartupDelayTime) & LOG_StartupDelayTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_StartupDelayTimeMS (paramDelay(knx.paramWord(LOG_StartupDelayTime))) // Zeitbasis -#define ParamLOG_HeartbeatDelayBase ((knx.paramByte(LOG_ParamBlockOffset + LOG_HeartbeatDelayBase) & LOG_HeartbeatDelayBaseMask) >> LOG_HeartbeatDelayBaseShift) +#define ParamLOG_HeartbeatDelayBase ((knx.paramByte(LOG_HeartbeatDelayBase) & LOG_HeartbeatDelayBaseMask) >> LOG_HeartbeatDelayBaseShift) // Zeit -#define ParamLOG_HeartbeatDelayTime (knx.paramWord(LOG_ParamBlockOffset + LOG_HeartbeatDelayTime) & LOG_HeartbeatDelayTimeMask) +#define ParamLOG_HeartbeatDelayTime (knx.paramWord(LOG_HeartbeatDelayTime) & LOG_HeartbeatDelayTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_HeartbeatDelayTimeMS (paramDelay(knx.paramWord(LOG_HeartbeatDelayTime))) // Uhrzeit und Datum nach einem Neustart vom Bus lesen -#define ParamLOG_ReadTimeDate ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_ReadTimeDate) & LOG_ReadTimeDateMask) +#define ParamLOG_ReadTimeDate ((bool)(knx.paramByte(LOG_ReadTimeDate) & LOG_ReadTimeDateMask)) // Akustischer Signalgeber vorhanden (Buzzer)? -#define ParamLOG_BuzzerInstalled ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_BuzzerInstalled) & LOG_BuzzerInstalledMask) +#define ParamLOG_BuzzerInstalled ((bool)(knx.paramByte(LOG_BuzzerInstalled) & LOG_BuzzerInstalledMask)) // Optischer Signalgeber vorhanden (RGB-LED)? -#define ParamLOG_LedInstalled ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_LedInstalled) & LOG_LedInstalledMask) +#define ParamLOG_LedInstalled ((bool)(knx.paramByte(LOG_LedInstalled) & LOG_LedInstalledMask)) // Uhrzeit und Datum empfangen über -#define ParamLOG_CombinedTimeDate ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_CombinedTimeDate) & LOG_CombinedTimeDateMask) +#define ParamLOG_CombinedTimeDate ((bool)(knx.paramByte(LOG_CombinedTimeDate) & LOG_CombinedTimeDateMask)) // Urlaubsbehandlung aktivieren? -#define ParamLOG_VacationKo ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_VacationKo) & LOG_VacationKoMask) +#define ParamLOG_VacationKo ((bool)(knx.paramByte(LOG_VacationKo) & LOG_VacationKoMask)) // Feiertage auf dem Bus verfügbar machen? -#define ParamLOG_HolidayKo ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_HolidayKo) & LOG_HolidayKoMask) +#define ParamLOG_HolidayKo ((bool)(knx.paramByte(LOG_HolidayKo) & LOG_HolidayKoMask)) // Nach Neustart Urlaubsinfo lesen? -#define ParamLOG_VacationRead ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_VacationRead) & LOG_VacationReadMask) +#define ParamLOG_VacationRead ((bool)(knx.paramByte(LOG_VacationRead) & LOG_VacationReadMask)) // Nach Neuberechnung Feiertagsinfo senden? -#define ParamLOG_HolidaySend ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_HolidaySend) & LOG_HolidaySendMask) +#define ParamLOG_HolidaySend ((bool)(knx.paramByte(LOG_HolidaySend) & LOG_HolidaySendMask)) // Sommerzeit ermitteln durch -#define ParamLOG_SummertimeAll ((knx.paramByte(LOG_ParamBlockOffset + LOG_SummertimeAll) & LOG_SummertimeAllMask) >> LOG_SummertimeAllShift) +#define ParamLOG_SummertimeAll ((knx.paramByte(LOG_SummertimeAll) & LOG_SummertimeAllMask) >> LOG_SummertimeAllShift) // Sommerzeit ermitteln durch -#define ParamLOG_SummertimeDE ((knx.paramByte(LOG_ParamBlockOffset + LOG_SummertimeDE) & LOG_SummertimeDEMask) >> LOG_SummertimeDEShift) +#define ParamLOG_SummertimeDE ((knx.paramByte(LOG_SummertimeDE) & LOG_SummertimeDEMask) >> LOG_SummertimeDEShift) // Sommerzeit ermitteln durch -#define ParamLOG_SummertimeWorld ((knx.paramByte(LOG_ParamBlockOffset + LOG_SummertimeWorld) & LOG_SummertimeWorldMask) >> LOG_SummertimeWorldShift) +#define ParamLOG_SummertimeWorld ((knx.paramByte(LOG_SummertimeWorld) & LOG_SummertimeWorldMask) >> LOG_SummertimeWorldShift) // Sommerzeit ermitteln durch -#define ParamLOG_SummertimeKO ((knx.paramByte(LOG_ParamBlockOffset + LOG_SummertimeKO) & LOG_SummertimeKOMask) >> LOG_SummertimeKOShift) +#define ParamLOG_SummertimeKO ((knx.paramByte(LOG_SummertimeKO) & LOG_SummertimeKOMask) >> LOG_SummertimeKOShift) // Diagnoseobjekt anzeigen -#define ParamLOG_Diagnose ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Diagnose) & LOG_DiagnoseMask) +#define ParamLOG_Diagnose ((bool)(knx.paramByte(LOG_Diagnose) & LOG_DiagnoseMask)) // Watchdog aktivieren -#define ParamLOG_Watchdog ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Watchdog) & LOG_WatchdogMask) +#define ParamLOG_Watchdog ((bool)(knx.paramByte(LOG_Watchdog) & LOG_WatchdogMask)) // 1. Neujahr -#define ParamLOG_Neujahr ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Neujahr) & LOG_NeujahrMask) +#define ParamLOG_Neujahr ((bool)(knx.paramByte(LOG_Neujahr) & LOG_NeujahrMask)) // 2. Heilige Drei Könige -#define ParamLOG_DreiKoenige ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_DreiKoenige) & LOG_DreiKoenigeMask) +#define ParamLOG_DreiKoenige ((bool)(knx.paramByte(LOG_DreiKoenige) & LOG_DreiKoenigeMask)) // 3. Weiberfastnacht -#define ParamLOG_Weiberfastnacht ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Weiberfastnacht) & LOG_WeiberfastnachtMask) +#define ParamLOG_Weiberfastnacht ((bool)(knx.paramByte(LOG_Weiberfastnacht) & LOG_WeiberfastnachtMask)) // 4. Rosenmontag -#define ParamLOG_Rosenmontag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Rosenmontag) & LOG_RosenmontagMask) +#define ParamLOG_Rosenmontag ((bool)(knx.paramByte(LOG_Rosenmontag) & LOG_RosenmontagMask)) // 5. Fastnachtsdienstag -#define ParamLOG_Fastnachtsdienstag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Fastnachtsdienstag) & LOG_FastnachtsdienstagMask) +#define ParamLOG_Fastnachtsdienstag ((bool)(knx.paramByte(LOG_Fastnachtsdienstag) & LOG_FastnachtsdienstagMask)) // 6. Aschermittwoch -#define ParamLOG_Aschermittwoch ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Aschermittwoch) & LOG_AschermittwochMask) +#define ParamLOG_Aschermittwoch ((bool)(knx.paramByte(LOG_Aschermittwoch) & LOG_AschermittwochMask)) // 7. Frauentag -#define ParamLOG_Frauentag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Frauentag) & LOG_FrauentagMask) +#define ParamLOG_Frauentag ((bool)(knx.paramByte(LOG_Frauentag) & LOG_FrauentagMask)) // 8. Gründonnerstag -#define ParamLOG_Gruendonnerstag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Gruendonnerstag) & LOG_GruendonnerstagMask) +#define ParamLOG_Gruendonnerstag ((bool)(knx.paramByte(LOG_Gruendonnerstag) & LOG_GruendonnerstagMask)) // 9. Karfreitag -#define ParamLOG_Karfreitag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Karfreitag) & LOG_KarfreitagMask) +#define ParamLOG_Karfreitag ((bool)(knx.paramByte(LOG_Karfreitag) & LOG_KarfreitagMask)) // 10. Ostersonntag -#define ParamLOG_Ostersonntag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Ostersonntag) & LOG_OstersonntagMask) +#define ParamLOG_Ostersonntag ((bool)(knx.paramByte(LOG_Ostersonntag) & LOG_OstersonntagMask)) // 11. Ostermontag -#define ParamLOG_Ostermontag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Ostermontag) & LOG_OstermontagMask) +#define ParamLOG_Ostermontag ((bool)(knx.paramByte(LOG_Ostermontag) & LOG_OstermontagMask)) // 12. Tag der Arbeit -#define ParamLOG_TagDerArbeit ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_TagDerArbeit) & LOG_TagDerArbeitMask) +#define ParamLOG_TagDerArbeit ((bool)(knx.paramByte(LOG_TagDerArbeit) & LOG_TagDerArbeitMask)) // 13. Christi Himmelfahrt -#define ParamLOG_Himmelfahrt ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Himmelfahrt) & LOG_HimmelfahrtMask) +#define ParamLOG_Himmelfahrt ((bool)(knx.paramByte(LOG_Himmelfahrt) & LOG_HimmelfahrtMask)) // 14. Pfingstsonntag -#define ParamLOG_Pfingstsonntag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Pfingstsonntag) & LOG_PfingstsonntagMask) +#define ParamLOG_Pfingstsonntag ((bool)(knx.paramByte(LOG_Pfingstsonntag) & LOG_PfingstsonntagMask)) // 15. Pfingstmontag -#define ParamLOG_Pfingstmontag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Pfingstmontag) & LOG_PfingstmontagMask) +#define ParamLOG_Pfingstmontag ((bool)(knx.paramByte(LOG_Pfingstmontag) & LOG_PfingstmontagMask)) // 16. Fronleichnam -#define ParamLOG_Fronleichnam ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Fronleichnam) & LOG_FronleichnamMask) +#define ParamLOG_Fronleichnam ((bool)(knx.paramByte(LOG_Fronleichnam) & LOG_FronleichnamMask)) // 17. Hohes Friedensfest -#define ParamLOG_Friedensfest ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Friedensfest) & LOG_FriedensfestMask) +#define ParamLOG_Friedensfest ((bool)(knx.paramByte(LOG_Friedensfest) & LOG_FriedensfestMask)) // 18. Mariä Himmelfahrt -#define ParamLOG_MariaHimmelfahrt ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_MariaHimmelfahrt) & LOG_MariaHimmelfahrtMask) +#define ParamLOG_MariaHimmelfahrt ((bool)(knx.paramByte(LOG_MariaHimmelfahrt) & LOG_MariaHimmelfahrtMask)) // 19. Tag der Deutschen Einheit -#define ParamLOG_DeutscheEinheit ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_DeutscheEinheit) & LOG_DeutscheEinheitMask) +#define ParamLOG_DeutscheEinheit ((bool)(knx.paramByte(LOG_DeutscheEinheit) & LOG_DeutscheEinheitMask)) // 31. Nationalfeiertag (AT) -#define ParamLOG_Nationalfeiertag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Nationalfeiertag) & LOG_NationalfeiertagMask) +#define ParamLOG_Nationalfeiertag ((bool)(knx.paramByte(LOG_Nationalfeiertag) & LOG_NationalfeiertagMask)) // 20. Reformationstag -#define ParamLOG_Reformationstag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Reformationstag) & LOG_ReformationstagMask) +#define ParamLOG_Reformationstag ((bool)(knx.paramByte(LOG_Reformationstag) & LOG_ReformationstagMask)) // 21. Allerheiligen -#define ParamLOG_Allerheiligen ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Allerheiligen) & LOG_AllerheiligenMask) +#define ParamLOG_Allerheiligen ((bool)(knx.paramByte(LOG_Allerheiligen) & LOG_AllerheiligenMask)) // 22. Buß- und Bettag -#define ParamLOG_BussBettag ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_BussBettag) & LOG_BussBettagMask) +#define ParamLOG_BussBettag ((bool)(knx.paramByte(LOG_BussBettag) & LOG_BussBettagMask)) // 32. Maria Empfängnis (AT) -#define ParamLOG_MariaEmpfaengnis ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_MariaEmpfaengnis) & LOG_MariaEmpfaengnisMask) +#define ParamLOG_MariaEmpfaengnis ((bool)(knx.paramByte(LOG_MariaEmpfaengnis) & LOG_MariaEmpfaengnisMask)) // 23. Erster Advent -#define ParamLOG_Advent1 ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Advent1) & LOG_Advent1Mask) +#define ParamLOG_Advent1 ((bool)(knx.paramByte(LOG_Advent1) & LOG_Advent1Mask)) // 24. Zweiter Advent -#define ParamLOG_Advent2 ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Advent2) & LOG_Advent2Mask) +#define ParamLOG_Advent2 ((bool)(knx.paramByte(LOG_Advent2) & LOG_Advent2Mask)) // 25. Dritter Advent -#define ParamLOG_Advent3 ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Advent3) & LOG_Advent3Mask) +#define ParamLOG_Advent3 ((bool)(knx.paramByte(LOG_Advent3) & LOG_Advent3Mask)) // 26. Vierter Advent -#define ParamLOG_Advent4 ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Advent4) & LOG_Advent4Mask) +#define ParamLOG_Advent4 ((bool)(knx.paramByte(LOG_Advent4) & LOG_Advent4Mask)) // 27. Heiligabend -#define ParamLOG_Heiligabend ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Heiligabend) & LOG_HeiligabendMask) +#define ParamLOG_Heiligabend ((bool)(knx.paramByte(LOG_Heiligabend) & LOG_HeiligabendMask)) // 28. Erster Weihnachtstag -#define ParamLOG_Weihnachtstag1 ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Weihnachtstag1) & LOG_Weihnachtstag1Mask) +#define ParamLOG_Weihnachtstag1 ((bool)(knx.paramByte(LOG_Weihnachtstag1) & LOG_Weihnachtstag1Mask)) // 29. Zweiter Weihnachtstag -#define ParamLOG_Weihnachtstag2 ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Weihnachtstag2) & LOG_Weihnachtstag2Mask) +#define ParamLOG_Weihnachtstag2 ((bool)(knx.paramByte(LOG_Weihnachtstag2) & LOG_Weihnachtstag2Mask)) // 30. Silvester -#define ParamLOG_Silvester ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_Silvester) & LOG_SilvesterMask) +#define ParamLOG_Silvester ((bool)(knx.paramByte(LOG_Silvester) & LOG_SilvesterMask)) // Breitengrad -#define ParamLOG_Latitude (knx.paramFloat(LOG_ParamBlockOffset + LOG_Latitude, Float_Enc_IEEE754Single)) +#define ParamLOG_Latitude (knx.paramFloat(LOG_Latitude, Float_Enc_IEEE754Single)) // Längengrad -#define ParamLOG_Longitude (knx.paramFloat(LOG_ParamBlockOffset + LOG_Longitude, Float_Enc_IEEE754Single)) +#define ParamLOG_Longitude (knx.paramFloat(LOG_Longitude, Float_Enc_IEEE754Single)) // Frequenz für Buzzer (leise) -#define ParamLOG_BuzzerSilent (knx.paramWord(LOG_ParamBlockOffset + LOG_BuzzerSilent)) +#define ParamLOG_BuzzerSilent (knx.paramWord(LOG_BuzzerSilent)) // Frequenz für Buzzer (normal) -#define ParamLOG_BuzzerNormal (knx.paramWord(LOG_ParamBlockOffset + LOG_BuzzerNormal)) +#define ParamLOG_BuzzerNormal (knx.paramWord(LOG_BuzzerNormal)) // Frequenz für Buzzer (laut) -#define ParamLOG_BuzzerLoud (knx.paramWord(LOG_ParamBlockOffset + LOG_BuzzerLoud)) +#define ParamLOG_BuzzerLoud (knx.paramWord(LOG_BuzzerLoud)) // Lötpad A / B / C entspicht -#define ParamLOG_LedMapping ((knx.paramByte(LOG_ParamBlockOffset + LOG_LedMapping) & LOG_LedMappingMask) >> LOG_LedMappingShift) +#define ParamLOG_LedMapping ((knx.paramByte(LOG_LedMapping) & LOG_LedMappingMask) >> LOG_LedMappingShift) // Zeitzone -#define ParamLOG_Timezone (knx.paramByte(LOG_ParamBlockOffset + LOG_Timezone) & LOG_TimezoneMask) +#define ParamLOG_Timezone (knx.paramByte(LOG_Timezone) & LOG_TimezoneMask) // Zeitzone-Vorzeichen -#define ParamLOG_TimezoneSign ((bool)knx.paramByte(LOG_ParamBlockOffset + LOG_TimezoneSign) & LOG_TimezoneSignMask) +#define ParamLOG_TimezoneSign ((bool)(knx.paramByte(LOG_TimezoneSign) & LOG_TimezoneSignMask)) // Zeitzone-Wert -#define ParamLOG_TimezoneValue (knx.paramByte(LOG_ParamBlockOffset + LOG_TimezoneValue) & LOG_TimezoneValueMask) +#define ParamLOG_TimezoneValue (knx.paramByte(LOG_TimezoneValue) & LOG_TimezoneValueMask) #define LOG_KoHeartbeat 1 #define LOG_KoTime 2 @@ -304,32 +316,34 @@ #define LOG_KoBuzzerLock 9 #define LOG_KoIsSummertime 10 -// Heartbeat -#define KoLOG_Heartbeat (knx.getGroupObject(LOG_KoOffset + LOG_KoHeartbeat)) -// Time -#define KoLOG_Time (knx.getGroupObject(LOG_KoOffset + LOG_KoTime)) -// Date -#define KoLOG_Date (knx.getGroupObject(LOG_KoOffset + LOG_KoDate)) -// Vacation -#define KoLOG_Vacation (knx.getGroupObject(LOG_KoOffset + LOG_KoVacation)) -// Holiday1 -#define KoLOG_Holiday1 (knx.getGroupObject(LOG_KoOffset + LOG_KoHoliday1)) -// Holiday2 -#define KoLOG_Holiday2 (knx.getGroupObject(LOG_KoOffset + LOG_KoHoliday2)) +// In Betrieb +#define KoLOG_Heartbeat (knx.getGroupObject(LOG_KoHeartbeat)) +// Uhrzeit/Datum +#define KoLOG_Time (knx.getGroupObject(LOG_KoTime)) +// Datum +#define KoLOG_Date (knx.getGroupObject(LOG_KoDate)) +// Urlaub +#define KoLOG_Vacation (knx.getGroupObject(LOG_KoVacation)) +// Welcher Feiertag ist heute? +#define KoLOG_Holiday1 (knx.getGroupObject(LOG_KoHoliday1)) +// Welcher Feiertag ist morgen? +#define KoLOG_Holiday2 (knx.getGroupObject(LOG_KoHoliday2)) // Diagnose -#define KoLOG_Diagnose (knx.getGroupObject(LOG_KoOffset + LOG_KoDiagnose)) -// LedLock -#define KoLOG_LedLock (knx.getGroupObject(LOG_KoOffset + LOG_KoLedLock)) -// BuzzerLock -#define KoLOG_BuzzerLock (knx.getGroupObject(LOG_KoOffset + LOG_KoBuzzerLock)) -// IsSummertime -#define KoLOG_IsSummertime (knx.getGroupObject(LOG_KoOffset + LOG_KoIsSummertime)) +#define KoLOG_Diagnose (knx.getGroupObject(LOG_KoDiagnose)) +// LED sperren +#define KoLOG_LedLock (knx.getGroupObject(LOG_KoLedLock)) +// Buzzer sperren +#define KoLOG_BuzzerLock (knx.getGroupObject(LOG_KoBuzzerLock)) +// Sommerzeit aktiv +#define KoLOG_IsSummertime (knx.getGroupObject(LOG_KoIsSummertime)) #define LOG_ChannelCount 99 // Parameter per channel #define LOG_ParamBlockOffset 26 #define LOG_ParamBlockSize 86 +#define LOG_ParamCalcIndex(index) (index + LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize) + #define LOG_fChannelDelayBase 0 // 2 Bits, Bit 7-6 #define LOG_fChannelDelayBaseMask 0xC0 #define LOG_fChannelDelayBaseShift 6 @@ -1078,809 +1092,834 @@ #define LOG_fE2OtherKOShift 0 // Zeitbasis -#define ParamLOG_fChannelDelayBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fChannelDelayBase) & LOG_fChannelDelayBaseMask) >> LOG_fChannelDelayBaseShift) +#define ParamLOG_fChannelDelayBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fChannelDelayBase)) & LOG_fChannelDelayBaseMask) >> LOG_fChannelDelayBaseShift) // Zeit -#define ParamLOG_fChannelDelayTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fChannelDelayTime) & LOG_fChannelDelayTimeMask) +#define ParamLOG_fChannelDelayTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fChannelDelayTime)) & LOG_fChannelDelayTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fChannelDelayTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fChannelDelayTime)))) // Logik-Operation -#define ParamLOG_fLogic (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fLogic)) +#define ParamLOG_fLogic (knx.paramByte(LOG_ParamCalcIndex(LOG_fLogic))) // Logik auswerten -#define ParamLOG_fCalculate (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fCalculate) & LOG_fCalculateMask) +#define ParamLOG_fCalculate (knx.paramByte(LOG_ParamCalcIndex(LOG_fCalculate)) & LOG_fCalculateMask) // Kanal deaktivieren (zu Testzwecken) -#define ParamLOG_fDisable ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fDisable) & LOG_fDisableMask) +#define ParamLOG_fDisable ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fDisable)) & LOG_fDisableMask)) // Alarmausgabe (Buzzer oder LED trotz Sperre schalten)? -#define ParamLOG_fAlarm ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fAlarm) & LOG_fAlarmMask) +#define ParamLOG_fAlarm ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fAlarm)) & LOG_fAlarmMask)) // Tor geht sofort wieder zu -#define ParamLOG_fTGate ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTGate) & LOG_fTGateMask) +#define ParamLOG_fTGate ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTGate)) & LOG_fTGateMask)) // Wert EIN intern weiterleiten -#define ParamLOG_fOInternalOn ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOInternalOn) & LOG_fOInternalOnMask) +#define ParamLOG_fOInternalOn ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fOInternalOn)) & LOG_fOInternalOnMask)) // Wert AUS intern weiterleiten -#define ParamLOG_fOInternalOff ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOInternalOff) & LOG_fOInternalOffMask) +#define ParamLOG_fOInternalOff ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fOInternalOff)) & LOG_fOInternalOffMask)) // Logik sendet ihren Wert weiter -#define ParamLOG_fTrigger (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTrigger)) +#define ParamLOG_fTrigger (knx.paramByte(LOG_ParamCalcIndex(LOG_fTrigger))) // Eingang 1 -#define ParamLOG_fTriggerE1 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTriggerE1) & LOG_fTriggerE1Mask) +#define ParamLOG_fTriggerE1 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTriggerE1)) & LOG_fTriggerE1Mask)) // Eingang 2 -#define ParamLOG_fTriggerE2 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTriggerE2) & LOG_fTriggerE2Mask) +#define ParamLOG_fTriggerE2 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTriggerE2)) & LOG_fTriggerE2Mask)) // Kanalausgang X -#define ParamLOG_fTriggerI1 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTriggerI1) & LOG_fTriggerI1Mask) +#define ParamLOG_fTriggerI1 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTriggerI1)) & LOG_fTriggerI1Mask)) // Kanalausgang Y -#define ParamLOG_fTriggerI2 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTriggerI2) & LOG_fTriggerI2Mask) +#define ParamLOG_fTriggerI2 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTriggerI2)) & LOG_fTriggerI2Mask)) // Logik sendet ihren Wert weiter -#define ParamLOG_fTriggerTime (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTriggerTime)) +#define ParamLOG_fTriggerTime (knx.paramByte(LOG_ParamCalcIndex(LOG_fTriggerTime))) // Beim schließen vom Tor wird -#define ParamLOG_fTriggerGateClose ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTriggerGateClose) & LOG_fTriggerGateCloseMask) >> LOG_fTriggerGateCloseShift) +#define ParamLOG_fTriggerGateClose ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTriggerGateClose)) & LOG_fTriggerGateCloseMask) >> LOG_fTriggerGateCloseShift) // Beim öffnen vom Tor wird -#define ParamLOG_fTriggerGateOpen ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTriggerGateOpen) & LOG_fTriggerGateOpenMask) >> LOG_fTriggerGateOpenShift) +#define ParamLOG_fTriggerGateOpen ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTriggerGateOpen)) & LOG_fTriggerGateOpenMask) >> LOG_fTriggerGateOpenShift) // Eingang 1 -#define ParamLOG_fE1 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1) & LOG_fE1Mask) +#define ParamLOG_fE1 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1)) & LOG_fE1Mask) // Wert für Eingang 1 wird ermittelt durch -#define ParamLOG_fE1Convert ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Convert) & LOG_fE1ConvertMask) >> LOG_fE1ConvertShift) +#define ParamLOG_fE1Convert ((knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Convert)) & LOG_fE1ConvertMask) >> LOG_fE1ConvertShift) // Wert für Eingang 1 wird ermittelt durch -#define ParamLOG_fE1ConvertFloat ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1ConvertFloat) & LOG_fE1ConvertFloatMask) >> LOG_fE1ConvertFloatShift) +#define ParamLOG_fE1ConvertFloat ((knx.paramByte(LOG_ParamCalcIndex(LOG_fE1ConvertFloat)) & LOG_fE1ConvertFloatMask) >> LOG_fE1ConvertFloatShift) // Wert für Eingang 1 wird ermittelt durch -#define ParamLOG_fE1ConvertSpecial ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1ConvertSpecial) & LOG_fE1ConvertSpecialMask) >> LOG_fE1ConvertSpecialShift) +#define ParamLOG_fE1ConvertSpecial ((knx.paramByte(LOG_ParamCalcIndex(LOG_fE1ConvertSpecial)) & LOG_fE1ConvertSpecialMask) >> LOG_fE1ConvertSpecialShift) // DPT für Eingang 1 -#define ParamLOG_fE1Dpt (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Dpt)) +#define ParamLOG_fE1Dpt (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Dpt))) // Falls Vorbelegung aus dem Speicher nicht möglich oder nicht gewünscht, dann vorbelegen mit -#define ParamLOG_fE1Default (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Default) & LOG_fE1DefaultMask) +#define ParamLOG_fE1Default (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Default)) & LOG_fE1DefaultMask) // Eingang vorbelegen mit -#define ParamLOG_fE1DefaultExt (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1DefaultExt) & LOG_fE1DefaultExtMask) +#define ParamLOG_fE1DefaultExt (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1DefaultExt)) & LOG_fE1DefaultExtMask) // Eingangswert speichern und beim nächsten Neustart als Vorbelegung nutzen? -#define ParamLOG_fE1DefaultEEPROM ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1DefaultEEPROM) & LOG_fE1DefaultEEPROMMask) +#define ParamLOG_fE1DefaultEEPROM ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1DefaultEEPROM)) & LOG_fE1DefaultEEPROMMask)) // Nur so lange zyklisch lesen, bis erstes Telegramm eingeht -#define ParamLOG_fE1DefaultRepeat ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1DefaultRepeat) & LOG_fE1DefaultRepeatMask) +#define ParamLOG_fE1DefaultRepeat ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1DefaultRepeat)) & LOG_fE1DefaultRepeatMask)) // Typ der Zeitschaltuhr -#define ParamLOG_fTYearDay ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTYearDay) & LOG_fTYearDayMask) +#define ParamLOG_fTYearDay ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTYearDay)) & LOG_fTYearDayMask)) // Beim Neustart letzte Schaltzeit nachholen -#define ParamLOG_fTRestoreState ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTRestoreState) & LOG_fTRestoreStateMask) >> LOG_fTRestoreStateShift) +#define ParamLOG_fTRestoreState ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTRestoreState)) & LOG_fTRestoreStateMask) >> LOG_fTRestoreStateShift) // Zeitbasis -#define ParamLOG_fE1RepeatBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1RepeatBase) & LOG_fE1RepeatBaseMask) >> LOG_fE1RepeatBaseShift) +#define ParamLOG_fE1RepeatBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fE1RepeatBase)) & LOG_fE1RepeatBaseMask) >> LOG_fE1RepeatBaseShift) // Zeit -#define ParamLOG_fE1RepeatTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1RepeatTime) & LOG_fE1RepeatTimeMask) +#define ParamLOG_fE1RepeatTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fE1RepeatTime)) & LOG_fE1RepeatTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fE1RepeatTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fE1RepeatTime)))) // Eingang 2 -#define ParamLOG_fE2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2) & LOG_fE2Mask) +#define ParamLOG_fE2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2)) & LOG_fE2Mask) // Wert für Eingang 2 wird ermittelt durch -#define ParamLOG_fE2Convert ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Convert) & LOG_fE2ConvertMask) >> LOG_fE2ConvertShift) +#define ParamLOG_fE2Convert ((knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Convert)) & LOG_fE2ConvertMask) >> LOG_fE2ConvertShift) // Wert für Eingang 2 wird ermittelt durch -#define ParamLOG_fE2ConvertFloat ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2ConvertFloat) & LOG_fE2ConvertFloatMask) >> LOG_fE2ConvertFloatShift) +#define ParamLOG_fE2ConvertFloat ((knx.paramByte(LOG_ParamCalcIndex(LOG_fE2ConvertFloat)) & LOG_fE2ConvertFloatMask) >> LOG_fE2ConvertFloatShift) // Wert für Eingang 2 wird ermittelt durch -#define ParamLOG_fE2ConvertSpecial ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2ConvertSpecial) & LOG_fE2ConvertSpecialMask) >> LOG_fE2ConvertSpecialShift) +#define ParamLOG_fE2ConvertSpecial ((knx.paramByte(LOG_ParamCalcIndex(LOG_fE2ConvertSpecial)) & LOG_fE2ConvertSpecialMask) >> LOG_fE2ConvertSpecialShift) // DPT für Eingang 2 -#define ParamLOG_fE2Dpt (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Dpt)) +#define ParamLOG_fE2Dpt (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Dpt))) // Falls Vorbelegung aus dem Speicher nicht möglich oder nicht gewünscht, dann vorbelegen mit -#define ParamLOG_fE2Default (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Default) & LOG_fE2DefaultMask) +#define ParamLOG_fE2Default (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Default)) & LOG_fE2DefaultMask) // Eingang vorbelegen mit -#define ParamLOG_fE2DefaultExt (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2DefaultExt) & LOG_fE2DefaultExtMask) +#define ParamLOG_fE2DefaultExt (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2DefaultExt)) & LOG_fE2DefaultExtMask) // Eingangswert speichern und beim nächsten Neustart als Vorbelegung nutzen? -#define ParamLOG_fE2DefaultEEPROM ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2DefaultEEPROM) & LOG_fE2DefaultEEPROMMask) +#define ParamLOG_fE2DefaultEEPROM ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2DefaultEEPROM)) & LOG_fE2DefaultEEPROMMask)) // Nur so lange zyklisch lesen, bis erstes Telegramm eingeht -#define ParamLOG_fE2DefaultRepeat ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2DefaultRepeat) & LOG_fE2DefaultRepeatMask) +#define ParamLOG_fE2DefaultRepeat ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2DefaultRepeat)) & LOG_fE2DefaultRepeatMask)) // Feiertagsbehandlung -#define ParamLOG_fTHoliday ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTHoliday) & LOG_fTHolidayMask) >> LOG_fTHolidayShift) +#define ParamLOG_fTHoliday ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTHoliday)) & LOG_fTHolidayMask) >> LOG_fTHolidayShift) // Urlaubsbehandlung -#define ParamLOG_fTVacation ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTVacation) & LOG_fTVacationMask) >> LOG_fTVacationShift) +#define ParamLOG_fTVacation ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTVacation)) & LOG_fTVacationMask) >> LOG_fTVacationShift) // Zeitbasis -#define ParamLOG_fE2RepeatBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2RepeatBase) & LOG_fE2RepeatBaseMask) >> LOG_fE2RepeatBaseShift) +#define ParamLOG_fE2RepeatBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fE2RepeatBase)) & LOG_fE2RepeatBaseMask) >> LOG_fE2RepeatBaseShift) // Zeit -#define ParamLOG_fE2RepeatTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2RepeatTime) & LOG_fE2RepeatTimeMask) +#define ParamLOG_fE2RepeatTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fE2RepeatTime)) & LOG_fE2RepeatTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fE2RepeatTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fE2RepeatTime)))) // Zeitbezug -#define ParamLOG_fTd1DuskDawn ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd1DuskDawn) & LOG_fTd1DuskDawnMask) >> LOG_fTd1DuskDawnShift) +#define ParamLOG_fTd1DuskDawn ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd1DuskDawn)) & LOG_fTd1DuskDawnMask) >> LOG_fTd1DuskDawnShift) // Zeitbezug -#define ParamLOG_fTd2DuskDawn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd2DuskDawn) & LOG_fTd2DuskDawnMask) +#define ParamLOG_fTd2DuskDawn (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd2DuskDawn)) & LOG_fTd2DuskDawnMask) // Zeitbezug -#define ParamLOG_fTd3DuskDawn ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd3DuskDawn) & LOG_fTd3DuskDawnMask) >> LOG_fTd3DuskDawnShift) +#define ParamLOG_fTd3DuskDawn ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd3DuskDawn)) & LOG_fTd3DuskDawnMask) >> LOG_fTd3DuskDawnShift) // Zeitbezug -#define ParamLOG_fTd4DuskDawn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd4DuskDawn) & LOG_fTd4DuskDawnMask) +#define ParamLOG_fTd4DuskDawn (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd4DuskDawn)) & LOG_fTd4DuskDawnMask) // Zeitbezug -#define ParamLOG_fTd5DuskDawn ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd5DuskDawn) & LOG_fTd5DuskDawnMask) >> LOG_fTd5DuskDawnShift) +#define ParamLOG_fTd5DuskDawn ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd5DuskDawn)) & LOG_fTd5DuskDawnMask) >> LOG_fTd5DuskDawnShift) // Zeitbezug -#define ParamLOG_fTd6DuskDawn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd6DuskDawn) & LOG_fTd6DuskDawnMask) +#define ParamLOG_fTd6DuskDawn (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd6DuskDawn)) & LOG_fTd6DuskDawnMask) // Zeitbezug -#define ParamLOG_fTd7DuskDawn ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd7DuskDawn) & LOG_fTd7DuskDawnMask) >> LOG_fTd7DuskDawnShift) +#define ParamLOG_fTd7DuskDawn ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd7DuskDawn)) & LOG_fTd7DuskDawnMask) >> LOG_fTd7DuskDawnShift) // Zeitbezug -#define ParamLOG_fTd8DuskDawn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd8DuskDawn) & LOG_fTd8DuskDawnMask) +#define ParamLOG_fTd8DuskDawn (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd8DuskDawn)) & LOG_fTd8DuskDawnMask) // Von-Wert -#define ParamLOG_fE1LowDelta ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDelta)) +#define ParamLOG_fE1LowDelta ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE1LowDelta))) // Bis-Wert -#define ParamLOG_fE1HighDelta ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDelta)) +#define ParamLOG_fE1HighDelta ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE1HighDelta))) // Von-Wert -#define ParamLOG_fE1LowDeltaFloat (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDeltaFloat, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1LowDeltaFloat (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1LowDeltaFloat), Float_Enc_IEEE754Single)) // Bis-Wert -#define ParamLOG_fE1HighDeltaFloat (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDeltaFloat, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1HighDeltaFloat (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1HighDeltaFloat), Float_Enc_IEEE754Single)) // Von-Wert -#define ParamLOG_fE1LowDeltaDouble (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDeltaDouble, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1LowDeltaDouble (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1LowDeltaDouble), Float_Enc_IEEE754Single)) // Bis-Wert -#define ParamLOG_fE1HighDeltaDouble (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDeltaDouble, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1HighDeltaDouble (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1HighDeltaDouble), Float_Enc_IEEE754Single)) // Nächste Zeile auswerten? -#define ParamLOG_fE1Low0Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low0Valid) & LOG_fE1Low0ValidMask) +#define ParamLOG_fE1Low0Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low0Valid)) & LOG_fE1Low0ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE1Low1Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low1Valid) & LOG_fE1Low1ValidMask) +#define ParamLOG_fE1Low1Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low1Valid)) & LOG_fE1Low1ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE1Low2Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low2Valid) & LOG_fE1Low2ValidMask) +#define ParamLOG_fE1Low2Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low2Valid)) & LOG_fE1Low2ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE1Low3Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low3Valid) & LOG_fE1Low3ValidMask) +#define ParamLOG_fE1Low3Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low3Valid)) & LOG_fE1Low3ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE1Low4Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low4Valid) & LOG_fE1Low4ValidMask) +#define ParamLOG_fE1Low4Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low4Valid)) & LOG_fE1Low4ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE1Low5Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low5Valid) & LOG_fE1Low5ValidMask) +#define ParamLOG_fE1Low5Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low5Valid)) & LOG_fE1Low5ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE1Low6Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low6Valid) & LOG_fE1Low6ValidMask) +#define ParamLOG_fE1Low6Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low6Valid)) & LOG_fE1Low6ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE1Low7Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low7Valid) & LOG_fE1Low7ValidMask) +#define ParamLOG_fE1Low7Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low7Valid)) & LOG_fE1Low7ValidMask)) // Eingang 1 ist EIN, wenn Wert gleich -#define ParamLOG_fE1LowDpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt2)) +#define ParamLOG_fE1LowDpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt2))) // ... oder wenn Wert gleich -#define ParamLOG_fE1Low1Dpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low1Dpt2)) +#define ParamLOG_fE1Low1Dpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low1Dpt2))) // ... oder wenn Wert gleich -#define ParamLOG_fE1Low2Dpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low2Dpt2)) +#define ParamLOG_fE1Low2Dpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low2Dpt2))) // ... oder wenn Wert gleich -#define ParamLOG_fE1Low3Dpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low3Dpt2)) +#define ParamLOG_fE1Low3Dpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low3Dpt2))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt2Fix (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt2Fix)) +#define ParamLOG_fE1LowDpt2Fix (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt2Fix))) // Von-Wert -#define ParamLOG_fE1LowDpt5 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt5)) +#define ParamLOG_fE1LowDpt5 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt5))) // Bis-Wert -#define ParamLOG_fE1HighDpt5 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt5)) +#define ParamLOG_fE1HighDpt5 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1HighDpt5))) // Eingang 1 ist EIN bei Wert -#define ParamLOG_fE1Low0Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low0Dpt5In)) +#define ParamLOG_fE1Low0Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low0Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE1Low1Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low1Dpt5In)) +#define ParamLOG_fE1Low1Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low1Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE1Low2Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low2Dpt5In)) +#define ParamLOG_fE1Low2Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low2Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE1Low3Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low3Dpt5In)) +#define ParamLOG_fE1Low3Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low3Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE1Low4Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low4Dpt5In)) +#define ParamLOG_fE1Low4Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low4Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE1Low5Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low5Dpt5In)) +#define ParamLOG_fE1Low5Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low5Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE1Low6Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low6Dpt5In)) +#define ParamLOG_fE1Low6Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low6Dpt5In))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt5Fix (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt5Fix)) +#define ParamLOG_fE1LowDpt5Fix (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt5Fix))) // Von-Wert -#define ParamLOG_fE1LowDpt5001 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt5001)) +#define ParamLOG_fE1LowDpt5001 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt5001))) // Bisrt -#define ParamLOG_fE1HighDpt5001 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt5001)) +#define ParamLOG_fE1HighDpt5001 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1HighDpt5001))) // Eingang 1 ist EIN bei Wert -#define ParamLOG_fE1Low0Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low0Dpt5xIn)) +#define ParamLOG_fE1Low0Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low0Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE1Low1Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low1Dpt5xIn)) +#define ParamLOG_fE1Low1Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low1Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE1Low2Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low2Dpt5xIn)) +#define ParamLOG_fE1Low2Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low2Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE1Low3Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low3Dpt5xIn)) +#define ParamLOG_fE1Low3Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low3Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE1Low4Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low4Dpt5xIn)) +#define ParamLOG_fE1Low4Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low4Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE1Low5Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low5Dpt5xIn)) +#define ParamLOG_fE1Low5Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low5Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE1Low6Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low6Dpt5xIn)) +#define ParamLOG_fE1Low6Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low6Dpt5xIn))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt5xFix (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt5xFix)) +#define ParamLOG_fE1LowDpt5xFix (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt5xFix))) // Von-Wert -#define ParamLOG_fE1LowDpt6 ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt6)) +#define ParamLOG_fE1LowDpt6 ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt6))) // Bis-Wert -#define ParamLOG_fE1HighDpt6 ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt6)) +#define ParamLOG_fE1HighDpt6 ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1HighDpt6))) // Eingang 1 ist EIN bei Wert -#define ParamLOG_fE1Low0Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low0Dpt6In)) +#define ParamLOG_fE1Low0Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low0Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE1Low1Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low1Dpt6In)) +#define ParamLOG_fE1Low1Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low1Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE1Low2Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low2Dpt6In)) +#define ParamLOG_fE1Low2Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low2Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE1Low3Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low3Dpt6In)) +#define ParamLOG_fE1Low3Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low3Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE1Low4Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low4Dpt6In)) +#define ParamLOG_fE1Low4Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low4Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE1Low5Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low5Dpt6In)) +#define ParamLOG_fE1Low5Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low5Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE1Low6Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low6Dpt6In)) +#define ParamLOG_fE1Low6Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low6Dpt6In))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt6Fix ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt6Fix)) +#define ParamLOG_fE1LowDpt6Fix ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt6Fix))) // Von-Wert -#define ParamLOG_fE1LowDpt7 (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt7)) +#define ParamLOG_fE1LowDpt7 (knx.paramWord(LOG_ParamCalcIndex(LOG_fE1LowDpt7))) // Bis-Wert -#define ParamLOG_fE1HighDpt7 (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt7)) +#define ParamLOG_fE1HighDpt7 (knx.paramWord(LOG_ParamCalcIndex(LOG_fE1HighDpt7))) // Eingang 1 ist EIN bei Wert -#define ParamLOG_fE1Low0Dpt7In (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low0Dpt7In)) +#define ParamLOG_fE1Low0Dpt7In (knx.paramWord(LOG_ParamCalcIndex(LOG_fE1Low0Dpt7In))) // ... oder bei Wert -#define ParamLOG_fE1Low1Dpt7In (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low1Dpt7In)) +#define ParamLOG_fE1Low1Dpt7In (knx.paramWord(LOG_ParamCalcIndex(LOG_fE1Low1Dpt7In))) // ... oder bei Wert -#define ParamLOG_fE1Low2Dpt7In (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low2Dpt7In)) +#define ParamLOG_fE1Low2Dpt7In (knx.paramWord(LOG_ParamCalcIndex(LOG_fE1Low2Dpt7In))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt7Fix (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt7Fix)) +#define ParamLOG_fE1LowDpt7Fix (knx.paramWord(LOG_ParamCalcIndex(LOG_fE1LowDpt7Fix))) // Von-Wert -#define ParamLOG_fE1LowDpt8 ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt8)) +#define ParamLOG_fE1LowDpt8 ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE1LowDpt8))) // Bis-Wert -#define ParamLOG_fE1HighDpt8 ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt8)) +#define ParamLOG_fE1HighDpt8 ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE1HighDpt8))) // Eingang 1 ist EIN bei Wert -#define ParamLOG_fE1Low0Dpt8In ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low0Dpt8In)) +#define ParamLOG_fE1Low0Dpt8In ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE1Low0Dpt8In))) // ... oder bei Wert -#define ParamLOG_fE1Low1Dpt8In ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low1Dpt8In)) +#define ParamLOG_fE1Low1Dpt8In ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE1Low1Dpt8In))) // ... oder bei Wert -#define ParamLOG_fE1Low2Dpt8In ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low2Dpt8In)) +#define ParamLOG_fE1Low2Dpt8In ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE1Low2Dpt8In))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt8Fix ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt8Fix)) +#define ParamLOG_fE1LowDpt8Fix ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE1LowDpt8Fix))) // Von-Wert -#define ParamLOG_fE1LowDpt9 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt9, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1LowDpt9 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1LowDpt9), Float_Enc_IEEE754Single)) // Bis-Wert -#define ParamLOG_fE1HighDpt9 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt9, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1HighDpt9 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1HighDpt9), Float_Enc_IEEE754Single)) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt9Fix (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt9Fix, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1LowDpt9Fix (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1LowDpt9Fix), Float_Enc_IEEE754Single)) // Von-Wert -#define ParamLOG_fE1LowDpt12 (knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt12)) +#define ParamLOG_fE1LowDpt12 (knx.paramLong(LOG_ParamCalcIndex(LOG_fE1LowDpt12))) // Bis-Wert -#define ParamLOG_fE1HighDpt12 (knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt12)) +#define ParamLOG_fE1HighDpt12 (knx.paramLong(LOG_ParamCalcIndex(LOG_fE1HighDpt12))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt12Fix (knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt12Fix)) +#define ParamLOG_fE1LowDpt12Fix (knx.paramLong(LOG_ParamCalcIndex(LOG_fE1LowDpt12Fix))) // Von-Wert -#define ParamLOG_fE1LowDpt13 ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt13)) +#define ParamLOG_fE1LowDpt13 ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE1LowDpt13))) // Bis-Wert -#define ParamLOG_fE1HighDpt13 ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt13)) +#define ParamLOG_fE1HighDpt13 ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE1HighDpt13))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt13Fix ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt13Fix)) +#define ParamLOG_fE1LowDpt13Fix ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE1LowDpt13Fix))) // Von-Wert -#define ParamLOG_fE1LowDpt14 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt14, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1LowDpt14 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1LowDpt14), Float_Enc_IEEE754Single)) // Bis-Wert -#define ParamLOG_fE1HighDpt14 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDpt14, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1HighDpt14 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1HighDpt14), Float_Enc_IEEE754Single)) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt14Fix (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt14Fix, Float_Enc_IEEE754Single)) +#define ParamLOG_fE1LowDpt14Fix (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE1LowDpt14Fix), Float_Enc_IEEE754Single)) // Eingang 1 ist EIN bei Szene -#define ParamLOG_fE1Low0Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low0Dpt17)) +#define ParamLOG_fE1Low0Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low0Dpt17))) // ... oder bei Szene -#define ParamLOG_fE1Low1Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low1Dpt17)) +#define ParamLOG_fE1Low1Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low1Dpt17))) // ... oder bei Szene -#define ParamLOG_fE1Low2Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low2Dpt17)) +#define ParamLOG_fE1Low2Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low2Dpt17))) // ... oder bei Szene -#define ParamLOG_fE1Low3Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low3Dpt17)) +#define ParamLOG_fE1Low3Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low3Dpt17))) // ... oder bei Szene -#define ParamLOG_fE1Low4Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low4Dpt17)) +#define ParamLOG_fE1Low4Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low4Dpt17))) // ... oder bei Szene -#define ParamLOG_fE1Low5Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low5Dpt17)) +#define ParamLOG_fE1Low5Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low5Dpt17))) // ... oder bei Szene -#define ParamLOG_fE1Low6Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low6Dpt17)) +#define ParamLOG_fE1Low6Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low6Dpt17))) // ... oder bei Szene -#define ParamLOG_fE1Low7Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1Low7Dpt17)) +#define ParamLOG_fE1Low7Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1Low7Dpt17))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDpt17Fix (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDpt17Fix)) +#define ParamLOG_fE1LowDpt17Fix (knx.paramByte(LOG_ParamCalcIndex(LOG_fE1LowDpt17Fix))) // Von-Wert -#define ParamLOG_fE1LowDptRGB ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDptRGB)) +#define ParamLOG_fE1LowDptRGB ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE1LowDptRGB))) // Bis-Wert -#define ParamLOG_fE1HighDptRGB ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1HighDptRGB)) +#define ParamLOG_fE1HighDptRGB ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE1HighDptRGB))) // Eingang 1 ist konstant -#define ParamLOG_fE1LowDptRGBFix ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1LowDptRGBFix)) +#define ParamLOG_fE1LowDptRGBFix ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE1LowDptRGBFix))) // Von-Wert -#define ParamLOG_fE2LowDelta ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDelta)) +#define ParamLOG_fE2LowDelta ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE2LowDelta))) // Bis-Wert -#define ParamLOG_fE2HighDelta ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDelta)) +#define ParamLOG_fE2HighDelta ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE2HighDelta))) // Von-Wert -#define ParamLOG_fE2LowDeltaFloat (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDeltaFloat, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2LowDeltaFloat (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2LowDeltaFloat), Float_Enc_IEEE754Single)) // Bis-Wert -#define ParamLOG_fE2HighDeltaFloat (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDeltaFloat, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2HighDeltaFloat (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2HighDeltaFloat), Float_Enc_IEEE754Single)) // Von-Wert -#define ParamLOG_fE2LowDeltaDouble (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDeltaDouble, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2LowDeltaDouble (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2LowDeltaDouble), Float_Enc_IEEE754Single)) // Bis-Wert -#define ParamLOG_fE2HighDeltaDouble (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDeltaDouble, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2HighDeltaDouble (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2HighDeltaDouble), Float_Enc_IEEE754Single)) // Nächste Zeile auswerten? -#define ParamLOG_fE2Low0Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low0Valid) & LOG_fE2Low0ValidMask) +#define ParamLOG_fE2Low0Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low0Valid)) & LOG_fE2Low0ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE2Low1Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low1Valid) & LOG_fE2Low1ValidMask) +#define ParamLOG_fE2Low1Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low1Valid)) & LOG_fE2Low1ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE2Low2Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low2Valid) & LOG_fE2Low2ValidMask) +#define ParamLOG_fE2Low2Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low2Valid)) & LOG_fE2Low2ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE2Low3Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low3Valid) & LOG_fE2Low3ValidMask) +#define ParamLOG_fE2Low3Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low3Valid)) & LOG_fE2Low3ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE2Low4Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low4Valid) & LOG_fE2Low4ValidMask) +#define ParamLOG_fE2Low4Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low4Valid)) & LOG_fE2Low4ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE2Low5Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low5Valid) & LOG_fE2Low5ValidMask) +#define ParamLOG_fE2Low5Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low5Valid)) & LOG_fE2Low5ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE2Low6Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low6Valid) & LOG_fE2Low6ValidMask) +#define ParamLOG_fE2Low6Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low6Valid)) & LOG_fE2Low6ValidMask)) // Nächste Zeile auswerten? -#define ParamLOG_fE2Low7Valid ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low7Valid) & LOG_fE2Low7ValidMask) +#define ParamLOG_fE2Low7Valid ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low7Valid)) & LOG_fE2Low7ValidMask)) // Eingang 2 ist EIN, wenn Wert gleich -#define ParamLOG_fE2Low0Dpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low0Dpt2)) +#define ParamLOG_fE2Low0Dpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low0Dpt2))) // ... oder wenn Wert gleich -#define ParamLOG_fE2Low1Dpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low1Dpt2)) +#define ParamLOG_fE2Low1Dpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low1Dpt2))) // ... oder wenn Wert gleich -#define ParamLOG_fE2Low2Dpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low2Dpt2)) +#define ParamLOG_fE2Low2Dpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low2Dpt2))) // ... oder wenn Wert gleich -#define ParamLOG_fE2Low3Dpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low3Dpt2)) +#define ParamLOG_fE2Low3Dpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low3Dpt2))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt2Fix (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt2Fix)) +#define ParamLOG_fE2LowDpt2Fix (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2LowDpt2Fix))) // Von-Wert -#define ParamLOG_fE2LowDpt5 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt5)) +#define ParamLOG_fE2LowDpt5 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2LowDpt5))) // Bis-Wert -#define ParamLOG_fE2HighDpt5 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt5)) +#define ParamLOG_fE2HighDpt5 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2HighDpt5))) // Eingang 2 ist EIN bei Wert -#define ParamLOG_fE2Low0Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low0Dpt5In)) +#define ParamLOG_fE2Low0Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low0Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE2Low1Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low1Dpt5In)) +#define ParamLOG_fE2Low1Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low1Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE2Low2Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low2Dpt5In)) +#define ParamLOG_fE2Low2Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low2Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE2Low3Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low3Dpt5In)) +#define ParamLOG_fE2Low3Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low3Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE2Low4Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low4Dpt5In)) +#define ParamLOG_fE2Low4Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low4Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE2Low5Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low5Dpt5In)) +#define ParamLOG_fE2Low5Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low5Dpt5In))) // ... oder bei Wert -#define ParamLOG_fE2Low6Dpt5In (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low6Dpt5In)) +#define ParamLOG_fE2Low6Dpt5In (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low6Dpt5In))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt5Fix (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt5Fix)) +#define ParamLOG_fE2LowDpt5Fix (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2LowDpt5Fix))) // Von-Wert -#define ParamLOG_fE2LowDpt5001 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt5001)) +#define ParamLOG_fE2LowDpt5001 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2LowDpt5001))) // Bis-Wert -#define ParamLOG_fE2HighDpt5001 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt5001)) +#define ParamLOG_fE2HighDpt5001 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2HighDpt5001))) // Eingang 2 ist EIN bei Wert -#define ParamLOG_fE2Low0Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low0Dpt5xIn)) +#define ParamLOG_fE2Low0Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low0Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE2Low1Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low1Dpt5xIn)) +#define ParamLOG_fE2Low1Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low1Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE2Low2Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low2Dpt5xIn)) +#define ParamLOG_fE2Low2Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low2Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE2Low3Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low3Dpt5xIn)) +#define ParamLOG_fE2Low3Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low3Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE2Low4Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low4Dpt5xIn)) +#define ParamLOG_fE2Low4Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low4Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE2Low5Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low5Dpt5xIn)) +#define ParamLOG_fE2Low5Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low5Dpt5xIn))) // ... oder bei Wert -#define ParamLOG_fE2Low6Dpt5xIn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low6Dpt5xIn)) +#define ParamLOG_fE2Low6Dpt5xIn (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low6Dpt5xIn))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt5xFix (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt5xFix)) +#define ParamLOG_fE2LowDpt5xFix (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2LowDpt5xFix))) // Von-Wert -#define ParamLOG_fE2LowDpt6 ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt6)) +#define ParamLOG_fE2LowDpt6 ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2LowDpt6))) // Bis-Wert -#define ParamLOG_fE2HighDpt6 ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt6)) +#define ParamLOG_fE2HighDpt6 ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2HighDpt6))) // Eingang 2 ist EIN bei Wert -#define ParamLOG_fE2Low0Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low0Dpt6In)) +#define ParamLOG_fE2Low0Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low0Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE2Low1Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low1Dpt6In)) +#define ParamLOG_fE2Low1Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low1Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE2Low2Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low2Dpt6In)) +#define ParamLOG_fE2Low2Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low2Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE2Low3Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low3Dpt6In)) +#define ParamLOG_fE2Low3Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low3Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE2Low4Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low4Dpt6In)) +#define ParamLOG_fE2Low4Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low4Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE2Low5Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low5Dpt6In)) +#define ParamLOG_fE2Low5Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low5Dpt6In))) // ... oder bei Wert -#define ParamLOG_fE2Low6Dpt6In ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low6Dpt6In)) +#define ParamLOG_fE2Low6Dpt6In ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low6Dpt6In))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt6Fix ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt6Fix)) +#define ParamLOG_fE2LowDpt6Fix ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fE2LowDpt6Fix))) // Von-Wert -#define ParamLOG_fE2LowDpt7 (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt7)) +#define ParamLOG_fE2LowDpt7 (knx.paramWord(LOG_ParamCalcIndex(LOG_fE2LowDpt7))) // Bis-Wert -#define ParamLOG_fE2HighDpt7 (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt7)) +#define ParamLOG_fE2HighDpt7 (knx.paramWord(LOG_ParamCalcIndex(LOG_fE2HighDpt7))) // Eingang 2 ist EIN bei Wert -#define ParamLOG_fE2Low0Dpt7In (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low0Dpt7In)) +#define ParamLOG_fE2Low0Dpt7In (knx.paramWord(LOG_ParamCalcIndex(LOG_fE2Low0Dpt7In))) // ... oder bei Wert -#define ParamLOG_fE2Low1Dpt7In (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low1Dpt7In)) +#define ParamLOG_fE2Low1Dpt7In (knx.paramWord(LOG_ParamCalcIndex(LOG_fE2Low1Dpt7In))) // ... oder bei Wert -#define ParamLOG_fE2Low2Dpt7In (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low2Dpt7In)) +#define ParamLOG_fE2Low2Dpt7In (knx.paramWord(LOG_ParamCalcIndex(LOG_fE2Low2Dpt7In))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt7Fix (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt7Fix)) +#define ParamLOG_fE2LowDpt7Fix (knx.paramWord(LOG_ParamCalcIndex(LOG_fE2LowDpt7Fix))) // Von-Wert -#define ParamLOG_fE2LowDpt8 ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt8)) +#define ParamLOG_fE2LowDpt8 ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE2LowDpt8))) // Bis-Wert -#define ParamLOG_fE2HighDpt8 ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt8)) +#define ParamLOG_fE2HighDpt8 ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE2HighDpt8))) // Eingang 2 ist EIN bei Wert -#define ParamLOG_fE2Low0Dpt8In ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low0Dpt8In)) +#define ParamLOG_fE2Low0Dpt8In ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE2Low0Dpt8In))) // ... oder bei Wert -#define ParamLOG_fE2Low1Dpt8In ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low1Dpt8In)) +#define ParamLOG_fE2Low1Dpt8In ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE2Low1Dpt8In))) // ... oder bei Wert -#define ParamLOG_fE2Low2Dpt8In ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low2Dpt8In)) +#define ParamLOG_fE2Low2Dpt8In ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE2Low2Dpt8In))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt8Fix ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt8Fix)) +#define ParamLOG_fE2LowDpt8Fix ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fE2LowDpt8Fix))) // Von-Wert -#define ParamLOG_fE2LowDpt9 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt9, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2LowDpt9 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2LowDpt9), Float_Enc_IEEE754Single)) // Bis-Wert -#define ParamLOG_fE2HighDpt9 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt9, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2HighDpt9 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2HighDpt9), Float_Enc_IEEE754Single)) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt9Fix (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt9Fix, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2LowDpt9Fix (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2LowDpt9Fix), Float_Enc_IEEE754Single)) // Von-Wert -#define ParamLOG_fE2LowDpt12 (knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt12)) +#define ParamLOG_fE2LowDpt12 (knx.paramLong(LOG_ParamCalcIndex(LOG_fE2LowDpt12))) // Bis-Wert -#define ParamLOG_fE2HighDpt12 (knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt12)) +#define ParamLOG_fE2HighDpt12 (knx.paramLong(LOG_ParamCalcIndex(LOG_fE2HighDpt12))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt12Fix (knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt12Fix)) +#define ParamLOG_fE2LowDpt12Fix (knx.paramLong(LOG_ParamCalcIndex(LOG_fE2LowDpt12Fix))) // Von-Wert -#define ParamLOG_fE2LowDpt13 ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt13)) +#define ParamLOG_fE2LowDpt13 ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE2LowDpt13))) // Bis-Wert -#define ParamLOG_fE2HighDpt13 ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt13)) +#define ParamLOG_fE2HighDpt13 ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE2HighDpt13))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt13Fix ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt13Fix)) +#define ParamLOG_fE2LowDpt13Fix ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE2LowDpt13Fix))) // Von-Wert -#define ParamLOG_fE2LowDpt14 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt14, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2LowDpt14 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2LowDpt14), Float_Enc_IEEE754Single)) // Bis-Wert -#define ParamLOG_fE2HighDpt14 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDpt14, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2HighDpt14 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2HighDpt14), Float_Enc_IEEE754Single)) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt14Fix (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt14Fix, Float_Enc_IEEE754Single)) +#define ParamLOG_fE2LowDpt14Fix (knx.paramFloat(LOG_ParamCalcIndex(LOG_fE2LowDpt14Fix), Float_Enc_IEEE754Single)) // Eingang 2 ist EIN bei Szene -#define ParamLOG_fE2Low0Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low0Dpt17)) +#define ParamLOG_fE2Low0Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low0Dpt17))) // ... oder bei Szene -#define ParamLOG_fE2Low1Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low1Dpt17)) +#define ParamLOG_fE2Low1Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low1Dpt17))) // ... oder bei Szene -#define ParamLOG_fE2Low2Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low2Dpt17)) +#define ParamLOG_fE2Low2Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low2Dpt17))) // ... oder bei Szene -#define ParamLOG_fE2Low3Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low3Dpt17)) +#define ParamLOG_fE2Low3Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low3Dpt17))) // ... oder bei Szene -#define ParamLOG_fE2Low4Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low4Dpt17)) +#define ParamLOG_fE2Low4Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low4Dpt17))) // ... oder bei Szene -#define ParamLOG_fE2Low5Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low5Dpt17)) +#define ParamLOG_fE2Low5Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low5Dpt17))) // ... oder bei Szene -#define ParamLOG_fE2Low6Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low6Dpt17)) +#define ParamLOG_fE2Low6Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low6Dpt17))) // ... oder bei Szene -#define ParamLOG_fE2Low7Dpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2Low7Dpt17)) +#define ParamLOG_fE2Low7Dpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2Low7Dpt17))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDpt17Fix (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDpt17Fix)) +#define ParamLOG_fE2LowDpt17Fix (knx.paramByte(LOG_ParamCalcIndex(LOG_fE2LowDpt17Fix))) // Von-Wert -#define ParamLOG_fE2LowDptRGB ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDptRGB)) +#define ParamLOG_fE2LowDptRGB ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE2LowDptRGB))) // Bis-Wert -#define ParamLOG_fE2HighDptRGB ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2HighDptRGB)) +#define ParamLOG_fE2HighDptRGB ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE2HighDptRGB))) // Eingang 2 ist konstant -#define ParamLOG_fE2LowDptRGBFix ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2LowDptRGBFix)) +#define ParamLOG_fE2LowDptRGBFix ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fE2LowDptRGBFix))) // Schaltwert -#define ParamLOG_fTd1Value ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd1Value) & LOG_fTd1ValueMask) +#define ParamLOG_fTd1Value ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTd1Value)) & LOG_fTd1ValueMask)) // Grad -#define ParamLOG_fTd1Degree ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd1Degree) & LOG_fTd1DegreeMask) >> LOG_fTd1DegreeShift) +#define ParamLOG_fTd1Degree ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd1Degree)) & LOG_fTd1DegreeMask) >> LOG_fTd1DegreeShift) // Stunde -#define ParamLOG_fTd1HourAbs ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd1HourAbs) & LOG_fTd1HourAbsMask) >> LOG_fTd1HourAbsShift) +#define ParamLOG_fTd1HourAbs ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd1HourAbs)) & LOG_fTd1HourAbsMask) >> LOG_fTd1HourAbsShift) // Sonnen auf-/untergang -#define ParamLOG_fTd1HourRel ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd1HourRel) & LOG_fTd1HourRelMask) >> LOG_fTd1HourRelShift) +#define ParamLOG_fTd1HourRel ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd1HourRel)) & LOG_fTd1HourRelMask) >> LOG_fTd1HourRelShift) // Minute -#define ParamLOG_fTd1MinuteAbs (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd1MinuteAbs)) +#define ParamLOG_fTd1MinuteAbs (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd1MinuteAbs))) // Minute -#define ParamLOG_fTd1MinuteRel (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd1MinuteRel)) +#define ParamLOG_fTd1MinuteRel (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd1MinuteRel))) // Wochentag -#define ParamLOG_fTd1Weekday (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd1Weekday) & LOG_fTd1WeekdayMask) +#define ParamLOG_fTd1Weekday (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd1Weekday)) & LOG_fTd1WeekdayMask) // Schaltwert -#define ParamLOG_fTd2Value ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd2Value) & LOG_fTd2ValueMask) +#define ParamLOG_fTd2Value ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTd2Value)) & LOG_fTd2ValueMask)) // Grad -#define ParamLOG_fTd2Degree ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd2Degree) & LOG_fTd2DegreeMask) >> LOG_fTd2DegreeShift) +#define ParamLOG_fTd2Degree ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd2Degree)) & LOG_fTd2DegreeMask) >> LOG_fTd2DegreeShift) // Stunde -#define ParamLOG_fTd2HourAbs ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd2HourAbs) & LOG_fTd2HourAbsMask) >> LOG_fTd2HourAbsShift) +#define ParamLOG_fTd2HourAbs ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd2HourAbs)) & LOG_fTd2HourAbsMask) >> LOG_fTd2HourAbsShift) // Sonnen auf-/untergang -#define ParamLOG_fTd2HourRel ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd2HourRel) & LOG_fTd2HourRelMask) >> LOG_fTd2HourRelShift) +#define ParamLOG_fTd2HourRel ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd2HourRel)) & LOG_fTd2HourRelMask) >> LOG_fTd2HourRelShift) // Minute -#define ParamLOG_fTd2MinuteAbs (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd2MinuteAbs)) +#define ParamLOG_fTd2MinuteAbs (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd2MinuteAbs))) // Minute -#define ParamLOG_fTd2MinuteRel (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd2MinuteRel)) +#define ParamLOG_fTd2MinuteRel (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd2MinuteRel))) // Wochentag -#define ParamLOG_fTd2Weekday (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd2Weekday) & LOG_fTd2WeekdayMask) +#define ParamLOG_fTd2Weekday (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd2Weekday)) & LOG_fTd2WeekdayMask) // Schaltwert -#define ParamLOG_fTd3Value ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd3Value) & LOG_fTd3ValueMask) +#define ParamLOG_fTd3Value ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTd3Value)) & LOG_fTd3ValueMask)) // Grad -#define ParamLOG_fTd3Degree ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd3Degree) & LOG_fTd3DegreeMask) >> LOG_fTd3DegreeShift) +#define ParamLOG_fTd3Degree ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd3Degree)) & LOG_fTd3DegreeMask) >> LOG_fTd3DegreeShift) // Stunde -#define ParamLOG_fTd3HourAbs ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd3HourAbs) & LOG_fTd3HourAbsMask) >> LOG_fTd3HourAbsShift) +#define ParamLOG_fTd3HourAbs ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd3HourAbs)) & LOG_fTd3HourAbsMask) >> LOG_fTd3HourAbsShift) // Sonnen auf-/untergang -#define ParamLOG_fTd3HourRel ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd3HourRel) & LOG_fTd3HourRelMask) >> LOG_fTd3HourRelShift) +#define ParamLOG_fTd3HourRel ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd3HourRel)) & LOG_fTd3HourRelMask) >> LOG_fTd3HourRelShift) // Minute -#define ParamLOG_fTd3MinuteAbs (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd3MinuteAbs)) +#define ParamLOG_fTd3MinuteAbs (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd3MinuteAbs))) // Minute -#define ParamLOG_fTd3MinuteRel (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd3MinuteRel)) +#define ParamLOG_fTd3MinuteRel (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd3MinuteRel))) // Wochentag -#define ParamLOG_fTd3Weekday (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd3Weekday) & LOG_fTd3WeekdayMask) +#define ParamLOG_fTd3Weekday (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd3Weekday)) & LOG_fTd3WeekdayMask) // Schaltwert -#define ParamLOG_fTd4Value ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd4Value) & LOG_fTd4ValueMask) +#define ParamLOG_fTd4Value ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTd4Value)) & LOG_fTd4ValueMask)) // Grad -#define ParamLOG_fTd4Degree ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd4Degree) & LOG_fTd4DegreeMask) >> LOG_fTd4DegreeShift) +#define ParamLOG_fTd4Degree ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd4Degree)) & LOG_fTd4DegreeMask) >> LOG_fTd4DegreeShift) // Stunde -#define ParamLOG_fTd4HourAbs ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd4HourAbs) & LOG_fTd4HourAbsMask) >> LOG_fTd4HourAbsShift) +#define ParamLOG_fTd4HourAbs ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd4HourAbs)) & LOG_fTd4HourAbsMask) >> LOG_fTd4HourAbsShift) // Sonnen auf-/untergang -#define ParamLOG_fTd4HourRel ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd4HourRel) & LOG_fTd4HourRelMask) >> LOG_fTd4HourRelShift) +#define ParamLOG_fTd4HourRel ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd4HourRel)) & LOG_fTd4HourRelMask) >> LOG_fTd4HourRelShift) // Minute -#define ParamLOG_fTd4MinuteAbs (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd4MinuteAbs)) +#define ParamLOG_fTd4MinuteAbs (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd4MinuteAbs))) // Minute -#define ParamLOG_fTd4MinuteRel (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd4MinuteRel)) +#define ParamLOG_fTd4MinuteRel (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd4MinuteRel))) // Wochentag -#define ParamLOG_fTd4Weekday (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd4Weekday) & LOG_fTd4WeekdayMask) +#define ParamLOG_fTd4Weekday (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd4Weekday)) & LOG_fTd4WeekdayMask) // Schaltwert -#define ParamLOG_fTd5Value ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd5Value) & LOG_fTd5ValueMask) +#define ParamLOG_fTd5Value ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTd5Value)) & LOG_fTd5ValueMask)) // Grad -#define ParamLOG_fTd5Degree ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd5Degree) & LOG_fTd5DegreeMask) >> LOG_fTd5DegreeShift) +#define ParamLOG_fTd5Degree ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd5Degree)) & LOG_fTd5DegreeMask) >> LOG_fTd5DegreeShift) // Stunde -#define ParamLOG_fTd5HourAbs ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd5HourAbs) & LOG_fTd5HourAbsMask) >> LOG_fTd5HourAbsShift) +#define ParamLOG_fTd5HourAbs ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd5HourAbs)) & LOG_fTd5HourAbsMask) >> LOG_fTd5HourAbsShift) // Sonnen auf-/untergang -#define ParamLOG_fTd5HourRel ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd5HourRel) & LOG_fTd5HourRelMask) >> LOG_fTd5HourRelShift) +#define ParamLOG_fTd5HourRel ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd5HourRel)) & LOG_fTd5HourRelMask) >> LOG_fTd5HourRelShift) // Minute -#define ParamLOG_fTd5MinuteAbs (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd5MinuteAbs)) +#define ParamLOG_fTd5MinuteAbs (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd5MinuteAbs))) // Minute -#define ParamLOG_fTd5MinuteRel (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd5MinuteRel)) +#define ParamLOG_fTd5MinuteRel (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd5MinuteRel))) // Wochentag -#define ParamLOG_fTd5Weekday (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd5Weekday) & LOG_fTd5WeekdayMask) +#define ParamLOG_fTd5Weekday (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd5Weekday)) & LOG_fTd5WeekdayMask) // Schaltwert -#define ParamLOG_fTd6Value ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd6Value) & LOG_fTd6ValueMask) +#define ParamLOG_fTd6Value ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTd6Value)) & LOG_fTd6ValueMask)) // Grad -#define ParamLOG_fTd6Degree ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd6Degree) & LOG_fTd6DegreeMask) >> LOG_fTd6DegreeShift) +#define ParamLOG_fTd6Degree ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd6Degree)) & LOG_fTd6DegreeMask) >> LOG_fTd6DegreeShift) // Stunde -#define ParamLOG_fTd6HourAbs ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd6HourAbs) & LOG_fTd6HourAbsMask) >> LOG_fTd6HourAbsShift) +#define ParamLOG_fTd6HourAbs ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd6HourAbs)) & LOG_fTd6HourAbsMask) >> LOG_fTd6HourAbsShift) // Sonnen auf-/untergang -#define ParamLOG_fTd6HourRel ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd6HourRel) & LOG_fTd6HourRelMask) >> LOG_fTd6HourRelShift) +#define ParamLOG_fTd6HourRel ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd6HourRel)) & LOG_fTd6HourRelMask) >> LOG_fTd6HourRelShift) // Minute -#define ParamLOG_fTd6MinuteAbs (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd6MinuteAbs)) +#define ParamLOG_fTd6MinuteAbs (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd6MinuteAbs))) // Minute -#define ParamLOG_fTd6MinuteRel (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd6MinuteRel)) +#define ParamLOG_fTd6MinuteRel (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd6MinuteRel))) // Wochentag -#define ParamLOG_fTd6Weekday (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd6Weekday) & LOG_fTd6WeekdayMask) +#define ParamLOG_fTd6Weekday (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd6Weekday)) & LOG_fTd6WeekdayMask) // Schaltwert -#define ParamLOG_fTd7Value ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd7Value) & LOG_fTd7ValueMask) +#define ParamLOG_fTd7Value ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTd7Value)) & LOG_fTd7ValueMask)) // Grad -#define ParamLOG_fTd7Degree ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd7Degree) & LOG_fTd7DegreeMask) >> LOG_fTd7DegreeShift) +#define ParamLOG_fTd7Degree ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd7Degree)) & LOG_fTd7DegreeMask) >> LOG_fTd7DegreeShift) // Stunde -#define ParamLOG_fTd7HourAbs ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd7HourAbs) & LOG_fTd7HourAbsMask) >> LOG_fTd7HourAbsShift) +#define ParamLOG_fTd7HourAbs ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd7HourAbs)) & LOG_fTd7HourAbsMask) >> LOG_fTd7HourAbsShift) // Sonnen auf-/untergang -#define ParamLOG_fTd7HourRel ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd7HourRel) & LOG_fTd7HourRelMask) >> LOG_fTd7HourRelShift) +#define ParamLOG_fTd7HourRel ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd7HourRel)) & LOG_fTd7HourRelMask) >> LOG_fTd7HourRelShift) // Minute -#define ParamLOG_fTd7MinuteAbs (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd7MinuteAbs)) +#define ParamLOG_fTd7MinuteAbs (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd7MinuteAbs))) // Minute -#define ParamLOG_fTd7MinuteRel (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd7MinuteRel)) +#define ParamLOG_fTd7MinuteRel (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd7MinuteRel))) // Wochentag -#define ParamLOG_fTd7Weekday (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd7Weekday) & LOG_fTd7WeekdayMask) +#define ParamLOG_fTd7Weekday (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd7Weekday)) & LOG_fTd7WeekdayMask) // Schaltwert -#define ParamLOG_fTd8Value ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd8Value) & LOG_fTd8ValueMask) +#define ParamLOG_fTd8Value ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTd8Value)) & LOG_fTd8ValueMask)) // Grad -#define ParamLOG_fTd8Degree ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd8Degree) & LOG_fTd8DegreeMask) >> LOG_fTd8DegreeShift) +#define ParamLOG_fTd8Degree ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd8Degree)) & LOG_fTd8DegreeMask) >> LOG_fTd8DegreeShift) // Stunde -#define ParamLOG_fTd8HourAbs ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd8HourAbs) & LOG_fTd8HourAbsMask) >> LOG_fTd8HourAbsShift) +#define ParamLOG_fTd8HourAbs ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd8HourAbs)) & LOG_fTd8HourAbsMask) >> LOG_fTd8HourAbsShift) // Sonnen auf-/untergang -#define ParamLOG_fTd8HourRel ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd8HourRel) & LOG_fTd8HourRelMask) >> LOG_fTd8HourRelShift) +#define ParamLOG_fTd8HourRel ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTd8HourRel)) & LOG_fTd8HourRelMask) >> LOG_fTd8HourRelShift) // Minute -#define ParamLOG_fTd8MinuteAbs (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd8MinuteAbs)) +#define ParamLOG_fTd8MinuteAbs (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd8MinuteAbs))) // Minute -#define ParamLOG_fTd8MinuteRel (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd8MinuteRel)) +#define ParamLOG_fTd8MinuteRel (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd8MinuteRel))) // Wochentag -#define ParamLOG_fTd8Weekday (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTd8Weekday) & LOG_fTd8WeekdayMask) +#define ParamLOG_fTd8Weekday (knx.paramByte(LOG_ParamCalcIndex(LOG_fTd8Weekday)) & LOG_fTd8WeekdayMask) // Mo -#define ParamLOG_fTy1Weekday1 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Weekday1) & LOG_fTy1Weekday1Mask) +#define ParamLOG_fTy1Weekday1 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Weekday1)) & LOG_fTy1Weekday1Mask)) // Di -#define ParamLOG_fTy1Weekday2 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Weekday2) & LOG_fTy1Weekday2Mask) +#define ParamLOG_fTy1Weekday2 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Weekday2)) & LOG_fTy1Weekday2Mask)) // Mi -#define ParamLOG_fTy1Weekday3 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Weekday3) & LOG_fTy1Weekday3Mask) +#define ParamLOG_fTy1Weekday3 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Weekday3)) & LOG_fTy1Weekday3Mask)) // Do -#define ParamLOG_fTy1Weekday4 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Weekday4) & LOG_fTy1Weekday4Mask) +#define ParamLOG_fTy1Weekday4 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Weekday4)) & LOG_fTy1Weekday4Mask)) // Fr -#define ParamLOG_fTy1Weekday5 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Weekday5) & LOG_fTy1Weekday5Mask) +#define ParamLOG_fTy1Weekday5 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Weekday5)) & LOG_fTy1Weekday5Mask)) // Sa -#define ParamLOG_fTy1Weekday6 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Weekday6) & LOG_fTy1Weekday6Mask) +#define ParamLOG_fTy1Weekday6 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Weekday6)) & LOG_fTy1Weekday6Mask)) // So -#define ParamLOG_fTy1Weekday7 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Weekday7) & LOG_fTy1Weekday7Mask) +#define ParamLOG_fTy1Weekday7 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Weekday7)) & LOG_fTy1Weekday7Mask)) // Tag -#define ParamLOG_fTy1Day ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Day) & LOG_fTy1DayMask) >> LOG_fTy1DayShift) +#define ParamLOG_fTy1Day ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Day)) & LOG_fTy1DayMask) >> LOG_fTy1DayShift) // Wochentag -#define ParamLOG_fTy1IsWeekday ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1IsWeekday) & LOG_fTy1IsWeekdayMask) +#define ParamLOG_fTy1IsWeekday ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1IsWeekday)) & LOG_fTy1IsWeekdayMask)) // Monat -#define ParamLOG_fTy1Month ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy1Month) & LOG_fTy1MonthMask) >> LOG_fTy1MonthShift) +#define ParamLOG_fTy1Month ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTy1Month)) & LOG_fTy1MonthMask) >> LOG_fTy1MonthShift) // Mo -#define ParamLOG_fTy2Weekday1 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Weekday1) & LOG_fTy2Weekday1Mask) +#define ParamLOG_fTy2Weekday1 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Weekday1)) & LOG_fTy2Weekday1Mask)) // Di -#define ParamLOG_fTy2Weekday2 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Weekday2) & LOG_fTy2Weekday2Mask) +#define ParamLOG_fTy2Weekday2 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Weekday2)) & LOG_fTy2Weekday2Mask)) // Mi -#define ParamLOG_fTy2Weekday3 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Weekday3) & LOG_fTy2Weekday3Mask) +#define ParamLOG_fTy2Weekday3 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Weekday3)) & LOG_fTy2Weekday3Mask)) // Do -#define ParamLOG_fTy2Weekday4 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Weekday4) & LOG_fTy2Weekday4Mask) +#define ParamLOG_fTy2Weekday4 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Weekday4)) & LOG_fTy2Weekday4Mask)) // Fr -#define ParamLOG_fTy2Weekday5 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Weekday5) & LOG_fTy2Weekday5Mask) +#define ParamLOG_fTy2Weekday5 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Weekday5)) & LOG_fTy2Weekday5Mask)) // Sa -#define ParamLOG_fTy2Weekday6 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Weekday6) & LOG_fTy2Weekday6Mask) +#define ParamLOG_fTy2Weekday6 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Weekday6)) & LOG_fTy2Weekday6Mask)) // So -#define ParamLOG_fTy2Weekday7 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Weekday7) & LOG_fTy2Weekday7Mask) +#define ParamLOG_fTy2Weekday7 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Weekday7)) & LOG_fTy2Weekday7Mask)) // Tag -#define ParamLOG_fTy2Day ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Day) & LOG_fTy2DayMask) >> LOG_fTy2DayShift) +#define ParamLOG_fTy2Day ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Day)) & LOG_fTy2DayMask) >> LOG_fTy2DayShift) // Wochentag -#define ParamLOG_fTy2IsWeekday ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2IsWeekday) & LOG_fTy2IsWeekdayMask) +#define ParamLOG_fTy2IsWeekday ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2IsWeekday)) & LOG_fTy2IsWeekdayMask)) // Monat -#define ParamLOG_fTy2Month ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy2Month) & LOG_fTy2MonthMask) >> LOG_fTy2MonthShift) +#define ParamLOG_fTy2Month ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTy2Month)) & LOG_fTy2MonthMask) >> LOG_fTy2MonthShift) // Mo -#define ParamLOG_fTy3Weekday1 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Weekday1) & LOG_fTy3Weekday1Mask) +#define ParamLOG_fTy3Weekday1 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Weekday1)) & LOG_fTy3Weekday1Mask)) // Di -#define ParamLOG_fTy3Weekday2 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Weekday2) & LOG_fTy3Weekday2Mask) +#define ParamLOG_fTy3Weekday2 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Weekday2)) & LOG_fTy3Weekday2Mask)) // Mi -#define ParamLOG_fTy3Weekday3 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Weekday3) & LOG_fTy3Weekday3Mask) +#define ParamLOG_fTy3Weekday3 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Weekday3)) & LOG_fTy3Weekday3Mask)) // Do -#define ParamLOG_fTy3Weekday4 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Weekday4) & LOG_fTy3Weekday4Mask) +#define ParamLOG_fTy3Weekday4 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Weekday4)) & LOG_fTy3Weekday4Mask)) // Fr -#define ParamLOG_fTy3Weekday5 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Weekday5) & LOG_fTy3Weekday5Mask) +#define ParamLOG_fTy3Weekday5 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Weekday5)) & LOG_fTy3Weekday5Mask)) // Sa -#define ParamLOG_fTy3Weekday6 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Weekday6) & LOG_fTy3Weekday6Mask) +#define ParamLOG_fTy3Weekday6 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Weekday6)) & LOG_fTy3Weekday6Mask)) // So -#define ParamLOG_fTy3Weekday7 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Weekday7) & LOG_fTy3Weekday7Mask) +#define ParamLOG_fTy3Weekday7 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Weekday7)) & LOG_fTy3Weekday7Mask)) // Tag -#define ParamLOG_fTy3Day ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Day) & LOG_fTy3DayMask) >> LOG_fTy3DayShift) +#define ParamLOG_fTy3Day ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Day)) & LOG_fTy3DayMask) >> LOG_fTy3DayShift) // Wochentag -#define ParamLOG_fTy3IsWeekday ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3IsWeekday) & LOG_fTy3IsWeekdayMask) +#define ParamLOG_fTy3IsWeekday ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3IsWeekday)) & LOG_fTy3IsWeekdayMask)) // Monat -#define ParamLOG_fTy3Month ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy3Month) & LOG_fTy3MonthMask) >> LOG_fTy3MonthShift) +#define ParamLOG_fTy3Month ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTy3Month)) & LOG_fTy3MonthMask) >> LOG_fTy3MonthShift) // Mo -#define ParamLOG_fTy4Weekday1 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Weekday1) & LOG_fTy4Weekday1Mask) +#define ParamLOG_fTy4Weekday1 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Weekday1)) & LOG_fTy4Weekday1Mask)) // Di -#define ParamLOG_fTy4Weekday2 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Weekday2) & LOG_fTy4Weekday2Mask) +#define ParamLOG_fTy4Weekday2 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Weekday2)) & LOG_fTy4Weekday2Mask)) // Mi -#define ParamLOG_fTy4Weekday3 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Weekday3) & LOG_fTy4Weekday3Mask) +#define ParamLOG_fTy4Weekday3 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Weekday3)) & LOG_fTy4Weekday3Mask)) // Do -#define ParamLOG_fTy4Weekday4 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Weekday4) & LOG_fTy4Weekday4Mask) +#define ParamLOG_fTy4Weekday4 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Weekday4)) & LOG_fTy4Weekday4Mask)) // Fr -#define ParamLOG_fTy4Weekday5 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Weekday5) & LOG_fTy4Weekday5Mask) +#define ParamLOG_fTy4Weekday5 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Weekday5)) & LOG_fTy4Weekday5Mask)) // Sa -#define ParamLOG_fTy4Weekday6 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Weekday6) & LOG_fTy4Weekday6Mask) +#define ParamLOG_fTy4Weekday6 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Weekday6)) & LOG_fTy4Weekday6Mask)) // So -#define ParamLOG_fTy4Weekday7 ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Weekday7) & LOG_fTy4Weekday7Mask) +#define ParamLOG_fTy4Weekday7 ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Weekday7)) & LOG_fTy4Weekday7Mask)) // Tag -#define ParamLOG_fTy4Day ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Day) & LOG_fTy4DayMask) >> LOG_fTy4DayShift) +#define ParamLOG_fTy4Day ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Day)) & LOG_fTy4DayMask) >> LOG_fTy4DayShift) // Wochentag -#define ParamLOG_fTy4IsWeekday ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4IsWeekday) & LOG_fTy4IsWeekdayMask) +#define ParamLOG_fTy4IsWeekday ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4IsWeekday)) & LOG_fTy4IsWeekdayMask)) // Monat -#define ParamLOG_fTy4Month ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fTy4Month) & LOG_fTy4MonthMask) >> LOG_fTy4MonthShift) +#define ParamLOG_fTy4Month ((knx.paramByte(LOG_ParamCalcIndex(LOG_fTy4Month)) & LOG_fTy4MonthMask) >> LOG_fTy4MonthShift) // Kanalausgang X -#define ParamLOG_fI1 ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fI1) & LOG_fI1Mask) >> LOG_fI1Shift) +#define ParamLOG_fI1 ((knx.paramByte(LOG_ParamCalcIndex(LOG_fI1)) & LOG_fI1Mask) >> LOG_fI1Shift) // Kanalausgang Y -#define ParamLOG_fI2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fI2) & LOG_fI2Mask) +#define ParamLOG_fI2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fI2)) & LOG_fI2Mask) // Kanalausgang X als interner Eingang 1, X = -#define ParamLOG_fI1Function (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fI1Function)) +#define ParamLOG_fI1Function (knx.paramByte(LOG_ParamCalcIndex(LOG_fI1Function))) // Kanalausgang Y als interner Eingang 2, Y = -#define ParamLOG_fI2Function (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fI2Function)) +#define ParamLOG_fI2Function (knx.paramByte(LOG_ParamCalcIndex(LOG_fI2Function))) // Zeitbasis -#define ParamLOG_fOStairtimeBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOStairtimeBase) & LOG_fOStairtimeBaseMask) >> LOG_fOStairtimeBaseShift) +#define ParamLOG_fOStairtimeBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fOStairtimeBase)) & LOG_fOStairtimeBaseMask) >> LOG_fOStairtimeBaseShift) // Zeit -#define ParamLOG_fOStairtimeTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOStairtimeTime) & LOG_fOStairtimeTimeMask) +#define ParamLOG_fOStairtimeTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fOStairtimeTime)) & LOG_fOStairtimeTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fOStairtimeTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fOStairtimeTime)))) // Zeitbasis -#define ParamLOG_fOBlinkBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOBlinkBase) & LOG_fOBlinkBaseMask) >> LOG_fOBlinkBaseShift) +#define ParamLOG_fOBlinkBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fOBlinkBase)) & LOG_fOBlinkBaseMask) >> LOG_fOBlinkBaseShift) // Zeit -#define ParamLOG_fOBlinkTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOBlinkTime) & LOG_fOBlinkTimeMask) +#define ParamLOG_fOBlinkTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fOBlinkTime)) & LOG_fOBlinkTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fOBlinkTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fOBlinkTime)))) // Ausgang schaltet zeitverzögert -#define ParamLOG_fODelay ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelay) & LOG_fODelayMask) +#define ParamLOG_fODelay ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fODelay)) & LOG_fODelayMask)) // Erneutes EIN führt zu -#define ParamLOG_fODelayOnRepeat ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelayOnRepeat) & LOG_fODelayOnRepeatMask) >> LOG_fODelayOnRepeatShift) +#define ParamLOG_fODelayOnRepeat ((knx.paramByte(LOG_ParamCalcIndex(LOG_fODelayOnRepeat)) & LOG_fODelayOnRepeatMask) >> LOG_fODelayOnRepeatShift) // Darauffolgendes AUS führt zu -#define ParamLOG_fODelayOnReset ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelayOnReset) & LOG_fODelayOnResetMask) +#define ParamLOG_fODelayOnReset ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fODelayOnReset)) & LOG_fODelayOnResetMask)) // Erneutes AUS führt zu -#define ParamLOG_fODelayOffRepeat ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelayOffRepeat) & LOG_fODelayOffRepeatMask) >> LOG_fODelayOffRepeatShift) +#define ParamLOG_fODelayOffRepeat ((knx.paramByte(LOG_ParamCalcIndex(LOG_fODelayOffRepeat)) & LOG_fODelayOffRepeatMask) >> LOG_fODelayOffRepeatShift) // Darauffolgendes EIN führt zu -#define ParamLOG_fODelayOffReset ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelayOffReset) & LOG_fODelayOffResetMask) +#define ParamLOG_fODelayOffReset ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fODelayOffReset)) & LOG_fODelayOffResetMask)) // Zeitbasis -#define ParamLOG_fODelayOnBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelayOnBase) & LOG_fODelayOnBaseMask) >> LOG_fODelayOnBaseShift) +#define ParamLOG_fODelayOnBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fODelayOnBase)) & LOG_fODelayOnBaseMask) >> LOG_fODelayOnBaseShift) // Zeit -#define ParamLOG_fODelayOnTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelayOnTime) & LOG_fODelayOnTimeMask) +#define ParamLOG_fODelayOnTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fODelayOnTime)) & LOG_fODelayOnTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fODelayOnTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fODelayOnTime)))) // Zeitbasis -#define ParamLOG_fODelayOffBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelayOffBase) & LOG_fODelayOffBaseMask) >> LOG_fODelayOffBaseShift) +#define ParamLOG_fODelayOffBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fODelayOffBase)) & LOG_fODelayOffBaseMask) >> LOG_fODelayOffBaseShift) // Zeit -#define ParamLOG_fODelayOffTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODelayOffTime) & LOG_fODelayOffTimeMask) +#define ParamLOG_fODelayOffTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fODelayOffTime)) & LOG_fODelayOffTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fODelayOffTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fODelayOffTime)))) // Ausgang hat eine Treppenlichtfunktion -#define ParamLOG_fOStair ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOStair) & LOG_fOStairMask) +#define ParamLOG_fOStair ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fOStair)) & LOG_fOStairMask)) // Treppenlicht kann verlängert werden -#define ParamLOG_fORetrigger ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fORetrigger) & LOG_fORetriggerMask) +#define ParamLOG_fORetrigger ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fORetrigger)) & LOG_fORetriggerMask)) // Treppenlicht kann ausgeschaltet werden -#define ParamLOG_fOStairOff ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOStairOff) & LOG_fOStairOffMask) +#define ParamLOG_fOStairOff ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fOStairOff)) & LOG_fOStairOffMask)) // Ausgang wiederholt zyklisch -#define ParamLOG_fORepeat ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fORepeat) & LOG_fORepeatMask) +#define ParamLOG_fORepeat ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fORepeat)) & LOG_fORepeatMask)) // Wiederholungsfilter -#define ParamLOG_fOOutputFilter ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOutputFilter) & LOG_fOOutputFilterMask) >> LOG_fOOutputFilterShift) +#define ParamLOG_fOOutputFilter ((knx.paramByte(LOG_ParamCalcIndex(LOG_fOOutputFilter)) & LOG_fOOutputFilterMask) >> LOG_fOOutputFilterShift) // Zeitbasis -#define ParamLOG_fORepeatOnBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fORepeatOnBase) & LOG_fORepeatOnBaseMask) >> LOG_fORepeatOnBaseShift) +#define ParamLOG_fORepeatOnBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fORepeatOnBase)) & LOG_fORepeatOnBaseMask) >> LOG_fORepeatOnBaseShift) // Zeit -#define ParamLOG_fORepeatOnTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fORepeatOnTime) & LOG_fORepeatOnTimeMask) +#define ParamLOG_fORepeatOnTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fORepeatOnTime)) & LOG_fORepeatOnTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fORepeatOnTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fORepeatOnTime)))) // Zeitbasis -#define ParamLOG_fORepeatOffBase ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fORepeatOffBase) & LOG_fORepeatOffBaseMask) >> LOG_fORepeatOffBaseShift) +#define ParamLOG_fORepeatOffBase ((knx.paramByte(LOG_ParamCalcIndex(LOG_fORepeatOffBase)) & LOG_fORepeatOffBaseMask) >> LOG_fORepeatOffBaseShift) // Zeit -#define ParamLOG_fORepeatOffTime (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fORepeatOffTime) & LOG_fORepeatOffTimeMask) +#define ParamLOG_fORepeatOffTime (knx.paramWord(LOG_ParamCalcIndex(LOG_fORepeatOffTime)) & LOG_fORepeatOffTimeMask) +// Zeit (in Millisekunden) +#define ParamLOG_fORepeatOffTimeMS (paramDelay(knx.paramWord(LOG_ParamCalcIndex(LOG_fORepeatOffTime)))) // DPT für Ausgang -#define ParamLOG_fODpt (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fODpt)) +#define ParamLOG_fODpt (knx.paramByte(LOG_ParamCalcIndex(LOG_fODpt))) // Wert für EIN senden? -#define ParamLOG_fOOn (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOn)) +#define ParamLOG_fOOn (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOn))) // Wert für EIN senden? -#define ParamLOG_fOOnBuzzer (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnBuzzer)) +#define ParamLOG_fOOnBuzzer (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnBuzzer))) // Wert für EIN senden? -#define ParamLOG_fOOnLed (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnLed)) +#define ParamLOG_fOOnLed (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnLed))) // Wert für EIN senden? -#define ParamLOG_fOOnAll (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnAll)) +#define ParamLOG_fOOnAll (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnAll))) // Wert für EIN senden als -#define ParamLOG_fOOnTone (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnTone)) +#define ParamLOG_fOOnTone (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnTone))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt1 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt1)) +#define ParamLOG_fOOnDpt1 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnDpt1))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt2)) +#define ParamLOG_fOOnDpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnDpt2))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt5 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt5)) +#define ParamLOG_fOOnDpt5 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnDpt5))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt5001 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt5001)) +#define ParamLOG_fOOnDpt5001 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnDpt5001))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt6 ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt6)) +#define ParamLOG_fOOnDpt6 ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnDpt6))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt7 (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt7)) +#define ParamLOG_fOOnDpt7 (knx.paramWord(LOG_ParamCalcIndex(LOG_fOOnDpt7))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt8 ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt8)) +#define ParamLOG_fOOnDpt8 ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fOOnDpt8))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt9 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt9, Float_Enc_IEEE754Single)) +#define ParamLOG_fOOnDpt9 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fOOnDpt9), Float_Enc_IEEE754Single)) // Wert für EIN senden als -#define ParamLOG_fOOnDpt12 (knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt12)) +#define ParamLOG_fOOnDpt12 (knx.paramLong(LOG_ParamCalcIndex(LOG_fOOnDpt12))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt13 ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt13)) +#define ParamLOG_fOOnDpt13 ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fOOnDpt13))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt14 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt14, Float_Enc_IEEE754Single)) +#define ParamLOG_fOOnDpt14 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fOOnDpt14), Float_Enc_IEEE754Single)) // Wert für EIN senden als -#define ParamLOG_fOOnDpt16 (knx.paramData(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt16)) +#define ParamLOG_fOOnDpt16 (knx.paramData(LOG_ParamCalcIndex(LOG_fOOnDpt16))) // Wert für EIN senden als -#define ParamLOG_fOOnDpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnDpt17)) +#define ParamLOG_fOOnDpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnDpt17))) // Wert für EIN senden als (3-Byte-RGB) -#define ParamLOG_fOOnRGB ((knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnRGB) & LOG_fOOnRGBMask) >> LOG_fOOnRGBShift) +#define ParamLOG_fOOnRGB ((knx.paramLong(LOG_ParamCalcIndex(LOG_fOOnRGB)) & LOG_fOOnRGBMask) >> LOG_fOOnRGBShift) // -#define ParamLOG_fOOnPAArea ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnPAArea) & LOG_fOOnPAAreaMask) >> LOG_fOOnPAAreaShift) +#define ParamLOG_fOOnPAArea ((knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnPAArea)) & LOG_fOOnPAAreaMask) >> LOG_fOOnPAAreaShift) // -#define ParamLOG_fOOnPALine (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnPALine) & LOG_fOOnPALineMask) +#define ParamLOG_fOOnPALine (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnPALine)) & LOG_fOOnPALineMask) // -#define ParamLOG_fOOnPADevice (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnPADevice)) +#define ParamLOG_fOOnPADevice (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnPADevice))) // Wert für EIN ermitteln als -#define ParamLOG_fOOnFunction (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOnFunction)) +#define ParamLOG_fOOnFunction (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOnFunction))) // Wert für AUS senden? -#define ParamLOG_fOOff (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOff)) +#define ParamLOG_fOOff (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOff))) // Wert für AUS senden? -#define ParamLOG_fOOffBuzzer (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffBuzzer)) +#define ParamLOG_fOOffBuzzer (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffBuzzer))) // Wert für AUS senden? -#define ParamLOG_fOOffLed (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffLed)) +#define ParamLOG_fOOffLed (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffLed))) // Wert für AUS senden? -#define ParamLOG_fOOffAll (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffAll)) +#define ParamLOG_fOOffAll (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffAll))) // Wert für AUS senden als -#define ParamLOG_fOOffTone (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffTone)) +#define ParamLOG_fOOffTone (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffTone))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt1 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt1)) +#define ParamLOG_fOOffDpt1 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffDpt1))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt2 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt2)) +#define ParamLOG_fOOffDpt2 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffDpt2))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt5 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt5)) +#define ParamLOG_fOOffDpt5 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffDpt5))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt5001 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt5001)) +#define ParamLOG_fOOffDpt5001 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffDpt5001))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt6 ((int8_t)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt6)) +#define ParamLOG_fOOffDpt6 ((int8_t)knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffDpt6))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt7 (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt7)) +#define ParamLOG_fOOffDpt7 (knx.paramWord(LOG_ParamCalcIndex(LOG_fOOffDpt7))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt8 ((int16_t)knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt8)) +#define ParamLOG_fOOffDpt8 ((int16_t)knx.paramWord(LOG_ParamCalcIndex(LOG_fOOffDpt8))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt9 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt9, Float_Enc_IEEE754Single)) +#define ParamLOG_fOOffDpt9 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fOOffDpt9), Float_Enc_IEEE754Single)) // Wert für AUS senden als -#define ParamLOG_fOOffDpt12 (knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt12)) +#define ParamLOG_fOOffDpt12 (knx.paramLong(LOG_ParamCalcIndex(LOG_fOOffDpt12))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt13 ((int32_t)knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt13)) +#define ParamLOG_fOOffDpt13 ((int32_t)knx.paramLong(LOG_ParamCalcIndex(LOG_fOOffDpt13))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt14 (knx.paramFloat(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt14, Float_Enc_IEEE754Single)) +#define ParamLOG_fOOffDpt14 (knx.paramFloat(LOG_ParamCalcIndex(LOG_fOOffDpt14), Float_Enc_IEEE754Single)) // Wert für AUS senden als -#define ParamLOG_fOOffDpt16 (knx.paramData(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt16)) +#define ParamLOG_fOOffDpt16 (knx.paramData(LOG_ParamCalcIndex(LOG_fOOffDpt16))) // Wert für AUS senden als -#define ParamLOG_fOOffDpt17 (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffDpt17)) +#define ParamLOG_fOOffDpt17 (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffDpt17))) // Wert für AUS senden als (3-Byte-RGB) -#define ParamLOG_fOOffRGB ((knx.paramLong(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffRGB) & LOG_fOOffRGBMask) >> LOG_fOOffRGBShift) +#define ParamLOG_fOOffRGB ((knx.paramLong(LOG_ParamCalcIndex(LOG_fOOffRGB)) & LOG_fOOffRGBMask) >> LOG_fOOffRGBShift) // -#define ParamLOG_fOOffPAArea ((knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffPAArea) & LOG_fOOffPAAreaMask) >> LOG_fOOffPAAreaShift) +#define ParamLOG_fOOffPAArea ((knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffPAArea)) & LOG_fOOffPAAreaMask) >> LOG_fOOffPAAreaShift) // -#define ParamLOG_fOOffPALine (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffPALine) & LOG_fOOffPALineMask) +#define ParamLOG_fOOffPALine (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffPALine)) & LOG_fOOffPALineMask) // -#define ParamLOG_fOOffPADevice (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffPADevice)) +#define ParamLOG_fOOffPADevice (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffPADevice))) // Wert für AUS ermitteln als -#define ParamLOG_fOOffFunction (knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fOOffFunction)) +#define ParamLOG_fOOffFunction (knx.paramByte(LOG_ParamCalcIndex(LOG_fOOffFunction))) // Kommunikationsobjekt für Eingang 1 -#define ParamLOG_fE1UseOtherKO ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1UseOtherKO) & LOG_fE1UseOtherKOMask) +#define ParamLOG_fE1UseOtherKO ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE1UseOtherKO)) & LOG_fE1UseOtherKOMask)) // Nummer des Kommunikationsobjekts -#define ParamLOG_fE1OtherKO (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE1OtherKO) & LOG_fE1OtherKOMask) +#define ParamLOG_fE1OtherKO (knx.paramWord(LOG_ParamCalcIndex(LOG_fE1OtherKO)) & LOG_fE1OtherKOMask) // Kommunikationsobjekt für Eingang 2 -#define ParamLOG_fE2UseOtherKO ((bool)knx.paramByte(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2UseOtherKO) & LOG_fE2UseOtherKOMask) +#define ParamLOG_fE2UseOtherKO ((bool)(knx.paramByte(LOG_ParamCalcIndex(LOG_fE2UseOtherKO)) & LOG_fE2UseOtherKOMask)) // Nummer des Kommunikationsobjekts -#define ParamLOG_fE2OtherKO (knx.paramWord(LOG_ParamBlockOffset + _channelIndex * LOG_ParamBlockSize + LOG_fE2OtherKO) & LOG_fE2OtherKOMask) +#define ParamLOG_fE2OtherKO (knx.paramWord(LOG_ParamCalcIndex(LOG_fE2OtherKO)) & LOG_fE2OtherKOMask) -// Communication objects per channel (multiple occurrence) +// deprecated #define LOG_KoOffset 20 + +// Communication objects per channel (multiple occurrence) +#define LOG_KoBlockOffset 20 #define LOG_KoBlockSize 3 + +#define LOG_KoCalcNumber(index) (index + LOG_KoBlockOffset + _channelIndex * LOG_KoBlockSize) +#define LOG_KoCalcIndex(number) ((number >= LOG_KoCalcNumber(0) && number < LOG_KoCalcNumber(LOG_KoBlockSize)) ? (number - LOG_KoOffset) % LOG_KoBlockSize : -1) + #define LOG_KoKOfE1 0 #define LOG_KoKOfE2 1 #define LOG_KoKOfO 2 -// KOf%C%E1 -#define KoLOG_KOfE1 (knx.getGroupObject(LOG_KoOffset + _channelIndex * LOG_KoBlockSize) + LOG_KoKOfE1) -// KOf%C%E2 -#define KoLOG_KOfE2 (knx.getGroupObject(LOG_KoOffset + _channelIndex * LOG_KoBlockSize) + LOG_KoKOfE2) -// KOf%C%O -#define KoLOG_KOfO (knx.getGroupObject(LOG_KoOffset + _channelIndex * LOG_KoBlockSize) + LOG_KoKOfO) +// Eingang 1 +#define KoLOG_KOfE1 (knx.getGroupObject(LOG_KoCalcNumber(LOG_KoKOfE1))) +// Eingang 2 +#define KoLOG_KOfE2 (knx.getGroupObject(LOG_KoCalcNumber(LOG_KoKOfE2))) +// Ausgang +#define KoLOG_KOfO (knx.getGroupObject(LOG_KoCalcNumber(LOG_KoKOfO))) #define MAIN_OpenKnxId 0xA0 -#define MAIN_ApplicationNumber 49 -#define MAIN_ApplicationVersion 46 -#define MAIN_OrderNumber "OpenKnxLogicDev" +#define MAIN_ApplicationNumber 48 +#define MAIN_ApplicationVersion 20 +#define MAIN_OrderNumber "OpenKnxLogic" diff --git a/src/TimerInterruptRP2040.cpp.bak b/src/TimerInterruptRP2040.cpp.bak deleted file mode 100644 index 7f02609..0000000 --- a/src/TimerInterruptRP2040.cpp.bak +++ /dev/null @@ -1,199 +0,0 @@ -/**************************************************************************************************************************** - TimerInterruptTest.ino - - For RP2040-based boards such as RASPBERRY_PI_PICO, ADAFRUIT_FEATHER_RP2040 and GENERIC_RP2040. - Written by Khoi Hoang - - Built by Khoi Hoang https://github.com/khoih-prog/TimerInterrupt_Generic - Licensed under MIT license - - The RPI_PICO system timer peripheral provides a global microsecond timebase for the system, and generates - interrupts based on this timebase. It supports the following features: - • A single 64-bit counter, incrementing once per microsecond - • This counter can be read from a pair of latching registers, for race-free reads over a 32-bit bus. - • Four alarms: match on the lower 32 bits of counter, IRQ on match: TIMER_IRQ_0-TIMER_IRQ_3 - - Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by - unsigned long miliseconds), you just consume only one RPI_PICO timer and avoid conflicting with other cores' tasks. - The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers - Therefore, their executions are not blocked by bad-behaving functions / tasks. - This important feature is absolutely necessary for mission-critical tasks. - - Based on SimpleTimer - A timer library for Arduino. - Author: mromani@ottotecnica.com - Copyright (c) 2010 OTTOTECNICA Italy - - Based on BlynkTimer.h - Author: Volodymyr Shymanskyy -*****************************************************************************************************************************/ -/* - Notes: - Special design is necessary to share data between interrupt code and the rest of your program. - Variables usually need to be "volatile" types. Volatile tells the compiler to avoid optimizations that assume - variable can not spontaneously change. Because your function may change variables while your program is using them, - the compiler needs this hint. But volatile alone is often not enough. - When accessing shared variables, usually interrupts must be disabled. Even with volatile, - if the interrupt changes a multi-byte variable between a sequence of instructions, it can be read incorrectly. - If your data is multiple variables, such as an array and a count, usually interrupts need to be disabled - or the entire sequence of your code which accesses the data. -*/ - -// These define's must be placed at the beginning before #include "TimerInterrupt_Generic.h" -// _TIMERINTERRUPT_LOGLEVEL_ from 0 to 4 -// Don't define _TIMERINTERRUPT_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system. -#define TIMER_INTERRUPT_DEBUG 1 -#define _TIMERINTERRUPT_LOGLEVEL_ 1 - -#include "TimerInterrupt_Generic.h" - -#ifndef LED_BUILTIN - #define LED_BUILTIN 25 // Pin D2 mapped to pin GPIO2/ADC12 of ESP32, control on-board LED -#endif - -#define PIN_D1 1 // Pin D1 mapped to pin GPIO1 of RPI_PICO - -bool TimerHandler0(struct repeating_timer *t) -{ - (void) t; - - static bool toggle0 = false; - static bool started = false; - - if (!started) - { - started = true; - pinMode(LED_BUILTIN, OUTPUT); - } - -#if (TIMER_INTERRUPT_DEBUG > 0) - Serial.print("ITimer0 called, millis() = "); - Serial.println(millis()); -#endif - - //timer interrupt toggles pin LED_BUILTIN - digitalWrite(LED_BUILTIN, toggle0); - toggle0 = !toggle0; - - return true; -} - -bool TimerHandler1(struct repeating_timer *t) -{ - (void) t; - - static bool toggle1 = false; - static bool started = false; - - if (!started) - { - started = true; - pinMode(PIN_D1, OUTPUT); - } - -#if (TIMER_INTERRUPT_DEBUG > 0) - Serial.print("ITimer1 called, millis() = "); - Serial.println(millis()); -#endif - - //timer interrupt toggles outputPin - digitalWrite(PIN_D1, toggle1); - toggle1 = !toggle1; - - return true; -} - -#define TIMER0_INTERVAL_MS 1000 -#define TIMER0_DURATION_MS 5000 - -#define TIMER1_INTERVAL_MS 3000 -#define TIMER1_DURATION_MS 15000 - -// Init RPI_PICO_Timer, can use any from 0-15 pseudo-hardware timers -RPI_PICO_Timer ITimer0(0); -RPI_PICO_Timer ITimer1(1); - -void setup() -{ - Serial.begin(115200); - - while (!Serial && millis() < 5000); - - delay(500); - - Serial.print(F("\nStarting TimerInterruptTest on ")); - Serial.println(BOARD_NAME); - Serial.println(RPI_PICO_TIMER_INTERRUPT_VERSION); - Serial.println(TIMER_INTERRUPT_GENERIC_VERSION); - Serial.print(F("CPU Frequency = ")); - Serial.print(F_CPU / 1000000); - Serial.println(F(" MHz")); - - // Interval in microsecs - if (ITimer0.attachInterruptInterval(TIMER0_INTERVAL_MS * 1000, TimerHandler0)) - { - Serial.print(F("Starting ITimer0 OK, millis() = ")); - Serial.println(millis()); - } - else - Serial.println(F("Can't set ITimer0. Select another freq. or timer")); - - // Interval in microsecs - if (ITimer1.attachInterruptInterval(TIMER1_INTERVAL_MS * 1000, TimerHandler1)) - { - Serial.print(F("Starting ITimer1 OK, millis() = ")); - Serial.println(millis()); - } - else - Serial.println(F("Can't set ITimer1. Select another freq. or timer")); - - Serial.flush(); -} - -void loop() -{ - static unsigned long lastTimer0 = 0; - static unsigned long lastTimer1 = 0; - - static bool timer0Stopped = false; - static bool timer1Stopped = false; - - if (millis() - lastTimer0 > TIMER0_DURATION_MS) - { - lastTimer0 = millis(); - - if (timer0Stopped) - { - Serial.print(F("Start ITimer0, millis() = ")); - Serial.println(millis()); - ITimer0.restartTimer(); - } - else - { - Serial.print(F("Stop ITimer0, millis() = ")); - Serial.println(millis()); - ITimer0.stopTimer(); - } - - timer0Stopped = !timer0Stopped; - } - - if (millis() - lastTimer1 > TIMER1_DURATION_MS) - { - lastTimer1 = millis(); - - if (timer1Stopped) - { - Serial.print(F("Start ITimer1, millis() = ")); - Serial.println(millis()); - ITimer1.restartTimer(); - } - else - { - Serial.print(F("Stop ITimer1, millis() = ")); - Serial.println(millis()); - ITimer1.stopTimer(); - } - - timer1Stopped = !timer1Stopped; - } -} \ No newline at end of file diff --git a/src/TimerInterruptSAMD.cpp.bak b/src/TimerInterruptSAMD.cpp.bak deleted file mode 100644 index 822ba74..0000000 --- a/src/TimerInterruptSAMD.cpp.bak +++ /dev/null @@ -1,191 +0,0 @@ -/**************************************************************************************************************************** - TimerInterruptTest.ino - For SAMD boards - Written by Khoi Hoang - - Built by Khoi Hoang https://github.com/khoih-prog/SAMD_TimerInterrupt - Licensed under MIT license - - Now even you use all these new 16 ISR-based timers,with their maximum interval practically unlimited (limited only by - unsigned long miliseconds), you just consume only one SAMD timer and avoid conflicting with other cores' tasks. - The accuracy is nearly perfect compared to software timers. The most important feature is they're ISR-based timers - Therefore, their executions are not blocked by bad-behaving functions / tasks. - This important feature is absolutely necessary for mission-critical tasks. -*****************************************************************************************************************************/ -/* - Notes: - Special design is necessary to share data between interrupt code and the rest of your program. - Variables usually need to be "volatile" types. Volatile tells the compiler to avoid optimizations that assume - variable can not spontaneously change. Because your function may change variables while your program is using them, - the compiler needs this hint. But volatile alone is often not enough. - When accessing shared variables, usually interrupts must be disabled. Even with volatile, - if the interrupt changes a multi-byte variable between a sequence of instructions, it can be read incorrectly. - If your data is multiple variables, such as an array and a count, usually interrupts need to be disabled - or the entire sequence of your code which accesses the data. -*/ - -#if !( defined(ARDUINO_SAMD_ZERO) || defined(ARDUINO_SAMD_MKR1000) || defined(ARDUINO_SAMD_MKRWIFI1010) \ - || defined(ARDUINO_SAMD_NANO_33_IOT) || defined(ARDUINO_SAMD_MKRFox1200) || defined(ARDUINO_SAMD_MKRWAN1300) || defined(ARDUINO_SAMD_MKRWAN1310) \ - || defined(ARDUINO_SAMD_MKRGSM1400) || defined(ARDUINO_SAMD_MKRNB1500) || defined(ARDUINO_SAMD_MKRVIDOR4000) \ - || defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS) || defined(__SAMD51__) || defined(__SAMD51J20A__) \ - || defined(__SAMD51J19A__) || defined(__SAMD51G19A__) || defined(__SAMD51P19A__) \ - || defined(__SAMD21E15A__) || defined(__SAMD21E16A__) || defined(__SAMD21E17A__) || defined(__SAMD21E18A__) \ - || defined(__SAMD21G15A__) || defined(__SAMD21G16A__) || defined(__SAMD21G17A__) || defined(__SAMD21G18A__) \ - || defined(__SAMD21J15A__) || defined(__SAMD21J16A__) || defined(__SAMD21J17A__) || defined(__SAMD21J18A__) ) -#error This code is designed to run on SAMD21/SAMD51 platform! Please check your Tools->Board setting. -#endif - -///////////////////////////////////////////////////////////////// - -// These define's must be placed at the beginning before #include "TimerInterrupt_Generic.h" -// _TIMERINTERRUPT_LOGLEVEL_ from 0 to 4 -// Don't define _TIMERINTERRUPT_LOGLEVEL_ > 0. Only for special ISR debugging only. Can hang the system. -// Don't define TIMER_INTERRUPT_DEBUG > 2. Only for special ISR debugging only. Can hang the system. -#define TIMER_INTERRUPT_DEBUG 0 -#define _TIMERINTERRUPT_LOGLEVEL_ 0 - -// Select only one to be true for SAMD21. Must must be placed at the beginning before #include "TimerInterrupt_Generic.h" -#define USING_TIMER_TC3 true // Only TC3 can be used for SAMD51 -#define USING_TIMER_TC4 false // Not to use with Servo library -#define USING_TIMER_TC5 false -#define USING_TIMER_TCC false -#define USING_TIMER_TCC1 false -#define USING_TIMER_TCC2 false // Don't use this, can crash on some boards - -// Uncomment To test if conflict with Servo library -//#include "Servo.h" - -///////////////////////////////////////////////////////////////// - -#include "TimerInterrupt_Generic.h" - -#ifndef LED_BUILTIN - #define LED_BUILTIN 13 -#endif - -unsigned int SWPin = 7; - -// TC3, TC4, TC5 max permissible TIMER_INTERVAL_MS is 1398.101 ms, larger will overflow, therefore not permitted -// Use TCC, TCC1, TCC2 for longer TIMER_INTERVAL_MS -#define TIMER_INTERVAL_MS 1000 - -#define TIMER_DURATION_MS 5000 - -volatile uint32_t preMillisTimer = 0; - -/////////////////////////////////////////////// - -#if (TIMER_INTERRUPT_USING_SAMD21) - - #if USING_TIMER_TC3 - #define SELECTED_TIMER TIMER_TC3 - #elif USING_TIMER_TC4 - #define SELECTED_TIMER TIMER_TC4 - #elif USING_TIMER_TC5 - #define SELECTED_TIMER TIMER_TC5 - #elif USING_TIMER_TCC - #define SELECTED_TIMER TIMER_TCC - #elif USING_TIMER_TCC1 - #define SELECTED_TIMER TIMER_TCC1 - #elif USING_TIMER_TCC2 - #define SELECTED_TIMER TIMER_TCC - #else - #error You have to select 1 Timer - #endif - -#else - - #if !(USING_TIMER_TC3) - #error You must select TC3 for SAMD51 - #endif - - #define SELECTED_TIMER TIMER_TC3 - -#endif - -// Init selected SAMD timer -SAMDTimer ITimer(SELECTED_TIMER); - -//////////////////////////////////////////////// - -void TimerHandler() -{ - static bool toggle = false; - -#if (TIMER_INTERRUPT_DEBUG > 0) - static uint32_t curMillis = 0; - - curMillis = millis(); - - if (curMillis > TIMER_INTERVAL_MS) - { - Serial.print("ITimer: millis() = "); - Serial.print(curMillis); - Serial.print(", delta = "); - Serial.println(curMillis - preMillisTimer); - } - - preMillisTimer = curMillis; -#endif - - //timer interrupt toggles pin LED_BUILTIN - digitalWrite(LED_BUILTIN, toggle); - toggle = !toggle; -} - -void setup() -{ - pinMode(LED_BUILTIN, OUTPUT); - - Serial.begin(115200); - - while (!Serial && millis() < 5000); - - delay(100); - - Serial.print(F("\nStarting TimerInterruptTest on ")); - Serial.println(BOARD_NAME); - Serial.println(SAMD_TIMER_INTERRUPT_VERSION); - Serial.println(TIMER_INTERRUPT_GENERIC_VERSION); - Serial.print(F("CPU Frequency = ")); - Serial.print(F_CPU / 1000000); - Serial.println(F(" MHz")); - - // Interval in millisecs - if (ITimer.attachInterruptInterval_MS(TIMER_INTERVAL_MS, TimerHandler)) - { - preMillisTimer = millis(); - Serial.print(F("Starting ITimer OK, millis() = ")); - Serial.println(preMillisTimer); - } - else - Serial.println(F("Can't set ITimer. Select another freq. or timer")); -} - -void loop() -{ - static unsigned long lastTimer = 0; - static bool timerStopped = false; - - - if (millis() - lastTimer > TIMER_DURATION_MS) - { - lastTimer = millis(); - - if (timerStopped) - { - preMillisTimer = millis(); - Serial.print(F("Start ITimer, millis() = ")); - Serial.println(preMillisTimer); - ITimer.restartTimer(); - } - else - { - Serial.print(F("Stop ITimer, millis() = ")); - Serial.println(millis()); - ITimer.stopTimer(); - } - - timerStopped = !timerStopped; - } -} \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index 5133041..d929737 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -6,32 +6,6 @@ void appSetup(bool iSaveSupported); void appLoop(); -uint32_t minFreeMemory = INT32_MAX; - -// #include "TimerInterrupt_Generic.h" - -// // Init selected SAMD timer -// SAMDTimer ITimer(TIMER_TC3); - - -// //////////////////////////////////////////////// - - -// // Init SAMD_ISR_Timer -// // Each SAMD_ISR_Timer can service 16 different ISR-based timers -// SAMD_ISR_Timer ISR_Timer; - - -// #define TIMER_INTERVAL_1S 1000L -// #define TIMER_INTERVAL_2S 2000L -// #define TIMER_INTERVAL_5S 5000L - - - -// void TimerHandler(void) -// { -// ISR_Timer.run(); -// } void setup() { @@ -68,7 +42,7 @@ void setup() // all MAIN_* parameters are generated by OpenKNXproducer for correct version checking by ETS // If you want just a bugfix firmware update without ETS-Application dependency, just increase firmwareRevision. // As soon, as you want again a sync between ETS-Application and firmware, set firmwareRevision to 0. - const uint8_t firmwareRevision = 1; + const uint8_t firmwareRevision = 2; openknx.readMemory(MAIN_OpenKnxId, MAIN_ApplicationNumber, MAIN_ApplicationVersion, firmwareRevision); // print values of parameters if device is already configured