/*
  xdrv_75_dali.ino - DALI support for Tasmota

  Copyright (C) 2022  Andrei Kazmirtsuk aka eeak and Theo Arends

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifdef USE_DALI
/*********************************************************************************************\
 * DALI support for Tasmota
 * 
 * Available commands:
 *   <byte1>..<byte4> = 0..255 or 0x00..0xFF     - Both decimal and hexadecimal is supported
 *   <broadcast> = 0                             - DALI default
 *   <device> = 1..64                            - DALI short address + 1
 *   <group> = 101..116                          - DALI group + 101
 *   <dt> = 6, 8                                 - DALI Device Type specific extended command
 * DaliSend <byte1>,<byte2>                      - Execute DALI code and do not expect a DALI backward frame
 * DaliSend <dt>,<byte1>,<byte2>                 - Execute DALI extended code for DT and do not expect a DALI backward frame
 * DaliSend <0xA3>,<byte2>,<byte3>,<byte4>       - Set DALI parameter using DTR0 and do not expect a DALI backward frame
 * DaliQuery <byte1>,<byte2>                     - Execute DALI code and report result (DALI backward frame)
 * DaliQuery <dt>,<byte1>,<byte2>                - Execute DALI extended code for DT and report result (DALI backward frame)
 * DaliScan 1|2                                  - Reset (0) or (1)/and commission device short addresses
 * DaliGear 1..64                                - Set max short address to speed up scanning - default 64
 * DaliGroup<1..16> [+]|-<device>,<device>...    - Add(+) or Remove(-) devices to/from group
 * DaliPower<broadcast>|<device>|<group> 0..254  - Control power (0 = Off, 1 = Last dimmer, 2 = Toggle, 3..254 = absolute light brightness)
 * DaliDimmer<broadcast>|<device>|<group> 0..100 - Control dimmer (0 = Off, 1..100 = precentage of brightness)
 * DaliLight 0|1                                 - Enable Tasmota light control for DaliTarget device - default 1
 * DaliTarget <broadcast>|<device>|<group>       - Set Tasmota light control device (0, 1..64, 101..116) - default 0
 * 
 * DALI background information
 * Address type        Address byte
 * ------------------  --------------------
 * Broadcast address   1111111S
 * 64 short address    0AAAAAAS
 * 16 group address    100AAAAS
 * Special command     101CCCC1 to 110CCCC1
 * A = Address bit, S = 0 Direct Arc Power control, S = 1 Command, C = Special command
 * 
 * Shelly DALI Dimmer Gen3 (ESP32C3-8M) - GPIO3 controls DALI power. In following template it is always ON. Max output is 16V/10mA (= 5 DALI gear)
 * Template {"NAME":"Shelly DALI Dimmer Gen3","GPIO":[34,4736,0,3840,11360,11392,128,129,0,1,576,0,0,0,0,0,0,0,0,1,1,1],"FLAG":0,"BASE":1}
 * AdcGpio1 10000,10000,4000        <- Temperature parameters
 * Backlog ButtonTopic 0; SetOption1 1; SetOption11 0; SetOption32 20; DimmerStep 5; LedTable 0
 * rule1 on button1#state=2 do dimmer + endon on button2#state=2 do dimmer - endon on button1#state=3 do power 2 endon on button2#state=3 do power 2 endon
 *
  --------------------------------------------------------------------------------------------
  Version yyyymmdd  Action    Description
  --------------------------------------------------------------------------------------------
  1.1.0.4 20251115  fix       - Tasmota light control using non-broadcast address
  1.1.0.3 20251112  remove    - Remove optional repeat for commands `DaliSend` and `DaliQuery`
                                Send twice is now based on DALI defined commands type
  1.1.0.2 20251109  update    - Add optional extended commands prefix for commands `DaliSend` and `DaliQuery`
  1.1.0.1 20241101  update    - Enable DALI if another light is already claimed
  1.1.0.0 20241031  update    - Add GUI sliders with feedback when `DaliLight 0`
                              - Add command `DaliGroupSliders 0..16` to show GUI sliders
  1.0.0.2 20241025  update    - Fix GPIO detection
                              - Fix ESP32(C3) transmit stability by disabling interrupts
  1.0.0.1 20241024  update    - Change from signal invert defines to GPIO config DALI RX_i/DALI TX_i
                              - Fix inverted DALI signal support
                              - Experimental support for Shelly DALI Dimmer Gen3
  1.0.0.0 20241022  update    - Refactor commission
                              - Add receive collision detection
  0.1.0.8 20241019  update    - Rename command `DaliCommission` to `DaliScan`
                              - Rename command `DaliWeb` to `DaliLight`
                              - Add command `DaliGear` to set max found gear to speed up scan response
  0.1.0.7 20241017  update    - Add command `DaliCommission 1|2` assigning short addresses
                              - Add command `DaliTarget 0, 1..64, 101..116` to select light control address
                              - Add command `DaliGroup1..16 +<devices>|-<devices>` to add/remove devices from group
                              - Extend commands `DaliPower` and `DaliDimmer` with index to control short address or group
                              - Remove non-functional MQTT interface
  0.1.0.6 20241014  update    - Fix received light command loop
                              - Add send collision detection
  0.1.0.5 20241014  update    - Add command `DaliSend [repeat]<address>,<command>`
                              - Add command `DaliQuery [repeat]<address>,<command>`
                              - Send frame twice (repeat) for DALI defined commands
                              - Add support for receiving backward frame
  0.1.0.4 20241013  update    - Fix intermittent bad send timing
  0.1.0.3 20241010  update    - Change DaliDimmer range from 0..254 to 0..100
                              - Add command `DaliWeb 0|1` to enable persistent Web light controls
  0.1.0.2 20241008  update    - Better receive error detection
  0.1.0.1 20241007  update    - To stablizie communication send DALI datagram twice like Busch-Jaeger does 
                              - Change DaliPower 0..2 to act like Tasmota Power (Off, On, Toggle)
                              - Keep last Dimmer value as default power on
  0.1.0.0 20241006  rewrite   - Add support for ESP8266 by Theo Arends
                              - Fix decoding of received DALI data
                              - Refactor command `DaliPower 0..254` controlling Broadcast devices
                              - Add command `DaliDimmer 0..254` controlling Broadcast devices
  0.0.0.1 20221027  publish   - Initial version by Andrei Kazmirtsuk aka eeak
\*********************************************************************************************/

#define XDRV_75                    75

#ifndef DALI_INIT_STATE
#define DALI_INIT_STATE            50      // DALI init dimmer state 50/254
#endif
#ifndef DALI_INIT_FADE 
#define DALI_INIT_FADE             1       // Fade between light states in number of seconds
#endif
#ifndef DALI_TIMEOUT
#define DALI_TIMEOUT               50      // DALI backward frame receive timeout (ms)
#endif

//#define DALI_LIGHT_COLOR_SUPPORT

//#define DALI_DEBUG
#ifndef DALI_DEBUG_PIN
#define DALI_DEBUG_PIN             4       // Debug GPIO
#endif

#include "include/xdrv_75_dali.h"

#define DALI_MAX_STORED            17      // Store broadcast and group states

#define DALI_TOPIC "DALI"
#define D_PRFX_DALI "Dali"

/*********************************************************************************************/

const char kDALICommands[] PROGMEM = D_PRFX_DALI "|"  // Prefix
  "|" D_CMND_POWER "|" D_CMND_DIMMER "|Target"
#ifdef USE_LIGHT
  "|Light"
#endif  // USE_LIGHT
  "|Send|Query|Scan|Group"
  "|GroupSliders|Gear";

void (* const DALICommand[])(void) PROGMEM = {
  &CmndDali, &CmndDaliPower, &CmndDaliDimmer, &CmndDaliTarget,
#ifdef USE_LIGHT
  &CmndDaliLight,
#endif  // USE_LIGHT
  &CmndDaliSend, &CmndDaliQuery, &CmndDaliScan, &CmndDaliGroup,
  &CmndDaliGroupSliders, &CmndDaliGear };

