STM32F4Discovery: CAN Silent/Loopback

[jcerna1 (Gast)]

Hallo!

Zuerst möchte ich mich entschuldigen, da ich spreche Deutsch schlect. 
Ich möchte CAN-Nachrichten im Silent/Loopback auf STM32F4Discovery 
empfangen. Ich bekomme "Transmit_OK" beim Senden, aber nichts geht in 
CAN_RDLxR / CAN_RDHxR Register empfangen. Was mache ich falsch?

Hier ist mein Code:

/* Includes */
#include "stm32f4xx.h"
#include "stm32f4_discovery.h"

void Delay(__IO uint32_t nCount) {
    while(nCount--) {
    }
}

void RCC_Configuration(void) {
  /* ENABLE CLOCKS */
  /* GPIOB clock enable */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  /* USART3 clock enable */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
  /* CAN1 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
  /* CAN2 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
}

void GPIO_Configuration(void) {
  GPIO_InitTypeDef GPIO_InitStructureUSART;
  GPIO_InitTypeDef GPIO_InitStructureCAN_RX;
  GPIO_InitTypeDef GPIO_InitStructureCAN_TX;

  /* GPIO USART Configuration */
  GPIO_InitStructureUSART.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
  GPIO_InitStructureUSART.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructureUSART.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructureUSART.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_InitStructureUSART.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructureUSART);

  /* Connect USART to AF */
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_USART3); //USART_TX 
= PB10
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_USART3); //USART_RX 
= PB11

  /* GPIO CAN_RX Configuration */
  GPIO_InitStructureCAN_RX.GPIO_Pin = GPIO_Pin_12;
  GPIO_InitStructureCAN_RX.GPIO_Mode = GPIO_Mode_AF;
  //GPIO_InitStructureCAN_TX.GPIO_OType = GPIO_OType_PP;
    //GPIO_InitStructureCAN_TX.GPIO_PuPd = GPIO_PuPd_NOPULL;
  //GPIO_InitStructureCAN_TX.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructureCAN_RX);

  /* GPIO CAN_TX Configuration */
  GPIO_InitStructureCAN_TX.GPIO_Pin = GPIO_Pin_13;
  GPIO_InitStructureCAN_TX.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructureCAN_TX.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructureCAN_TX.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_InitStructureCAN_TX.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructureCAN_TX);

  /* Connect CAN_RX & CAN_TX to AF9 */
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource12, GPIO_AF_CAN2); //CAN_RX = 
PB12
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_CAN2); //CAN_TX = 
PB13
}

void USART_Configuration(void) {
  USART_InitTypeDef USART_InitStructure;

  /* USART3 configuration */
  /* 256000 baud, window 8bits, one stop bit, no parity, no hw control, 
rx/tx enabled */
  USART_InitStructure.USART_BaudRate = 256000;
  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(USART3, &USART_InitStructure);

  USART_Cmd(USART3, ENABLE);
}

void CAN_Configuration(void) {
  CAN_InitTypeDef CAN_InitStructure;

  /* CAN2 reset */
  CAN_DeInit(CAN2);

  /* CAN2 configuration */
  CAN_InitStructure.CAN_TTCM = DISABLE; // time-triggered communication 
mode = DISABLED
  CAN_InitStructure.CAN_ABOM = DISABLE; // automatic bus-off management 
mode = DISABLED
  CAN_InitStructure.CAN_AWUM = DISABLE; // automatic wake-up mode = 
DISABLED
  CAN_InitStructure.CAN_NART = DISABLE; // non-automatic retransmission 
mode = DISABLED
  CAN_InitStructure.CAN_RFLM = DISABLE; // receive FIFO locked mode = 
DISABLED
  CAN_InitStructure.CAN_TXFP = DISABLE; // transmit FIFO priority = 
DISABLED
  CAN_InitStructure.CAN_Mode = CAN_Silent_Loopback; //Silent_LoopBack; 
// normal CAN mode
  CAN_InitStructure.CAN_SJW = CAN_SJW_1tq; // synchronization jump width 
= 1
  CAN_InitStructure.CAN_BS1 = CAN_BS1_14tq; //14
  CAN_InitStructure.CAN_BS2 = CAN_BS2_6tq; //6
  CAN_InitStructure.CAN_Prescaler = 4; // baudrate 500 kbps
  //CAN_InitStructure.CAN_Prescaler = 16; // baudrate 125 kbps
  if (CAN_Init(CAN2, &CAN_InitStructure)) { // initialize CAN
    STM_EVAL_LEDInit(LED6); // initialize and
    STM_EVAL_LEDOn(LED6);   // turn ON blue LED if CAN initialization is 
successful
  }
}

