DMX-Empfang mit STM32F767

/* 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

  */