DMX-Empfang mit STM32F767

[Sebastian (moonwalker2828)]

Moin zusammen,
ich bin schon lange stiller Leser dieses tollen Forums, habe nun ein 
Problem, das zu lösen ich alleine gerade nicht im Stande bin.

Ich habe durch glückliche Umstände ein Board erhalten, auf dem ein 
STM32F767 nebst Peripherie zum DMX512-Empfang vorhanden ist.
Ich habe schon diverse Dinge mit dem Board umsetzen können, scheitere 
aber an dem DMX-empfang und sehe glaube ich den Wald vor lauter Bäumen 
nicht.
DMX kommt über UARt 5 rein, ich würde gerne den Wert an DMX-Adresse XY 
auf UART1 ausgeben lassen.

Hier mal, was ich derzeit versuche - gekürzt ,Datei dazu im Anhang.:

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define DMX_FRAME_SIZE 513
#define DMX_BREAK_TIME_US  88
#define DMX_MARK_AFTER_BREAK_TIME_US 8
#define DMX_BIT_TIME_US 4
#define MIN_INTER_FRAME_TIME 176
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/



TIM_HandleTypeDef htim2;

UART_HandleTypeDef huart5;
UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

//receive Buffer
uint8_t dmx_data[DMX_FRAME_SIZE];
char buffer[50];
uint32_t last_frame_time = 0;
// DMX512 receive state
enum {
    DMX_STATE_BREAK,
    DMX_STATE_START,
    DMX_STATE_DATA,
    DMX_STATE_IDLE
} dmx_state = DMX_STATE_IDLE;

// DMX512 receive address
#define DMX_ADDRESS 1

// DMX512 receive flag
volatile uint8_t dmx_received = 0;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_UART5_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_TIM2_Init(void);
static void MX_RTC_Init(void);
/* USER CODE BEGIN PFP */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_UART5_Init();
  MX_USART1_UART_Init();
  MX_TIM2_Init();
  MX_RTC_Init();
  /* USER CODE BEGIN 2 */
  HAL_UART_Transmit(&huart1, "MAINBOARD_DMX_TEST_V_0_3\r\n",28  ,1000);

    HAL_GPIO_WritePin(GPIOE, GPIO_PIN_11, GPIO_PIN_RESET);    // /D/E_IN_TX  (U2 Driver disable)
    
    HAL_GPIO_WritePin(GPIOE, GPIO_PIN_12, GPIO_PIN_RESET);    // RE_IN_RX    (U2 Receiver enable)
    
    HAL_GPIO_WritePin(GPIOD, GPIO_PIN_10, GPIO_PIN_SET);    // Source: DMX-Cable
    


    // Start DMX512 reception
        HAL_UART_Receive_IT(&huart5, dmx_data, DMX_FRAME_SIZE);


  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    // Check if DMX512 data has been received
            if (dmx_received)
            {
                // Reset DMX512 receive flag
                dmx_received = 0;

                // Check DMX512 address
                if (dmx_data[DMX_ADDRESS] != 0)
                {
                    // Display DMX512 value on UART1
                    char buf[20];
                    sprintf(buf, "DMX value: %d\r\n", dmx_data[DMX_ADDRESS]);
                    HAL_UART_Transmit(&huart1, (uint8_t *)buf, strlen(buf), HAL_MAX_DELAY);
                }
            }


    /* USER CODE END WHILE */








    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure LSE Drive Capability
  */
  HAL_PWR_EnableBkUpAccess();
  __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE|RCC_OSCILLATORTYPE_LSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 25;
  RCC_OscInitStruct.PLL.PLLN = 432;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 9;  //9
  RCC_OscInitStruct.PLL.PLLR = 7;  //7
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Activate the Over-Drive mode
  */
  if (HAL_PWREx_EnableOverDrive() != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_7) != HAL_OK)
  {
    Error_Handler();
  }
}



