STM32F429 CAN

[Dirk Ka. (Gast)]

Guten Abend,

da der STM32 nun so populär geworden ist, habe ich mir den auch mal 
zugelegt.
Und zwar auf dem discovery board mit LCD. Dort ist der F429 drauf.

Wollte etwas mit dem Can spielen, habe die CAN2 Schnittstelle frei 
gemacht, indem ist den OTG weg gemacht habe. Der CAN1 wird komplett 
blockiert.
Ich benutze also die Pins PB12 und PB13.

Leider klappt das nach 2 Tagen immer noch nicht.
Sehe keine andere Möglichkeit mehr, als Euch zu fragen.
Diverse Threads schon durchgelesen, hilft alles nix.

Als Anhang gleich mein Code.
Die Libr. habe ich direct von ST.
Der µC läuft mit 180MHz.
CAN Baud ist 500kb
Falls noch was fehlt, Bescheid sagen, lade ich hoch.

#include "main.h"
#include "stm32f4xx_conf.h"
#include "stm32f4xx_tim.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx.h"
#include "misc.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_can.h"


int main(void)
{

 SystemInit(); 


 
//__________CAN INIT__________
  
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  CAN_InitTypeDef CAN_InitStructure;
  CAN_FilterInitTypeDef CAN_FilterInitStructure;

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

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource0, GPIO_AF_CAN2);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource1, GPIO_AF_CAN2);

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  CAN_DeInit(CAN2);
  CAN_InitStructure.CAN_ABOM = DISABLE;
  CAN_InitStructure.CAN_AWUM = DISABLE;
  CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
  CAN_InitStructure.CAN_NART = DISABLE;
  CAN_InitStructure.CAN_RFLM = DISABLE;
  CAN_InitStructure.CAN_SJW  = CAN_SJW_2tq;
  CAN_InitStructure.CAN_TTCM = DISABLE;
  CAN_InitStructure.CAN_TXFP = DISABLE;

  CAN_InitStructure.CAN_BS1 = CAN_BS1_12tq;
  CAN_InitStructure.CAN_BS2 = CAN_BS2_5tq;
  CAN_InitStructure.CAN_Prescaler = 5;
  CAN_Init(CAN2, &CAN_InitStructure);

    // Init the CAN filter
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0;
    CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;
    CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;
    CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
    CAN_FilterInitStructure.CAN_FilterNumber = 0;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInit(&CAN_FilterInitStructure);

    NVIC_InitStructure.NVIC_IRQChannel = CAN2_RX0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    NVIC_Init(&NVIC_InitStructure);

    // Enable "FIFO 0 message pending" interrupt
    CAN_ITConfig(CAN2, CAN_IT_FMP0, ENABLE);

//__________ENDE CAN INIT



  while(1)
  {
    }
}


void CAN2_RX0_IRQHandler()
{
  // Check CAN2_Rx status
  if( CAN_GetITStatus(CAN2, CAN_IT_FMP0))
  {
    if(GPIO_ReadOutputDataBit(GPIOG, GPIO_Pin_13)){
          GPIO_WriteBit(GPIOG, GPIO_Pin_13, RESET);
        }else{
          GPIO_WriteBit(GPIOG, GPIO_Pin_13, SET);
        }

    // Clear CAN buffer
//  clear_CanRxMessage();
  }
}

Mit dem Code will ich erreichen, dass die LED am Pin PG13 wenigstens ein 
Mal angeht. Würde heißen, dass der Can Controller was empfangen hat, und 
die Routinen funktionieren.
Die LED bleibt natürlich aus.
Die LED ist eingestellt, und funktioniert soweit. Den Part habe ich halt 
rausgelöscht.


Wäre für jede Hilfe sehr dankbar.
mfg DK

[Dr. Sommer (Gast)]

Was hast du denn am CAN angeschlossen?

[Dirk Ka. (Gast)]

Hast Recht, ist natürlich auch wichtig.
an den Pins ist ein High-Speed Transceiver (slope control auf GND), 120 
Ohm Widerstand.
Als Sender benutze ich den PEAK CAN USB.
Habe schon oft mit CAN gearbeitet, und kann den Hardwarefehler 
eigentlich komplett ausschließen.
Muss also an der Software liegen.

[Markus M. (Firma: EleLa - www.elela.de) (mmvisual)]

Probiere es mal damit:

  GPIO_PinAFConfig(GPIOB, GPIO_PinSource12, GPIO_AF_CAN2);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_CAN2);

