STM32——串口通信升级版（队列方式）

#ifndef _USART_QUEUE_H_
#define _USART_QUEUE_H_

#include "type.h"

typedef enum
{
  USART_QUEUE_EMPTY = 0,
  USART_QUEUE_FULL = 1,
  USART_QUEUE_OK = 2,
} usart_queue_status_t;

#define USART_QUEUE_SIZE  1024

typedef struct
{  
  uint16_t front;
  uint16_t rear;
  uint16_t size;
  char data[USART_QUEUE_SIZE];
} usart_queue_t;

extern usart_queue_t usart1_send, usart3_send;

void UsartQueueInit(usart_queue_t *q);
uint8_t UsartQueuePush(usart_queue_t *q, uint8_t data);
uint8_t UsartQueuePop(usart_queue_t *q, uint8_t *data);

#endif /* _USART_QUEUE_H_ */

#include "usart_queue.h"

usart_queue_t usart1_send, usart3_send;

void UsartQueueInit(usart_queue_t *q)
{
  q->size = 0;
  q->front = 0;
  q->rear = 0;
}

uint8_t UsartQueuePush(usart_queue_t *q, uint8_t data)
{
  if(((q->rear % USART_QUEUE_SIZE) == q->front) && (q->size == USART_QUEUE_SIZE))
  {
    return USART_QUEUE_FULL;
  }

  q->data[q->rear] = data;
  q->rear = (q->rear + 1) % USART_QUEUE_SIZE;
  q->size++;

  return USART_QUEUE_OK;
}

uint8_t UsartQueuePop(usart_queue_t *q, uint8_t *data)
{
  if((q->front == q->rear) && (q->size == 0))
  {
    return USART_QUEUE_EMPTY;
  }
  
  *data = q->data[q->front];
  q->front = (q->front + 1) % USART_QUEUE_SIZE;
  q->size--;

  return USART_QUEUE_OK;
}

#ifndef _USART_H_
#define _USART_H_

#include "stm32f10x.h"
#include "type.h"

void UsartInit(USART_TypeDef* usart, uint32_t bound);
void DiagDump(const void *data, uint32_t length);

#endif /* _USART_H_ */

#include "usart.h"
#include "usart_queue.h"
#include "target.h"
#include "stm32f10x_iwdg.h"
#include <stdio.h>
#include <string.h>
#include "debug.h"

int fputc(int ch, FILE *f)
{
  while (USART_GetFlagStatus(USART1_CHANNEL, USART_FLAG_TC) == RESET);

  USART_SendData(USART1_CHANNEL, (unsigned char)ch);

  return ch;
}

static void uart_gpio_init(USART_TypeDef *usart)
{
  if(USART1_CHANNEL == usart)
  {
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

    USART1_TX_CONFIG();
    USART1_RX_CONFIG();
  }
  if(USART3_CHANNEL == usart)
  {
    RCC_APB2PeriphClockCmd(RCC_APB1Periph_USART3 | RCC_APB2Periph_AFIO, ENABLE);

    USART3_TX_CONFIG();
    USART3_RX_CONFIG();
  }
}

static void uart_nvic_init(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;

  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}

//===================================================================================
void UsartInit(USART_TypeDef *usart, uint32_t bound)
{
  USART_InitTypeDef USART_InitStructure;

  uart_gpio_init(usart);
  uart_nvic_init();

  USART_InitStructure.USART_BaudRate   =  bound;
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits   = USART_StopBits_1;
  USART_InitStructure.USART_Parity   = USART_Parity_No ;
  USART_InitStructure.USART_Mode     = USART_Mode_Rx | USART_Mode_Tx;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

  USART_Init(usart, &USART_InitStructure);
  USART_ITConfig(usart, USART_IT_RXNE, ENABLE);
  USART_Cmd(usart, ENABLE);
}

void DiagDump(const void *data, uint32_t length)
{
  const uint8_t *buffer = data;
  uint32_t i;

  for(i = 0; i < length; ++i)
  {
    printf("%2x", buffer[i]);
    printf(" ");
  }
  printf("\r\n");
}

void USART1_IRQHandler(void)
{
//  static uint16_t usart_rx_status = 0;
  uint8_t ret;

  // receive interrupt, must be 0x0d 0x0a at the end;
  if(USART_GetITStatus(USART1_CHANNEL, USART_IT_RXNE) != RESET)
  {
    ret = USART_ReceiveData(USART1_CHANNEL); // receive data (a byte)
    UsartQueuePush(&usart1_send, ret);
  }
}

void USART3_IRQHandler(void)
{
//  static uint16_t usart_rx_status = 0;
  uint8_t ret;

  if(USART_GetITStatus(USART3_CHANNEL, USART_IT_RXNE) != RESET)
  {
    ret = USART_ReceiveData(USART3_CHANNEL);
    UsartQueuePush(&usart3_send, ret);
  }
}

#ifndef _DEBUG_H_
#define _DEBUG_H_

#include <stdio.h>
#include "usart.h"

#define CONFIG_UART             

#ifndef CONFIG_UART
//#define CONFIG_LED    
//#define CONFIG_KEY            
//#define CONFIG_ADC
//#define CONFIG_CAN              
//#define CONFIG_WATCHDOG
#define CONFIG_W5500
#endif

#ifdef CONFIG_UART
#define debug(fmt, args...)     printf("[debug.h] "fmt, ##args)
#define debug_dump(buf, length) DiagDump(buf, length)
#else
#define debug(fmt, args...)
#define debug_dump(buf, length)
#endif /* CONFIG_DEBUG */

#endif /* _DEBUG_H_ */