El problema integrado del microcontrolador del brazo de programación en lenguaje C cotex m3 es el siguiente. Definitivamente adóptalo, por favor da una respuesta experta.

Usar bibliotecas del sistema e inicializarlas una por una puede ser lo mejor.

O puedes formar gradualmente tu propia biblioteca de códigos usando códigos escritos por ti mismo o por otros, y luego usarlos según sea necesario (por ejemplo, inicializando solo parte del contenido)

Para Por ejemplo, mi propia aplicación USART/*

Alita?2012-07-14?v1

Alita?2012-07-15?V2?

Título: Todos los UART (UART4/5) y USART (1,2,3) se fusionarán aquí para una administración unificada

Parámetro: Ninguno

Volver : Ninguno

1. Inicialización de puerto

2. Funciones de comunicación básicas

*/

void?Full_USART_Configuration(void)

{

/*

1. Inicializar USART1

2. Inicializar USART2

3. Inicializar USART3

4. Inicialice UART4

*/

//?0. Objeto público ***

USART_InitTypeDef?USART_InitStructure //?USART objeto; estructura

USART_ClockInitTypeDef?USART_ClockInitStructure; //?Estructura de reloj

GPIO_InitTypeDef?GPIO_InitStructure //?Estructura GPIO universal

//1. = =======================================

// Inicialización puerto USART?TX (PA9) salida push-pull

GPIO_InitStructure.GPIO_Pin?=?GPIO_Pin_9;

GPIO_InitStructure.GPIO_Mode?=?GPIO_Mode_AF_PP;

GPIO_InitStructure .GPIO_Speed ​​?=?GPIO_Speed_50MHz;

GPIO_Init(GPIOA,?&GPIO_InitStructure);

//Inicializar entrada flotante del puerto USART?TX (PA10)

GPIO_InitStructure .GPIO_Pin?=?GPIO_Pin_10;

GPIO_InitStructure.GPIO_Mode?=?GPIO_Mode_IN_FLOATING;

GPIO_Init(GPIOA,?&GPIO_InitStructure);

//

USART_ClockInitStructure.USART_Clock?=?

USART_Clock_Disable; ? //Reloj de actividad de bajo nivel

USART_ClockInitStructure.USART_CPOL?=?USART_CPOL_Low; p> USART_ClockInitStructure.USART_CPHA?=?USART_CPHA_2Edge; //Captura de datos en el segundo borde del reloj

USART_ClockInitStructure.USART_LastBit?=?

USART_LastBit_Disable //El último bit de datos Los pulsos de reloj no salen de SCLK

/*?Configurar?los?parámetros?sincrónicos?USART1?*/

USART_ClockInit(USART1,?&USART_ClockInitStructure); //?Inicializar el reloj

//

USART_InitStructure.USART_BaudRate?=?USART_BRATES; ///?Velocidad en baudios: ¿USART_BRATES predeterminado? Prueba 9600, una velocidad mayor pierde datos

USART_InitStructure.USART_WordLength?=?

USART_WordLength_8b ; //?Longitud de datos 8

USART_InitStructure.USART_StopBits?=?USART_StopBits_1; //?Bit de parada 1

USART_InitStructure.USART_Parity?=?USART_Parity_No? //Pérdida de paridad (la verificación de paridad no está habilitada)

USART_InitStructure.USART_HardwareFlowControl?=?

USART_HardwareFlowControl_None

USART_InitStructure.USART_Mode?=?

USART_Mode_Rx; ?|?USART_Mode_Tx; //Habilitar recepción|Habilitar transmisión

USART_Init(USART1,?&USART_InitStructure

USART_Cmd(USART1,?ENABLE); p>

//?2 Inicializar USART2======================================. ======

//Inicializar salida push-pull del puerto USART?TX (PA2)

GPIO_InitStructure.GPIO_Pin?=?GPIO_Pin_2;

GPIO_InitStructure .GPIO_Mode?=?GPIO_Mode_AF_PP;

GPIO_InitStructure.GPIO_Speed?=?GPIO_Speed_50MHz;

GPIO_Init(GPIOA,?&GPIO_InitStructure

//Inicializar USART); ? Entrada flotante del puerto TX (PA3)

GPIO_InitStructure.GPIO_Pin?=?GPIO_Pin_3;

GPIO_InitStructure.GPIO_Mode?=?GPIO_Mode_IN_FLOATING;

GPIO_Init(GPIOA,? &GPIO_InitStructure);

//

USART_ClockInitStructure.USART_Clock?=?

USART_Clock_Disable ? //Reloj de actividad de bajo nivel

USART_ClockInitStructure . USART_CPOL?=?USART_CPOL_Low; //Reloj de nivel bajo

USART_ClockInitStructure.USART_CPHA?=?USART

_CPHA_2Edge; //Captura de datos en el segundo flanco del reloj

USART_ClockInitStructure.USART_LastBit?=?

USART_LastBit_Disable //El pulso de reloj del último bit de datos no se emite desde SCLK

USART_ClockInit(USART2,?&USART_ClockInitStructure); //Inicializar el reloj

//

USART_InitStructure.USART_BaudRate?=?USART_BRATES //Baud; velocidad - predeterminado USART_BRATES ?Prueba 9600, pérdida de datos a mayor velocidad

USART_InitStructure.USART_WordLength?=?

USART_WordLength_8b ///?Longitud de datos 8

USART_InitStructure; .USART_StopBits?=? USART_StopBits_1; //?Bit de parada 1

USART_InitStructure.USART_Parity?=?USART_Parity_No? //Paridad deshabilitada (la verificación de paridad no está habilitada)

USART_InitStructure. USART_HardwareFlowControl?=?

USART_HardwareFlowControl_None;

USART_InitStructure.USART_Mode?=?

USART_Mode_Rx?|?USART_Mode_Tx //?Habilitar recepción|Habilitar transmisión

USART_Init(USART2,?&USART_InitStructure);

USART_Cmd(USART2,?ENABLE); //Habilitar USART1

///?3. == ===================================

//Inicializar el USART TX puerto (PB10) Salida push-pull

GPIO_InitStructure.GPIO_Pin?=?GPIO_Pin_10;

GPIO_InitStructure.GPIO_Mode?=?GPIO_Mode_AF_PP;

GPIO_InitStructure.GPIO_Speed?= ?GPIO_Speed_50MHz ;

GPIO_Init(GPIOB,?&GPIO_InitStructure);

//Inicializar entrada flotante del puerto USART?TX (PB11)

GPIO_InitStructure.GPIO_Pin?= ? GPIO_Pin_11;

GPIO_InitStructure.GPIO_Mode?=?GPIO_Mode_IN_FLOATING;

GPIO_Init(GPIOB,?&GPIO_InitStructure);

//

USART_ClockInitStructure . USART_Clock?=?

USART_Clock_Disable ? //Reloj de actividad de bajo nivel

USART_ClockInitStructur

e.USART_CPOL?=?USART_CPOL_Low; //Nivel bajo del reloj

USART_ClockInitStructure.USART_CPHA?=?USART_CPHA_2Edge; //Captura de datos en el segundo borde del reloj

USART_ClockInitStructure.USART_LastBit? =?

USART_LastBit_Disable; //El pulso de reloj del último bit de datos no se emite desde SCLK

USART_ClockInit(USART3,?&USART_ClockInitStructure //Inicializar el reloj

//

USART_InitStructure.USART_BaudRate?=?USART_BRATES; //

Velocidad en baudios: USART_BRATES predeterminado? Prueba 9600, una velocidad mayor pierde datos

USART_InitStructure.USART_WordLength?= ?

USART_WordLength_8b; //?Longitud de datos 8

USART_InitStructure.USART_StopBits?=?USART_StopBits_1; //?Bit de parada 1

USART_InitStructure.USART_Parity?=? USART_Parity_No? ; // Paridad deshabilitada (la verificación de paridad no está habilitada)

USART_InitStructure.USART_HardwareFlowControl?=?

USART_HardwareFlowControl_None

USART_InitStructure.USART_Mode?=?

USART_Mode_Rx?|?USART_Mode_Tx; //?Habilitar recepción|Habilitar transmisión

USART_Init(USART3,?&USART_InitStructure

USART_Cmd(USART3,?ENABLE); ; //Habilitar USART1

///?4. Inicializar USART4============================== ============

//Inicializar salida push-pull del puerto USART?TX (PC10)

GPIO_InitStructure.GPIO_Pin?=?GPIO_Pin_10;

GPIO_InitStructure.GPIO_Mode?=?GPIO_Mode_AF_PP;

GPIO_InitStructure.GPIO_Speed?=?GPIO_Speed_50MHz;

GPIO_Init(GPIOC,?&GPIO_InitStructure

///?Inicializar entrada flotante del puerto USART?TX (PC11)

GPIO_InitStructure.GPIO_Pin?=?GPIO_Pin_11;

GPIO_InitStructure.GPIO_Mode?=?GPIO_Mode_IN_FLOATING;

GPIO_Init(GPIOC,?&GPIO_InitStructure);

//

USART_ClockInitStructure.USA

RT_Clock?=?

USART_Clock_Disable; ? //Reloj de nivel bajo

USART_ClockInitStructure.USART_CPOL?=?USART_CPOL_Low; //Reloj de nivel bajo

USART_ClockInitStructure .USART_CPHA ?=?USART_CPHA_2Edge; //Captura de datos en el segundo flanco del reloj

USART_ClockInitStructure.USART_LastBit?=?

USART_LastBit_Disable //El pulso de reloj del último bit de datos lo hace. no sigue la salida SCLK

USART_ClockInit(UART4,?&USART_ClockInitStructure); //Reloj de inicialización

//

USART_InitStructure.USART_BaudRate?=?USART_BRATES // ?Velocidad de bits de onda: prueba USART_BRATES predeterminada 9600, una velocidad mayor pierde datos

USART_InitStructure.USART_WordLength?=?

USART_WordLength_8b //Longitud de datos 8

USART_InitStructure .USART_StopBits?=?USART_StopBits_1; //Paridad deshabilitada (la verificación de paridad no está habilitada)

USART_InitStructure . USART_HardwareFlowControl?=?

USART_HardwareFlowControl_None;

USART_InitStructure.USART_Mode?=?

USART_Mode_Rx?|?USART_Mode_Tx //?Habilitación de recepción|Habilitación de transmisión

USART_Init(UART4,?&USART_InitStructure);

USART_Cmd(UART4,?ENABLE); //Enable USART1

}

En el Al mismo tiempo, los parámetros a nivel de mensaje se utilizan al sobrecargar fputc para controlar el canal para enviar mensajes, ya sea USARTx o transmisión de puerto completo // La función fputc en la biblioteca de lenguaje C está sobrecargada para usar USART para enviar datos

int?fputc(int?ch,?FILE?*f)

{

switch(USARTChannel_Flag)

{

caso?0:{}romper;

caso?1:

{

USART_SendData(USART1,?(u8)?ch);

while(USART_GetFlagStatus(

USART1,?USART_FLAG_TC)?==?RESET){ }

}romper;

caso?2 :

{

USART_SendData(USART2,?(u8)?ch);

while(USART_GetFlag

Estado(

USART2,?USART_FLAG_TC)?==?RESET){ }

}interrupción;

caso?3:

{

USART_SendData(USART3,?(u8)?ch);

while(USART_GetFlagStatus(

USART3,?USART_FLAG_TC)?==?RESET){ }

}romper;

caso?4:

{

USART_SendData(UART4,?(u8)?ch);

while(USART_GetFlagStatus(

UART4,?USART_FLAG_TC)?==?RESET){ }

}romper;

return?ch

}

} De esta manera, siempre que este código pase completamente la prueba, se puede modificar de acuerdo con esta plantilla en el futuro. Si solo se usa USART1, entonces. el resto será bloqueado