STM32 CAN通信

#include "stm32f10x.h"

#include"stdio.h" 

voidRCC_Config(void);

voidGPIO_Config(void);

voidUSART_Config(void);

voidCAN_Config(void);

int main(void)

 {

uint8_t TransmitMailbox = 0;

     CanTxMsg TxMessage;

     CanRxMsg RxMessage;uint32_t i = 0;

     RCC_Config();

GPIO_Config();

  USART_Config();

   CAN_Config();

TxMessage.ExtId=0x00AA0000;

TxMessage.IDE = CAN_ID_EXT;

TxMessage.RTR = CAN_RTR_DATA; 

TxMessage.DLC = 8;

TxMessage.Data[0] = 0x00;

TxMessage.Data[1] = 0x11;

     TransmitMailbox=CAN_Transmit(CAN1, &TxMessage);

while((CAN_TransmitStatus(CAN1, TransmitMailbox) != CANTXOK) && (i != 0xFFFF))

printf("\r\n The CAN1 has sended data:0x%x,0x%x\r\n",TxMessage.Data[0],TxMessage.Data[1]);

  while((CAN_MessagePending(CAN1, CAN_FIFO0) < 1) && (i != 0xFFFF))

RxMessage.StdId = 0x00;

RxMessage.IDE = CAN_ID_EXT;

RxMessage.DLC = 0;

RxMessage.Data[0] = 0x00;

RxMessage.Data[1] = 0x00;

CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);

printf("\r\n The CAN has Receive data :0x%x,0x%x\r\n",RxMessage.Data[0], RxMessage.Data[1]);

 while(1);

}

void RCC_Config(void)

{

SystemInit();

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA  ,ENABLE);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);

}

void  GPIO_Config(void)

{

    GPIO_InitTypeDef GPIO_InitStructure; 

 

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

  GPIO_Init(GPIOA, &GPIO_InitStructure);

 

/* Configure USART1 Tx (PA.09) as alternate function push-pull */

 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;

 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

 GPIO_Init(GPIOA, &GPIO_InitStructure);

 

 /* Configure USART1 Rx (PA.10) as input floating */

 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;

 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;

 GPIO_Init(GPIOA, &GPIO_InitStructure);

}

void CAN_Config(void)

{

   CAN_InitTypeDef CAN_InitStructure;

   CAN_FilterInitTypeDef CAN_FilterInitStructure;

   CAN_DeInit(CAN1);

   CAN_StructInit(&CAN_InitStructure);

   CAN_InitStructure.CAN_TTCM = DISABLE;

   CAN_InitStructure.CAN_ABOM = DISABLE;

   CAN_InitStructure.CAN_AWUM = DISABLE;

   CAN_InitStructure.CAN_NART = DISABLE;

   CAN_InitStructure.CAN_RFLM = ENABLE; 

   CAN_InitStructure.CAN_TXFP = DISABLE;

   CAN_InitStructure.CAN_Mode = CAN_Mode_LoopBack; 

   CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;

   CAN_InitStructure.CAN_BS1 = CAN_BS1_8tq; 

   CAN_InitStructure.CAN_BS2 = CAN_BS2_7tq; 

   CAN_InitStructure.CAN_Prescaler = 5;

   CAN_Init(CAN1,&CAN_InitStructure);

CAN_FilterInitStructure.CAN_FilterNumber = 0;

    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;

    CAN_FilterInitStructure.CAN_FilterIdHigh = 0x00AA;

    CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;

    CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x00FF;

    CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;

    CAN_FilterInitStructure.CAN_FilterFIFOAssignment =0;

    CAN_FilterInit(&CAN_FilterInitStructure);

}

void USART_Config()

{

USART_InitTypeDef USART_InitStructure;

//USART_ClockInitTypeDef USART_ClockInitStructure;

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;

 /* Configure USART1 */

 USART_Init(USART1, &USART_InitStructure);

 /* Enable USART1 Receive and Transmit interrupts */

 /* Enable the USART1 */

 USART_Cmd(USART1, ENABLE);

}

 int fputc(int ch,FILE*f)

{

USART_SendData(USART1,(u8) ch);

while(USART_GetFlagStatus(USART1,USART_FLAG_TC)==RESET);

return ch;

}