STM32的串口通信UART/TTL

Interrupt Mode

  ===============

  In Interrupt Mode, the USART communication can be managed by 8 interrupt sources and 10 pending bits: 

 

  Pending Bits:

  ------------- 

     1. USART_IT_TXE :  to indicate the status of the transmit buffer register

     2. USART_IT_RXNE : to indicate the status of the receive buffer register

     3. USART_IT_TC :   to indicate the status of the transmit operation

     4. USART_IT_IDLE : to indicate the status of the Idle Line

     5. USART_IT_CTS :  to indicate the status of the nCTS input

     6. USART_IT_LBD :  to indicate the status of the LIN break detection

     7. USART_IT_NE :   to indicate if a noise error occur

     8. USART_IT_FE :   to indicate if a frame error occur

     9. USART_IT_PE :   to indicate if a parity error occur

    10. USART_IT_ORE :  to indicate if an Overrun error occur

 

  Interrupt Source:

  -----------------

     1. USART_IT_TXE :  specifies the interrupt source for the Tx buffer empty interrupt. 

     2. USART_IT_RXNE : specifies the interrupt source for the Rx buffer not empty interrupt.

     3. USART_IT_TC :   specifies the interrupt source for the Transmit complete interrupt. 

     4. USART_IT_IDLE : specifies the interrupt source for the Idle Line interrupt.             

     5. USART_IT_CTS :  specifies the interrupt source for the CTS interrupt. 

     6. USART_IT_LBD :  specifies the interrupt source for the LIN break detection interrupt. 

     7. USART_IT_PE :   specifies the interrupt source for the parity error interrupt. 

     8. USART_IT_ERR :  specifies the interrupt source for the errors interrupt.

 

[url=home.php?mod=space&uid=536309]@NOTE[/url] Some parameters are coded in order to use them as interrupt source or as pending bits.

 

  In this Mode it is advised to use the following functions:

     - void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState);

     - ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT);

     - void USART_ClearITPendingBit(USART_TypeDef* USARTx, uint16_t USART_IT);

#ifndef __BUFFER_H_

#define __BUFFER_H_

 

#include "stm32f10x.h"

 

typedef struct

{

  u8* buf;

  u16 size;

  u16 front;

  u16 rear;

} BufferTypeDef;

 

typedef struct

{

  u8 size;

  u8 length;

  u8* data;

} BufferClip;

 

void Buffer_Reset(BufferTypeDef* buff);

u16  Buffer_Length(BufferTypeDef* buff);

u8   Buffer_Push(BufferTypeDef* buff, u8 data);

u8   Buffer_Pop(BufferTypeDef* buff, u8* data);

u8   Buffer_Pop_All(BufferTypeDef* buff, BufferClip* clip);

void Buffer_Print(BufferTypeDef* buff);

void Buffer_Print_Hex(BufferTypeDef* buff);

void Buffer_Print_All(BufferTypeDef* buff);

 

void Buffer_Clip_Print(BufferClip* clip);

void Buffer_Clip_Print_Hex(BufferClip* clip);

 

#endif

 

 

 

 

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "buffer.h"

 

void Buffer_Reset(BufferTypeDef* buff)

{

  buff->front = 0;

  buff->rear = 0;

}

 

u16 Buffer_Length(BufferTypeDef* buff)

{

  if (buff->rear >= buff->front) {

    return buff->rear - buff->front;

  } else {

    return (buff->size - buff->front) + (buff->rear - 0);

  }

}

 

u8 Buffer_Push(BufferTypeDef* buff, u8 data)

{

  buff->buf[buff->rear] = data;

  buff->rear++;

  if (buff->rear >= buff->size) {

    buff->rear = 0;

  }

  if (buff->front == buff->rear) {

    buff->front = (buff->front + 1) % buff->size;

    return NULL;

  } else {

    return !NULL;

  }

}

 

u8 Buffer_Pop(BufferTypeDef* buff, u8* data)