void CAN_FilterConfiguration(void) {
  CAN_FilterInitTypeDef CAN_FilterInitStructure;

  /* CAN2 filter configuration */
  CAN_FilterInitStructure.CAN_FilterNumber = 0; // filter number = 0 
(0<=x<=13)
  CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask; // 
filter mode = identifier mask based filtering
  CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_16bit;
  CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0300 << 5; //0x0000;
  CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
  CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x03FF << 5;
  CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
  CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0; // FIFO 
= 0
  CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
  CAN_FilterInit(&CAN_FilterInitStructure);
}

void CAN_TxMessage(void) {
  CanTxMsg TxMessage;

  /* CAN message to send */
  TxMessage.StdId = 0x7DF;
  TxMessage.ExtId = 0x01;
  TxMessage.RTR = CAN_RTR_DATA;
  TxMessage.IDE = CAN_ID_STD;
  TxMessage.DLC = 8;
  TxMessage.Data[0] = 0x02;
  TxMessage.Data[1] = 0x01;
  TxMessage.Data[2] = 0x05;
  TxMessage.Data[3] = 0x00;
  TxMessage.Data[4] = 0x00;
  TxMessage.Data[5] = 0x00;
  TxMessage.Data[6] = 0x00;
  TxMessage.Data[7] = 0x00;

  //while (1) {
    CAN_TransmitStatus(CAN2, 0);
    CAN_Transmit(CAN2, &TxMessage);
    int initStatus = CAN_TransmitStatus(CAN2, 0);
    if(initStatus == 1){
      STM_EVAL_LEDInit(LED4); // initialize and
      STM_EVAL_LEDOn(LED4);   // turn ON green LED if transmit was 
successful
    }
  //}
}

void CAN_OBDII_RequestCurrentData(int PIDNumber) {
  CanTxMsg TxMessage;

  TxMessage.StdId = 0x7DF; // PID request identifier
  TxMessage.ExtId = 0x7DF;
  TxMessage.RTR = CAN_RTR_DATA;
  TxMessage.IDE = CAN_ID_STD;
  TxMessage.DLC = 8;
  TxMessage.Data[0] = 0x02; // number of additional bytes = 2
  TxMessage.Data[1] = 0x01; // show current data = 1
  TxMessage.Data[2] = PIDNumber; // PID code number
  TxMessage.Data[3] = 0x00;
  TxMessage.Data[4] = 0x00;
  TxMessage.Data[5] = 0x00;
  TxMessage.Data[6] = 0x00;
  TxMessage.Data[7] = 0x00;

  CAN_Transmit(CAN2, &TxMessage); // transmit OBDII PID request via 
CAN2/mailbox0
}

void CAN_RxMessage(void) {
  CanRxMsg RxMessage;
  int d0=0;
  while(1) {
  CAN_Receive(CAN2,CAN_FIFO0,&RxMessage);

  d0 = RxMessage.Data[0];
  d0 = RxMessage.Data[1];
  d0 = RxMessage.Data[2];
  d0 = RxMessage.Data[3];
  d0 = RxMessage.Data[4];
  d0 = RxMessage.Data[5];
  d0 = RxMessage.Data[6];
  d0 = RxMessage.Data[7];

  }
}

int main(void)
{
  /* Initialize Clocks */
  RCC_Configuration();
  /* Initialize GPIO */
  GPIO_Configuration();
  /* Initialize USART */
  USART_Configuration();
  /* Initialize CAN */
  CAN_Configuration();
  /* Initialize CAN Reception Filter */
  //CAN_FilterConfiguration();
  /* Transfer CAN message */
  CAN_TxMessage();
  /* Receive CAN message */
  CAN_RxMessage();
}