struct DALI {
  uint32_t bit_cycles;
  uint32_t last_activity;
  uint32_t received_dali_data;                 // Data received from DALI bus
  uint8_t pin_rx;
  uint8_t pin_tx;
  uint8_t max_short_address;
  uint8_t address;
  uint8_t command;
  uint8_t last_dimmer;
  uint8_t dimmer[DALI_MAX_STORED];
  uint8_t web_dimmer[DALI_MAX_STORED];
  uint8_t target;
  uint8_t target_rgbwaf;
  uint8_t device_type;
  bool allow_light;
  bool last_power;
  bool power[DALI_MAX_STORED];
  bool available;
  bool response;
  bool light_sync;
  bool probe;
  bool invert_rx;
  bool invert_tx;
} *Dali = nullptr;

/*********************************************************************************************\
 * DALI low level
\*********************************************************************************************/

uint32_t DaliKelvinToMirek(uint32_t kelvin) {
  if (kelvin < 16) {
    return 65535;
  }
  if (kelvin > 1000000) {
    return 0;
  }
  return 1000000 / kelvin;
}

uint32_t DaliMirekToKelvin(uint32_t mirek) {
  if (mirek <= 0) {
    return 1000001;
  }
  if (mirek >= 65535) {
    return 0;
  }
  return 1000000 / mirek;
}

/*-------------------------------------------------------------------------------------------*/

uint32_t DaliTarget2Address(uint32_t target) {
  // 1..64    = Short address
  // 101..116 = Group address
  // Others   = Broadcast
  if ((target >= 1) && (target <= 64)) {       // 1 .. 64
    return (target -1) << 1;                   // Short address: 0b00000000 .. 0b01111110
  }
  else if ((target >= 101) && (target <= 116)) {  // 101 .. 116
    return ((target -101) << 1) | 0x80;        // Group address: 0b10000000 .. 0b10011110
  }
  return DALI_BROADCAST_DP;                    // Broadcast address: 0b11111110
}

/*
uint32_t DaliAddress2Target(uint32_t adr) {
  if (adr >= 254) {                            // 0b1111111S
    return 0;                                  // Broadcast address (0)
  }
  else if ((adr >= 128) && (adr <= 159)) {     // 0b1000000S .. 0b1001111S
    return (adr >> 1) +101;                    // Group address (101 .. 116)
  }
  return (adr >> 1) +1;                        // 0b0000000S .. 0b0111111S Short address (1 .. 64)
}
*/

/*-------------------------------------------------------------------------------------------*/

uint32_t DaliSaveState(uint32_t adr, uint32_t cmd) {
  if (adr &0x01) { return 0; }                 // No address
  int index = -1;
  if (DALI_BROADCAST_DP == adr) {              // Broadcast address
    index = 0;
  }
  adr >>= 1;
  if ((adr >= 0x40) && (adr <= 0x4F)) {        // Group address 0 to 15
    index = adr -0x3F;
  }
  if (index >= 0) {
    Dali->last_power = Dali->power[index];
    Dali->power[index] = (cmd);                // State
    if (Dali->power[index]) {
      Dali->last_dimmer = Dali->dimmer[index];
      Dali->dimmer[index] = cmd;               // Value
    }
    if ((0 == index) && !Dali->power[0]) {     // Only on Broadcast change to power Off
      for (uint32_t i = 0; i < DALI_MAX_STORED; i++) {
        Dali->power[i] = false;                // Log all group power as Off when Broadcast is Off
      }
    }
  } else {
    index = 0;                                 // Use broadcast
  }
  return index;
}

/*-------------------------------------------------------------------------------------------*/

void DaliEnableRxInterrupt(void) {
  Dali->available = false;
  attachInterrupt(Dali->pin_rx, DaliReceiveData, (Dali->invert_rx) ? RISING : FALLING);
}

void DaliDisableRxInterrupt(void) {
  detachInterrupt(Dali->pin_rx);
}

/*-------------------------------------------------------------------------------------------*\
 * DALI receive
\*-------------------------------------------------------------------------------------------*/

void IRAM_ATTR DaliReceiveData(void);          // Fix ESP8266 ISR not in IRAM! exception
void DaliReceiveData(void) {
  /*
  Forward frame (1 Start bit + 16 data bits) * 2 bits/bit (manchester encoding) + 2 * 2 Stop bits = 38 bits
  DALI data 0xFE64       1 1 1 1 1 1 1 0 0 1 1 0 0 1 0 0       Forward frame
  Start and Stop bits  1                                 1 1
  Manchester data     0101010101010101101001011010011010
  Stop bits                                             1111                  

  Backward frame (1 Start bit + 8 data bits) * 2 bits/bit (manchester encoding) + 2 * 2 Stop bits = 22 bits
  DALI data 0x64         0 1 1 0 0 1 0 0                       Backward frame
  Start and Stop bits  1                 1 1
  Manchester data     011001011010011010
  Stop bits                             1111                  

  Bit number          01234567890123456789012345678901234567
                                1         2         3
  */
  if (Dali->available) { return; }             // Skip if last input is not yet handled
  uint32_t gap_time = millis() - Dali->last_activity;
  uint32_t wait = ESP.getCycleCount() + (Dali->bit_cycles / 2);
  int bit_state = 0; 
  bool dali_read;
  uint32_t received_dali_data = 0;
  uint32_t bit_number = 0;
  while (bit_number < 38) {
    while (ESP.getCycleCount() < wait);
    wait += Dali->bit_cycles;                  // Auto roll-over
    dali_read = (digitalRead(Dali->pin_rx) != Dali->invert_rx);
#ifdef DALI_DEBUG
    digitalWrite(DALI_DEBUG_PIN, bit_number&1);  // Add LogicAnalyzer poll indication
#endif  // DALI_DEBUG
    if (bit_number < 34) {                     // 34 manchester encoded bits
      bit_state += (dali_read) ? 1 : -1;
      if (0 == bit_state) {                    // Manchester encoding total 2 bits is always 0
        if (bit_number > 2) {                  // Skip start bit
          received_dali_data <<= 1;
          received_dali_data |= dali_read;
        }
      }
      else if ((2 == bit_state) &&
               (bit_number == 19)) {           // Possible backward frame detected - Chk stop bits
        bit_state = 0;
        bit_number = 35;
      }
      else if (abs(bit_state) > 1) {           // Invalid manchester data (too many 0 or 1)
        break;
      }
    } else {                                   // 4 high Stop bits
      if (bit_state != 0) {                    // Invalid manchester data
        break;
      }
      else if (dali_read != 1) {               // Invalid level of stop bit
        bit_state = 1;
        break;
      }
    }
    bit_number++;
  }
  Dali->last_activity = millis();

  if (bit_state != 0) {                        // Invalid Manchester encoding including start and stop bits               
    received_dali_data |= 0x00010000;          // Possible collision or invalid reply of repeated frame due to handling of first frame
    if (Dali->response) {                      // Expect backward frame with no collision
      AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("DLI: Rx collision"));
    }
  }
  if (Dali->probe) {
    AddLog(LOG_LEVEL_DEBUG, PSTR("DLI: Rx %05X %d"), received_dali_data, gap_time);
  } else {
    if (Dali->response ||                      // Response from last message send
       (Dali->received_dali_data != received_dali_data)) {  // Skip duplicates
      Dali->received_dali_data = received_dali_data;
      Dali->available = true;                  // Any data received
    }
  }
}

/*-------------------------------------------------------------------------------------------*\
 * DALI send
\*-------------------------------------------------------------------------------------------*/

