外部调完，可以解析下发的MQTT数据了，但是路径文件太大准备换成http模式

yincheng.zhong

7 天以前 b53fff11e6f0d560594834de32886239cbba90a3

 STM32H743/Core/Src/stm32h7xx_it.c

@@ -20,10 +20,10 @@
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32h7xx_it.h"
#include "bluetooth.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "bluetooth.h"
#include "DBG.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
@@ -56,10 +56,34 @@

/* USER CODE END 0 */

/* store fault info for post-mortem inspection */
typedef struct {
  volatile uint32_t r0;
  volatile uint32_t r1;
  volatile uint32_t r2;
  volatile uint32_t r3;
  volatile uint32_t r12;
  volatile uint32_t lr;
  volatile uint32_t pc;
  volatile uint32_t psr;
  volatile uint32_t cfsr;
  volatile uint32_t hfsr;
  volatile uint32_t mmfar;
  volatile uint32_t bfar;
} MemFaultInfo_t;

volatile MemFaultInfo_t g_memFaultInfo;

void MemManage_Handler_C(uint32_t *pulFaultStackAddress);


/* External variables --------------------------------------------------------*/
extern TIM_HandleTypeDef htim1;
extern TIM_HandleTypeDef htim2;
extern TIM_HandleTypeDef htim3;
extern TIM_HandleTypeDef htim4;
extern DMA_HandleTypeDef hdma_uart4_rx;
extern DMA_HandleTypeDef hdma_uart5_rx;
extern DMA_HandleTypeDef hdma_uart5_tx;
extern DMA_HandleTypeDef hdma_usart1_rx;
extern DMA_HandleTypeDef hdma_usart1_tx;
extern DMA_HandleTypeDef hdma_usart2_rx;
@@ -68,6 +92,8 @@
extern DMA_HandleTypeDef hdma_usart3_tx;
extern DMA_HandleTypeDef hdma_usart6_rx;
extern DMA_HandleTypeDef hdma_usart6_tx;
extern UART_HandleTypeDef huart4;
extern UART_HandleTypeDef huart5;
extern UART_HandleTypeDef huart1;
extern UART_HandleTypeDef huart2;
extern UART_HandleTypeDef huart3;
@@ -114,15 +140,59 @@
/**
  * @brief This function handles Memory management fault.
  */
void MemManage_Handler(void)
{
  /* USER CODE BEGIN MemoryManagement_IRQn 0 */
//__attribute__((naked)) void MemManage_Handler(void)
//{
//  __ASM volatile(
//      "TST LR, #4\n\t"
//      "ITE EQ\n\t"
//      "MRSEQ R0, MSP\n\t"
//      "MRSNE R0, PSP\n\t"
//      "B MemManage_Handler_C\n\t"
//  );
//}

  /* USER CODE END MemoryManagement_IRQn 0 */
/* C handler: pulFaultStackAddress points to stacked r0, r1, r2, r3, r12, lr, pc, psr */
void MemManage_Handler_C(uint32_t *pulFaultStackAddress)
{
  /* save stacked registers */
  g_memFaultInfo.r0 = pulFaultStackAddress[0];
  g_memFaultInfo.r1 = pulFaultStackAddress[1];
  g_memFaultInfo.r2 = pulFaultStackAddress[2];
  g_memFaultInfo.r3 = pulFaultStackAddress[3];
  g_memFaultInfo.r12 = pulFaultStackAddress[4];
  g_memFaultInfo.lr = pulFaultStackAddress[5];
  g_memFaultInfo.pc = pulFaultStackAddress[6];
  g_memFaultInfo.psr = pulFaultStackAddress[7];

  /* save fault status registers */
  g_memFaultInfo.cfsr = SCB->CFSR;
  g_memFaultInfo.hfsr = SCB->HFSR;
  g_memFaultInfo.mmfar = SCB->MMFAR;
  g_memFaultInfo.bfar = SCB->BFAR;

  /* try to print brief info to debug UART (may not always succeed in fault context) */
  DBG_Printf("*** MemManage Fault ***\r\n");
  DBG_Printf("CFSR=0x%08x HFSR=0x%08x MMFAR=0x%08x BFAR=0x%08x\r\n",
             (unsigned)g_memFaultInfo.cfsr,
             (unsigned)g_memFaultInfo.hfsr,
             (unsigned)g_memFaultInfo.mmfar,
             (unsigned)g_memFaultInfo.bfar);
  DBG_Printf("R0=0x%08x R1=0x%08x R2=0x%08x R3=0x%08x\r\n",
             (unsigned)g_memFaultInfo.r0,
             (unsigned)g_memFaultInfo.r1,
             (unsigned)g_memFaultInfo.r2,
             (unsigned)g_memFaultInfo.r3);
  DBG_Printf("R12=0x%08x LR=0x%08x PC=0x%08x PSR=0x%08x\r\n",
             (unsigned)g_memFaultInfo.r12,
             (unsigned)g_memFaultInfo.lr,
             (unsigned)g_memFaultInfo.pc,
             (unsigned)g_memFaultInfo.psr);

  /* break here for debugger, then loop forever */
  __asm volatile ("BKPT #0");
  while (1)
  {
    /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */
    /* USER CODE END W1_MemoryManagement_IRQn 0 */
    __asm volatile ("WFI");
  }
}

@@ -275,20 +345,6 @@
}

