AnsweredAssumed Answered

STM32F4 Can-Bus Problem

Question asked by doganay.serhat on Oct 9, 2015
Latest reply on Oct 11, 2015 by doganay.serhat
Hi, everyone. I've a problem with Can-bus. I have STM32F4 discovery and use Keil uVision. I am building that code but, it can't run. No error or no warning. I use MCP2551 as can transceiver. I will send data to CanModule2 from CanModule1 and I view it from PC. I took this code from clive1. Thanks clive1. But i can't run this code. Help me please. This final year project. Thanks..

My 



//  CAN1 PB8 (RX), PB9 (TX) 
//  CAN2 PB5 (RX), PB6 (TX)  
//  USART6 PC7 (RX), PC6 (TX) 
 
#include "stm32f4xx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h> //
 
//****************************************************************************
 
void RCC_Configuration(void)
{
  /* --------------------------- System Clocks Configuration -----------------*/
  /* USART6 clock enable */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);
 
  /* Enable CAN clocks */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1 | RCC_APB1Periph_CAN2, ENABLE);
 
  /* GPIO[B,D,C] clock enable */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOD | RCC_AHB1Periph_GPIOC, ENABLE);
}
 
//****************************************************************************
 
void GPIO_Configuration(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
 
  /*-------------------------- GPIO Configuration ----------------------------*/
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 
  /* Configure USART RX and TX pins */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
 
  /* Connect USART pins to AF */
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource7, GPIO_AF_USART6);   // USART6_RX
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource6, GPIO_AF_USART6);  // USART6_TX
 
  /* Configure CAN1 RX and TX pins */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
 
  /* Connect CAN1 pins to AF */
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_CAN1); // CAN1_RX
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_CAN1); // CAN1_TX
 
  /* Configure CAN2 RX and TX pins */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
 
  /* Connect CAN2 pins to AF */
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_CAN2); // CAN2_RX
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_CAN2); // CAN2_TX
}
 
//****************************************************************************
 
void USART6_Configuration(void)
{
  USART_InitTypeDef USART_InitStructure;
 
  /* USARTx configuration ------------------------------------------------------*/
  /* USARTx configured as follow:
        - BaudRate = 115200 baud
        - Word Length = 8 Bits
        - One Stop Bit
        - No parity
        - Hardware flow control disabled (RTS and CTS signals)
        - Receive and transmit enabled
  */
  USART_InitStructure.USART_BaudRate = 115200;
  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(USART6, &USART_InitStructure);
 
  USART_Cmd(USART6, ENABLE);
}
 
//****************************************************************************
 
void CAN_Configuration(void)
{
  RCC_ClocksTypeDef     RCC_Clocks;
  CAN_InitTypeDef       CAN_InitStructure;
  CAN_FilterInitTypeDef CAN_FilterInitStructure;
 
  RCC_GetClocksFreq(&RCC_Clocks);
 
  /* CAN register init */
  CAN_DeInit(CAN1);
  CAN_DeInit(CAN2);
 
  CAN_StructInit(&CAN_InitStructure);
 
  /* CAN cell init */
  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;
 
  /* quanta 1+6+7 = 14, 14 * 24 = 336, 42000000 / 336 = 125000 */
  /* CAN Baudrate = 125Kbps (CAN clocked at 42 MHz) Prescale = 24 */
 
  /* Requires a clock with integer division into APB clock */
 
  CAN_InitStructure.CAN_SJW = CAN_SJW_1tq; // 1+6+7 = 14, 1+14+6 = 21, 1+15+5 = 21
  CAN_InitStructure.CAN_BS1 = CAN_BS1_6tq;
  CAN_InitStructure.CAN_BS2 = CAN_BS2_7tq;
  CAN_InitStructure.CAN_Prescaler = RCC_Clocks.PCLK1_Frequency / (14 * 1000000); // quanta by baudrate
 
  CAN_Init(CAN1, &CAN_InitStructure);
  CAN_Init(CAN2, &CAN_InitStructure);
 
  /* CAN filter init */
  CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask; // IdMask or IdList
  CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit; // 16 or 32
 
  CAN_FilterInitStructure.CAN_FilterIdHigh      = 0x0000; // Everything, otherwise 11-bit in top bits
  CAN_FilterInitStructure.CAN_FilterIdLow       = 0x0000;
  CAN_FilterInitStructure.CAN_FilterMaskIdHigh  = 0x0000;
  CAN_FilterInitStructure.CAN_FilterMaskIdLow   = 0x0000;
 
  CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0; // Rx
  CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
 
  CAN_FilterInitStructure.CAN_FilterNumber = 0; // CAN1 [ 0..13]
 
  CAN_FilterInit(&CAN_FilterInitStructure);
 
  CAN_FilterInitStructure.CAN_FilterNumber = 14; // CAN2 [14..27]
 
  CAN_FilterInit(&CAN_FilterInitStructure);
}
 
//****************************************************************************
 
void CAN2RX(void)
{
  CanRxMsg RxMessage;
 
  if (CAN_MessagePending(CAN2, CAN_FIFO0))
  {
    memset(&RxMessage, 0, sizeof(RxMessage));
 
    /* receive */
    CAN_Receive(CAN2, CAN_FIFO0, &RxMessage);
 
    printf("RX %04X - %02X - %02X %02X %02X %02X %02X %02X %02X %02X\n",
      RxMessage.StdId, RxMessage.DLC,
      RxMessage.Data[0],RxMessage.Data[1],RxMessage.Data[2],RxMessage.Data[3],
      RxMessage.Data[4],RxMessage.Data[5],RxMessage.Data[6],RxMessage.Data[7]);
  }
}
 
//****************************************************************************
 
void CAN1TX(void)
{
  CanTxMsg TxMessage;
 
  // transmit */
  TxMessage.StdId = 0x123;
  TxMessage.ExtId = 0x00;
  TxMessage.RTR = CAN_RTR_DATA;
  TxMessage.IDE = CAN_ID_STD;
  TxMessage.DLC = 8;
 
  TxMessage.Data[0] = 0x02;
  TxMessage.Data[1] = 0x11;
  TxMessage.Data[2] = 0x11;
  TxMessage.Data[3] = 0x11;
 
  while(1) // Do not want to exit
  {
    volatile uint32_t i;
    static int j = 0;
    uint8_t TransmitMailbox = 0;
 
    TxMessage.Data[4] = (j >>  0) & 0xFF; // Cycling
    TxMessage.Data[5] = (j >>  8) & 0xFF;
    TxMessage.Data[6] = (j >> 16) & 0xFF;
    TxMessage.Data[7] = (j >> 24) & 0xFF;
    j++;
 
    TransmitMailbox = CAN_Transmit(CAN1, &TxMessage);
 
    i = 0;
    while((CAN_TransmitStatus(CAN1, TransmitMailbox) != CANTXOK) && (i != 0xFFFFFF)) // Wait on Transmit
    {
      i++;
      CAN2RX(); // Pump RX
    }
 
    CAN2RX();
  }
}
 
//****************************************************************************
 
int main(void)
{
  RCC_Configuration();
 
  GPIO_Configuration();
 
  USART6_Configuration();
 
  CAN_Configuration();
 
  puts("CAN Test");
 
  CAN1TX();
 
  while(1); // Don't want to exit
}
#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t* file, uint32_t line)
{
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
 
  /* Infinite loop */
  while (1)
  {
  }
}
#endif

Outcomes