void DaliSendDataOnce(uint16_t send_dali_data) {
  /*
  DALI protocol forward frame
  DALI data 0xFE64       1 1 1 1 1 1 1 0 0 1 1 0 0 1 0 0
  Start and Stop bits  1                                 1 1
  Manchester data     0101010101010101101001011010011010
  Stop bits                                             1111                  

  Bit number          01234567890123456789012345678901234567
                                1         2         3
  */
  Dali->last_activity += 14;                   // As suggested by DALI protocol (> 9.17 ms)
  while (!TimeReached(Dali->last_activity)) {
    delay(1);                                  // Wait for bus to be free if needed
  }
  bool bit_value;
  bool pin_value;
  bool dali_read;
  bool collision = false;
  uint32_t bit_pos = 15;
  uint32_t bit_number = 0;

#ifdef ESP32
  {portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
  portENTER_CRITICAL(&mux);
#endif

  uint32_t wait = ESP.getCycleCount();
  while (bit_number < 35) {                    // 417 * 35 = 14.7 ms
    if (!collision) {
      if (0 == (bit_number &1)) {              // Even bit
        //          Start bit,              Stop bit,                Data bits
        bit_value = (0 == bit_number) ? 1 : (34 == bit_number) ? 0 : (bool)((send_dali_data >> bit_pos--) &1);  // MSB first
      } else {                                 // Odd bit
        bit_value = !bit_value;                // Complement bit
      }
      pin_value = bit_value ? LOW : HIGH;      // Invert bit
    } else {
      if (34 == bit_number) {
        pin_value = HIGH;                      // Set to idle
      }
    }

    digitalWrite(Dali->pin_tx, (Dali->invert_tx) ? !pin_value : pin_value);
    wait += Dali->bit_cycles;                  // Auto roll-over
    while (ESP.getCycleCount() < wait);

    if (!collision) {
      dali_read = (digitalRead(Dali->pin_rx) != Dali->invert_rx);
      if ((HIGH == pin_value) && (LOW == dali_read)) {  // Collision if write is 1 and bus is 0
        collision = true;
        pin_value = LOW;
        bit_number = 29;                       // Keep bus low for 4 bits
        AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("DLI: Tx collision"));
      }
    }

    bit_number++;
  }

#ifdef ESP32
  portEXIT_CRITICAL(&mux);}
#endif

//  delayMicroseconds(1100);                     // Adds to total 15.8 ms
  Dali->last_activity = millis();
}

/*-------------------------------------------------------------------------------------------*/

void DaliSendData(uint32_t adr, uint32_t cmd) {
  adr &= 0xFF;
  cmd &= 0xFF;

  Dali->address = adr;
  Dali->command = cmd;
  DaliSaveState(adr, cmd);

  bool send_twice = false;
  if (adr &0x01) {                             // Selector bit (command) or special command
    if (DALI_102_ENABLE_DEVICE_TYPE_X == adr) {
      Dali->device_type = cmd;                 // Next command will be an extended command
    }
    uint32_t send_twice_extended_start;
    uint32_t send_twice_extended_end;
    if (4 == Dali->device_type) {
      send_twice_extended_start = DALI_205_REFERENCE_SYSTEM_POWER;
      send_twice_extended_end = DALI_205_RESERVED237;
    }
    else if (6 == Dali->device_type) {
      send_twice_extended_start = DALI_207_REFERENCE_SYSTEM_POWER;
      send_twice_extended_end = DALI_207_RESERVED236;
    }
    else if (8 == Dali->device_type) {
      send_twice_extended_start = DALI_209_SET_TEMPORARY_X_COORDINATE;
      send_twice_extended_end = DALI_209_START_AUTO_CALIBRATION;
    }
    if ((DALI_102_INITIALISE == adr) ||
        (DALI_102_RANDOMISE == adr) ||
        ((cmd >= DALI_102_RESET) && (cmd <= DALI_102_RESERVED143)) ||  // Configuration commands
        (Dali->device_type && (cmd >= send_twice_extended_start) && (cmd <= send_twice_extended_end))) {
      send_twice = true;
    }
  }

#ifdef DALI_DEBUG
  AddLog(LOG_LEVEL_DEBUG, PSTR("DLI: Tx DT%d, Twice %d, Adr 0x%02X, Cmd 0x%02X"), Dali->device_type, send_twice, adr, cmd);
#endif  // DALI_DEBUG

  uint16_t send_dali_data = adr << 8 | cmd;

  DaliDisableRxInterrupt();
  DaliSendDataOnce(send_dali_data);            // Takes 14.7 ms
  if (send_twice) {
    DaliSendDataOnce(send_dali_data);          // Takes 14.7 ms
  }
  delay(2);                                    // Block response
  DaliEnableRxInterrupt();

  if (Dali->device_type && (cmd >= 224) && (cmd <= 255)) {  // Extended commands
    Dali->device_type = 0;                     // Reset after execution of extended command
  }
}

/*-------------------------------------------------------------------------------------------*/

int DaliSendWaitResponse(uint32_t adr, uint32_t cmd, uint32_t timeout = DALI_TIMEOUT);
int DaliSendWaitResponse(uint32_t adr, uint32_t cmd, uint32_t timeout) {
  Dali->response = true;
  DaliSendData(adr, cmd);
  while (!Dali->available && timeout--) {      // Expect backward frame within DALI_TIMEOUT ms
    delay(1);
  };
  int result = -1;                             // DALI NO or no response
  if (Dali->available) {
    Dali->available = false;                   // DALI collision (-2) or valid data (>=0)
    result = (Dali->received_dali_data &0x00010000) ? -2 : Dali->received_dali_data;
  }
  Dali->response = false;

#ifdef DALI_DEBUG
  AddLog(LOG_LEVEL_DEBUG, PSTR("DLI: Rx 0x%05X"), result);
#endif  // DALI_DEBUG

  return result;
}

/*********************************************************************************************\
 * DALI tools
 * 
 * Courtesy of https://github.com/qqqlab/DALI-Lighting-Interface
\*********************************************************************************************/

bool DaliSetDTR(uint32_t dtr, uint32_t adr, uint32_t value) {
  uint8_t dtr_set[3] = { DALI_102_SET_DTR0, DALI_102_SET_DTR1, DALI_102_SET_DTR2 };
  uint8_t dtr_query[3] = { DALI_102_QUERY_CONTENT_DTR0, DALI_102_QUERY_CONTENT_DTR1, DALI_102_QUERY_CONTENT_DTR2 };

  if (dtr > 2) { dtr = 0; }
  DaliSendData(dtr_set[dtr], value);           // Store value in DTR
  int result = DaliSendWaitResponse(adr, dtr_query[dtr]);  // Get DTR value
  return (result == value);
}

bool DaliSetValue(uint32_t adr, uint32_t getcmd, uint32_t setcmd, uint32_t v) {
  // Set a parameter value, returns true on success
  int current_v = DaliSendWaitResponse(adr, getcmd);  // Get current parameter value
  if (current_v == v) { return true; }         // Already set
  if (!DaliSetDTR(0, adr, v)) { return false; }
  DaliSendData(adr, setcmd);                   // Set parameter value = DTR
  current_v = DaliSendWaitResponse(adr, getcmd);  // Get current parameter value
  if (current_v != v) { return false; }        // Set failed
  return true;
}

bool DaliSetOperatingMode(uint32_t adr, uint32_t v) {
  return DaliSetValue(adr, DALI_102_QUERY_OPERATING_MODE, DALI_102_SET_OPERATING_MODE, v);
}

bool DaliSetMaxLevel(uint32_t adr, uint32_t v) {
  return DaliSetValue(adr, DALI_102_QUERY_MAX_LEVEL, DALI_102_SET_MAX_LEVEL, v);
}

bool DaliSetMinLevel(uint32_t adr, uint32_t v) {
  return DaliSetValue(adr, DALI_102_QUERY_MIN_LEVEL, DALI_102_SET_MIN_LEVEL, v);
}

bool DaliSetSystemFailureLevel(uint32_t adr, uint32_t v) {
  return DaliSetValue(adr, DALI_102_QUERY_SYSTEM_FAILURE_LEVEL, DALI_102_SET_SYSTEM_FAILURE_LEVEL, v);
}

bool DaliSetPowerOnLevel(uint32_t adr, uint32_t v) {
  return DaliSetValue(adr, DALI_102_QUERY_POWER_ON_LEVEL, DALI_102_SET_POWER_ON_LEVEL, v);
}

int DaliQueryExtendedVersionNumber(uint32_t adr, uint32_t device_type) {
  DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, device_type);  // Enable Extended command
  return DaliSendWaitResponse(adr, 255);       // DALI_xxx_QUERY_EXTENDED_VERSION_NUMBER
}

