Building a small CAN-Bus with CAN1 and CAN2 module of the STM32F105

[mubinicyer]

Posted on April 03, 2014 at 01:25

Hi,

I want to build a small CAN-Bus Network using CAN1 and CAN2 module of the STM32F105RCT6. Before testing the network I noticed something in the standard periphery library from ST. In my startup file startup_stm32f10x_md.c all of the IRQ handlers are listed (defined or whatever) except IRQHandlers for CAN2. I have following Handlers regarding to CAN:

USB_HP_CAN1_TX_IRQHandler, /*!< 19: USB High Priority or CAN1 TX */
USB_LP_CAN1_RX0_IRQHandler, /*!< 20: USB Low Priority or CAN1 RX0 */
CAN1_RX1_IRQHandler, /*!< 21: CAN1 RX1 */
CAN1_SCE_IRQHandler, /*!< 22: CAN1 SCE */

Where is the IRQHandlers for CAN2. Can I just add them at the end of list? And another issue: In file stm32f10x_can.c the functionsCAN_FilterInit andCAN_SlaveStartBankuse only one parameter assuming that the CAN module being used is number 1. Is that correct? What shall I do if I want to init a filter for CAN2?

[Tesla DeLorean]

Posted on April 03, 2014 at 01:39

Connectivity Line?

STM32F10x_StdPeriph_Lib_V3.5.0\Libraries\CMSIS\CM3\DeviceSupport\ST\STM32F10x\startup\arm\startup_stm32f10x_cl.s STM32F10x_StdPeriph_Lib_V3.5.0\Project\STM32F10x_StdPeriph_Examples\CAN\DualCAN\readme.txt

[mubinicyer]

Posted on April 03, 2014 at 09:51Oh men, thank you. I just didn't see it. I will try it.

[mubinicyer]

Posted on April 03, 2014 at 22:24 Hi again, I tried the DualCAN example from the ST Library but I could not run it. I attached a probe of osciloscope at PA12, nothing happens, it stays at 2.5V also idle. My code is so:

#define CAN1_PORT GPIOA
#define CAN1_Pin_RX GPIO_Pin_11
#define CAN1_Pin_TX GPIO_Pin_12
#define CAN2_PORT GPIOB // Remap
#define CAN2_Pin_RX GPIO_Pin_5
#define CAN2_Pin_TX GPIO_Pin_6
void CAN_Configuration(void)
{
CAN_DeInit(CAN1);
CAN_DeInit(CAN2);
CAN_StructInit(&CAN_InitStructure);
CAN_InitStructure.CAN_Prescaler = 36;
CAN_InitStructure.CAN_SJW = CAN_SJW_2tq;
CAN_InitStructure.CAN_BS1 = CAN_BS1_11tq;
CAN_InitStructure.CAN_BS2 = CAN_BS2_4tq;
CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
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 = ENABLE;
CAN_Init(CAN1, &CAN_InitStructure);
CAN_Init(CAN2, &CAN_InitStructure);
CAN_FilterInitStructure.CAN_FilterNumber = 1;
CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterIdHigh = 0x6420;
CAN_FilterInitStructure.CAN_FilterIdLow = 0x0;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0;
CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0;
CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
/* CAN2 filter init */
CAN_FilterInitStructure.CAN_FilterNumber = 15;
CAN_FilterInitStructure.CAN_FilterIdHigh = 0x2460;
CAN_FilterInit(&CAN_FilterInitStructure);
}
void RCC_Configuration(void)
{
//
// RCC system reset(for debug purpose)
//
RCC_DeInit();
//
// Enable HSE
//
RCC_HSEConfig(RCC_HSE_ON);
//
// Wait till HSE is ready
//
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
//
// HCLK = SYSCLK
//
RCC_HCLKConfig(RCC_SYSCLK_Div1);
//
// PCLK2 = HCLK
//
RCC_PCLK2Config(RCC_HCLK_Div1);
//
// PCLK1 = HCLK/2
//
RCC_PCLK1Config(RCC_HCLK_Div2);
//
// Flash 2 wait state
//
FLASH_SetLatency(FLASH_Latency_2);
//
// Enable Prefetch Buffer
//
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
//
// PLLCLK = 8MHz * 9 = 72 MHz
//
RCC_PLLConfig(0x00010000, RCC_PLLMul_9);
//
//Enable PLL
//
RCC_PLLCmd(ENABLE);
//
//Wait till PLL is ready
//
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
//
// Select PLL as system clock source
//
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
//
// Wait till PLL is used as system clock source
//
while (RCC_GetSYSCLKSource() != 0x08)
{
}
}
//
// Enable GPIOA, GPIOC and AFIO clock
//
RCC_APB1PeriphClockCmd( RCC_APB1Periph_TIM3 | \
RCC_APB1Periph_CAN1 | \
RCC_APB1Periph_CAN2 | \
, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | \
RCC_APB2Periph_GPIOB | \
RCC_APB2Periph_GPIOC | \
RCC_APB2Periph_ADC1 | \
RCC_APB2Periph_AFIO , ENABLE);
}
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
//
// Set the Vector Table base location at 0x08000000
//
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
//
// Configure one bit for preemption priority
//
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
/*
* Enable the EXTI9_5 Interrupt
*/
NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 4;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/*
* Enable EXTI 9-5 Lines interrupt
*/
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/*
* CAN1 RX and CAN2 RX interrupts
*/
NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = CAN2_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
CAN_ITConfig(CAN2, CAN_IT_FMP0, ENABLE);
}
void GPIO_Configuration(void)
{
// other GPIO configurations
// ...
// CAN1-bus input and outputs
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Pin = CAN1_Pin_RX;
GPIO_Init(CAN1_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = CAN1_Pin_TX;
GPIO_Init(CAN1_PORT, &GPIO_InitStructure);
// CAN2-bus input and outputs
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
GPIO_InitStructure.GPIO_Pin = CAN2_Pin_RX;
GPIO_Init(CAN2_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = CAN2_Pin_TX;
GPIO_Init(CAN2_PORT, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remap_CAN2, ENABLE);
}
file: stm3210x_it.c
void CAN1_RX0_IRQHandler(void)
{
CAN_Receive(CAN1, CAN_FIFO0, &CanRxMessage);
if( (CanRxMessage.StdId == 0x321) && (CanRxMessage.IDE == CAN_ID_STD) )
{
UART_Send(USART2, (const unsigned char *)''CAN2 RX0 interrupt: '');
for (i = 0; i < 
5
; ++i) {
UART_Send_Numeric(USART2, CanRxMessage.Data[i], 10);
UART_Send(USART2, (const unsigned char *)'':'');
}
UART_Send(USART2, (const unsigned char *)''

'');
}
}
void CAN2_RX0_IRQHandler(void)
{
CAN_Receive(CAN2, CAN_FIFO0, &CanRxMessage);
if( (CanRxMessage.StdId == 0x321) && (CanRxMessage.IDE == CAN_ID_STD) )
{
UART_Send(USART2, (const unsigned char *)''CAN2 RX0 interrupt: '');
for (
i
= 
0
; i < 5; ++i) {
UART_Send_Numeric(USART2, CanRxMessage.Data[i], 10);
UART_Send(USART2, (const unsigned char *)'':'');
}
UART_Send(USART2, (const unsigned char *)''

'');
}
}
void EXTI0_IRQHandler(void)
{
EXTI_ClearITPendingBit(EXTI_Line0);
uint8_t tag[5], TxMailbox, CAN_Status;
uint64_t 
rfid_tag
= 
0
;
CanTxMessage.StdId
= 
0x321
;
CanTxMessage.ExtId
= 
0
;
CanTxMessage.RTR
= 
CAN_RTR_DATA
;
CanTxMessage.IDE
= 
CAN_ID_STD
;
CanTxMessage.DLC
= 
8
;
if(GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_8)){
GPIO_WriteBit(GPIOC, GPIO_Pin_8, Bit_RESET);
}else{
GPIO_WriteBit(GPIOC, GPIO_Pin_8, Bit_SET);
}
if(RFID_ReadTag(tag)) {
for (
i
= 
0
; i < 7; ++i) {
CanTxMessage.Data[i] = 0;
}
for (
i
= 
0
; i < 5; ++i) {
rfid_tag <<= 8;
rfid_tag |= tag[i];
CanTxMessage.Data[i] = tag[i];
}
UART_Send(USART2, (const unsigned char *)''RFID Number: '');
UART_Send_Numeric(USART2, rfid_tag, 10);
UART_Send(USART2, (const unsigned char *)''

'');
}
while( !( (CAN1->TSR & CAN_TSR_TME0) || (CAN1->TSR & CAN_TSR_TME1) || (CAN1->TSR & CAN_TSR_TME2) ));
TxMailbox = CAN_Transmit(CAN1, &CanTxMessage);
CAN_Status = CAN_TransmitStatus(CAN1, TxMailbox);
UART_Send(USART2, (const unsigned char *)''TM: '');
switch (CAN_Status) {
case CAN_TxStatus_Failed:
UART_Send(USART2, (const unsigned char *)''CAN_TxStatus_Failed.'');
break;
case CAN_TxStatus_Ok:
UART_Send(USART2, (const unsigned char *)''CAN_TxStatus_Ok.'');
break;
case CAN_TxStatus_NoMailBox:
UART_Send(USART2, (const unsigned char *)''CAN_TxStatus_NoMailBox.'');
break;
case CAN_TxStatus_Pending:
UART_Send(USART2, (const unsigned char *)''CAN_TxStatus_Pending.'');
break;
default:
break;
}
UART_Send(USART2, (const unsigned char *)''

'');
if(GPIO_ReadOutputDataBit(GPIOC, GPIO_Pin_9)){
GPIO_WriteBit(GPIOC, GPIO_Pin_9, Bit_RESET);
}else{
GPIO_WriteBit(GPIOC, GPIO_Pin_9, Bit_SET);
}
}

I am receiving always ''

CAN_TxStatus_Pending''

on serial port (connected to USART2)

[Tesla DeLorean]

Posted on April 03, 2014 at 23:18

Do you have a transceiver on the bus? Is it connected to another device?

Most implementations using 105/107 parts I've seen use PD0/PD1 for CAN1 What version of the library are you using? SystemInit() should manage the clock configuration. The CAN baud rate looks a bit odd. ~59Kbit

[mubinicyer]

Posted on April 04, 2014 at 00:00

I want to make a connection between two CAN modules of one STM32F105RCT6. I am using CooCox IDE and the most of the RCC Configurations are added automatically. I use STM32F10x_StdPeriph_Lib_V3.5.0

I have two ISO1050 Transcievers from TI. One is connected to CAN1 and other is connected to CAN2. I connected both of the transciever with two wires (CAN_H and CAN_L, and of course they are connected to the same GND).Let me try port remapping for CAN1.I made the Baudrate slow in order to see it on my small osciloscope, Let me try other baudrates as well.