{

  if (buff->front == buff->rear) return NULL;

 

  *data = buff->buf[buff->front];

  buff->front = (buff->front + 1) % buff->size;

  return !NULL;

}

 

u8 Buffer_Pop_All(BufferTypeDef* buff, BufferClip* clip)

{

  if (buff->front == buff->rear) return NULL;

  

  memset(clip->data, 0x00, clip->size * sizeof(u8));

  clip->length = 0;

  if (buff->front > buff->rear) {

    while (buff->front < buff->size && clip->length <= clip->size) {

      *(clip->data + clip->length++) = buff->buf[buff->front++];

    }

    if (buff->front == buff->size) {

      buff->front = 0;

    }

  }

  while (buff->front < buff->rear && clip->length <= clip->size) {

    *(clip->data + clip->length++) = buff->buf[buff->front++];

  }

  return !NULL;

}

 

void Buffer_Print(BufferTypeDef* buff)

{

  printf("BUFF:[%03d,%03d)",buff->front, buff->rear);

  if (buff->front == buff->rear) {

    // print nothing;

  } else if (buff->front < buff->rear) {

    for(int i=buff->front; i < buff->rear; i++) {

      printf("%c", buff->buf[i]);

    }

  } else {

    for(int i = buff->front; i < buff->size; i++) {

      printf("%c", buff->buf[i]);

    }

    for(int i = 0; i < buff->rear; i++) {

      printf("%c", buff->buf[i]);

    }

  }

  printf("\r\n");

}

 

void Buffer_Print_Hex(BufferTypeDef* buff)

{

  printf("BUFF:[%03d,%03d)",buff->front, buff->rear);

  if (buff->front == buff->rear) {

    // print nothing;

  } else if (buff->front < buff->rear) {

    for(int i=buff->front; i<buff->rear; i++) {

      printf("%02X ", buff->buf[i]);

    }

  } else {

    for(int i=buff->front; i < buff->size; i++) {

      printf("%02X ", buff->buf[i]);

    }

    for(int i=0; i<buff->rear; i++) {

      printf("%02X ", buff->buf[i]);

    }

  }

  printf("\r\n");

}

 

void Buffer_Print_All(BufferTypeDef* buff)

{

  printf("BUFF:[%d,%d)",buff->front, buff->rear);

  for(int i=0; i < buff->size; i++) {

    printf("%c", buff->buf[i]);

  }

  printf("\r\n");

}

 

void Buffer_Clip_Print(BufferClip* clip)

{

  printf("CLIP:[%03d]", clip->length);

  for(int i = 0; i < clip->length; i++) {

    printf("%c", clip->data[i]);

  }

  printf("\r\n");

}

 

void Buffer_Clip_Print_Hex(BufferClip* clip)

{

  printf("CLIP:[%03d]", clip->length);

  for(int i = 0; i < clip->length; i++) {

    printf("%02X ", clip->data[i]);

  }

  printf("\r\n");

}

BufferTypeDef RFID_RX_BUF;

u8 RFID_RX_BUF_BUFF[RFID_BUF_SIZE] = {0x00};

 

BufferClip RFID_RX_CLIP;

u8 RFID_RX_CLIP_DATA[UINT8_MAX] = {0x00};

 

u8 RFID_RX_STATE = 0;

 

void RFID_Init(void)