/**
  * @brief This function handles TIM1 update interrupt.
  */
void TIM1_UP_IRQHandler(void)
{
  /* USER CODE BEGIN TIM1_UP_IRQn 0 */

  /* USER CODE END TIM1_UP_IRQn 0 */
  HAL_TIM_IRQHandler(&htim1);
  /* USER CODE BEGIN TIM1_UP_IRQn 1 */

  /* USER CODE END TIM1_UP_IRQn 1 */
}

/**
  * @brief This function handles TIM2 global interrupt.
  */
void TIM2_IRQHandler(void)
@@ -317,6 +373,20 @@
}

/**
  * @brief This function handles TIM4 global interrupt.
  */
void TIM4_IRQHandler(void)
{
  /* USER CODE BEGIN TIM4_IRQn 0 */

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

  /* USER CODE END TIM4_IRQn 1 */
}

/**
  * @brief This function handles USART1 global interrupt.
  */
void USART1_IRQHandler(void)
@@ -373,23 +443,91 @@
}

/**
  * @brief This function handles UART4 global interrupt.
  */
void UART4_IRQHandler(void)
{
  /* USER CODE BEGIN UART4_IRQn 0 */

  /* USER CODE END UART4_IRQn 0 */
  HAL_UART_IRQHandler(&huart4);
  /* USER CODE BEGIN UART4_IRQn 1 */

  /* USER CODE END UART4_IRQn 1 */
}

/**
  * @brief This function handles UART5 global interrupt.
  */
void UART5_IRQHandler(void)
{
  /* USER CODE BEGIN UART5_IRQn 0 */

  /* USER CODE END UART5_IRQn 0 */
  HAL_UART_IRQHandler(&huart5);
  /* USER CODE BEGIN UART5_IRQn 1 */

  /* USER CODE END UART5_IRQn 1 */
}

/**
  * @brief This function handles DMA2 stream0 global interrupt.
  */
void DMA2_Stream0_IRQHandler(void)
{
  /* USER CODE BEGIN DMA2_Stream0_IRQn 0 */

  /* USER CODE END DMA2_Stream0_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_uart4_rx);
  /* USER CODE BEGIN DMA2_Stream0_IRQn 1 */

  /* USER CODE END DMA2_Stream0_IRQn 1 */
}

/**
  * @brief This function handles DMA2 stream1 global interrupt.
  */
void DMA2_Stream1_IRQHandler(void)
{
  /* USER CODE BEGIN DMA2_Stream1_IRQn 0 */

  /* USER CODE END DMA2_Stream1_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_uart5_rx);
  /* USER CODE BEGIN DMA2_Stream1_IRQn 1 */

  /* USER CODE END DMA2_Stream1_IRQn 1 */
}

/**
  * @brief This function handles DMA2 stream2 global interrupt.
  */
void DMA2_Stream2_IRQHandler(void)
{
  /* USER CODE BEGIN DMA2_Stream2_IRQn 0 */

  /* USER CODE END DMA2_Stream2_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_uart5_tx);
  /* USER CODE BEGIN DMA2_Stream2_IRQn 1 */

  /* USER CODE END DMA2_Stream2_IRQn 1 */
}

/**
  * @brief This function handles USART6 global interrupt.
  */
void USART6_IRQHandler(void)
{
  /* USER CODE BEGIN USART6_IRQn 0 */
  // Circular DMA Mode: Just set a flag, do NOT stop DMA
  uint32_t tmp_flag = 0;
    uint32_t temp;
    tmp_flag = __HAL_UART_GET_FLAG(&huart6, UART_FLAG_IDLE); 

    if ((tmp_flag != RESET)) 
    {

        g_u32BtIdleIntCount++; // Debug Counter
        __HAL_UART_CLEAR_IDLEFLAG(&huart6);
        HAL_UART_DMAStop(&huart6); //
        temp  =  __HAL_DMA_GET_COUNTER(&hdma_usart6_rx);
        uart6_dma_recv_len =  UART6_DMA_RX_BUF_SIZE - temp;
        uart6_dma_recv_end_flag = 1;
        // For Circular DMA, we do NOT stop DMA. Just set a flag to notify Poll.
        uart6_dma_recv_end_flag = 1; // Notify Poll that new data arrived
    }

  /* USER CODE END USART6_IRQn 0 */