#ifdef DALI_LIGHT_COLOR_SUPPORT
uint32_t DaliQueryRGBWAF(uint32_t adr) {
  uint32_t rgbwaf_channels = 0;
  if (DaliQueryExtendedVersionNumber(adr, 8) >= 0) {  // Colour device
    DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 8);  // Enable Extended command
    int result = DaliSendWaitResponse(adr, DALI_209_QUERY_COLOUR_TYPE_FEATURES);
    if (result >= 0) { 
      rgbwaf_channels = (result >> 5) & 0x07;  // RGBWAF channels in bits 5..7
    }
  }
  return rgbwaf_channels;
}
#endif  // DALI_LIGHT_COLOR_SUPPORT

/*-------------------------------------------------------------------------------------------*/

uint32_t DaliGearPresent(void) {
  uint32_t count = 0;
  for (uint32_t sa = 0; sa < Dali->max_short_address; sa++) {  // Scanning 64 addresses takes about 2500 ms
    if (DaliSendWaitResponse(sa << 1 | 1, DALI_102_QUERY_CONTROL_GEAR_PRESENT, 20) >= 0) {
      count++;
    }
  }
  return count;
}

/*-------------------------------------------------------------------------------------------*/

void DaliInitLight(void) {
  // Taken from Shelly Dali Dimmer ;-)
  DaliSendData(DALI_102_SET_DTR0, DALI_INIT_FADE);  // Fade x second
  DaliSendData(0xFF, DALI_102_SET_FADE_TIME);
  DaliSendData(DALI_102_SET_DTR0, 0);          // Power off after gear power restore
  DaliSendData(0xFF, DALI_102_SET_POWER_ON_LEVEL);
  DaliSendData(DALI_102_SET_DTR0, 0xFE);       // Reset all but short circuit
  DaliSendData(0xFF, DALI_102_SET_SYSTEM_FAILURE_LEVEL);
}

/*********************************************************************************************\
 * DALI commissioning short addresses
 * 
 * Courtesy of https://github.com/qqqlab/DALI-Lighting-Interface
\*********************************************************************************************/

void DaliSetSearchAddress(uint32_t adr) {
  // Set search address
  DaliSendData(DALI_102_SEARCHADDRH, adr>>16);
  DaliSendData(DALI_102_SEARCHADDRM, adr>>8);
  DaliSendData(DALI_102_SEARCHADDRL, adr);
}

/*-------------------------------------------------------------------------------------------*/

void DaliSetSearchAddressDifference(uint32_t adr_new, uint32_t adr_current) {
  // Set search address, but set only changed bytes (takes less time)
  if ( (uint8_t)(adr_new>>16) !=  (uint8_t)(adr_current>>16) ) DaliSendData(DALI_102_SEARCHADDRH, adr_new>>16);
  if ( (uint8_t)(adr_new>>8)  !=  (uint8_t)(adr_current>>8)  ) DaliSendData(DALI_102_SEARCHADDRM, adr_new>>8);
  if ( (uint8_t)(adr_new)     !=  (uint8_t)(adr_current)     ) DaliSendData(DALI_102_SEARCHADDRL, adr_new);
}

/*-------------------------------------------------------------------------------------------*/

bool DaliCompare() {
  // Is the random address smaller or equal to the search address?
  // As more than one device can reply, the reply gets garbled
  uint8_t retry = 2;
  while (retry > 0) {
    // Compare is true if we received any activity on the bus as reply.
    // Sometimes the reply is not registered... so only accept retry times 'no reply' as a real false compare
    int rv = DaliSendWaitResponse(DALI_102_COMPARE, 0x00);
    if (rv == 0xFF) return true;               // Yes reply
    if (rv == -2) return true;                 // Reply but collision
    retry--;
  }
  return false;
}

/*-------------------------------------------------------------------------------------------*/

uint32_t DaliFindAddress(void) {
  // Find addr with binary search
  uint32_t adr = 0x800000;
  uint32_t addsub = 0x400000;
  uint32_t adr_last = adr;
  DaliSetSearchAddress(adr);
  
  while (addsub) {
    DaliSetSearchAddressDifference(adr, adr_last);
    adr_last = adr;
    if (DaliCompare()) {                       // Returns true if searchadr > adr
      adr -= addsub;
    } else {
      adr += addsub;
    }
    addsub >>= 1;
  }
  DaliSetSearchAddressDifference(adr, adr_last);
  adr_last = adr;
  if (!DaliCompare()) {
    adr++;
    DaliSetSearchAddressDifference(adr, adr_last);
  }
  return adr;
}

/*-------------------------------------------------------------------------------------------*/

void DaliProgramShortAddress(uint8_t shortadr) {
  // The slave shall store the received 6-bit address (AAAAAA) as a short address if it is selected.
  DaliSendData(DALI_102_PROGRAM_SHORT_ADDRESS, (shortadr << 1) | 0x01);

  AddLog(LOG_LEVEL_INFO, PSTR("DLI: Set short address %d"), shortadr +1);
}

/*-------------------------------------------------------------------------------------------*/

uint32_t DaliCommission(uint8_t init_arg) {
  // Based on Shelly DALI Dimmer Gen3 received frames
  // init_arg=11111111 : all without short address
  // init_arg=00000000 : all 
  // init_arg=0AAAAAA1 : only for this shortadr
  // returns number of new short addresses assigned
  DaliSendData(0xFF, DALI_102_RESET);          // Turns ON all lights
  uint8_t arr[64];
  uint32_t sa;
  for (sa = 0; sa < 64; sa++) {
    arr[sa] = 0;
  }
  delay(450);                                  // It is not guaranteed that any commands will be received properly within the next 300ms
  DaliSendData(DALI_102_SET_DTR0, 0xFF);
  DaliSendData(0xFF, DALI_102_SET_SHORT_ADDRESS);
  DaliSendData(DALI_102_TERMINATE, 0x00);      // Terminate the DALI_102_INITIALISE command
  delay(15);
  // Start commissioning
  DaliSendData(DALI_102_INITIALISE, init_arg);
  DaliSendData(DALI_102_RANDOMISE, 0x00);
  delay(100);                                  // The new random address shall be available within a time period of 100ms.

  uint32_t cnt = 0;
  while (true) {                               // Find random addresses and assign unused short addresses
    uint32_t adr = DaliFindAddress();
    if (adr > 0xffffff) { break; }             // No more random addresses found -> exit
    for (sa = 0; sa < 64; sa++) {              // Find first unused short address
      if (0 == arr[sa]) { break; }
    }
    if (sa >= 64) { break; }                   // All 64 short addresses assigned -> exit
    arr[sa] = 1;                               // Mark short address as used
    cnt++;
 
    DaliProgramShortAddress(sa);               // Assign short address
    DaliSendData(DALI_102_WITHDRAW, 0x00);     // Remove the device from the search
    DaliSendData(sa << 1, DALI_102_OFF);       // Turns OFF latest short address light

    delay(1);
    OsWatchLoop();                             // Feed blocked-loop watchdog
  }

  delay(100);
  DaliSendData(DALI_102_TERMINATE, 0x00);      // Terminate the DALI_102_INITIALISE command

  uint32_t address = DALI_BROADCAST_DP;
#ifdef USE_LIGHT
  DaliInitLight();
  if (Settings->sbflag1.dali_light) {          // DaliLight 1
    address = DaliTarget2Address(Dali->target);
  }
#endif  // USE_LIGHT
  DaliSendData(address, Dali->power[0]);       // Restore lights
  return cnt;
}

/*********************************************************************************************/

void ResponseAppendDali(uint32_t index) {
  char number[12];
  uint8_t dimmer = changeUIntScale(Dali->dimmer[index], 0, 254, 0, 100);
  ResponseAppend_P(PSTR("\"DALI\":{\"Power%s\":\"%s\",\"Dimmer%s\":%d,\"Address\":%d,\"Command\":%d}"), 
    (0==index)?"":itoa(index+100, number, 10), GetStateText(Dali->power[index]),
    (0==index)?"":itoa(index+100, number, 10), dimmer,
    Dali->address, Dali->command);
}

