void can_init(can_t* can_filters)
{
gpio_clock_init(GPIOA);
can_clock_init(CAN1);
GPIO_InitTypeDef GPIO_InitStructure =
{
.GPIO_Pin = CAN_RX_PIN,
.GPIO_Speed = GPIO_Speed_50MHz,
.GPIO_Mode = GPIO_Mode_IN_FLOATING,
};
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = CAN_TX_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
CAN_InitTypeDef CAN_InitStructure;
CAN_StructInit(&CAN_InitStructure);
CAN_InitStructure.CAN_Prescaler = 1;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW = CAN_SJW_4tq;
CAN_InitStructure.CAN_BS1 = CAN_BS1_11tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_4tq;
CAN_InitStructure.CAN_ABOM = ENABLE;
CAN_InitStructure.CAN_RFLM = ENABLE;
CAN_Init(CAN1, &CAN_InitStructure);
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
CAN_ITConfig(CAN1, CAN_IT_FMP1, ENABLE);
NVIC_InitTypeDef NVIC_InitStructure =
{
.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn,
.NVIC_IRQChannelPreemptionPriority = 7,
.NVIC_IRQChannelSubPriority = 0,
.NVIC_IRQChannelCmd = ENABLE,
};
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX1_IRQn;
NVIC_Init(&NVIC_InitStructure);
for (int i = 0; i < can_filters->n_filters; i++)
CAN_FilterInit(can_filters->CAN_filterInit + i);
xCAN_receive_queue0 = xQueueCreate(10, sizeof(CanRxMsg));
xCAN_receive_queue1 = xQueueCreate(10, sizeof(CanRxMsg));
}
void USB_LP_CAN1_RX0_IRQHandler()
{
CanRxMsg RxMessage;
portBASE_TYPE resch = pdFALSE;
CAN_Receive(CAN1, CAN_FIFO0,&RxMessage);
xQueueSendFromISR(xCAN_receive_queue0, &RxMessage, &resch);
portEND_SWITCHING_ISR(resch);
}
void Can1_Init(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
// 首先打开电源及时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = USB_HP_CAN1_TX_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// 然后配置pin
Can_GPIO_Config();
CAN_config_init();
CAN_ITConfig(CAN1, CAN_IT_FMP0 | CAN_IT_FF0 | CAN_IT_FOV0, ENABLE); // fifo0中断
CAN_ITConfig(CAN1, CAN_IT_FMP1 | CAN_IT_FF1 | CAN_IT_FOV1, ENABLE); // fifo1中断
//CAN_ITConfig(CAN1, CAN_IT_TME, DISABLE); // 发送中断
}
EXPORT void Can_Hw_DisableControllerInterrupts(uint8 controller)
{
imask_t state;
Can_UnitType *canUnit;
CAN_HW_t *canHw;
canUnit = CAN_GET_PRIVATE_DATA(controller);
VALIDATE_NO_RV( (canUnit->state!=CANIF_CS_UNINIT), 0x4, CAN_E_UNINIT );
Irq_Save(state);
if(canUnit->lock_cnt > 0 )
{
// Interrupts already disabled
canUnit->lock_cnt++;
Irq_Restore(state);
return;
}
canUnit->lock_cnt++;
Irq_Restore(state);
/* Don't try to be intelligent, turn everything off */
canHw = GetController(controller);
/* Turn off the tx interrupt mailboxes */
CAN_ITConfig(canHw, CAN_IT_TME, DISABLE);
/* Turn off the bus off/tx warning/rx warning and error and rx */
CAN_ITConfig(canHw, CAN_IT_FMP0 | CAN_IT_BOF | CAN_IT_ERR | CAN_IT_WKU, DISABLE);
}
extern hal_result_t hal_can_enable(hal_can_t id)
{
hal_result_t res;
//hal_can_internals_t *intitem = s_hal_can_internals[HAL_can_id2index(id)];
hal_can_internal_item_t* intitem = s_hal_can_theinternals.items[HAL_can_id2index(id)];
CAN_TypeDef* CANx = HAL_can_port2peripheral(id);
if(hal_false == s_hal_can_initted_is(id))
{
return(hal_res_NOK_generic);
}
if(NULL == intitem)
{
return(hal_res_NOK_generic);
}
//res = s_hal_can_hw_registers_init(id); // hardware setup
hl_can_enable((hl_can_t)id);
if(res != hal_res_OK)
{
return(hal_res_NOK_generic);
}
// disable scheduling
hal_base_osal_scheduling_suspend();
intitem->enabled = 1;
// configure interrupts on rx (CAN_IT_FMP0 -> FIFO 0 message pending) and tx (CAN_IT_TME -> transmit mailbox empty)
// it is the same using only one call of CAN_ITConfig() or two ...
CAN_ITConfig(HAL_can_port2peripheral(id), (CAN_IT_FMP0 | CAN_IT_TME), ENABLE);
//CAN_ITConfig(HAL_can_port2peripheral(id), CAN_IT_FMP0, ENABLE);
//CAN_ITConfig(HAL_can_port2peripheral(id), CAN_IT_TME, ENABLE);
CAN_ITConfig( HAL_can_port2peripheral(id), CAN_IT_ERROR, ENABLE); // VALE
// nvic
s_hal_can_isr_rx_enable(id);
// dont enable the nvic for the tx
//s_hal_can_tx_enable(id);
s_hal_can_isr_tx_disable(id);
intitem->txisrisenabled = 0;
s_hal_can_isr_err_enable(id);// VALE
// it is in can driver by K&%L. it was not in hal-1. it seems not be important. it does not make can2 work ..
CANx->MCR &= ~(1 << 0); /* normal operating mode, reset INRQ */
while (CANx->MSR & (1 << 0));
// enable scheduling
hal_base_osal_scheduling_restart();
return(hal_res_OK);
}
void Can_IT_Config(void)
{
#if USE_CAN1_R0
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
#endif
#if USE_CAN1_R1
CAN_ITConfig(CAN1, CAN_IT_FMP1, ENABLE);
#endif
#if USE_CAN2_R0
CAN_ITConfig(CAN2, CAN_IT_FMP0, ENABLE);
#endif
#if USE_CAN2_R1
CAN_ITConfig(CAN2, CAN_IT_FMP1, ENABLE);
#endif
}
/*
***************************************************************
* 名称: can1_init
* 功能: can1初始化
* 输入: 1.baud_num
* 输出: NULL
* 返回: NULL
* 描述: 无
***************************************************************
*/
void can1_init(u32 baud_num)
{
CAN_InitTypeDef CAN_InitStructure;
/* CAN register init */
CAN_NVIC_Configuration();
CAN_GPIO_Configuration();
CAN_Address_GPIO_Config();
CAN_StructInit(&CAN_InitStructure);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM = DISABLE; // 非时间触发通信模式
CAN_InitStructure.CAN_ABOM = DISABLE; // 软件自动离线管理
CAN_InitStructure.CAN_AWUM = DISABLE; // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
CAN_InitStructure.CAN_NART = DISABLE; // 禁止报文自动传送
CAN_InitStructure.CAN_RFLM = DISABLE; // 报文不锁定,新的覆盖旧的
CAN_InitStructure.CAN_TXFP = ENABLE; // 优先级由报文标识符决定
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW = BaudTable[baud_num].SJW;
CAN_InitStructure.CAN_BS1 = BaudTable[baud_num].BS1;
CAN_InitStructure.CAN_BS2 = BaudTable[baud_num].BS2;
CAN_InitStructure.CAN_Prescaler = BaudTable[baud_num].PreScale;
CAN_Init(CAN1, &CAN_InitStructure);
//设置CAN接收过滤器
CAN_ConfigFilter(0, 0x7ff); // 广播地址，接受广播命令
CAN_ConfigFilter(1, Read_CAN_Address()&0x7f); // 本节点真实地址
//使能接收中断
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
}
/**
* @brief This function handles CAN1 TX irq and sends more data if available
*/
static void PIOS_CAN_TxGeneric(void)
{
CAN_ClearITPendingBit(can_dev->cfg->regs, CAN_IT_TME);
bool valid = PIOS_CAN_validate(can_dev);
PIOS_Assert(valid);
bool tx_need_yield = false;
if (can_dev->tx_out_cb) {
// Prepare CAN message structure
CanTxMsg msg;
msg.StdId = CAN_COM_ID;
msg.ExtId = 0;
msg.IDE = CAN_ID_STD;
msg.RTR = CAN_RTR_DATA;
msg.DLC = (can_dev->tx_out_cb)(can_dev->tx_out_context, msg.Data, MAX_SEND_LEN, NULL, &tx_need_yield);
// Send message and get mailbox number
if (msg.DLC > 0) {
CAN_Transmit(can_dev->cfg->regs, &msg);
} else {
CAN_ITConfig(can_dev->cfg->regs, CAN_IT_TME, DISABLE);
}
// TODO: deal with failure to send and keep the message to retransmit
}
#if defined(PIOS_INCLUDE_FREERTOS)
portEND_SWITCHING_ISR(tx_need_yield ? pdTRUE : pdFALSE);
#endif /* defined(PIOS_INCLUDE_FREERTOS) */
}
int RecvFrame(u8 type,u8 *pRecvFrame)
{
u8 os_err;
int iLength=0;//系统时间 有问题
while(1){
switch(type){
case OBD_TYPE_ISO:
iLength=Normal_RecvFrame(pRecvFrame,50);
break;
case OBD_TYPE_KWP:
iLength=KWP_RecvFrame(pRecvFrame);
break;
case OBD_TYPE_VPW:
iLength=VPW_RecvFrame(pRecvFrame);
break;
case OBD_TYPE_PWM:
iLength=PWM_RecvFrame(pRecvFrame);
break;
case OBD_TYPE_CAN1:
case OBD_TYPE_CAN2:
CAN_ITConfig(CAN1,CAN_IT_FMP0 | CAN_IT_FOV0, ENABLE);
OSSemPend(sem_obd_prot, 1*OS_TICKS_PER_SEC, &os_err);//timeout: 1 seconds
if(os_err)break;
iLength=CAN_RecvFrame(pRecvFrame);
break;
}
if(iLength==0)continue;
else break;
}
my_icar.event = 0;
return iLength;
}
static void CAN_device_init_1(int baud)
{
CAN_DeInit(CAN1);
/* CAN GPIOs configuration ************************************************* */
/* Enable GPIO clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
/* Connect CAN pins to Alternate Function */
GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_9);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_9);
initGPIO(GPIOB, GPIO_Pin_8 | GPIO_Pin_9);
/* CAN configuration ******************************************************* */
/* Enable CAN clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
initCAN(CAN1, baud);
//set default filter
CAN_device_set_filter(0, 0, 0, 0, 0);
/* Enable FIFO 0 message pending Interrupt */
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
initCANInterrupts(CAN1, USB_LP_CAN1_RX0_IRQn);
}
void CAN2_TX_IRQHandler(void)
{
CanTxMsg tx;
if(_buffer_pull(__can->tx,&tx,sizeof(CanTxMsg)))
CAN_Transmit(CAN2,&tx);
else
CAN_ITConfig(CAN2, CAN_IT_TME, DISABLE);
}
void CAN_Config(void) {
CAN_InitTypeDef CAN_InitStruct;
CAN_FilterInitTypeDef CAN_FilterInitStruct;
NVIC_InitTypeDef NVIC_InitStruct;
GPIO_InitTypeDef GPIO_InitStruct;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_9);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_9);
GPIO_StructInit(&GPIO_InitStruct);
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStruct);
// can peripherial
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
CAN_StructInit(&CAN_InitStruct);
CAN_InitStruct.CAN_ABOM = DISABLE;
CAN_InitStruct.CAN_AWUM = DISABLE;
CAN_InitStruct.CAN_NART = DISABLE;
CAN_InitStruct.CAN_RFLM = DISABLE;
CAN_InitStruct.CAN_TTCM = DISABLE;
CAN_InitStruct.CAN_TXFP = DISABLE;
CAN_InitStruct.CAN_Prescaler = 18; // 125000 Baud rate assuimg CAN speed 36MHz
CAN_InitStruct.CAN_SJW = CAN_SJW_1tq;
CAN_InitStruct.CAN_BS1 = CAN_BS1_13tq;
CAN_InitStruct.CAN_BS2 = CAN_BS2_2tq;
CAN_InitStruct.CAN_Mode = CAN_Mode_Normal;
CAN_Init(CAN1, &CAN_InitStruct);
// can filter
CAN_FilterInitStruct.CAN_FilterNumber = 0;
CAN_FilterInitStruct.CAN_FilterMode = CAN_FilterMode_IdMask;
CAN_FilterInitStruct.CAN_FilterScale = CAN_FilterScale_32bit;
CAN_FilterInitStruct.CAN_FilterActivation = ENABLE;
CAN_FilterInitStruct.CAN_FilterFIFOAssignment = CAN_FIFO0;
CAN_FilterInitStruct.CAN_FilterIdHigh = 0;
CAN_FilterInitStruct.CAN_FilterIdLow = 0;
CAN_FilterInitStruct.CAN_FilterMaskIdHigh = 0;
CAN_FilterInitStruct.CAN_FilterMaskIdLow = 0;
CAN_FilterInit(&CAN_FilterInitStruct);
// can interrupt
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
NVIC_InitStruct.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
NVIC_Init(&NVIC_InitStruct);
}
void DST_CAN_1::CAN_Configuration_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
//使能相关时钟
RCC_AHB1PeriphClockCmd(RCC_CAN_1, ENABLE);//使能PORTA时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);//使能CAN1时钟
//初始化GPIO
GPIO_InitStructure.GPIO_Pin = CAN_1_TX | CAN_1_RX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100MHz
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
GPIO_Init(GPIO_CAN_1, &GPIO_InitStructure);//初始化CAN_1_TX,CAN_1_RX
//引脚复用映射配置
GPIO_PinAFConfig(GPIOD,GPIO_PinSource1,GPIO_AF_CAN1); //GPIOD1复用为CAN1_TX
GPIO_PinAFConfig(GPIOD,GPIO_PinSource0,GPIO_AF_CAN1); //GPIOD0复用为CAN1_RX
//CAN单元设置
CAN_InitStructure.CAN_TTCM=DISABLE; //非时间触发通信模式
CAN_InitStructure.CAN_ABOM=DISABLE; //软件自动离线管理
CAN_InitStructure.CAN_AWUM=DISABLE;//睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
CAN_InitStructure.CAN_NART=ENABLE; //禁止报文自动传送
CAN_InitStructure.CAN_RFLM=DISABLE; //报文不锁定,新的覆盖旧的
CAN_InitStructure.CAN_TXFP=DISABLE; //优先级由报文标识符决定
CAN_InitStructure.CAN_Mode= CAN_Mode_Normal; //模式设置
CAN_InitStructure.CAN_SJW=CAN_SJW_1tq; //重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位 CAN_SJW_1tq~CAN_SJW_4tq
CAN_InitStructure.CAN_BS1=CAN_BS1_9tq; //Tbs1范围CAN_BS1_1tq ~CAN_BS1_16tq
CAN_InitStructure.CAN_BS2=CAN_BS2_4tq;//Tbs2范围CAN_BS2_1tq ~ CAN_BS2_8tq
CAN_InitStructure.CAN_Prescaler=3; //分频系数(Fdiv)为brp+1
CAN_Init(CAN1, &CAN_InitStructure); // 初始化CAN1
//配置过滤器
CAN_FilterInitStructure.CAN_FilterNumber=0; //过滤器0
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //32位
CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;////32位ID
CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;//32位MASK
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;//过滤器0关联到FIFO0
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //激活过滤器0
CAN_FilterInit(&CAN_FilterInitStructure);//滤波器初始化
CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);//★FIFO0★消息挂号中断允许.
NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // 主优先级为1
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 次优先级为0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
EXPORT void Can_Hw_EnableControllerInterrupts( uint8 controller )
{
imask_t state;
Can_UnitType *canUnit;
CAN_HW_t *canHw;
const Can_ControllerConfigType *canHwConfig;
canUnit = CAN_GET_PRIVATE_DATA(controller);
VALIDATE_NO_RV( (canUnit->state!=CANIF_CS_UNINIT), 0x5, CAN_E_UNINIT );
Irq_Save(state);
if( canUnit->lock_cnt > 1 )
{
// IRQ should still be disabled so just decrement counter
canUnit->lock_cnt--;
Irq_Restore(state);
return;
} else if (canUnit->lock_cnt == 1)
{
canUnit->lock_cnt = 0;
}
Irq_Restore(state);
canHw = GetController(controller);
canHwConfig = CAN_GET_CONTROLLER_CONFIG(Can_Global.channelMap[controller]);
if( canHwConfig->CanRxProcessing == CAN_PROCESS_TYPE_INTERRUPT ) {
/* Turn on the rx interrupt */
CAN_ITConfig(canHw, CAN_IT_FMP0, ENABLE);
}
if( canHwConfig->CanTxProcessing == CAN_PROCESS_TYPE_INTERRUPT ) {
/* Turn on the tx interrupt mailboxes */
CAN_ITConfig(canHw, CAN_IT_TME, ENABLE);
}
// BusOff here represents all errors and warnings
if( canHwConfig->CanBusOffProcessing == CAN_PROCESS_TYPE_INTERRUPT ) {
/* Turn on the bus off/tx warning/rx warning and error and rx */
CAN_ITConfig(canHw, CAN_IT_BOF | CAN_IT_ERR | CAN_IT_WKU, ENABLE);
}
return;
}
static void PIOS_CAN_RxStart(uintptr_t can_id, uint16_t rx_bytes_avail)
{
struct pios_can_dev *can_dev = (struct pios_can_dev *)can_id;
bool valid = PIOS_CAN_validate(can_dev);
PIOS_Assert(valid);
CAN_ITConfig(can_dev->cfg->regs, CAN_IT_FMP1, ENABLE);
}
void InitCAN(void)
{
// Setup CAN Pins
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = CAN_RX_PIN | CAN_TX_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// Alternate functions
GPIO_PinAFConfig(GPIOA, GPIO_PinSource11, GPIO_AF_CAN1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource12, GPIO_AF_CAN1);
// Setup CAN-modules
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
/* CAN register init */
CAN_DeInit(CAN1);
/* CAN cell init */
CAN_InitTypeDef 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 = DISABLE;
CAN_InitStructure.CAN_TXFP = DISABLE;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW = CAN_SJW_3tq;
/* CAN Baudrate = 500 KBps (CAN clocked at 42 MHz) */
CAN_InitStructure.CAN_BS1 = CAN_BS1_4tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_2tq;
CAN_InitStructure.CAN_Prescaler = (42000000 / 7) / 500000;
CAN_Init(CAN1, &CAN_InitStructure);
/* CAN filter init */
CAN_FilterInitTypeDef CAN_FilterInitStructure;
CAN_FilterInitStructure.CAN_FilterNumber = 0;
CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;
CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0;
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
/* Enable FIFO 0 message pending Interrupt */
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
}
void TSVN_CAN_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remap2_CAN1 , ENABLE);
GPIO_PinRemapConfig(GPIO_Remap_PD01 , ENABLE);
CAN_DeInit(CAN1);
CAN_InitStructure.CAN_TTCM = DISABLE;
CAN_InitStructure.CAN_ABOM = DISABLE;
CAN_InitStructure.CAN_AWUM = DISABLE;
CAN_InitStructure.CAN_NART = DISABLE;
CAN_InitStructure.CAN_RFLM = DISABLE;
CAN_InitStructure.CAN_TXFP = DISABLE;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1 = CAN_BS1_3tq; //3
CAN_InitStructure.CAN_BS2 = CAN_BS2_5tq; //5
CAN_InitStructure.CAN_Prescaler = 4;
CAN_FilterInitStructure.CAN_FilterNumber = 0;
CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;
CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0;
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);
CAN_Init(CAN1, &CAN_InitStructure);
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f10x_xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f10x.c file
*/
/* Configures LED 1..4 */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDOff(LED1);
DFLASH
/* NVIC configuration */
NVIC_Config();
RCC_Configuration();
GPIO_Configuration();
USART_InitStructure.USART_BaudRate = 19200;
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(USART1, &USART_InitStructure);
USART_Cmd(USART1, ENABLE);
Debug("\nZZZZZZZZZZZZZZzzzzzzzzzzzzzzzzzz!!!!!!!!!!!!!!!!!!!!");
DFLASH
/* CAN configuration */
CAN_Config();
Delay();
CAN_ITConfig(CANx, CAN_IT_FMP0, ENABLE);
/* Infinite loop */
short int x,led;
while(1) {
x++;
if (x == 0) {
if (led) {
STM_EVAL_LEDOn(LED1);
Delay();
}
else {
STM_EVAL_LEDOff(LED1);
TxMessage.Data[0]++;
CAN_Transmit(CANx, &TxMessage);
Delay();
}
led ^= 1;
}
}//END While
}//END main
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f10x_xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f10x.c file
*/
/* NVIC configuration */
NVIC_Config();
/* Configures LED 1..4 */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Configure Push button key */
STM_EVAL_PBInit(BUTTON_KEY, BUTTON_MODE_GPIO);
/* CAN configuration */
CAN_Config();
CAN_ITConfig(CANx, CAN_IT_FMP0, ENABLE);
/* turn off all leds*/
STM_EVAL_LEDOff(LED1);
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
/* Infinite loop */
while(1)
{
while(STM_EVAL_PBGetState(BUTTON_KEY) == KEY_PRESSED)
{
if(KeyNumber == 0x4)
{
KeyNumber = 0x00;
}
else
{
LED_Display(++KeyNumber);
TxMessage.Data[0] = KeyNumber;
CAN_Transmit(CANx, &TxMessage);
Delay();
while(STM_EVAL_PBGetState(BUTTON_KEY) != KEY_NOT_PRESSED)
{
}
}
}
}
}
/**
* @file CAN_Configuration
* @brief Configures the CAN
* @param 无
* @retval 无
*/
void CAN_Configuration(void)
{
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
GPIO_Configuration();
/* CAN register init */
CAN_DeInit(CAN1);
CAN_StructInit(&CAN_InitStructure);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM = DISABLE; /* 时间触发禁止, 时间触发：CAN硬件的内部定时器被激活，并且被用于产生时间戳 */
CAN_InitStructure.CAN_ABOM = DISABLE; /* 自动离线禁止，自动离线：一旦硬件监控到128次11个隐性位，就自动退出离线状态。在这里要软件设定后才能退出 */
CAN_InitStructure.CAN_AWUM = DISABLE; /* 自动唤醒禁止，有报文来的时候自动退出休眠 */
CAN_InitStructure.CAN_NART = DISABLE; /* 报文重传, 如果错误一直传到成功止，否则只传一次 */
CAN_InitStructure.CAN_RFLM = DISABLE; /* 接收FIFO锁定, 1--锁定后接收到新的报文摘不要，0--接收到新的报文则覆盖前一报文 */
CAN_InitStructure.CAN_TXFP = ENABLE; /* 发送优先级 0---由标识符决定 1---由发送请求顺序决定 */
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal; /* 模式 */
CAN_InitStructure.CAN_SJW = CAN_SJW_1tq; /* 重新同步跳宽，只有can硬件处于初始化模式时才能访问这个寄存器 */
CAN_InitStructure.CAN_BS1 = CAN_BS1_4tq; /* 时间段1 */
CAN_InitStructure.CAN_BS2 = CAN_BS2_3tq; /* 时间段2 */
CAN_InitStructure.CAN_Prescaler = 45; /* 波特率预分频数 */
/* 波特率计算方法 */
/* CANbps= Fpclk/((BRP+1)*((Tseg1+1)+(Tseg2+1)+1) 此处计算为 CANbps=36000000/(45*(4+3+1))=100kHz */ //此处Tseg1+1 = CAN_BS1_8tp
/* 配置大方向: Tseg1>=Tseg2 Tseg2>=tq; Tseg2>=2TSJW */
if (CAN_Init(CAN1,&CAN_InitStructure) == CANINITFAILED)
{
/* 初始化时先设置CAN_MCR的初始化位 */
/* 然后查看硬件是否真的设置了CAN_MSR的初始化位来确认是否进入了初始化模式 */
}
/* 配置CAN过滤器 */
/* 32位对应的id */
/* stdid[10:0]，extid[17:0],ide,rtr */
/* 16位对应的id */
/* stdid[10:0],ide,rtr,extid[17:15] */
/* 一般使用屏蔽模式 */
/* 要注意的是fifo接收存满了中断，还有就是fifo的概念，即取的一直是最早那一个数据， 要释放才能取下一个数据 */
/* 常使用的中断有 */
/* 1,有信息中断，即fifo挂号中断 */
/* 2,fifo满中断 */
/* 3,fifo满之后又有信息来则中断，即fifo溢出中断 */
CAN_FilterInitStructure.CAN_FilterNumber=0; /* 过滤器0 */
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; /* 屏敝模式 */
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; /* 32位 */
CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000; /* 以下四个都为0, 表明不过滤任何id */
CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=0; /* 能够通过该过滤器的报文存到fifo0中 */
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); /* 挂号中断, 进入中断后读fifo的报文函数释放报文清中断标志 */
CAN_FilterInit(&CAN_FilterInitStructure);
}
static void PIOS_CAN_TxStart(uintptr_t can_id, uint16_t tx_bytes_avail)
{
struct pios_can_dev *can_dev = (struct pios_can_dev *)can_id;
bool valid = PIOS_CAN_validate(can_dev);
PIOS_Assert(valid);
CAN_ITConfig(can_dev->cfg->regs, CAN_IT_TME, ENABLE);
USB_HP_CAN1_TX_IRQHandler();
}
void CAN2_Configuration(void)
{
CAN_InitTypeDef can;
CAN_FilterInitTypeDef can_filter;
GPIO_InitTypeDef gpio;
NVIC_InitTypeDef nvic;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource12, GPIO_AF_CAN2);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_CAN2);
gpio.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 ;
gpio.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(GPIOB, &gpio);
nvic.NVIC_IRQChannel = CAN2_RX0_IRQn;
nvic.NVIC_IRQChannelPreemptionPriority = 1;
nvic.NVIC_IRQChannelSubPriority = 0;
nvic.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&nvic);
CAN_DeInit(CAN2);
CAN_StructInit(&can);
can.CAN_TTCM = DISABLE;
can.CAN_ABOM = DISABLE;
can.CAN_AWUM = DISABLE;
can.CAN_NART = DISABLE;
can.CAN_RFLM = DISABLE;
can.CAN_TXFP = ENABLE;
can.CAN_Mode = CAN_Mode_Normal;
can.CAN_SJW = CAN_SJW_1tq;
can.CAN_BS1 = CAN_BS1_9tq;
can.CAN_BS2 = CAN_BS2_4tq;
can.CAN_Prescaler = 3; //CAN BaudRate 42/(1+9+4)/3=1Mbps
CAN_Init(CAN2, &can);
can_filter.CAN_FilterNumber=14;
can_filter.CAN_FilterMode=CAN_FilterMode_IdMask;
can_filter.CAN_FilterScale=CAN_FilterScale_32bit;
can_filter.CAN_FilterIdHigh=0x0000;
can_filter.CAN_FilterIdLow=0x0000;
can_filter.CAN_FilterMaskIdHigh=0x0000;
can_filter.CAN_FilterMaskIdLow=0x0000;
can_filter.CAN_FilterFIFOAssignment=0;//the message which pass the filter save in fifo0
can_filter.CAN_FilterActivation=ENABLE;
CAN_FilterInit(&can_filter);
CAN_ITConfig(CAN2,CAN_IT_FMP0,ENABLE);
}
EXPORT Can_ReturnType Can_Hw_Write( Can_HwHandleType/* Can_HTHType */ hth, const Can_PduType *pduInfo ) {
Can_ReturnType rv = CAN_OK;
CAN_HW_t *canHw;
const Can_HardwareObjectType *hohObj;
const Can_ControllerConfigType *canHwConfig;
uint32 controller;
imask_t state;
hohObj = Can_FindHoh(hth, &controller);
if (hohObj == NULL)
return CAN_NOT_OK;
Can_UnitType *canUnit = CAN_GET_PRIVATE_DATA(controller);
canHw = GetController(controller);
Irq_Save(state);
CanTxMsg TxMessage;
TxMessage.RTR=CAN_RTR_DATA;
TxMessage.DLC=pduInfo->length;
memcpy(TxMessage.Data, pduInfo->sdu, pduInfo->length);
if (hohObj->CanIdType == CAN_ID_TYPE_EXTENDED) {
TxMessage.IDE=CAN_ID_EXT;
TxMessage.ExtId=pduInfo->id;
} else {
TxMessage.IDE=CAN_ID_STD;
TxMessage.StdId=pduInfo->id;
}
// check for any free box
if(CAN_Transmit(canHw,&TxMessage) != CAN_NO_MB) {
canHwConfig = CAN_GET_CONTROLLER_CONFIG(Can_Global.channelMap[controller]);
if( canHwConfig->CanTxProcessing == CAN_PROCESS_TYPE_INTERRUPT ) {
/* Turn on the tx interrupt mailboxes */
CAN_ITConfig(canHw,CAN_IT_TME, ENABLE);
}
// Increment statistics
canUnit->stats.txSuccessCnt++;
// Store pdu handle in unit to be used by TxConfirmation
canUnit->swPduHandle = pduInfo->swPduHandle;
} else {
rv = CAN_BUSY;
}
Irq_Restore(state);
return rv;
}
/*******************************************************************************
* Function Name :
* Description :
* Output :
* Return :
*******************************************************************************/
void _CAN::TX_ISR(_CAN *p) {
CanTxMsg buf={0,0,CAN_ID_STD,CAN_RTR_DATA,0,0,0,0,0,0,0,0,0};
if(p) { // klic za prijavo instance
me=p;
me->tx=_buffer_init(100*sizeof(CanTxMsg));
} else { // klic iz ISR, instanca in buffer morata bit ze formirana
if(_buffer_pull(me->tx,&buf,sizeof(CanTxMsg)))
CAN_Transmit(__CAN__,&buf); // oddaj, ce je kaj na bufferju
else
CAN_ITConfig(__CAN__, CAN_IT_TME, DISABLE); // sicer zapri interrupt
}
}
extern hal_result_t hal_can_disable(hal_can_t id)
{
//hal_can_internals_t *intitem = s_hal_can_internals[HAL_can_id2index(id)];
hal_can_internal_item_t* intitem = s_hal_can_theinternals.items[HAL_can_id2index(id)];
if(hal_false == s_hal_can_initted_is(id))
{
return(hal_res_NOK_generic);
}
if(NULL == intitem)
{
return(hal_res_NOK_generic);
}
// disable scheduling
hal_base_osal_scheduling_suspend();
intitem->enabled = 0;
// deconfigure interrupts on rx (CAN_IT_FMP0 -> FIFO 0 message pending) and tx (CAN_IT_TME -> transmit mailbox empty)
// it is the same using only one call of CAN_ITConfig() or two ...
CAN_ITConfig(HAL_can_port2peripheral(id), (CAN_IT_FMP0 | CAN_IT_TME), DISABLE);
CAN_ITConfig(HAL_can_port2peripheral(id), CAN_IT_TME, DISABLE);
CAN_ITConfig(HAL_can_port2peripheral(id), CAN_IT_FMP0, DISABLE);
CAN_ITConfig( HAL_can_port2peripheral(id), CAN_IT_ERROR, DISABLE); // VALE
// nvic
s_hal_can_isr_rx_disable(id);
// dont disable the nvic for the tx. it was never enabled
s_hal_can_isr_tx_disable(id);
intitem->txisrisenabled = 0;
s_hal_can_isr_err_disable(id); // VALE
// enable scheduling
hal_base_osal_scheduling_restart();
return(hal_res_OK);
}
/*******************************************************************************
* Function Name :
* Description :
* Output :
* Return :
*******************************************************************************/
void _CAN::Send(CanTxMsg *msg) {
if(_buffer_count(tx) > 0 || (__CAN__->TSR & CAN_TSR_TME) == 0) {
_buffer_push(tx,&msg,sizeof(msg));
} else
CAN_Transmit(__CAN__,msg);
CAN_ITConfig(__CAN__, CAN_IT_TME, ENABLE);
//________ debug print__________________________________________________________________
if(_BIT(_LM::debug, DBG_CAN_TX)) {
// _io *temp=_stdio(lm->io);
printf("\r\n:%04d>%02X ",__time__ % 10000,msg->StdId);
for(int i=0;i<msg->DLC;++i)
printf(" %02X",msg->Data[i]);
printf("\r\n:");
// _stdio(temp);
}
}
void CAN_Initialise()
{
CAN_InitTypeDef CAN_InitStruct;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
void GPIO_Initialise();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2,ENABLE);
/* CAN register init */
CAN_DeInit(CAN2);
/* CAN cell init */
CAN_InitStruct.CAN_TTCM = DISABLE;
CAN_InitStruct.CAN_ABOM = DISABLE;
CAN_InitStruct.CAN_AWUM = DISABLE;
CAN_InitStruct.CAN_NART = DISABLE;
CAN_InitStruct.CAN_RFLM = DISABLE;
CAN_InitStruct.CAN_TXFP = DISABLE;
CAN_InitStruct.CAN_Mode = CAN_Mode_Normal;
CAN_InitStruct.CAN_SJW = CAN_SJW_3tq;
//Bus length 3-5m.
/* CAN Baudrate = 500 KBps (CAN clocked at 42 MHz) */
CAN_InitStruct.CAN_BS1 = CAN_BS1_4tq;
CAN_InitStruct.CAN_BS2 = CAN_BS2_2tq;
CAN_InitStruct.CAN_Prescaler = (42000000 / 7) / 500000; //12
CAN_Init(CAN2, &CAN_InitStruct);
/* CAN filter init */
CAN_FilterInitStructure.CAN_FilterNumber = 0;
CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;
CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0;
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
/* Enable FIFO 0 message pending Interrupt */
CAN_ITConfig(CAN2, CAN_IT_FMP0, ENABLE);
}
void _CAN1_Init()
{
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
_CAN1_GPIO_Init();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
CAN_InitStructure.CAN_TTCM=DISABLE;
CAN_InitStructure.CAN_ABOM=DISABLE;
CAN_InitStructure.CAN_AWUM=DISABLE;
CAN_InitStructure.CAN_NART=DISABLE;
CAN_InitStructure.CAN_RFLM=DISABLE;
CAN_InitStructure.CAN_TXFP=DISABLE;
//CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;
CAN_InitStructure.CAN_Mode=CAN_Mode_LoopBack;
CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;/*重新同步跳宽*/
CAN_InitStructure.CAN_BS1=CAN_BS1_4tq;/*时间段1*/
CAN_InitStructure.CAN_BS2=CAN_BS2_3tq;/*时间段2*/
CAN_InitStructure.CAN_Prescaler=45;/*波特率预分频数*/
CAN_Init(CAN1,&CAN_InitStructure);
//允许所有报文通过
CAN_FilterInitStructure.CAN_FilterNumber=0; //设置过滤器组0，范围为0~13
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;//指定过滤器被设置为标识符屏蔽模式
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;//给出过滤器位宽为32位
CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=0;//为过滤器分配缓存 此处到//fifo 因为 CAN_FilterInitStructure.CAN_FilterNumber=0;
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel=CAN1_RX1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/*
* 函数名：CAN_Filter_Config
* 描述 ：CAN的过滤器 配置
* 输入 ：无
* 输出 : 无
* 调用 ：内部调用
*/
static void CAN_Filter_Config(void)
{
CAN_FilterInitTypeDef CAN_FilterInitStructure;
/*CAN过滤器初始化*/
CAN_FilterInitStructure.CAN_FilterNumber=0; //过滤器组0
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; //工作在标识符屏蔽位模式
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //过滤器位宽为单个32位。
/* 使能报文标示符过滤器按照标示符的内容进行比对过滤，扩展ID不是如下的就抛弃掉，是的话，会存入FIFO0。 */
CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16; //要过滤的ID高位
CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
CAN_FilterInitStructure.CAN_FilterMaskIdHigh= 0xFFFF; //过滤器高16位每位必须匹配
CAN_FilterInitStructure.CAN_FilterMaskIdLow= 0xFFFF; //过滤器低16位每位必须匹配
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0 ; //过滤器被关联到FIFO0
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //使能过滤器
CAN_FilterInit(&CAN_FilterInitStructure);
/*CAN通信中断使能*/
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
}
void CAN1_RX0_IRQHandler() {
/* Advance buffer head. */
uint16_t tempRX_Head = ((&CAN1_Buf)->RX_Head + 1) & (CAN_BUFSIZE-1);
/* Check for overflow. */
uint16_t tempRX_Tail = (&CAN1_Buf)->RX_Tail;
CanRxMsg data;
CAN_Receive(CAN1, CAN_FIFO0, &data);
if (tempRX_Head == tempRX_Tail) {
/* Disable the CAN1 Receive interrupt */
CAN_ITConfig(CAN1, CAN_IT_FMP0, DISABLE);
}else{
(&CAN1_Buf)->RX[(&CAN1_Buf)->RX_Head] = data;
(&CAN1_Buf)->RX_Head = tempRX_Head;
}
__DSB(); // prevent erroneous recall of this handler due to delayed memory write
}
/**
* @brief Main program
* @param None
* @retval : None
*/
int main(void)
{
uint32_t i=0;
/* System clocks configuration ---------------------------------------------*/
RCC_Configuration();
/* NVIC configuration ------------------------------------------------------*/
NVIC_Configuration();
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration();
/* CAN configuration */
CAN_Config();
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
/* turn off all leds*/
LED_Display(5);
/* Infinite loop*/
while(1)
{
while(Key_Status()== Key_Pressed)
{
if(Key_Pressed_Number==0x4)
{
Key_Pressed_Number = 0x00;
}
else
{
LED_Display(++Key_Pressed_Number);
TxMessage.Data[0] = Key_Pressed_Number;
CAN_Transmit(CAN1, &TxMessage);
for(i=0;i<0xFFFF;i++);
while(Key_Status()!= Key_NoPressed);
}
}
}
}