/**
  * @brief TIM2 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM2_Init(void)
{

  /* USER CODE BEGIN TIM2_Init 0 */

  /* USER CODE END TIM2_Init 0 */

  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  /* USER CODE BEGIN TIM2_Init 1 */

  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 0;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 0xFFFFFFFF;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_ETRMODE2;
  sClockSourceConfig.ClockPolarity = TIM_CLOCKPOLARITY_NONINVERTED;
  sClockSourceConfig.ClockPrescaler = TIM_CLOCKPRESCALER_DIV1;
  sClockSourceConfig.ClockFilter = 0;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_DISABLE;
  sSlaveConfig.InputTrigger = TIM_TS_ITR0;
  if (HAL_TIM_SlaveConfigSynchro(&htim2, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */

  /* USER CODE END TIM2_Init 2 */

}

/**
  * @brief UART5 Initialization Function
  * @param None
  * @retval None
  */
static void MX_UART5_Init(void)
{

  /* USER CODE BEGIN UART5_Init 0 */

  /* USER CODE END UART5_Init 0 */

  /* USER CODE BEGIN UART5_Init 1 */

  /* USER CODE END UART5_Init 1 */
  huart5.Instance = UART5;
  huart5.Init.BaudRate = 250000;
  huart5.Init.WordLength = UART_WORDLENGTH_8B;
  huart5.Init.StopBits = UART_STOPBITS_2;
  huart5.Init.Parity = UART_PARITY_NONE;
  huart5.Init.Mode = UART_MODE_RX;
  huart5.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart5.Init.OverSampling = UART_OVERSAMPLING_16;
  huart5.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart5.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXOVERRUNDISABLE_INIT;//UART_ADVFEATURE_RXOVERRUNDISABLE_INIT
  if (HAL_UART_Init(&huart5) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN UART5_Init 2 */
  huart5.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_RXOVERRUNDISABLE_INIT;//UART_ADVFEATURE_RXOVERRUNDISABLE_INIT
  // Enable UART5 interrupts
     HAL_NVIC_SetPriority(UART5_IRQn, 0, 0);
     HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
     HAL_NVIC_EnableIRQ(UART5_IRQn);
  /* USER CODE END UART5_Init 2 */

}






/* USER CODE BEGIN 4 */

// DMX512 UART5 receive interrupt handler-Ansatz mit Timer zur MAB-detection
void UART5_IRQHandlerX(void)
{
  //HAL_UART_Transmit(&huart1, "U5IRQ\r\n", 9, 100);
    uint32_t isrflags = READ_REG(huart5.Instance->ISR);
    uint32_t cr1its = READ_REG(huart5.Instance->CR1);

    // Check for DMX512 break and mark-after-break conditions
    if ((isrflags & USART_ISR_FE) != RESET)
    {
        // DMX512 break detected
        dmx_state = DMX_STATE_START;
        // Debug message
                        char* message = "DMX512 break detected\r\n";
                        HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);

        // Start timer to measure time since break
        __HAL_TIM_SET_COUNTER(&htim2, 0);
        HAL_TIM_Base_Start_IT(&htim2);
    }
    else if ((isrflags & USART_ISR_RXNE) != RESET && (dmx_state == DMX_STATE_BREAK))//Change DMX_STATE_START to DMX_STATE_BREAK for check
    {
        // DMX512 mark-after-break detected
      // Debug message
                      char* message = "DMX512 mark-after-break detected\r\n";
                      HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
        dmx_state = DMX_STATE_DATA;
        HAL_TIM_Base_Stop_IT(&htim2);
        uint32_t time_since_break = __HAL_TIM_GET_COUNTER(&htim2);
        uint32_t bit_time = (SystemCoreClock / 250000) / 8;  // calculate bit time for 250 kbps baud rate
        uint32_t data_offset = (time_since_break - bit_time) / bit_time;

        // Check that the data offset is within range
        if (data_offset >= 0 && data_offset < DMX_FRAME_SIZE)
        {
          HAL_UART_Transmit(&huart1, "Offset in Range\r\n", 17, 100);
            // Start receiving DMX512 data bytes
            HAL_UART_Receive_IT(&huart5, &dmx_data[data_offset], DMX_FRAME_SIZE - data_offset);
            // Wait for the data to be received
                        while (HAL_UART_GetState(&huart5) != HAL_UART_STATE_READY &&
                               HAL_UART_GetState(&huart5) != HAL_UART_STATE_BUSY_RX) {}
                        // Debug messages
                                   char* message1 = "HAL_UART_Receive_IT() called\r\n";
                                   HAL_UART_Transmit(&huart1, (uint8_t*)message1, strlen(message1), HAL_MAX_DELAY);
                                   char* message2 = "Data offset: %d\r\n";
                                   sprintf(buffer, message2, data_offset);
                                   HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), HAL_MAX_DELAY);

        }
        else
        {
          HAL_UART_Transmit(&huart1, "Offset NOT in Range\r\n", 21, 100);
            // Invalid data offset, restart reception
            dmx_state = DMX_STATE_BREAK;
            HAL_UART_AbortReceive_IT(&huart5);
        }
    }
    else if ((isrflags & USART_ISR_IDLE) != RESET)
    {
        // DMX512 frame received
        dmx_received = 1;
        dmx_state = DMX_STATE_IDLE;
        __HAL_UART_CLEAR_IDLEFLAG(&huart5);

        // Debug message
        char* message = "DMX512 frame received\r\n";
        HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
        // Wait for minimum inter-frame time (176 microseconds)
                uint32_t frame_time = __HAL_TIM_GET_COUNTER(&htim2);
                uint32_t inter_frame_time = frame_time - last_frame_time;
                if (inter_frame_time < MIN_INTER_FRAME_TIME)
                {
                    HAL_Delay(MIN_INTER_FRAME_TIME - inter_frame_time);
                }
                last_frame_time = frame_time;

                // Reset timer for next frame
                __HAL_TIM_SET_COUNTER(&htim2, 0);
    }
}