void ResponseDali(uint32_t index) {
  Response_P(PSTR("{"));
  ResponseAppendDali(index);
  ResponseJsonEnd();
}

/*-------------------------------------------------------------------------------------------*/

void DaliLoop(void) {
  if (!Dali->available || Dali->response) { return; }

  AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("DLI: Rx 0x%05X"), Dali->received_dali_data);

  if (Dali->received_dali_data &0x00010000) { 
    Dali->available = false;
    return;                                    // Rx collision
  }

  Dali->address = Dali->received_dali_data >> 8;
  Dali->command = Dali->received_dali_data;
  uint32_t index = DaliSaveState(Dali->address, Dali->command);  // Update dimmer and power

  bool show_response = true;
#ifdef USE_LIGHT
  if (Dali->allow_light && (DaliTarget2Address(Dali->target) == Dali->address)) {
    if (Settings->sbflag1.dali_light) {        // DaliLight 1
      uint8_t dim_old = changeUIntScale(Dali->last_dimmer, 0, 254, 0, 100);
      uint8_t dim_new = changeUIntScale(Dali->dimmer[index], 0, 254, 0, 100);
      if (Dali->last_power != Dali->power[index]) {
        Dali->light_sync = true;               // Block local loop
        ExecuteCommandPower(LightDevice(), Dali->power[index], SRC_SWITCH);
      }
      else if (dim_old != dim_new) {
        char scmnd[20];
        snprintf_P(scmnd, sizeof(scmnd), PSTR(D_CMND_DIMMER " %d"), dim_new);
        Dali->light_sync = true;               // Block local loop
        ExecuteCommand(scmnd, SRC_SWITCH);
      }
      show_response = false;
    }
  }
#endif  // USE_LIGHT
  if (show_response) {
    ResponseDali(index);
    MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, PSTR(D_PRFX_DALI));
  }

  Dali->available = false;
}

/*-------------------------------------------------------------------------------------------*/

void DaliEverySecond(void) {
  if (5 == TasmotaGlobal.uptime) {
    DaliInitLight();
  }
}

/*-------------------------------------------------------------------------------------------*/

#ifdef USE_LIGHT
bool DaliSetChannels(void) {
  if (Settings->sbflag1.dali_light) {          // DaliLight 1
    Settings->light_fade = 0;                  // Use Dali fading
    Settings->light_correction = 0;            // Use Dali light correction
    if (Dali->light_sync) {                    // Block local loop
      Dali->light_sync = false;
    } else {
      uint8_t *cur_col = (uint8_t*)XdrvMailbox.data;
      // cur_col[0] = Red, cur_col[1] = Green, cur_col[2] = Blue, cur_col[3] = Warm = Amber, cur_col[4] = Cold = White
      for (uint32_t i = 0; i < 5; i++) {
        if (255 == cur_col[i]) { cur_col[1] = 254; }  // Max Dali value
      }
      uint32_t adr = DaliTarget2Address(Dali->target);

#ifdef DALI_LIGHT_COLOR_SUPPORT
      if (Dali->target_rgbwaf > 0) {           // Colour control
        if (!DaliSetDTR(0, adr, 0x7F)) { return true; }  // Linked Channel control
        DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 8);  // Enable Extended command
        DaliSendData(adr, DALI_209_SET_TEMPORARY_RGBWAF_CONTROL);

        if (!DaliSetDTR(0, adr, cur_col[0])) { return true; }  // DALI Red
        if (!DaliSetDTR(1, adr, cur_col[1])) { return true; }  // DALI Green
        if (!DaliSetDTR(2, adr, cur_col[2])) { return true; }  // DALI Blue
        DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 8);  // Enable Extended command
        DaliSendData(adr, DALI_209_SET_TEMPORARY_RGB_DIMLEVEL);

        if (Dali->target_rgbwaf > 3) {
          if (!DaliSetDTR(0, adr, cur_col[4])) { return true; }  // DALI While
          if (!DaliSetDTR(1, adr, cur_col[3])) { return true; }  // DALI Amber
          if (!DaliSetDTR(2, adr, 255)) { return true; }         // DALI Freecolour - no change
          DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 8);  // Enable Extended command
          DaliSendData(adr, DALI_209_SET_TEMPORARY_WAF_DIMLEVEL);
        }

        DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 8);  // Enable Extended command
        DaliSendData(adr, DALI_209_ACTIVATE);
        return true;
      }
#endif  // DALI_LIGHT_COLOR_SUPPORT

      DaliSendData(adr, cur_col[0]);           // DAPC command - dim level
    }
  }
  return true;
}
#endif  // USE_LIGHT

/*-------------------------------------------------------------------------------------------*/

bool DaliInit(uint32_t function) {
  int pin_tx = -1;
  bool invert_tx = false;
  if (PinUsed(GPIO_DALI_TX)) {
    pin_tx = Pin(GPIO_DALI_TX);
  }
  else if (PinUsed(GPIO_DALI_TX_INV)) {
    pin_tx = Pin(GPIO_DALI_TX_INV);
    invert_tx = true;
  }
  int pin_rx = -1;
  bool invert_rx = false;
  if (PinUsed(GPIO_DALI_RX)) {
    pin_rx = Pin(GPIO_DALI_RX);
  }
  else if (PinUsed(GPIO_DALI_RX_INV)) {
    pin_rx = Pin(GPIO_DALI_RX_INV);
    invert_rx = true;
  }
  if ((-1 == pin_tx) || (-1 == pin_rx)) { return false; }

  Dali = (DALI*)calloc(sizeof(DALI), 1);    // Need calloc to reset registers to 0/false
  if (!Dali) { return false; }

  Dali->pin_tx = pin_tx;
  Dali->invert_tx = invert_tx;
  Dali->pin_rx = pin_rx;
  Dali->invert_rx = invert_rx;

  Dali->allow_light = (FUNC_MODULE_INIT == function);  // Light control is possible

  AddLog(LOG_LEVEL_INFO, PSTR("DLI: GPIO%d(RX%s) and GPIO%d(TX%s)%s"),
    Dali->pin_rx, (Dali->invert_rx)?"i":"", Dali->pin_tx, (Dali->invert_tx)?"i":"", (Dali->allow_light)?" as light":"");

  pinMode(Dali->pin_tx, OUTPUT);
  digitalWrite(Dali->pin_tx, (Dali->invert_tx) ? LOW : HIGH);  // Idle
  pinMode(Dali->pin_rx, INPUT);
#ifdef DALI_DEBUG
  pinMode(DALI_DEBUG_PIN, OUTPUT);
  digitalWrite(DALI_DEBUG_PIN, HIGH);
#endif  // DALI_DEBUG

  Dali->max_short_address = 64;
  for (uint32_t i = 0; i < DALI_MAX_STORED; i++) {
    Dali->dimmer[i] = DALI_INIT_STATE;
  }

  // Manchester twice 1200 bps = 2400 bps = 417 (protocol 416.76 +/- 10%) us
  Dali->bit_cycles = ESP.getCpuFreqMHz() * 1000000 / 2400;

  DaliEnableRxInterrupt();

  if (!Dali->allow_light) {
    Settings->sbflag1.dali_light = false;      // No light control possible
  }
#ifdef USE_LIGHT
  if (!Settings->sbflag1.dali_light) {         // DaliLight 0
    return false;
  }

  Settings->light_fade = 0;                    // Use Dali fading instead
  Settings->light_correction = 0;              // Use Dali light correction
  UpdateDevicesPresent(1);
  TasmotaGlobal.light_type = LT_SERIAL1;       // Single channel

#ifdef DALI_LIGHT_COLOR_SUPPORT
  Dali->target_rgbwaf = DaliQueryRGBWAF(DaliTarget2Address(Dali->target));
  if (Dali->target_rgbwaf > 0) {
    TasmotaGlobal.light_type = LT_RGB;         // RGB channel (TBD)
  }
#endif  // DALI_LIGHT_COLOR_SUPPORT

  return true;
#else
  return false;
#endif  // USE_LIGHT
}

