Método para llamar a la biblioteca de firmware del puerto serie de configuración de Lanqiao Cup integrado
Debido a que el juego es ajustado, el tiempo requerido para llamar a la biblioteca de firmware puede ahorrar tiempo rápidamente
aquí, llame al firmware de la biblioteca para configurar el puerto serie dos veces
y una vez para configurar el
tiempo de inicialización del puerto serie es usar printf para imprimir caracteres.Inicialización del
puerto serie de la ruta
\ Biblioteca de firmware STM32 v3.5 \ STM32F10x_StdPeriph_Lib_V3.5.0 \ Utilities \ STM32_EVAL \ STM3210B_EVAL
Abra el archivo stm3210b_eval.c para encontrar esta función
void STM_EVAL_COMInit(COM_TypeDef COM, USART_InitTypeDef* USART_InitStruct)
Hay un dicho que dice que copiar esta función
no ahorra mucho tiempo en el proceso de configuración,
pero reduce el tiempo para pensar,
es decir, se siente mejor escribir directamente si el pensamiento es claro.
Echemos un vistazo a esta función.
Si queremos usar PA2PA3 como puerto serie,
solo necesitamos activar el reloj del puerto serie 2 y el reloj GPIOA. No es
necesario habilitar la reasignación de puertos. Todos estos se eliminan. El
código de reloj original
/* Enable GPIO clock */
RCC_APB2PeriphClockCmd(COM_TX_PORT_CLK[COM] | COM_RX_PORT_CLK[COM] | RCC_APB2Periph_AFIO, ENABLE);
if (COM == COM1)
{
RCC_APB2PeriphClockCmd(COM_USART_CLK[COM], ENABLE);
}
else
{
/* Enable the USART2 Pins Software Remapping */
GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);
RCC_APB1PeriphClockCmd(COM_USART_CLK[COM], ENABLE);
}
Cambiar a
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 , ENABLE);
A continuación, veamos si GPIO
PA2 debe escribir en PA3 o leer y cambiar directamente el Pin.
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure USART Rx as input floating */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* USART configuration */
USART_Init(COM_USART[COM], USART_InitStruct);
/* Enable USART */
USART_Cmd(COM_USART[COM], ENABLE);
Lo siguiente es una inicialización de un canal.
Esto es suficiente, lo cambiamos a USART2.
Luego, abrimos el archivo inicializado. La
ruta es la siguiente:
STM32 firmware library v3.5 \ STM32F10x_StdPeriph_Lib_V3.5.0 \ Project \ STM32F10x_StdPeriph_Examples \ USART \ Printf
encuentra el
comienzo de main.c es un párrafo Inicializa la configuración del puerto serie,
y luego la copiamos y hacemos algunos cambios en nuestra primera función de copia,
es decir, una función contiene otra función y el
código se publica para verlo por ti mismo
#include "uart.h"
void STM_EVAL_COMInit(USART_InitTypeDef* USART_InitStruct)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIO clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2 , ENABLE);
/* Configure USART Tx as alternate function push-pull */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure USART Rx as input floating */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* USART configuration */
USART_Init(USART2, USART_InitStruct);
/* Enable USART */
USART_Cmd(USART2, ENABLE);
}
void USART2_Init(void)
{
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_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
STM_EVAL_COMInit(&USART_InitStructure);
}
Luego configuramos la interrupción y su función de manejo de interrupciones
Todavía tenemos que encontrar
la
ruta main.c de DMA_interrupt en la colección de la biblioteca de firmware correspondiente de la siguiente manera:
Biblioteca de firmware STM32 v3.5 \ STM32F10x_StdPeriph_Lib_V3.5.0 \ Project \ STM32F10x_StdPeriph_Examples \ USART \ DMA_Interrupt
Primero busque el código de configuración de interrupción
NVIC_InitTypeDef NVIC_InitStructure;
/* Enable the USARTz Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = USARTz_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
Simplemente cambie el canal de configuración al puerto serie 2
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
A continuación, habilite la recepción de la interrupción.
También busque el comentario en el archivo y podrá encontrar rápidamente la oración.
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
Abra directamente la función
del archivo actual DMA_Interrupt interrupt configuration en la biblioteca de firmware, que es stm32 ... it.c para
encontrar fácilmente la función de recepción de interrupciones
void USART3_IRQHandler(void)
{
if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
{
/* Read one byte from the receive data register */
RxBuffer2[RxCounter++] = USART_ReceiveData(USART3);
if(RxCounter == NbrOfDataToRead)
{
/* Disable the USART3 Receive interrupt */
USART_ITConfig(USART3, USART_IT_RXNE, DISABLE);
}
}
}
Luego limpiamos el contenido y escribimos una bandera clara
void USART2_IRQHandler(void)
{
if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
{
/* Read one byte from the receive data register */
USART_ClearITPendingBit(USART2, USART_IT_RXNE);
}
}
Luego configuraremos printf
El puerto serie de la copa de puente azul incorporada utiliza Printf para generar
Escribí un artículo sobre la salida de cadenas, pero para imprimir algunas variables, las variables deben imprimirse como tipos de caracteres,
por lo que estas funciones se pueden completar fácilmente con printf
Primero, busque el código main.c del primer archivo en el RTC en la biblioteca de firmware. La
ruta es la siguiente:
biblioteca de firmware STM32 v3.5 \ STM32F10x_StdPeriph_Lib_V3.5.0 \ Project \ STM32F10x_StdPeriph_Examples \ RTC \ Calendar
y luego busque el Time_Show vacío (void) función para comenzar a copiar La última función
y luego la función que necesitamos
PUTCHAR_PROTOTYPE
{
USART_SendData(EVAL_COM1, (uint8_t) ch);
while (USART_GetFlagStatus(EVAL_COM1, USART_FLAG_TC) == RESET)
{
}
return ch;
}
Lo copiamos en nuestro archivo principal y
luego encontramos el código que define este archivo anteriormente.
#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__ */
Entonces solo necesitamos tomar el fputc (int ch, FILE * f) y reemplazar PUTCHAR_PROTOTYPE directamente.
De hecho, podemos ver que el código de definición de macro también es el mismo, pero hay más condiciones de juicio. El
código modificado
int fputc(int ch, FILE *f)
{
/* Place your implementation of fputc here */
/* e.g. write a character to the USART */
USART_SendData(USART2, (uint8_t) ch);
/* Loop until the end of transmission */
while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET)
{
}
return ch;
}
Al compilar finalmente, hable sobre la micro biblioteca de lenguaje C establecida por keil con (importante)
puerto serie completo para enviar el código de lenguaje c
#include "usart.h"
void USART_Config()
{
GPIO_InitTypeDef GPIO_InitStrure;
USART_InitTypeDef USART_InitSture;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO,ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
GPIO_InitStrure.GPIO_Mode=GPIO_Mode_AF_PP;
GPIO_InitStrure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_InitStrure.GPIO_Pin=GPIO_Pin_2;
GPIO_Init(GPIOA,&GPIO_InitStrure);
GPIO_InitStrure.GPIO_Mode=GPIO_Mode_IN_FLOATING;
GPIO_InitStrure.GPIO_Speed=GPIO_Speed_50MHz;
GPIO_InitStrure.GPIO_Pin=GPIO_Pin_3;
GPIO_Init(GPIOA,&GPIO_InitStrure);
USART_InitSture.USART_BaudRate=115200;
USART_InitSture.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
USART_InitSture.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
USART_InitSture.USART_Parity=USART_Parity_No;
USART_InitSture.USART_StopBits=USART_StopBits_1;
USART_InitSture.USART_WordLength=USART_WordLength_8b;
USART_Init(USART2,&USART_InitSture);
USART_Cmd(USART2,ENABLE);
USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
}
void USART_SendString(int8_t *str)
{
u8 index =0;//index 指数
do
{
USART_SendData(USART2,str[index]);
while(USART_GetFlagStatus(USART2,USART_FLAG_TXE)==RESET);
index++;
}
while(str[index]!=0);
}
void NVIC_USART_Config()
{
NVIC_InitTypeDef NVIC_InitStrure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
NVIC_InitStrure.NVIC_IRQChannel=USART2_IRQn;
NVIC_InitStrure.NVIC_IRQChannelCmd=ENABLE;
NVIC_InitStrure.NVIC_IRQChannelPreemptionPriority=1;
NVIC_InitStrure.NVIC_IRQChannelSubPriority=1;
NVIC_Init(&NVIC_InitStrure);
}
int fputc(int ch, FILE *f)
{
/* Place your implementation of fputc here */
/* e.g. write a character to the USART */
USART_SendData(USART2, (uint8_t) ch);
/* Loop until the end of transmission */
while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET)
{
}
return ch;
}
Archivo de encabezado en serie
#ifndef __USART_H
#define __USART_H
#include "stm32f10x.h"
#include "stm32f10x_it.h"
#include "stdio.h"
void USART_Config(void);
void USART_SendString(int8_t *str);
void NVIC_USART_Config(void);
#endif
Uso de la función principal
int main(void)
{
u32 i=255;
SysTick_Config(SystemCoreClock/1000);
LED_Init();
BEEP_Init();
BEEP_Control(OPEN);
Delay_Ms(100);
BEEP_Control(CLOSE);
USART_Config();
NVIC_USART_Config();
RTC_Configuration();
Time_Adjust(23,55,55);
while(1)
{
i++;
if(i==20000)i=0;
/* If 1s has been elapsed */
if (TimeDisplay == 1)
{
/* Display current time */
Time_Display(RTC_GetCounter());
TimeDisplay = 0;
}
printf("i = %d ",i);
}
}