// UART5 error interrupt handler
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
    // Error handling, restart reception
    dmx_state = DMX_STATE_BREAK;
    HAL_UART_AbortReceive_IT(&huart5);
    HAL_UART_Receive_IT(&huart5, dmx_data, DMX_FRAME_SIZE);
}
// UART5 receive complete interrupt handler
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    // Error handling, restart reception
    dmx_state = DMX_STATE_BREAK;
    HAL_UART_AbortReceive_IT(&huart5);
    HAL_UART_Receive_IT(&huart5, dmx_data, DMX_FRAME_SIZE);
}


// TIM2 update interrupt handler
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2)
    {
        // Stop timer and reset DMX512 state
        HAL_TIM_Base_Stop_IT(&htim2);
        dmx_state = DMX_STATE_BREAK;
        HAL_UART_AbortReceive_IT(&huart5);
    }
}
/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */

Ich bekomme auf uart 1 angezeigt,  "DMX512 frame received" und "Break 
detected", aber komme nie in den Status "Mark-after-break" detected.

Was kann ich tun, um hier weiter zu kommen?

Ich sitze nun schon fast zwei Tage an diesem Problem und habe - wie man 
am code sieht- schon diverse Dinge versucht....

Danke für eure Hilfe!

[Sebastian (moonwalker2828)]

Tut mir leid, dass der Code so umfangreich aussieht.

Ich wäre auch mit einem grundsätzlichen Hinweis wie man einen 
dmx-empfang ohne separaten timerpin auf dem stm32 angeht, sehr 
glücklich.

Kann mir irgendjemand einen Hinweis geben?
Langsam verzweifle ich an dem Problem, nicht zu Letzt, weil mir der 
Gesamtüberblick ein wenig fehlt.

[Harry L. (mysth)]

Also erstmal gehört längerer Quelltext in den Anhang und nicht in den 
Text!