[Dirk Ka. (Gast)]

Danke, das war definitiv der Fehler Nr. 1! :)
Jetzt kann der PEAK CAN die Nachricht wenigstens abschicken.
(Wenn der Empfänger nicht da oder nicht bereit ist, geht keine Nachricht 
raus).
Leider wird die LED am PG13 immer noch kein einziges Mal gesetzt.
Muss man die Interrupts sonst noch wo aktivieren, außer das was schon 
gemacht wurde?
Danke

[Μαtthias W. (matthias)]

Globales Interrupt enable?

[Dirk Ka. (Gast)]

Im Programm habe ich schon einen Timer-Interrupt, der auch funktioniert.
Somit ist doch automatisch Globales Interrupt enable = aktiv, oder?

[holger (Gast)]

>>  if( CAN_GetITStatus(CAN2, CAN_IT_FMP0))

Kommentier das doch einfach mal aus und schau
ob du überhaupt in den Interrupt kommst.

[Dr. Sommer (Gast)]

Dirk Ka. schrieb:
> Im Programm habe ich schon einen Timer-Interrupt, der auch funktioniert.
> Somit ist doch automatisch Globales Interrupt enable = aktiv, oder?
Automatisch auf keinen Fall! Wenn schon weil du die Interrupts dafür 
aktiviert hast. Aktivieren geht mit __enable_irq ();

[holger (Gast)]

>> Im Programm habe ich schon einen Timer-Interrupt, der auch funktioniert.
>> Somit ist doch automatisch Globales Interrupt enable = aktiv, oder?
>Automatisch auf keinen Fall! Wenn schon weil du die Interrupts dafür
>aktiviert hast. Aktivieren geht mit __enable_irq ();

Muss man nicht. Es reicht wenn die Interrupts einzeln
aktiviert werden. __enable_irq () braucht man nur nach
__disable_irq();

[Dirk Ka. (Gast)]

Habe ich. Läuft da nicht rein.

void CAN2_RX0_IRQHandler()
{
  // Check CAN2_Rx status
//  if( CAN_GetITStatus(CAN2, CAN_IT_FMP0))
//  {
    if(GPIO_ReadOutputDataBit(GPIOG, GPIO_Pin_13)){
          GPIO_WriteBit(GPIOG, GPIO_Pin_13, RESET);
        }else{
          GPIO_WriteBit(GPIOG, GPIO_Pin_13, SET);
        }

    // Clear CAN buffer
//  clear_CanRxMessage();
//  }
}

Was kann ich noch probieren?

[Dirk Ka. (Gast)]

Die CAN_SJW, CAN_BS1, CAN_BS2 sollten so richtig sein, oder?
Ehrlich gesagt checke ich diese Einstellungen nicht.
Habe das so aus dem Bit Timing Calculator übernommen.

[holger (Gast)]

Wenn du deinen Prozessor mal auf 168MHz taktest
könntest du diese Einstellungen mal versuchen:

CAN_InitStructure.CAN_SJW       = CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1       = CAN_BS1_14tq;
CAN_InitStructure.CAN_BS2       = CAN_BS2_6tq;
CAN_InitStructure.CAN_Prescaler = 4;

Das hat bei mir funktioniert mit 500kBit.

[Dirk Ka. (Gast)]