/*********************************************************************************************\
 * Commands
\*********************************************************************************************/

bool DaliJsonParse(void) {
  // {"addr":254,"cmd":100}
  // {"addr":2}
  // {"dim":3}

  bool served = false;
  JsonParser parser((char *)XdrvMailbox.data);
  JsonParserObject root = parser.getRootObject();
  if (root) {
    int DALIindex = 0;
    int ADRindex = 0;
    int8_t DALIdim = -1;
    uint32_t DALIaddr = DALI_BROADCAST_DP;

    JsonParserToken val = root[PSTR("cmd")];
    if (val) {
      uint32_t cmd = val.getUInt();
      val = root[PSTR("addr")];
      if (val) {
        uint32_t addr = val.getUInt();
        AddLog(LOG_LEVEL_DEBUG, PSTR("DLI: cmd = %d, addr = %d"), cmd, addr);
        DaliSendData(addr, cmd);
        return true;
      } else {
        return false;
      }
    }
    val = root[PSTR("addr")];
    if (val) {
      uint32_t addr = val.getUInt();
      if ((addr >= 0) && (addr < 64)) {
        DALIaddr = addr  << 1;
      }
    }
    val = root[PSTR("dim")];
    if (val) {
      uint8_t dim = val.getUInt();
      if (dim < 255) {
        DALIdim = dim;
      }
    }
    DaliSendData(DALIaddr, DALIdim);
    served = true;
  }
  return served;
}

/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

