Hôm nay mình sẽ giới thiếu lập trình uart stm32f4

USART (Universal synchronous asynchronous receiver transmitter) truyền nhận nối tiếp đồng bộ và không đồng bộ. Trong truyền thông nối tiếp dữ liệu truyền sẽ nối đuôi nhau trên một hay vài đường truyền. Ưu điểm của truyền thông nối tiếp là vi điều khiển có khả năng truyền-nhận nhiều dữ liệu, tiết kiệm đường đường IO, nhưng nhược điểm là không được nhanh như truyền song song và dễ bị mất, lỗi dữ liệu, phải có kế hoạch phòng ngừa các tình huống này

max_exp_uart

Để kết nối UART các bạn cần bộ chuyển đổi UART-PC

ở đây các bạn nhớ phân biệt RS232 và UART

Sơ đồ kết nối các bạn tham khảo trên mạng

chú ý:TX-RX,RX-TX ,GND-GND

uart1

 

Kết nối MCU

với chíp STM32F407VX có 5 bộ UART tham khảo datasheet STM32F4

sơ đồ kết nối MCU:

stm

MCU kết nối UART1

PA9->RX

PA10->TX

GND->GND

-Board chuyển đổi có thể dùng module PL2303,CH340…

Về chương trình STM32F4:

MAIN.C

/**
******************************************************************************
* @file main.c
* @author MCD Application Team
* @version V1.0.0
* @date 18-April-2011
* @brief Main program body
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
******************************************************************************
*/

/* Includes ——————————————————————*/
#include “stm32f4xx.h”
#include “usart.h”
extern __IO uint32_t TimmingDelay;
void delay_ms(__IO uint32_t time);

uint32_t data=0;

int main(void)
{
uint32_t i;
SysTick_Config(SystemCoreClock/1000);
USART_Configuration();
USART_NVIC_Config();

i=0x1ffffff;

while (1)
{
printf(“ABC\n\r”,data);
delay_ms(100);
}
}
void delay_ms(__IO uint32_t time)
{
TimmingDelay = time;
while(TimmingDelay !=0);
}

/**
* @}
*/

/**
* @}
*/

FILE uart.c

#include “usart.h”

#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to ‘Yes’) calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif /* __GNUC__ */

/*******************************************************************************
* Function Name : USART_Configuration
* Description : Configure Open_USART
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void USART_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;

RCC_AHB1PeriphClockCmd(Open_USART_TX_GPIO_CLK,ENABLE);
RCC_AHB1PeriphClockCmd(Open_USART_RX_GPIO_CLK,ENABLE);

#ifdef USART1_OPEN
RCC_APB2PeriphClockCmd(Open_USART_CLK,ENABLE);
#else
RCC_APB1PeriphClockCmd(Open_USART_CLK,ENABLE);
#endif
GPIO_PinAFConfig(Open_USART_TX_GPIO_PORT, Open_USART_TX_SOURCE, Open_USART_TX_AF);
GPIO_PinAFConfig(Open_USART_RX_GPIO_PORT, Open_USART_RX_SOURCE, Open_USART_RX_AF);

/*
* Open_USART_TX -> PA9 , Open_USART_RX -PA10
*/
GPIO_InitStructure.GPIO_Pin = Open_USART_TX_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;

GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(Open_USART_TX_GPIO_PORT, &GPIO_InitStructure);

GPIO_InitStructure.GPIO_Pin = Open_USART_RX_PIN;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(Open_USART_RX_GPIO_PORT, &GPIO_InitStructure);

/*
USARTx configured as follow:
– BaudRate = 115200 baud
– Word Length = 8 Bits
– One Stop Bit
– No parity
– Hardware flow control disabled (RTS and CTS signals)
– Receive and transmit
*/

