Electrical – DALI Communication: Is DALI protocol a byte transfer mechanism or packet layer mechanism

dalilightingserialuart

As per the DALI light-control standard protocol, DALI bus communication uses Asynchronous half-duplex(two-wire) serial communication. It uses Manchester coding at 1200 bits per second(baud). A DALI bus can have up to 64 slave devices in the network.

I am trying to implement DALI protocol on STM32E407 (as Master) and STM32F3Discovery board (as Slave). I am looking for some practical advice on implementing DALI communication.

I have a few basic questions about DALI communication:

Is DALI protocol itself is a byte transfer mechanism or is it a software level packet layer (like CAN)?

If DALI is a packet layer mechanism, which byte-level transfer mechanism will better suits for it?

If it is the popular asynchronous communication protocol UART(or USART), how good is UART(or USART) for multi-processor communication (for around 64 slave devices)?? and at micro-controller level, how much faster the serial interface (UART or USART) should be to "DALI 1200 baud rate" for efficient execution Manchester coding?

Thanks in advance!

Best Answer

DALI describes the physical layer, the protocol and the command set.

It is not really a UART type protocol (unless you had external manchester coding), and the usual way to implement is couple of opto isolators and a transistor plus some passives for the the physical layer (Which must be isolated) a timer or two generating interrupts plus a couple of pins with interrupt on change for the IO.

For transmit you set up a 2400Hz interrupt and generate the biphase in software in the ISR.

For receive you use the interrupt on change and a timer to write a simple state machine to extract the 24 bit (IIRC) messages).

The gotcha with DALI is the need for a random number generator for the auto discovery stuff, finding sufficient entropy in a device with no user IO can be a bit of a pain.

Note also that to be DALI compliant you need to hit the dimming curve for your luminare type fairly closely, and DALI uses a log curve (Unlike DMX).

Related Solutions

Electronic – Serial Communication Rx ISR logic design

I will propose a method that you may find helpful with some modification to suit your needs.

In this method the ISR is so small , it only saves data in an array for later decoding in the main program , two counters are used to detect of received data and decoded data. offcourse you can use pointer instead of the counters.

   ISR:
 { 
    Receivedbytes[i++]= Rxbuffer;
    dataReceived++;
    }

    main:

    void UARTdecode{

    if (dataDecoded<dataRecived)
    {
    Received byte = Receivedbytes[j++];
    ///// where routine 
    if(Received Byte == Keyword && !ChannelOK)
          {
            Set ChannelOK 
          }
    ..
    ..
    ..
    //// end of routine 

    dataDecoded+=x; (where x is the amount of data decoded or message length)
    }

    }

P.S:It is VERY IMPORTANT that i and j are declared as Static variables

You can also check arduino hardware serial library source code , it is open source and it uses ISR to receive data "HardwareSerial.h" in the installation directory

Electrical – STM32: Manchester coding bit banging implementation problem

This is how I have finally solved the problem. This should conclude my problem

void TIM4_IRQHandler(void)
{

  HAL_TIM_IRQHandler(&htim4);
  /* USER CODE BEGIN TIM4_IRQn 1 */

  if(i < 9)
   {
    /* Capture the timer value when interrupt occured */
     tmp[1] = HAL_TIM_ReadCapturedValue(&htim4, TIM_CHANNEL_3);

    if(tmp[1] > tmp[0])
     {
      uwDiffCapture = tmp[1] - tmp[0];
     }
     else /* if tmp[1] <= tmp[0]*/
       {
         uwDiffCapture = (0xFFFF - tmp[0]) + tmp[1];
       }
     /* Left shifting the vector */
     tmp[0] = tmp[1];

     if (clock_sync == 1)
     {
       if(update_variable == 0)
       {
          if ((uwDiffCapture > 6000) && (uwDiffCapture < 7000))
            {
              update_variable = 1;
              i = i-1;
            }
          else if ((uwDiffCapture > 12000) && (uwDiffCapture < 13000))
            {
             msg[i] = !Current_bit;
            }
          else 
            {
              Manch_Error();
            }

    }
  else if(update_variable == 1)
    {
      /* only execute the next block if that some variable =1; */

      /* Wait for next interupt but How ?? */
      if((uwDiffCapture > 6000) && (uwDiffCapture < 7000))
    {
      msg[i] = Current_bit;
              update_variable = 0;

    }
      else
    {

      Manch_Error();
    }

    }
  Current_bit = msg[i];
  i++;

}

  if(clock_sync == 0)
{

  if((uwDiffCapture > 12700) && (uwDiffCapture < 12900 ))
    {

      clock_sync = 1;
      if(HAL_GPIO_ReadPin(TIM_4_3_GPIO_Port, TIM_4_3_Pin) == GPIO_PIN_RESET)
    {
      Current_bit = 0;

    }
      else if(HAL_GPIO_ReadPin(TIM_4_3_GPIO_Port, TIM_4_3_Pin) == GPIO_PIN_SET)
    {
      Current_bit = 1;

    }
      else
    {

      Manch_Error();
    }

    }
  }

}
}

My trick was to write complete decoding in IRQHandler(), this way I could avoid volatile variable usage and compiler optimizations.

Related Topic