【极海APM32F407 Tiny Board】 CAN通信收发测试
[复制链接]
本帖最后由 TL-LED 于 2023-6-30 20:25 编辑
这篇来测试下极海APM32F407 Tiny Board开发板的CAN1通信收发测试。
一、硬件部分
测试使用CAN1，使用到的引脚PB8和PB9功能复用
PB8和PB9引脚功能
测试CAN通信需要收发器芯片，这里测试使用SN65HVD230芯片，下面是参考电路。
硬件连接图
手工搭建的CAN收发器，连接CAN卡。
二、程序部分
2.1、can.c
#include "main.h"
#include "can.h"
uint8_t intFlag1 = FAILED;
uint8_t intFlag2 = FAILED;
uint8_t can1_rxflag=0;
CAN_RxMessage_T Can1_RxMessage;
CAN_TxMessage_T Can1_TxMessage;
void CAN_Delay(uint32_t cnt)
{
while(cnt--)
{
__NOP();
}
}
void CAN_TxMessageInit(CAN_TxMessage_T *txMessage)
{
txMessage->stdID = 0x00;
txMessage->extID = 0x00;
txMessage->typeID = CAN_TYPEID_STD;
txMessage->dataLengthCode = 0;
for (uint8_t i = 0; i < 8; i++)
{
txMessage->data[i]=0x00;
}
}
void CAN_RxMessageInit(CAN_RxMessage_T *rxMessage)
{
rxMessage->stdID = 0x00;
rxMessage->extID = 0x00;
rxMessage->typeID = 0;
rxMessage->dataLengthCode = 0;
rxMessage->filterMatchIndex = 0;
for (uint8_t i = 0; i < 8; i++)
{
rxMessage->data[i]=0x00;
}
}
void CAN1_RxIsr(void)
{
CAN_RxMessageInit(&Can1_RxMessage);
/* receive */
CAN_RxMessage(CAN1, CAN_RX_FIFO_0, &Can1_RxMessage);
can1_rxflag=1;
}
/*!
* @brief This function handles CAN2 Interrpt Handler
*
* @param None
*
* @retval None
*/
void CAN2_RxIsr(void)
{
CAN_RxMessage_T RxMessage;
CAN_TxMessage_T TxMessage;
CAN_TxMessageInit(&TxMessage);
CAN_RxMessageInit(&RxMessage);
/* receive */
CAN_RxMessage(CAN2, CAN_RX_FIFO_0, &RxMessage);
if ((RxMessage.extID == 0x333333) && \
(RxMessage.typeID == CAN_TYPEID_EXT) && \
(RxMessage.dataLengthCode == 2 ) && \
(RxMessage.data[0] == 0xC3) && \
(RxMessage.data[1] == 0xD3))
{
intFlag2 = PASSED;
/* CAN2 transmit data to CAN1 */
TxMessage.extID = 0x444444;
TxMessage.remoteTxReq = CAN_RTXR_DATA;
TxMessage.typeID = CAN_TYPEID_EXT;
TxMessage.dataLengthCode = 2;
TxMessage.data[0] = 0xC4;
TxMessage.data[1] = 0xD4;
CAN_TxMessage(CAN2, &TxMessage);
}
else
{
intFlag2 = FAILED;
}
}
void NVIC_Configuration(void)
{
NVIC_EnableIRQRequest(CAN1_RX0_IRQn, 0, 0);
NVIC_EnableIRQRequest(CAN2_RX0_IRQn, 0, 0);
}
void CAN_GPIOInit(void)
{
GPIO_Config_T GPIO_InitStructure;
RCM_EnableAHB1PeriphClock(RCM_AHB1_PERIPH_GPIOB);
/* USE_CAN1 */
GPIO_InitStructure.pin = GPIO_PIN_8|GPIO_PIN_9;
GPIO_InitStructure.mode = GPIO_MODE_AF;
GPIO_InitStructure.otype = GPIO_OTYPE_PP;
GPIO_InitStructure.speed = GPIO_SPEED_100MHz;
GPIO_InitStructure.pupd = GPIO_PUPD_UP;
GPIO_Config(GPIOB, &GPIO_InitStructure);
GPIO_ConfigPinAF(GPIOB, GPIO_PIN_SOURCE_8, GPIO_AF_CAN1);
GPIO_ConfigPinAF(GPIOB, GPIO_PIN_SOURCE_9, GPIO_AF_CAN1);
/* USE_CAN2 */
GPIO_InitStructure.pin = GPIO_PIN_12|GPIO_PIN_13;
GPIO_InitStructure.mode = GPIO_MODE_AF;
GPIO_InitStructure.otype = GPIO_OTYPE_PP;
GPIO_InitStructure.speed = GPIO_SPEED_100MHz;
GPIO_InitStructure.pupd = GPIO_PUPD_UP;
GPIO_Config(GPIOB, &GPIO_InitStructure);
GPIO_ConfigPinAF(GPIOB, GPIO_PIN_SOURCE_12, GPIO_AF_CAN2);
GPIO_ConfigPinAF(GPIOB, GPIO_PIN_SOURCE_13, GPIO_AF_CAN2);
}
void CAN_Init(uint8_t baud)
{
CAN_Config_T CAN_ConfigStructure;
CAN_FilterConfig_T CAN_FilterStruct;
uint32_t apb1Clock;
uint16_t prescaler;
uint16_t timeSegment1;
uint16_t timeSegment2;
RCM_EnableAPB1PeriphClock(RCM_APB1_PERIPH_CAN1 | RCM_APB1_PERIPH_CAN2);
RCM_ReadPCLKFreq(&apb1Clock, NULL);
apb1Clock /= 1000000;
/* Config GPIO for CAN */
CAN_GPIOInit();
/* CAN register init */
CAN_Reset(CAN1);
CAN_Reset(CAN2);
CAN_ConfigStructInit(&CAN_ConfigStructure);
/* CAN cell init */
CAN_ConfigStructure.autoBusOffManage = DISABLE;
CAN_ConfigStructure.autoWakeUpMode = DISABLE;
CAN_ConfigStructure.nonAutoRetran = DISABLE;
CAN_ConfigStructure.rxFIFOLockMode = DISABLE;
CAN_ConfigStructure.txFIFOPriority = DISABLE;
CAN_ConfigStructure.mode = CAN_MODE_NORMAL;
/* Baudrate = PCLK1 / (prescaler * (timeSegment1 + timeSegment2 + 1)) */
CAN_ConfigStructure.syncJumpWidth = CAN_SJW_1;
/* When APB1 Clock is not 42M, you should calculate by you clock!! */
if (baud == CAN_BAUD_500K)
{
CAN_ConfigStructure.timeSegment1 = CAN_TIME_SEGMENT1_2;
CAN_ConfigStructure.timeSegment2 = CAN_TIME_SEGMENT2_3;
CAN_ConfigStructure.prescaler = 14;
}
else if (baud == CAN_BAUD_1M)
{
CAN_ConfigStructure.timeSegment1 = CAN_TIME_SEGMENT1_2;
CAN_ConfigStructure.timeSegment2 = CAN_TIME_SEGMENT2_3;
CAN_ConfigStructure.prescaler = 7;
}
else //!< 125K and 250K
{
CAN_ConfigStructure.timeSegment1 = CAN_TIME_SEGMENT1_3;
CAN_ConfigStructure.timeSegment2 = CAN_TIME_SEGMENT2_4;
CAN_ConfigStructure.prescaler = apb1Clock >> baud;
}
CAN_Config(CAN1, &CAN_ConfigStructure);
CAN_Config(CAN2, &CAN_ConfigStructure);
/* CAN filter init */
CAN_FilterStruct.filterMode = CAN_FILTER_MODE_IDMASK;
CAN_FilterStruct.filterScale = CAN_FILTER_SCALE_32BIT;
CAN_FilterStruct.filterIdHigh = 0x0000;
CAN_FilterStruct.filterIdLow = 0x0000;
CAN_FilterStruct.filterMaskIdHigh = 0x0000;
CAN_FilterStruct.filterMaskIdLow = 0x0000;
CAN_FilterStruct.filterFIFO = CAN_FILTER_FIFO_0;
CAN_FilterStruct.filterActivation = ENABLE;
/* CAN1 filter can be from 0 to 13 */
CAN_FilterStruct.filterNumber = 0;
CAN_ConfigFilter(&CAN_FilterStruct);
/* CAN2 filter can be from 14 to 27(using CAN1 register) */
CAN_FilterStruct.filterNumber = 14;
CAN_ConfigFilter(&CAN_FilterStruct);
prescaler = CAN_ConfigStructure.prescaler;
timeSegment1 = CAN_ConfigStructure.timeSegment1;
timeSegment2 = CAN_ConfigStructure.timeSegment2;
printf(" Configuration :\r\n");
printf(" APB1 Clock : %d MHz\r\n", apb1Clock);
printf(" CAN Baud : %d K\r\n",
(apb1Clock * 1000) / (prescaler * (timeSegment1 + timeSegment2 + 3)));
}
void init_can(void)
{
printf("init can \r\n");
CAN_Init(CAN_BAUD_500K);
/* CAN FIFO0 message pending interrupt enable */
CAN_EnableInterrupt(CAN1, CAN_INT_F0MP);
//CAN_EnableInterrupt(CAN2, CAN_INT_F0MP);
NVIC_EnableIRQRequest(CAN1_RX0_IRQn, 0, 0);
//NVIC_EnableIRQRequest(CAN2_RX0_IRQn, 0, 0);
}
void can1_txbuf(uint32_t id,uint8_t *txbuf)
{
uint8_t txx=0;
/* CAN1 transmit data*/
Can1_TxMessage.extID = id;
Can1_TxMessage.remoteTxReq = CAN_RTXR_DATA;
Can1_TxMessage.typeID = CAN_TYPEID_EXT;
Can1_TxMessage.dataLengthCode = 8;
for(txx=0;txx<8;txx++)
{
Can1_TxMessage.data[txx] = txbuf[txx];
}
CAN_TxMessage(CAN1, &Can1_TxMessage);
}
uint8_t can_txbuf[8];
//stc_can_rx_frame_t can_rxbuf;
uint8_t u=0;
uint8_t i=0;
void can_test(void)
{
if(can1_rxflag==1)
{
can1_rxflag=0;
if(Can1_RxMessage.typeID == CAN_TYPEID_EXT)
{
printf("CAN1 extID received ID: %.8x: ", (unsigned int)Can1_RxMessage.extID);
} else{
printf("CAN1 stdID received ID: %.8x: ", (unsigned int)Can1_RxMessage.stdID);
}
printf("Data: ");
for (i = 0; i < (uint8_t)Can1_RxMessage.dataLengthCode; i++)
{
printf(" %.2x.", Can1_RxMessage.data[i]);
}
printf("\r\n");
if(Can1_RxMessage.typeID == CAN_TYPEID_EXT)
{
can1_txbuf(Can1_RxMessage.extID+1, Can1_RxMessage.data);
} else{
can1_txbuf(Can1_RxMessage.stdID+1, Can1_RxMessage.data);
}
}
}
2.2、can.h
#ifndef _CAN_H
#define _CAN_H
enum
{
FAILED = 0, /*!< Failed value */
PASSED = 1 /*!< Passed value */
};
enum
{
CAN_BAUD_125K = 0, /*!< CAN baud rate config to 125K */
CAN_BAUD_250K = 1, /*!< CAN baud rate config to 250K */
CAN_BAUD_500K = 2, /*!< CAN baud rate config to 500K */
CAN_BAUD_1M = 3 /*!< CAN baud rate config to 1M */
};
/* You can choose the way as polling or interrupt */
#define CAN_TEST_POLLING
#define CAN_TEST_INT
void CAN1_RxIsr(void);
void CAN2_RxIsr(void);
void init_can(void);
void can_test(void);
void can1_txbuf(uint32_t id,uint8_t *txbuf);
#endif
2.3、main.c
#include "main.h"
#include "Board.h"
#include "oled_i2c.h"
int main(void)
{
uint8_t i=0;
SysTick_Init();
init_led();
init_usart();
init_can();
printf("oled init!\r\n");
led2_off();
led3_on();
while (1)
{
can_test();
led2_tog();
SysTick_Delay_ms(100);
}
}
三、程序运行
下载程序，复位开发板
3.1、扩展帧测试
CAN调试软件发送扩展帧数据，开发板接收到数据后，ID+1返回发送的数据，串口输出接收到的CAN数据，同时输出是扩展帧还是标准帧。
3.2、标准帧测试
| 
提升卡
变色卡
千斤顶
1/6 
京公网安备 11010802033920号
Copyright © 2005-2025 EEWORLD.com.cn, Inc. All rights reserved