USART_InitStructure.USART_BaudRate = 9600;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(Open_USART, &USART_InitStructure);
/* Enable the Open_USART Transmit interrupt: this interrupt is generated when the
Open_USART transmit data register is empty */
USART_ITConfig(Open_USART,USART_IT_RXNE,ENABLE);

USART_Cmd(Open_USART, ENABLE);

}

void USART_NVIC_Config(void)
{
NVIC_InitTypeDef NVIC_InitStructure;

/* Enable the USARTx Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = Open_USART_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}

/* Use no semihosting */
#if 1
#pragma import(__use_no_semihosting)
struct __FILE
{
int handle;
};
FILE __stdout;

_sys_exit(int x)
{
x = x;
}
#endif

/**
* @brief Retargets the C library printf function to the USART.
* @param None
* @retval None
*/
PUTCHAR_PROTOTYPE
{
/* Place your implementation of fputc here */
/* e.g. write a character to the USART */
USART_SendData(Open_USART, (uint8_t) ch);

/* Loop until the end of transmission */
while (USART_GetFlagStatus(Open_USART, USART_FLAG_TC) == RESET)
{}

return ch;
}

file UART.H

#ifndef _USART_H
#define _USART_H

#include <stdio.h>
#include “stm32f4xx.h”

#define USART1_OPEN
//#define USART2_OPEN
//#define USART3_OPEN

/**
* @brief Definition for COM port1, connected to USART3
*/
#ifdef USART1_OPEN
#define Open_USART USART1
#define Open_USART_CLK RCC_APB2Periph_USART1

#define Open_USART_TX_PIN GPIO_Pin_9
#define Open_USART_TX_GPIO_PORT GPIOA
#define Open_USART_TX_GPIO_CLK RCC_AHB1Periph_GPIOA
#define Open_USART_TX_SOURCE GPIO_PinSource9
#define Open_USART_TX_AF GPIO_AF_USART1

#define Open_USART_RX_PIN GPIO_Pin_10
#define Open_USART_RX_GPIO_PORT GPIOA
#define Open_USART_RX_GPIO_CLK RCC_AHB1Periph_GPIOA
#define Open_USART_RX_SOURCE GPIO_PinSource10
#define Open_USART_RX_AF GPIO_AF_USART1

#define Open_USART_IRQn USART1_IRQn
#define USARTx_IRQHANDLER USART1_IRQHandler

#elif defined USART2_OPEN
#define Open_USART USART2
#define Open_USART_CLK RCC_APB1Periph_USART2

#define Open_USART_TX_PIN GPIO_Pin_2
#define Open_USART_TX_GPIO_PORT GPIOA
#define Open_USART_TX_GPIO_CLK RCC_AHB1Periph_GPIOA
#define Open_USART_TX_SOURCE GPIO_PinSource2
#define Open_USART_TX_AF GPIO_AF_USART2

#define Open_USART_RX_PIN GPIO_Pin_3
#define Open_USART_RX_GPIO_PORT GPIOA
#define Open_USART_RX_GPIO_CLK RCC_AHB1Periph_GPIOA
#define Open_USART_RX_SOURCE GPIO_PinSource3
#define Open_USART_RX_AF GPIO_AF_USART2

#define Open_USART_IRQn USART2_IRQn
#define USARTx_IRQHANDLER USART2_IRQHandler

#elif defined USART3_OPEN
#define Open_USART USART3
#define Open_USART_CLK RCC_APB1Periph_USART3

#define Open_USART_TX_PIN GPIO_Pin_10
#define Open_USART_TX_GPIO_PORT GPIOC
#define Open_USART_TX_GPIO_CLK RCC_AHB1Periph_GPIOC
#define Open_USART_TX_SOURCE GPIO_PinSource10
#define Open_USART_TX_AF GPIO_AF_USART3

#define Open_USART_RX_PIN GPIO_Pin_11
#define Open_USART_RX_GPIO_PORT GPIOC
#define Open_USART_RX_GPIO_CLK RCC_AHB1Periph_GPIOC
#define Open_USART_RX_SOURCE GPIO_PinSource11
#define Open_USART_RX_AF GPIO_AF_USART3

#define Open_USART_IRQn USART3_IRQn
#define USARTx_IRQHANDLER USART3_IRQHandler
#else
#error “Please select The COM to be used (in usart.h)”
#endif

void USART_Configuration(void);
void USART_NVIC_Config(void);

#endif /*_USART_H*/

file IT.C

/**
******************************************************************************
* @file I2C/EEPROM/stm32f4xx_it.c
* @author MCD Application Team
* @version V1.0.0
* @date 30-September-2011
* @brief Main Interrupt Service Routines.
* This file provides template for all exceptions handler and
* peripherals interrupt service routine.
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
******************************************************************************
*/

/* Includes ——————————————————————*/
#include “stm32f4xx_it.h”
#include “usart.h”

/** @addtogroup STM32F4xx_StdPeriph_Examples
* @{
*/

/** @addtogroup I2C_EEPROM
* @{
*/

/* Private typedef ———————————————————–*/
/* Private define ————————————————————*/
/* Private macro ————————————————————-*/
/* Private variables ———————————————————*/
/* Private function prototypes ———————————————–*/
/* Private functions ———————————————————*/

/******************************************************************************/
/* Cortex-M4 Processor Exceptions Handlers */
/******************************************************************************/

/**
* @brief This function handles NMI exception.
* @param None
* @retval None
*/
void NMI_Handler(void)
{
}

/**
* @brief This function handles Hard Fault exception.
* @param None
* @retval None
*/
void HardFault_Handler(void)
{
/* Go to infinite loop when Hard Fault exception occurs */
while (1)
{
}
}

/**
* @brief This function handles Memory Manage exception.
* @param None
* @retval None
*/
void MemManage_Handler(void)
{
/* Go to infinite loop when Memory Manage exception occurs */
while (1)
{
}
}

/**
* @brief This function handles Bus Fault exception.
* @param None
* @retval None
*/
void BusFault_Handler(void)
{
/* Go to infinite loop when Bus Fault exception occurs */
while (1)
{
}
}

/**
* @brief This function handles Usage Fault exception.
* @param None
* @retval None
*/
void UsageFault_Handler(void)
{
/* Go to infinite loop when Usage Fault exception occurs */
while (1)
{
}
}

/**
* @brief This function handles SVCall exception.
* @param None
* @retval None
*/
void SVC_Handler(void)
{
}

/**
* @brief This function handles Debug Monitor exception.
* @param None
* @retval None
*/
void DebugMon_Handler(void)
{
}

/**
* @brief This function handles PendSVC exception.
* @param None
* @retval None
*/
void PendSV_Handler(void)
{
}

/**
* @brief This function handles SysTick Handler.
* @param None
* @retval None
*/
__IO uint32_t TimmingDelay;

void SysTick_Handler(void)
{
if(TimmingDelay !=0)
{
TimmingDelay –;
}
}

/******************************************************************************/
/* STM32F4xx Peripherals Interrupt Handlers */
/* Add here the Interrupt Handler for the used peripheral(s) (PPP), for the */
/* available peripheral interrupt handler’s name please refer to the startup */
/* file (startup_stm32f4xx.s). */
/******************************************************************************/
void USARTx_IRQHANDLER(void)
{
if(USART_GetITStatus(Open_USART, USART_IT_RXNE) != RESET)
{
//USART_ClearITPendingBit(USART2,USART_IT_RXNE);
printf(“\n\rUSART Hyperterminal Interrupts Receive a word: %c\n\r”,USART_ReceiveData(Open_USART));
}
}

/**
* @brief This function handles PPP interrupt request.
* @param None
* @retval None
*/
/*void PPP_IRQHandler(void)
{
}*/

/**
* @}
*/

/**
* @}
*/

/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

Bình luận

Bình luận