CAN BUS Acknowledgment error

OP #3898430
Hallo

           I am using STM32F429 CAN bus Program with TJA1041A as CAN 
Transreciver.

The Problem is the messages are not getting acknowledged and herewith I 
am attaching the code for further reference.I am using PCAN View to see 
the messages.

I kindly request to check the code and tell me if there r any faults.

Code:-

int main(void)
{

 RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);

// SystemInit();

    GPIO_InitTypeDef GPIO_InitDef;
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
    GPIO_InitDef.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13;
    GPIO_InitDef.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitDef.GPIO_OType = GPIO_OType_PP;
    GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_InitDef.GPIO_Speed = GPIO_Speed_100MHz;
   GPIO_Init(GPIOB, &GPIO_InitDef);

/* Connect CAN pins to AF */
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource12, GPIO_AF_CAN2); // CAN2_RX
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_CAN2); // CAN2_TX

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

   GPIO_InitDef.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
    GPIO_InitDef.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitDef.GPIO_OType = GPIO_OType_PP;
    GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_InitDef.GPIO_Speed = GPIO_Speed_100MHz;

  /* Connect PD5 and PD7 pins  for CAN Transreceiver to enable and 
stanby */

 GPIO_Init(GPIOD, &GPIO_InitDef);
     GPIO_SetBits(GPIOD, GPIO_Pin_5|GPIO_Pin_7);

   RCC_ClocksTypeDef     RCC_Clocks;
  CAN_InitTypeDef       CAN_InitStructure;
  CAN_FilterInitTypeDef CAN_FilterInitStructure;

  RCC_GetClocksFreq(&RCC_Clocks);

  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+14+6 = 21, 21 * 4 = 84, 42000000 / 84 = 5000000 */
  /* CAN Baudrate = 500Kbps (CAN clocked at 42 MHz) Prescale = 4 */

  /* 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_14tq;
  CAN_InitStructure.CAN_BS2 = CAN_BS2_6tq;
  CAN_InitStructure.CAN_Prescaler = 4; // quanta by baudrate - 125kbps

  CAN_Init(CAN2, &CAN_InitStructure);

  /* CAN filter init */
  CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask; // 
IdMask or IdList
  CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_16bit; // 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);
  CAN_ITConfig(CAN2, CAN_IT_FMP0, ENABLE);

 CanTxMsg TxMessage;

  // transmit */
  TxMessage.StdId = 0x321;
  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)
  {
    uint32_t i;
     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(CAN2, &TxMessage);

i = 0;
    while((CAN_TransmitStatus(CAN2, TransmitMailbox) != CANTXOK) && (i 
!= 0xFFFF)) // Wait on Transmit
    {
      i++;
      CAN2RX();// Pump RX
    }

  }

}
Sure, that your device transmit a message? (not loop back mode - check 
it/measure it)

In case, that your transceiver can be dactivate - is it activated?

Is you Peak device in Listen only mode? In Listen only mode the device 
do not send an acknowlede.

In case all of them should be correct - Change the bitrate of the Peak 
and transmit a message. Now the Peak should go in Error Busoff. In other 
case your device is not active on the CAN bus.
You mean:

You see the CAN messages of your STM on the CAN bus?

Is the Peak your second node? Send with the Peak device. Do you see this 
messages, too?

> /* Connect PD5 and PD7 pins  for CAN Transreceiver to enable and
stanby */

>  GPIO_Init(GPIOD, &GPIO_InitDef);
>     GPIO_SetBits(GPIOD, GPIO_Pin_5|GPIO_Pin_7);

High active?
OP
If I transmit a message with the PCAN View,it shows an Error Message 
with some ID and displays "BUS HEAVY."



I have checked my GPIO function also and its also perfectly right..



I am sending the following message from PCAn

ID :123
DLC:8
Data(8) = All 0x00
Peak and STM are connected and online.

1) You send with the STM and see the waveform. You get an Acknowledge 
Error.
2) You send with the Peak and see the waveform. You see a Error Message 
(Acknowledge Error, too?). Only one? Bus heavy.
3) You switch the Peak to a different CAN bitrate (use a higher bitrate) 
and send a message. You see the waveform and the error like 2).

Sure, that the CAN busses are connected of both devices and both running 
at the same time?

One additional test:

Connect CAN-H and CAN-L (short circuit). If you transmit a message with 
the STM, the STM has to go in Busoff. If you transmit with the Peak, the 
Peak has to go in Busoff.
OP
I want to know whether CAN2 bus alone can be initalized seperately and 
transmit the messages.

Because when I studied through the reference manual,I came to know CAN2 
is a Slave and CAN1 is a Master Node.



So I kindly request you to tell me whether is ist possible to implement 
CAN2 message communication seperately by initalzing the GPIO Pins
The simplest test would be to measure the CAN waveform -> bittime.
The easierst is, to measure the Bittiming on the TX/RX pin instead on 
CAN-H/CAN-L.

But I was the meaning, if you write, you checked the waveform, that you 
did see, that the bittiming is correct.
Can you ask directly, what you don't understand?

1 bit of 500kbit/s is 2µs. This can you check with the oscilloscope.
For easier measurement the CPU pins are better to use as the Transceiver 
Pins.

To measure the CAN bitrate is easier as the check of the APB clock.

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 11 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.