Damit du mal ein Gefühl für den Umgang mit UART in der HAL bekommst, 
schau dir mal meine UART-Routinen an!
Die sollten sich auch für DMX nutzen lassen.

Beitrag "[STM32/HAL] simples U(S)ART-Library"

[Harald A. (embedded)]

Sebastian schrieb:
> Ich wäre auch mit einem grundsätzlichen Hinweis wie man einen
> dmx-empfang ohne separaten timerpin auf dem stm32 angeht, sehr
> glücklich.
>
Es gibt hier Forum so ein paar Trigger, die heftigste Reaktionen 
auslösen können, z.B. einen Mikrocontroller nutzen obwohl NE555 reicht, 
DCF, bleifreies Lot und leider auch DMX. Das nur zur Warnung vorab. Such 
dir aus den Antworten das Beste heraus.
Früher habe ich DMX-Empfänger gebaut und hatte natürlich auch immer das 
leidliche Thema mit der Break-Erkennung. Grundsätzlich geht es ohne 
separaten Timerpin. Man wartet auf einen UART-Framing-Error (ggf. kann 
man bei diesem STM gar einen INT auslösen? Der Framing-Error wird durch 
den Break ausgelöst, das das Stopbit nicht an der erwarteten Stelle 
steht. Der Inhalt des empfangenen Datenbytes muss „0“ sein. Fehler 
löschen und auf das nächste Byte warten. Ist das ebenfalls „0“ (diesmal 
ohne Framing-Error) hat man ausreichend genau den Beginn des Frames 
erkannt.
Manchmal habe ich noch in der Interrupt-Routine, wo der Framing-Error 
behandelt wurde, zusätzlich noch geschaut, ob der RX-Pin immer noch auf 
Low ist. Das ist aber optional und nicht unbedingt erforderlich.

[Sebastian (moonwalker2828)]

Vielen Dank,
Deinen Code schaue ich mir morgen früh am PC an.
Eine normale uart -kommunikation zwischen PC und stm, oder auch stm zu 
stm habe ich bereits erfolgreich implementiert. Ich scheitere 
tatsächlich an den speziellen Gegebenheiten bei DMX: Break von 88us, 
Mark after Break 8u
- und der Tatsache, dass nicht notwendigerweise immer alle 513 Pakete 
auch vom Sender gesendet werden.

Bezüglich des Quellcodes im Anhang gelobe ich Besserung!

[Harald A. (embedded)]

Auf die detaillierte Auswertung der Zeit des MAB kannst Du meiner 
Meinung nach verzichten.

[Sebastian (moonwalker2828)]

@ Harald A.

Vielen Dank. Ja, ich weiss, dass DMX hier ein Triggerthema ist -warum 
auch immer.
Deinen Ansatz finde ich interessant, das muss ich mir Mal in Ruhe mit 
den verfügbaren Ressourcen ansehen.

Ich hab zumindest das Gefühl, bei diesem Problem viel über den stm zu 
lernen - und das ist bei so einem Hobbyprojekt ja auch immer sehr 
befriedigend - auch wenn es dann gerne auch mal Erfolge geben darf. 
Aber, dass der Anfang nicht einfach würde, wusste ich.

[Harald A. (embedded)]

Es gibt auch einen INT für LIN Break, das Konzept ist sehr ähnlich 
(Eingang für min. 11 Bitzeiten Low). Müsste man schauen, ob sich für 
diesen Betriebsmodus auch 250kbit konfigurieren lässt, das ist für LIN 
untypisch.

[Sebastian (moonwalker2828)]

Harald A. schrieb:
> Es gibt auch einen INT für LIN Break, das Konzept ist sehr ähnlich
> (Eingang für min. 11 Bitzeiten Low). Müsste man schauen, ob sich für
> diesen Betriebsmodus auch 250kbit konfigurieren lässt, das ist für LIN
> untypisch.

Puuh, klingt auch nach einer Überlegung, mit lin habe ich noch gar 
nichts gemacht bisher.

Danke für deine tolle Unterstützung!
Wie gesagt, ich lerne sehr viel.

[Sebastian (moonwalker2828)]

Harald A. schrieb:
 Grundsätzlich geht es ohne
> separaten Timerpin. Man wartet auf einen UART-Framing-Error (ggf. kann
> man bei diesem STM gar einen INT auslösen? Der Framing-Error wird durch
> den Break ausgelöst, das das Stopbit nicht an der erwarteten Stelle
> steht. Der Inhalt des empfangenen Datenbytes muss „0“ sein. Fehler
> löschen und auf das nächste Byte warten. Ist das ebenfalls „0“ (diesmal
> ohne Framing-Error) hat man ausreichend genau den Beginn des Frames
> erkannt.

Vielen Dank :)

Den Teil habe ich gerade implementieren können und er scheint zu 
funktionieren.
Vielleicht magst Du ja einmal draufschauen, so sieht meine IRQ-Routine 
derzeit aus:

void UART5_IRQHandlerX(void){
  uint32_t isrflags = READ_REG(huart5.Instance->ISR);
  uint32_t cr1its = READ_REG(huart5.Instance->CR1);
  //uint32_t URDR = READ_REG(huart5.Instance->RDR);

  //Debug-message
   char* message = "IRQ_CALLED\r\n";
   HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
   char buf3[64];
            //   snprintf(buf3, 64, "UART5 ISR flags: 0x%08X, CR1: 0x%08X\r\n", isrflags, cr1its);
           //    HAL_UART_Transmit(&huart1, (uint8_t*)buf3, strlen(buf3), HAL_MAX_DELAY);

  if ((isrflags & USART_ISR_FE)!=RESET){    //IF Frameerror detected
    message="Frame-error detected\r\n";
    HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);

            snprintf(buf3, 64, "UART5 ISR flags: 0x%08X, CR1: 0x%08X\r\n", isrflags, cr1its);
            HAL_UART_Transmit(&huart1, (uint8_t*)buf3, strlen(buf3), HAL_MAX_DELAY);




    if(READ_REG(huart5.Instance->RDR)==RESET){
    message="DATA0\r\n";
    HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
    dmx_stat=DMX_BRAKE;
    }
    WRITE_REG(huart5.Instance->ICR, USART_ICR_FECF);    //Schreibe 1 in Frame-error-clear-reg -> Lösche FE

  }

  if((dmx_stat==DMX_BRAKE)&&(READ_REG(huart5.Instance->RDR)==RESET)&&(isrflags & USART_ISR_FE)==RESET){  //Framebeginn detektiert
    message="Start_of_Frame\r\n";
        HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
    dmx_stat=DMX_IDLE;  //ist natürlich Quatsch, müsste DM_START sein
    //DMX-Startpaket muss null sein, sonst RDM o.ä.
    //Danach folgen die Datenpakete
    // einlesen in ein Array
  }
}