void CmndDali(void) {
  // Dali {"addr":254,"cmd":100} - Any address and/or command
  // Dali 0|1                    - Enable DALI receive probe
  if (XdrvMailbox.data_len > 0) {
    if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload <= 1)) {
      Dali->probe = XdrvMailbox.payload;
      ResponseCmndNumber(Dali->probe);
      return;
    }
    DaliJsonParse();
  }
  ResponseDali(0);
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliTarget(void) {
  // DaliTarget          - Set transmit target
  // DaliTarget 0        - Set target to broadcast address
  // DaliTarget 1..64    - Set target to short address
  // DaliTarget 101..116 - Set target to group address
  if (((XdrvMailbox.payload >= 1) && (XdrvMailbox.payload <= 64)) ||
      ((XdrvMailbox.payload >= 101) && (XdrvMailbox.payload <= 116)) ||
      (XdrvMailbox.payload == 0)) {
    Dali->target = XdrvMailbox.payload;
  }
#ifdef DALI_LIGHT_COLOR_SUPPORT
  Dali->target_rgbwaf = DaliQueryRGBWAF(DaliTarget2Address(Dali->target));
#endif  // DALI_LIGHT_COLOR_SUPPORT
  ResponseCmndNumber(Dali->target);
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliPower(void) {
  // DaliPower 0       - Broadcast power off
  // DaliPower 1       - Broadcast power on to last dimmer state
  // DaliPower 2       - Broadcast toggle power off or last dimmer state
  // DaliPower 3..254  - Broadcast equals DaliDimmer command
  // DaliPower 0..254  - Broadcast control
  // DaliPower0 0..254 - Broadcast control (= DaliPower)
  // DaliPower1 0..254 - Short address 0 control
  // DaliPower3 0..254 - Short address 2 control
  uint32_t index = 0;                          // Broadcast
  if ((XdrvMailbox.index >= 101) && (XdrvMailbox.index <= 116)) {
    index = XdrvMailbox.index - 100;           // Group1 to 16
  }
  if (((XdrvMailbox.index >= 0) && (XdrvMailbox.index <= 64)) ||
      ((XdrvMailbox.index >= 101) && (XdrvMailbox.index <= 116))) {
    if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload <= 254)) {
      if (XdrvMailbox.payload <= 2) {
        if (2 == XdrvMailbox.payload) {
          XdrvMailbox.payload = (Dali->power[index]) ? 0 : 1;
        }
        if (1 == XdrvMailbox.payload) {
          XdrvMailbox.payload = Dali->dimmer[index];
        }
      }
      DaliSendData(DaliTarget2Address(XdrvMailbox.index), XdrvMailbox.payload);
    }
  }
  ResponseDali(index);
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliDimmer(void) {
  // DaliDimmer 0..100  - Broadcast set power off or dimmer state
  // DaliDimmer0 0..100 - Broadcast set power off or dimmer state
  // DaliDimmer1 0..100 - Short address 0 set power off or dimmer state
  // DaliDimmer3 0..100 - Short address 2 set power off or dimmer state
  uint32_t index = 0;                          // Broadcast
  if ((XdrvMailbox.index >= 101) && (XdrvMailbox.index <= 116)) {
    index = XdrvMailbox.index - 100;           // Group1 to 16
  }
  if (((XdrvMailbox.index >= 0) && (XdrvMailbox.index <= 64)) ||
      ((XdrvMailbox.index >= 101) && (XdrvMailbox.index <= 116))) {
    if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload <= 100)) {
      uint8_t dimmer = changeUIntScale(XdrvMailbox.payload, 0, 100, 0, 254);
      DaliSendData(DaliTarget2Address(XdrvMailbox.index), dimmer);
    }
  }
  ResponseDali(index);
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliGroup(void) {
  // DaliGroup1 1,2   - Add device 1 and 2 to group 1
  // DaliGroup1 -1,2  - Remove device 1 and 2 to group 1
  if ((XdrvMailbox.index >= 1) && (XdrvMailbox.index <= 16)) {
    uint32_t group = XdrvMailbox.index -1;
    bool more = false;
    char temp[200] = { 0 };
    if (XdrvMailbox.data_len) {
      uint32_t command = DALI_102_ADD_TO_GROUP0;
      temp[0] = '+';
      if ('+' == XdrvMailbox.data[0]) {        // Add devices
        XdrvMailbox.data++;
        XdrvMailbox.data_len--;
      }
      else if ('-' == XdrvMailbox.data[0]) {   // Remove devices
        command = DALI_102_REMOVE_FROM_GROUP0;
        XdrvMailbox.data++;
        XdrvMailbox.data_len--;
        temp[0] = '-';
      }
      uint32_t argc = ArgC();                  // Number of devices
      if (argc) {
        command |= group;
        uint32_t sas[argc];
        ParseParameters(argc, sas);
        for (uint32_t arg = 0; arg < argc; arg++) {
          uint32_t sa = sas[arg] -1;
          if (sa < 64) {
            snprintf_P(temp, sizeof(temp), PSTR("%s%s%d"), temp, (more)?",":"", sa +1);
            more = true;
            DaliSendData(sa << 1 | 1, command);
          }
        }
        ResponseCmndIdxChar(temp);
      }
    } else {
      uint32_t command = DALI_102_QUERY_GROUPS_0_7;
      uint32_t bitmask = 1 << group;
      if (group > 7) {
        command = DALI_102_QUERY_GROUPS_8_15;
        bitmask = 1 << group - 8;
      }
      for (uint32_t sa = 0; sa < Dali->max_short_address; sa++) {   // Scanning 64 addresses takes about 2500 ms
        int result = DaliSendWaitResponse(sa << 1 | 1, command, 20);
        if ((result >= 0) && (result & bitmask)) {
          snprintf_P(temp, sizeof(temp), PSTR("%s%s%d"), temp, (more)?",":"", sa +1);
          more = true;
        }
      }
      if (!strlen(temp)) {
        snprintf_P(temp, sizeof(temp), PSTR("None"));
      }
      ResponseCmndIdxChar(temp);
    }
  }
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliGear(void) {
  if ((XdrvMailbox.payload >= 1) && (XdrvMailbox.payload <= 64)) {
    Dali->max_short_address = XdrvMailbox.payload;
  }
  uint32_t count = DaliGearPresent();
  ResponseCmnd();
  ResponseAppend_P(PSTR("%d,\"Present\":%d}"), Dali->max_short_address, count);
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliSend(void) {
  // Send command
  // DaliSend 0xa5,255           - DALI Initialise
  // DaliSend 6,3,0xe2           - DALI DT6 (6) for address 1 (3) extended command disable current protector (0xe2) 
  // DaliSend 0x01,0xa3,0x2d,254 - Set Power On level (0x2d) for address 0 (0x01) to 254 only if Read Power On level (0xa3) is different

  uint32_t values[5] = { 0 };
  uint32_t params = ParseParameters(5, values);

#ifdef DALI_DEBUG
  AddLog(LOG_LEVEL_DEBUG, PSTR("DLI: index %d, params %d, values %d,%d,%d,%d,%d"), XdrvMailbox.index, params, values[0], values[1], values[2], values[3], values[4]);
#endif  // DALI_DEBUG

  if (6 == XdrvMailbox.index) {  // DaliSend6 - DT6 = 207 = Extended LED commands 224...236
    /*
    params    0                                               1                                2
    DaliSend6 <broadcast>|<device>|<group> |<special_command>,<command>|<special_command_data>,<dtr0_data>
              254         0..126   128..158 160..251          0..255    0..255                 0..255
    DaliSend6 <broadcast>|<device>|<group>,<command>
    */
    if ((params >= 2) && (values[1] >= 224) && (values[1] <= 255)) {  // DT6 extended command
      if ((DALI_207_SELECT_DIMMING_CURVE == values[1]) ||
          (DALI_207_SET_FAST_FADE_TIME == values[1])) {
        // DaliSend6 <broadcast>|<device>|<group>,<command>,<dtr0>
        if (!DaliSetDTR(0, values[0], values[2])) { return; }
      }
      DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 6);  // Enable Extended command
      DaliSendData(values[0], values[1]);
      ResponseCmndDone();
      return;
    }
  }
  if (8 == XdrvMailbox.index) {  // DaliSend8 - DT8 = 209 = Extended colour commands 224...246
    /*
    params    0                                               1                                2                                     3                       4
    DaliSend8 <broadcast>|<device>|<group> |<special_command>,<command>|<special_command_data>,<dtr0_data>|<dtr0_1_data>|<dtr2_data>,<dtr1_data>|<dtr2_data>,<dtr2_data>
              254         0..126   128..158 160..251          0..255    0..255                 0..255      0..65535      0..255      0..255      0..255      0..255
    DaliSend8 <special_command>,<special_command_data>
    DaliSend8 <broadcast>|<device>|<group>,<command>
    */
    if ((params >= 2) && (values[1] >= 224) && (values[1] <= 255)) {  // DT8 extended command
      // params == 3
      if ((DALI_209_SET_TEMPORARY_RGBWAF_CONTROL == values[1]) ||
          (DALI_209_STORE_GEAR_FEATURES_STATUS == values[1]) ||
          (DALI_209_ASSIGN_COLOUR_TO_LINKED_COMMAND == values[1])) {
        // DaliSend8 <broadcast>|<device>|<group>,<command>,<dtr0_data>
        if (!DaliSetDTR(0, values[0], values[2])) { return; }
      }
      else if ((DALI_209_SET_TEMPORARY_X_COORDINATE == values[1]) ||
               (DALI_209_SET_TEMPORARY_Y_COORDINATE == values[1]) ||
               (DALI_209_SET_TEMPORARY_COLOUR_TEMP_TC == values[1])) {
        // DaliSend8 <broadcast>|<device>|<group>,<command>,<dtr0_1_data>
        if (!DaliSetDTR(0, values[0], values[2] % 256)) { return; }
        if (!DaliSetDTR(1, values[0], values[2] / 256)) { return; }
      }
      else if (DALI_209_STORE_XY_COORDINATE_PRIMARY_N == values[1]) {
        // DaliSend8 <broadcast>|<device>|<group>,<command>,<dtr2_data>
        if (!DaliSetDTR(2, values[0], values[2])) { return; }
      }
      // params == 4
      else if ((DALI_209_SET_TEMPORARY_PRIMARY_N_DIMLEVEL == values[1]) ||
               (DALI_209_STORE_TY_PRIMARY_N == values[1]) ||
               (DALI_209_STORE_COLOUR_TEMP_TC_LIMIT == values[1])) {
        // DaliSend8 <broadcast>|<device>|<group>,<command>,<dtr0_1_data>,<dtr2_data>
        if (!DaliSetDTR(0, values[0], values[2] % 256)) { return; }
        if (!DaliSetDTR(1, values[0], values[2] / 256)) { return; }
        if (!DaliSetDTR(2, values[0], values[3])) { return; }
      }    
      // params == 5
      else if ((DALI_209_SET_TEMPORARY_RGB_DIMLEVEL == values[1]) ||
               (DALI_209_SET_TEMPORARY_WAF_DIMLEVEL == values[1])) {
        // DaliSend8 <broadcast>|<device>|<group>,<command>,<dtr0_data>,<dtr1_data>,<dtr2_data>
        if (!DaliSetDTR(0, values[0], values[2])) { return; }
        if (!DaliSetDTR(1, values[0], values[3])) { return; }
        if (!DaliSetDTR(2, values[0], values[4])) { return; }
      }
      DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 8);  // Enable Extended command
      DaliSendData(values[0], values[1]);
      ResponseCmndDone();
      return;
    }
  }
  /*
  params    0     1                                               2                                3             4
  DaliSend [<dt>,]<broadcast>|<device>|<group> |<special_command>,<command>|<special_command_data>,<dtr0_1_data>,<dtr2_data>
            6,8   254         0..126   128..158 160..251          0..255    0..255                 0..255/65535  0..255
  DaliSend <special_command>,<special_command_data>
  DaliSend <broadcast>|<device>|<group>,<command>
  DaliSend <broadcast>|<device>|<group>,<command>,<dtr0>
  */
  if (2 == params) {                                 // Prepare for default Extended command DT6 - LEDs
    if ((values[1] >= 224) && (values[1] <= 255)) {  // Extended command
      values[2] = values[1];
      values[1] = values[0];
      values[0] = 6;                                 // Default to DT6 - LEDs
      params = 3;
    }
  }
  if (3 == params) {                                 // Set extended command mode
    DaliSendWaitResponse(DALI_102_ENABLE_DEVICE_TYPE_X, values[0] &0xFF);  // Enable Extended command
    values[0] = values[1];
    values[1] = values[2];
    params = 2;
  }
  if (2 == params) {
    DaliSendData(values[0], values[1]);
    ResponseCmndDone();
  }
  else if (4 == params) {
    if (DaliSetValue(values[0] &0x1FF, values[1] &0xFF, values[2] &0xFF, values[3] &0xFF)) {
      ResponseCmndDone();
    } else {
      ResponseCmndFailed();
    }
  }
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliQuery(void) {
  // Send command and return response or -1 (no response within DALI_TIMEOUT)
  // DaliQuery 0xff,0x90 - DALI Query status
  // DaliQuery 0xff,144  - DALI Query status
  // DaliQuery 6,7,237   - DALI DT6 (6) for address 3 (7) extended command query status (237)
  uint32_t values[3] = { 0 };
  uint32_t params = ParseParameters(3, values);

  if (6 == XdrvMailbox.index) {  // DaliQuery6 - DT6 = 207 = Extended LED commands 224...236
    if ((params >= 2) && (values[1] >= 224) && (values[1] <= 255)) {  // DT6 extended command
      DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 6);  // Enable Extended command
      int result = DaliSendWaitResponse(values[0], values[1]);
      ResponseCmndNumber(result);
      return;
    }
  }
  if (8 == XdrvMailbox.index) {  // DaliQuery8 - DT8 = 209 = Extended colour commands 224...246
    if ((params >= 2) && (values[1] >= 224) && (values[1] <= 255)) {  // DT8 extended command
      if (DALI_209_QUERY_COLOUR_VALUE == values[1]) {
        if (!DaliSetDTR(0, values[0], values[2])) { return; }
      }
      DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, 8);  // Enable Extended command
      int result = DaliSendWaitResponse(values[0], values[1]);
      if (DALI_209_QUERY_COLOUR_VALUE == values[1]) {
        if (result >= 0) {
          uint32_t result2 = result << 8;
          int result = DaliSendWaitResponse(values[0], DALI_102_QUERY_CONTENT_DTR0);
          if (result >= 0) { 
            result = result2 | result;
          }
        }
      }
      ResponseCmndNumber(result);
      return;
    }
  }
  if (2 == params) {
    if ((values[1] >= 224) && (values[1] <= 255)) {  // Extended command
      values[2] = values[1];
      values[1] = values[0];
      values[0] = 6;                                 // Default to DT6 - LEDs
      params = 3;
    }
  }
  if (3 == params) {
//    DaliSendWaitResponse(DALI_102_ENABLE_DEVICE_TYPE_X, values[0] &0xFF);  // Enable Extended command
    DaliSendData(DALI_102_ENABLE_DEVICE_TYPE_X, values[0]);  // Enable Extended command
    values[0] = values[1];
    values[1] = values[2];
    params = 2;
  }
  if (2 == params) {
    int result = DaliSendWaitResponse(values[0] &0x1FF, values[1] &0xFF);
    ResponseCmndNumber(result);
  }
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliScan(void) {
  // Scan short addresses
  // DaliScan 1     - Reset and commission short addresses
  // DaliScan 2     - Commission unassigned short addresses
  if ((XdrvMailbox.payload >= 1) && (XdrvMailbox.payload <= 2)) {
    uint32_t init_arg = 0x00;                  // Commission all
    if (2 == XdrvMailbox.payload) {
      init_arg = 0xFF;                         // Commission all without short addresses
    }
    int result = DaliCommission(init_arg);
    ResponseCmndNumber(result);
  }
}