Grade ausprobiert. Nun kann der PEAK CAN wieder keine Nachricht 
rausquetschen :(
Ich habe jetzt nur in der system_stm32f4xx.c
#if defined (STM32F427_437xx) || defined (STM32F429_439xx)
  uint32_t SystemCoreClock = 168000000;
eingestellt.
Und dann natürlich deine Settings übernommern.

Weiß nicht, ob der Takt sonst noch irgendwo eingestellt wird.

Kotzt mich echt langsam an :( :( :(

[holger (Gast)]

In der system_stm32f4xx.c

#define PLL_N      336

>uint32_t SystemCoreClock = 168000000;

Damit setzt du die Variable SystemCoreClock, mehr aber nicht.

[Dirk Ka. (Gast)]

Leider immer noch kein Erfolg.
Ich sehe, du willst wohl helfen.
Soll ich den CooCox Projektordner hochladen?
Sollte dann auf den F429I discovery Board geflashed werden.

[hp-freund (Gast)]

Ich denke Du solltest dich mit den Filterregeln beschäftigen.
Ist zwar F1, aber das Prinzip sollte das Gleiche sein:

http://diller-technologies.de/stm32.html#can

[Dirk Ka. (Gast)]

Im Anhang der Projektordner.
Alle .c und .h Dateien aus dem Netz gesammelt ;)

main.c komplett:

//--------------------------------------------------------------
// File     : main.c
// Datum    : 29.10.2013
// Version  : 1.1
// Autor    : UB
// EMail    : mc-4u(@)t-online.de
// Web      : www.mikrocontroller-4u.de
// CPU      : STM32F429
// IDE      : CooCox CoIDE 1.7.4
// GCC      : 4.7 2012q4
// Module   : CMSIS_BOOT, M4_CMSIS_CORE
// Funktion : Demo der LCD-Library (ILI9341)
// Hinweis  : Diese zwei Files muessen auf 8MHz stehen
//              "cmsis_boot/stm32f4xx.h"
//              "cmsis_boot/system_stm32f4xx.c"
// In Configuration diese Define hinzufügen :
// "STM32F429_439xx" , "__ASSEMBLY__" , "USE_STDPERIPH_DRIVER"
//--------------------------------------------------------------

#include "main.h"
#include "stm32f4xx_conf.h"
#include "stm32_ub_lcd_ili9341.h"
#include "stm32_ub_graphic2d.h"
#include "stm32_ub_font.h"
#include "stm32f4xx_tim.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx.h"
#include "misc.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_can.h"



volatile unsigned char X_pos[15];


int main(void)
{
  uint32_t n;




  SystemInit(); // Quarz Einstellungen aktivieren





  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG,ENABLE);

    // Strukturen festlegen
    GPIO_InitTypeDef GPIO_InitGPIO;

    // Pin Parameter einstellen
    GPIO_InitGPIO.GPIO_Pin = (GPIO_Pin_14);
    GPIO_InitGPIO.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitGPIO.GPIO_OType = GPIO_OType_PP;
    GPIO_InitGPIO.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_InitGPIO.GPIO_Speed = GPIO_Speed_50MHz;

    // Port initialisieren
    GPIO_Init(GPIOG, &GPIO_InitGPIO);



  TIM_TimeBaseInitTypeDef TIM_TimeBaseInitTIM;
  NVIC_InitTypeDef NVIC_InitStructure;

  // Takt für Timer2 einschalten
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

  // Timer 2 konfigurieren
  TIM_TimeBaseInitTIM.TIM_ClockDivision = TIM_CKD_DIV1;
  TIM_TimeBaseInitTIM.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInitTIM.TIM_Period = 700;
  TIM_TimeBaseInitTIM.TIM_Prescaler = 17999;
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitTIM);

  TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);

  // Timer Interrupt konfigurieren
  NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_Init(&NVIC_InitStructure);

  // Timer starten
  TIM_Cmd(TIM2, ENABLE);




  // Init vom LCD
  UB_LCD_Init();
  // Init der Layer
  UB_LCD_LayerInit_Fullscreen();
  // auf Hintergrund schalten
  UB_LCD_SetLayer_1();
  // Hintergrund komplett mit einer Farbe füllen
  UB_LCD_FillLayer(RGB_COL_WHITE);
  // auf Vordergrund schalten
  UB_LCD_SetLayer_2();
  // Vordergrund komplett mit einer Farbe füllen
  UB_LCD_FillLayer(RGB_COL_BLACK);

//Testrechteck zeichnen
  UB_Graphic2D_DrawFullRectDMA(150, 30, 50, 50, 990);





//__________CAN INIT__________
  CAN_InitTypeDef CAN_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;
  CAN_FilterInitTypeDef CAN_FilterInitStructure;

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

  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource12, GPIO_AF_CAN2);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_CAN2);

  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  CAN_DeInit(CAN2);
  CAN_InitStructure.CAN_ABOM = DISABLE;
  CAN_InitStructure.CAN_AWUM = DISABLE;
  CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
  CAN_InitStructure.CAN_NART = DISABLE;
  CAN_InitStructure.CAN_RFLM = DISABLE;
  CAN_InitStructure.CAN_SJW  = CAN_SJW_1tq;
  CAN_InitStructure.CAN_TTCM = DISABLE;
  CAN_InitStructure.CAN_TXFP = DISABLE;

  CAN_InitStructure.CAN_BS1 = CAN_BS1_12tq;
  CAN_InitStructure.CAN_BS2 = CAN_BS2_5tq;
  CAN_InitStructure.CAN_Prescaler = 5;
  CAN_Init(CAN2, &CAN_InitStructure);

    // Init the CAN filter
    CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0;
    CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;
    CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;
    CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
    CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
    CAN_FilterInitStructure.CAN_FilterNumber = 0;
    CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    CAN_FilterInit(&CAN_FilterInitStructure);