Nun muss ich mir den Rest noch überlegen....also,
1. Check ob das als nächstes folgende Byte 0 ist ( Startbyte)
2. einlesen der folgenden Bytes in ein Array (sollten dann ja die Daten 
sein
3. Abbruchbedingungen: a) alle 513 Frames übertragen -> State wieder auf 
Idle

b) weniger als 513 Frames übertragen, aber Frameerror -> sollte auf 
Brake hindeuten.

So weit richtig? Verbesserungsvorschläge / Anmerkungen?

Danke nochmal für die tolle Hilfe :)

[Harald A. (embedded)]

Na ja, es sind ja manchmal auch weniger als 512 Bytes, das ist nach Norm 
zulässig.
Vlt. so:

Init:
Framing-Interrupt aufsetzen
Erstes Bytes im Empfangsbuffer auf 0xFF setzen

Zur Laufzeit:
- Per Interrupt warten auf Framing Error
- Im Interrupt DMA für den Empfang von 513 Bytes aufsetzen
- Gleichzeitig schauen, ob der vorherige Empfang das 1.Byte auf 0 
gebracht hat
- Auswerten, ob überhaupt x Bytes per DMA empfangen wurden
- Daten für gültig/ungültig erklären
- 1. Byte wieder auf 0xFF setzen, damit es wieder überschrieben wird