/*-------------------------------------------------------------------------------------------*/

void CmndDaliGroupSliders(void) {
  // DaliGroupSliders 0..16  - Add group sliders
  if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload <= 16)) {
    Settings->mbflag2.dali_group_sliders = XdrvMailbox.payload;
    TasmotaGlobal.restart_flag = 2;            // Restart to update GUI
  }
  ResponseCmndNumber(Settings->mbflag2.dali_group_sliders);
}

#ifdef USE_LIGHT
/*-------------------------------------------------------------------------------------------*/

void CmndDaliLight(void) {
  // DaliLight 0  - Disable light controls
  // DaliLight 1  - Enable light controls
  if (Dali->allow_light && (XdrvMailbox.data_len > 0)) {
    Settings->sbflag1.dali_light = XdrvMailbox.payload &1;  // DaliLight 0/1
    TasmotaGlobal.restart_flag = 2;            // Restart to update GUI
  }
  ResponseCmndStateText(Settings->sbflag1.dali_light);  // DaliLight 0/1
}
#endif  // USE_LIGHT

/*********************************************************************************************\
 * Presentation
\*********************************************************************************************/

#ifdef USE_WEBSERVER
const char HTTP_MSG_SLIDER_DALI[] PROGMEM =
  "<tr>"
  "<td style='width:15%%'><button id='k75%d' style='background:#%06x;' onclick='la(\"&k75=%d\");'>%s%s</button></td>"
  "<td style='width:85%%'><div class='r' style='background-image:linear-gradient(to right,#000,#FFF);'>"
  "<input id='i75%d' type='range' min='1' max='100' value='%d' onchange='lc(\"i\",75%d,value)'></div></td>"
  "</tr>";

void DaliWebAddMainSlider(void) {
  WSContentSend_P(HTTP_TABLE100);
  char number[12];
  for (uint32_t i = Settings->sbflag1.dali_light; i <= Settings->mbflag2.dali_group_sliders; i++) {  // DaliLight 0/1, DaliGroupSliders
    Dali->web_dimmer[i] = Dali->dimmer[i];
    WSContentSend_P(HTTP_MSG_SLIDER_DALI,      // Brightness - Black to White
      i,                                       // k75<i>
      WebColor((Dali->power[i]) ? COL_BUTTON : COL_BUTTON_OFF),
      i,                                       // k75=<i>
      (0==i)?"B":"G",                          // B (Broadcast) or G1 to G16 (Group)
      (0==i)?"":itoa(i, number, 10),
      i,                                       // i75<i>
      changeUIntScale(Dali->web_dimmer[i], 0, 254, 0, 100),
      i                                        // i75<i>
    );
  }
  WSContentSend_P(PSTR("</table>"));
}

/*********************************************************************************************/

void DaliWebGetArg(void) {
  char tmp[8];                                 // WebGetArg numbers only
  char svalue[32];                             // Command and number parameter
  char webindex[8];                            // WebGetArg name

  uint32_t index;
  for (uint32_t i = Settings->sbflag1.dali_light; i <= Settings->mbflag2.dali_group_sliders; i++) {  // DaliLight 0/1, DaliGroupSliders
    snprintf_P(webindex, sizeof(webindex), PSTR("i75%d"), i);
    WebGetArg(webindex, tmp, sizeof(tmp));     // 0 - 100 percent
    if (strlen(tmp)) {
      index = i;
      if (index > 0) { index += 100; }         // Group
      snprintf_P(svalue, sizeof(svalue), PSTR("DaliDimmer%d %s"), index, tmp);
      ExecuteWebCommand(svalue);
    }
  }
  WebGetArg(PSTR("k75"), tmp, sizeof(tmp));
  if (strlen(tmp)) {
    index = atoi(tmp);
    if (index > 0) { index += 100; }           // Group
    snprintf_P(svalue, sizeof(svalue), PSTR("DaliPower%d 2"), index);
    ExecuteWebCommand(svalue);
  }
}

/*********************************************************************************************/

void DaliWebShow(void) {
  WSContentSend_P(PSTR("</table>"));         // Terminate current {t}
  WSContentSend_P(HTTP_MSG_EXEC_JAVASCRIPT);  // "<img style='display:none;' src onerror=\""
  for (uint32_t i = Settings->sbflag1.dali_light; i <= Settings->mbflag2.dali_group_sliders; i++) {  // DaliLight 0/1, DaliGroupSliders
    WSContentSend_P(PSTR("eb('k75%d').style='background:#%06x';"),
      i, WebColor((Dali->power[i]) ? COL_BUTTON : COL_BUTTON_OFF));
    if (Dali->dimmer[i] != Dali->web_dimmer[i]) {
      if (WebUpdateSliderTime()) {
        Dali->web_dimmer[i] = Dali->dimmer[i];
      }
      WSContentSend_P(PSTR("eb('i75%d').value='%d';"),
        i, changeUIntScale(Dali->dimmer[i], 0, 254, 0, 100));
    }
  }
  WSContentSend_P(PSTR("\">{t}"));           // Restart {t} = <table style='width:100%'>
  WSContentSeparator(3);                     // Don't print separator on next WSContentSeparator(1)
}

#endif  // USE_WEBSERVER

/*********************************************************************************************\
 * Interface
\*********************************************************************************************/

bool Xdrv75(uint32_t function) {
  bool result = false;

  if (FUNC_MODULE_INIT == function) {          // Try to claim DALI as light
    result = DaliInit(function);
  }
  else if ((FUNC_PRE_INIT == function) && !Dali) {  // If claim failed then use DALI controls only
    DaliInit(function);
  }
  else if (Dali) {
    switch (function) {
      case FUNC_LOOP:
        DaliLoop();
        break;
      case FUNC_EVERY_SECOND:
        DaliEverySecond();
        break;
#ifdef USE_LIGHT
      case FUNC_SET_CHANNELS:
        result = DaliSetChannels();
        break;
#endif  // USE_LIGHT
      case FUNC_JSON_APPEND:
        ResponseAppend_P(PSTR(","));
        ResponseAppendDali(0);
        break;
#ifdef USE_WEBSERVER
      case FUNC_WEB_SENSOR:
        DaliWebShow();
        break;
      case FUNC_WEB_ADD_MAIN_BUTTON:
        DaliWebAddMainSlider();
        break;
      case FUNC_WEB_GET_ARG:
        DaliWebGetArg();
        break;
#endif  // USE_WEBSERVER
      case FUNC_COMMAND:
        result = DecodeCommand(kDALICommands, DALICommand);
        break;
      case FUNC_ACTIVE:
        result = true;
        break;
    }
  }
  return result;
}

#endif  // USE_DALI