{

  RFID_RX_BUF.buf = RFID_RX_BUF_BUFF;

  RFID_RX_BUF.size = RFID_BUF_SIZE;

  RFID_RX_CLIP.data = RFID_RX_CLIP_DATA;

  RFID_RX_CLIP.size = UINT8_MAX;

 

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);

  RCC_APB1PeriphClockCmd(RFID_RCC, ENABLE);

  // GPIO for TX

  GPIO_InitTypeDef  GPIO_InitStructure;

  GPIO_InitStructure.GPIO_Pin = RFID_TX_PIN;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(RFID_TX_GPIO, &GPIO_InitStructure);

  // GPIO for RX

  GPIO_InitStructure.GPIO_Pin = RFID_RX_PIN;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

  GPIO_Init(RFID_RX_GPIO, &GPIO_InitStructure); 

  // NVIC

  NVIC_InitTypeDef NVIC_InitStructure;

  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

  NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;

  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority =1;

  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;

  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;

  NVIC_Init(&NVIC_InitStructure);

  // USART

  USART_DeInit(RFID_USART);

  USART_InitTypeDef USART_InitStructure;

  USART_InitStructure.USART_BaudRate = 115200;

  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_Tx | USART_Mode_Rx;

  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

  USART_Init(RFID_USART, &USART_InitStructure);

  USART_ClearFlag(RFID_USART, USART_FLAG_CTS);

  USART_Cmd(RFID_USART, ENABLE);

 

  USART_ITConfig(RFID_USART, USART_IT_RXNE, ENABLE);

  printf("## RFID Initialized ##\r\n");

}

void USART3_IRQHandler(void)

{

  u8 rev_byte;

  u32 clear;

  if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  {

    rev_byte = USART_ReceiveData(USART3);

    Buffer_Push(&RFID_RX_BUF, rev_byte);

    // Reset the TIM2 counter and enable it

    TIM_SetCounter(TIM2, 0);

    TIM_Cmd(TIM2, ENABLE);

    USART_ClearITPendingBit(USART3, USART_IT_RXNE);

  }

}

 

void TIM2_IRQHandler(void)

{

  if(TIM_GetITStatus(TIM2, TIM_IT_Update) == SET) {

    printf("RFID_RX_STATE++\r\n");

    RFID_RX_STATE++;

  }

  TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

  TIM_Cmd(TIM2, DISABLE);

}

void RFID_Send_String(const u8* data, u16 length)

{

  printf("RFID CMD: ");

  for (u16 i = 0; i < length; i++) {

    printf("%02X ", *(data + i));

    USART_SendData(RFID_USART, *(data + i));

    while(USART_GetFlagStatus(RFID_USART, USART_FLAG_TXE) == RESET) { // Wait till sent

      ;// Do nothing

    }

  }

  printf(">> Sent\r\n");

}

 

bool RFID_Send_Cmd(const u8* cmd, u16 length)

{

  RFID_Send_String(cmd, length);

  // Delay 50ms to avoid being joinned by other commands

  Systick_Delay_ms(50);

 

  u8 waittime = 10;

  while (waittime--) {

    if(RFID_RX_STATE > 0) {

      printf("RFID_RX_STATE %d\r\n", RFID_RX_STATE);

      if (Buffer_Pop_All(&RFID_RX_BUF, &RFID_RX_CLIP) != NULL) {

        Buffer_Clip_Print_Hex(&RFID_RX_CLIP);

        RFID_Handle_Message();

      }

      RFID_RX_STATE--;

    }

    Systick_Delay_ms(50);

  }

  return true;

}

u8 ESP8266_Send_Cmd2(char *cmd, char *ack, char *ack2, u16 waittime)

{

  ESP8266_Send_String((u8 *)cmd);

  Systick_Delay_ms(50);

  // Make sure waittime is set

  if (waittime < 10) waittime = 10;

 

  while (waittime--) {

    if(ESP_RX_STATE > 0) {

      printf("ESP_RX_STATE %d\r\n", ESP_RX_STATE);

      ESP_RX_STATE--;

      if (Buffer_Pop_All(&ESP_RX_BUF, &ESP_RX_CLIP) != NULL) {

        Buffer_Clip_Print(&ESP_RX_CLIP);

        if(strstr((char *)(ESP_RX_CLIP.data), ack) != NULL) {

          printf("return success\r\n\n");

          return ACK_SUCCESS;

        }

        if (strlen(ack2) > 0) {

          if(strstr((char *)(ESP_RX_CLIP.data), ack2) != NULL) {

            printf("return success\r\n\n");

            return ACK_SUCCESS;

          }

        }

      }

    }

    Systick_Delay_ms(20);

  }

  printf("return defeat\r\n\n");

  return ACK_DEFEAT;

}