//    NVIC_InitTypeDef NVIC_InitStructure;
    NVIC_InitStructure.NVIC_IRQChannel = CAN2_RX0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    NVIC_Init(&NVIC_InitStructure);

    // Enable "FIFO 0 message pending" interrupt
    CAN_ITConfig(CAN2, CAN_IT_FMP0, ENABLE);

//__________ENDE CAN INIT



  while(1)
  {

    }
}




void TIM2_IRQHandler(void){
 TIM_ClearITPendingBit(TIM2, TIM_IT_Update);

  if(GPIO_ReadOutputDataBit(GPIOG, GPIO_Pin_14)){
      GPIO_WriteBit(GPIOG, GPIO_Pin_14, RESET);
    }else{
      GPIO_WriteBit(GPIOG, GPIO_Pin_14, SET);
    }

}

void CAN2_RX0_IRQHandler()
{
  // Check CAN2_Rx status
//  if( CAN_GetITStatus(CAN2, CAN_IT_FMP0))
//  {
    if(GPIO_ReadOutputDataBit(GPIOG, GPIO_Pin_13)){
          GPIO_WriteBit(GPIOG, GPIO_Pin_13, RESET);
        }else{
          GPIO_WriteBit(GPIOG, GPIO_Pin_13, SET);
        }

    // Clear CAN buffer
//  clear_CanRxMessage();
//  }
}

Sorry, wenn etwas unübersichtlich und als Baukasten.. ist alles nur zum 
Ausprobieren.

[holger (Gast)]

>Leider immer noch kein Erfolg.

Dann ist da wohl noch was anderes faul.

>Ich sehe, du willst wohl helfen.

Bei CAN ist das aber leider nicht so leicht wie
bei einem UART.

>Grade ausprobiert. Nun kann der PEAK CAN wieder keine Nachricht
>rausquetschen :(

Dann war deine Einstellung für 180MHz Clock wohl schon passend.
Die Arbitrierung hat geklappt. Sonst würde da irgendwo Busheavy
stehen. Beim PCAN Viewer gibt es eine kleine Gemeinheit.
Da wird auch schon mal funktionierender CAN Verkehr angezeigt
obwohl auf der Schnittstelle nichts rausgeht. Drück da öfter
mal auf den Reset Button.

[hp-freund (Gast)]

Aus dem link oben:

In diesem Beispiel ist ein Filter auf die Standard-ID 0x123 definiert. Alle Nachrichten mit anderen IDs werden von der Hardware ignoriert.

[Dirk Ka. (Gast)]

Ich kontrolliere mit dem Oszilloscope, dass am PB13 und PB12 was 
passiert.
Also der PEAK sendet, Trancseiver funktioniert.
Wird halt nur kein Interrupt ausgelöst.
Habe schon von der vorgeschlagenen Seite den Filterpart komplett 
reinkopiert.
Sende auch 0x123 als ID.
Kommt trotzdem nicht in den Interrupt.
Sehr komisch, bei einigen läuft das ja, und zwar mit selben 
Bibliotheken, Code...
Hat jemand mein Projekt in CoIDE geöffnet?
Bin schon echt am Ausarten :)

Gruß DK

[Dirk Ka. (Gast)]

Ich vermute schon fast, dass es mit dieser NVIC_ Geschichte zusammen 
hängt.
Habe schon wie ein Affe alles Andere durchprobiert.

Die Nachrichten kommen an dem uC pin an, also die Hardware funktioniert.
Der CAN-Controller ist scheinbar richtig initialisiert, weil der Sender 
die Nachrichten los bekommt.

Weiss nicht, wie wichtig das ist, aber ich verwende nur Can2, weil der 
Can1 hardwaremäßig komplett blockiert ist.
Alle Beispiele basieren aber auf Can1, ich denke, dass ich da eine 
Kleinigkeit übersehen habe, die nicht sofort auffällt.