Anmerkungen:
- Erst nach dem Empfang des nächsten Framing-Errors weiß man, ob die 
Daten gültig sind. Ist aber nur eine kleine Verzögerung
- man kann dieses Konzept auf zwei alternierende Buffer ausweiten, wenn 
man das braucht. Schließlich werden die Daten sofort nach Gültigstellung 
sofort wieder überschrieben. In normalen Anwendungen aber auch kein 
Problem.

[Sebastian (moonwalker2828)]

Hallo Harald,

Danke für deinen Input, ich war nun ein paar Tage nicht mehr an der 
Baustelle dran.
Leider komme ich nicht wirklich vorwärts. Den DMA-Code habe ich nicht 
zum Laufen bekommen, das sind für mich ohne Hilfe gerade leider zu viele 
Unbekannte auf einmal.

Ich bin nun noch einmal einen Schritt zurück gegangen und habe folgendes 
gebaut:

void UART5_IRQHandlerX(void)
{
  char* message = "IRQ\r\n";
  //HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
   uint16_t rx;
   uint32_t isrflags = READ_REG(huart5.Instance->ISR);

   if ((isrflags & USART_ISR_ORE) != RESET) // Data Overrun?
   {
     rx=huart5.Instance->RDR;    //Zeichen lesen
    WRITE_REG(huart5.Instance->ICR,USART_ICR_ORECF);    //Overrun errorflag löschen
      dmx_stat=DMX_BREAK;        //Warte auf Reset / Break
       message = "BREAK0";
        //HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
   }
   else
   {
      if ((isrflags & USART_ISR_FE)!=RESET)//Break oder Frameerror?
      {
        rx=huart5.Instance->RDR;    //Zeichen lesen
        WRITE_REG(huart5.Instance->ICR,USART_ICR_FECF);    //Frameerror errorflag löschen
         if (rx == 0)
         {
           dmx_stat=DMX_START; // FE WAS a BREAK -> Warte auf Start Byte!
         } else {
           dmx_stat=DMX_BREAK; // Warte einfach auf Reset (BREAK)
         }
      }
      else
      {
         if ((isrflags & USART_ISR_RXNE)!=RESET) // Empfangsinterrupt?
         {
            rx = huart5.Instance->RDR;; // Lese das Zeichen
            switch (dmx_stat)
            {
            case DMX_START:
               if (rx == 0)
               {
                 dmx_stat=DMX_DATA;    //Wechsle in Datenempfangsstatus
                 DMXInDataCounter=0;        //Datenzähler auf 0
               } else {
                 dmx_stat=DMX_BREAK; // Warte einfach auf Reset
               }
               break;
            case  DMX_DATA: // Daten ablegen
              dmx_data0[DMXInDataCounter]= huart5.Instance->RDR;

              char buf3[64];
              snprintf(buf3, 64, "data packageNo: 0x%08X, contains: 0x%08X\r\n", DMXInDataCounter, dmx_data0[DMXInDataCounter]);
                        HAL_UART_Transmit(&huart1, (uint8_t*)buf3, strlen(buf3), HAL_MAX_DELAY);


              char* message = "DMX512 Writing Data\r\n";
                             // HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
              DMXInDataCounter++;
               HAL_UART_AbortReceive_IT(&huart5);

               HAL_UART_Receive_IT(&huart5, dmx_data0, DMX_FRAME_SIZE);

               if (DMXInDataCounter >= DMX_FRAME_SIZE)
               {
                 char* message = "reached_MAX\r\n";
                                               HAL_UART_Transmit(&huart1, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
                dmx_stat=DMX_BREAK; // ALL CHANNELS RECEIVED
                 HAL_UART_AbortReceive_IT(&huart5);
                 HAL_UART_Receive_IT(&huart5, dmx_data0, DMX_FRAME_SIZE);
               }
               break;
            default :
               break;
            }
         }
         else
         {
           
           //WRITE_REG(huart5.Instance->ICR,0x00000000);

            WRITE_REG(huart5.Instance->ICR,USART_ICR_ORECF);
            WRITE_REG(huart5.Instance->ICR,USART_ICR_IDLECF);
            WRITE_REG(huart5.Instance->ICR,USART_ICR_FECF);

         }
      }
   }
}

Damit kann ich das erste Byte sicher, folgende Bytes teilweise 
empfangen.

So weit ich meiner UART1 trauen kann, empfange ich das package 0x00 mit 
den richtigen Daten, die am Pult eingestellt sind, alle folgenden mit 
Inhalt 0, obwohl das Pult andere Werte sendet und das Signal auch super 
sauber aussieht (Oszi).
Bei Package 0x22 bricht das Ganze ab und startet wieder mit Package 0x00 
- was eigentlich auch nicht zu dem passt, was das Pult ausgibt.

Hast Du eine Idee, oder einen Ansatz für mich?

Danke...ich will auch nicht nerven, aber mir gehen gerade die Ideen aus.

[Harald A. (embedded)]

Tja, da jetzt im einzelnen durchzusteigen ist aus der Ferne schwierig. 
Ich würde empfehlen zunächst einmal ein DMA Beispiel aus der Google 
Suche ins Laufen zu bringen, muss ja nicht DMX sein, vlt. erstmal eine 
„normale“ Baudrate. Du baust ja auch ganz offensichtlich auf dem Code 
Generator von STM auf (Name gerade vergessen). Hier gibt es Beispiele:

https://deepbluembedded.com/how-to-receive-uart-serial-data-with-stm32-dma-interrupt-polling/

[Harald A. (embedded)]

Weiterhin fällt mir auf, dass Du ein print im Interrupt ausführst. Du 
hast von Int zu Int nur 44usec. Weiß nicht, ob das hinkommt. Weiterhin 
könntest Du einzelne Portpins setzen, die Du dann mit einem Logic 
Analyzer parallel zum DMX Datenstrom auswertest. Für Sigrok gibt es 
bestimmt einen DMX-Decoder, die LA Hardware kostet fast nichts.

[J. S. (engineer)]

Das Protokoll hast du verstanden und richtig implementiert? Auch die 
Pausen-Zeiten? So ohne weiteres arbeitet da eine Standard-UART nicht 
richtig drauf. Ich habe den DMX in einem kleinen Core im FPGA. Da ist 
das wesentlich handlicher.

[Harald A. (embedded)]

Jürgen S. schrieb:
> Das Protokoll hast du verstanden und richtig implementiert? Auch die
> Pausen-Zeiten? So ohne weiteres arbeitet da eine Standard-UART nicht
> richtig drauf. Ich habe den DMX in einem kleinen Core im FPGA. Da ist
> das wesentlich handlicher.

Das würde mich jetzt mal interessieren, warum eine Standard UART da 
nicht funktionieren sollte (habe es selber schon mehrfach auf 
verschiedenen Controllern umgesetzt. Einzig mit einer Fujitsu MB90F387 
gab es Probleme, da die Startbit-Erkennung nicht Flanken- sondern 
Level-getriggert war und somit aus dem Framing-Error nicht sauber 
rauskam.
Und was meinst Du mit Pausenzeiten? Mark-after-Break?

[C-hater (c-hater)]

Harald A. schrieb:

> Einzig mit einer Fujitsu MB90F387
> gab es Probleme, da die Startbit-Erkennung nicht Flanken- sondern
> Level-getriggert war und somit aus dem Framing-Error nicht sauber
> rauskam.

Das gleiche Problem existiert z.B. bei der TMS320Fxxx-Reihe von TI.