Sonst bin ich komplett ratlos im Moment, und morgen nachmittag muss Can 
laufen, sonst ist der uC bei uns in der Firma aus dem Rennen, und wir 
bleiben weiterhin beim PIC :(((((

Ich hoffe, Ihr könnt mir da helfen, selber kriege ich das anscheinend 
net auf die Reihe.

Danke an alle Beteiligte.

DK

[Uwe B. (derexponent)]

Hi Dirk Ka,

-wenn du in meinem Quellcode für CAN-2 die Kommentare gelesen hättest,
wärst du über das hier gestolpert :

//--------------------------------------------------------------
// setzt zwei Filter auf std_id [11bit] + Mode mit Maske
// falls ein Filter nicht benötigt wird,
// dann den Filter doppelt anlegen
//
// Ein CAN-Frame kommt nur durch, wenn seine ID+Mode
// mit Hilfe der Maske übereinstimmt
//
// nr = [14...27] (für CAN2)
//--------------------------------------------------------------
void UB_CAN2_std_FilterMask(CAN2_STD_FM_t filter, uint8_t nr)
{
  if(nr<14) nr=14;
  if(nr>27) nr=14;

  CAN_FilterInitStructure.CAN_FilterNumber = nr;

   ...
}

also das hier ist falsch :

CAN_FilterInitStructure.CAN_FilterNumber = 0;

den rest musst du selber suchen

Gruss Uwe

[Dirk Ka. (Gast)]

Hallo Uwe!

Danke schon mal für die Antwort und für deine tolle Projekte und 
Beispiele!
Habe jetzt mit
>CAN_FilterInitStructure.CAN_FilterNumber = 14;
Probiert.
Bringt leider immer noch nichts.
Ich benutze nur die Standartlib. von ST. Also nur die can.c und can.h
Habe aber gesehen, dass in CAN_FilterInit routine nur vom CAN1 die Rede 
ist. z.B.
>/* Initialisation mode for the filter */
>  CAN1->FMR |= FMR_FINIT;

Habe die alle auf CAN2 geändert, tut sich aber immer noch nichts.
Ergebnis ist immer gleich.
Die Nachrichten kommen an, werden aber nicht "wahrgenommen", das heißt, 
kein Interrupt wird ausgelöst.

Gruß DK

[Uwe B. (derexponent)]

gibt es einen Grund warum die nicht meine Quellen benutzt
oder funktionieren die auch nicht ?

(ich hab leider nur CAN-1 getestet)

[Henry N. (henry67)]

Vielleicht mal den CAN Transceiver richtig nach Referenz initialisieren:

CAN_OperatingModeRequest(CAN1, CAN_OperatingMode_Initialization);
CAN_OperatingModeRequest(CAN1, CAN_OperatingMode_Normal);

[ABCD M. (ramachandran_m)]

Hallo Dirk Ka

Now I am also facing the same Problem.

I am using CAN2 in STM32F429 and trying to send the messages through 
TJA1041A CAN transreceiver and sending those to PCAN.

I kindly request you to tell me on how did u solve this problem

[Steffen R. (steffen_rose)]

Selten ist es immer das gleich Problem. Es sind eher die Schritte zur 
Problemfindung immer die gleichen. Doch da würde ich denken, macht sich 
ein neuer Thread besser.

Hast Du alle Tipps, die hier gegeben wurde, bereits geprüft?

[ABCD M. (ramachandran_m)]

Ich habe nicht gefunden die solution for das problem

[Peter L. (localhost)]

Wir hatten damals das discovery board mit stm32f4 ohne LCD. Merkwürdig, 
dass bei der neuen 144 Pin Version beide CAN Busse nicht mehr ohne 
Modifikation zur Verfügung stehen.
Wir benutzten das xpcc Framework, funktionierte auf beiden Bussen. Und 
benötigt auch nur 5 Zeilen Code. ;)
https://github.com/roboterclubaachen/xpcc/blob/develop/examples/stm32f4_discovery/can/main.cpp

Für das neue discovery board müsste man uU ein paar Configs anpassen.

[Max (Gast)]

Ganz wichtig, wenn man den Can2 beim sTM32F4 benutzen moechte ist 
folgendes:
1.) der CAN1 muss angeschaltet sein (zumindest die Clock) denn der Can2 
ist dem irgendwie untergeordnet
2.) man muss den Anfang der Can2 Filter festlegen:
https://github.com/roboterclubaachen/xpcc/blob/develop/src/xpcc/architecture/platform/peripheral/can/stm32/can_filter.cpp.in#L84
Das ganze funktioniert wie ein Slider, der die Filter zwischen Can1 und 
Can2 aufteilt und so weit ich weis bekommt nach dem Reset der Can1 alle 
Filter und der Can2 keine.

Vielleicht hilft das ja.

Max

[Steffen R. (steffen_rose)]

Default ist halbe/halbe bei den Filterbänken.