STM32F7Discovery CAN-Bus

[Lega (Gast)]

Einen freundlichen Gruß an die Gemeinde!
Ich versuche seit ein paar Tagen mein STM32F7Disco in Betrieb zu nehmen. 
Speziell den CAN-Bus mit HAL-Driver. Das Verschicken der Nachricht 
funktioniert soweit.
Nun zu meiner Frage:  Wie kann ich einen CAN-Receiv-Interrupt auslösen, 
bzw. abfangen.  Bei ST32F4Doscovery konnte man ja 
“CAN1_RX0_IRQHandler(void)“ nutzen um auf die ankommende Nachrichten zu 
reagieren. Womit kann ich bei HAL-Basiertem Programm abfabgen?
Meine Initialisierung sieht wie folgt aus:

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void stm32F7_HAS_CAN_GPIO_Init(){
  //~~~~~~~~~~~~  HAL_GPIO_Init(); ~~~~~~~~~~~~~~~~~~~~~~~~

      GPIO_InitTypeDef GPIO_InitStruct;

      GPIO_InitStruct.Pin = CAN1_TX | CAN1_RX;
      GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
      GPIO_InitStruct.Pull = GPIO_NOPULL;
      GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
      GPIO_InitStruct.Alternate = GPIO_AF9_CAN1;

      HAL_GPIO_Init(CAN1_PORT, &GPIO_InitStruct);
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void stm32F7_HAS_CAN_Init(){

      CANx_CLK_ENABLE();
      CANx_GPIO_CLK_ENABLE();


    stm32F7_HAS_CAN_GPIO_Init();

    CAN_FilterConfTypeDef sFilterConfig;

    /*##-1- Configure the CAN peripheral #######################################*/
    CanHandle.Instance = CAN1;
    CanHandle.pTxMsg = &TxMessage;
    CanHandle.pRxMsg = &RxMessage;



    CanHandle.Init.TTCM = DISABLE;
    CanHandle.Init.ABOM = DISABLE;
    CanHandle.Init.AWUM = DISABLE;
    CanHandle.Init.NART = DISABLE;
    CanHandle.Init.RFLM = DISABLE;
    CanHandle.Init.TXFP = DISABLE;
//    CanHandle.Init.Mode = CAN_MODE_NORMAL;
    CanHandle.Init.Mode = CAN_MODE_LOOPBACK;
    CanHandle.Init.SJW = CAN_SJW_1TQ;
    CanHandle.Init.BS1 = CAN_BS1_7TQ;
    CanHandle.Init.BS2 = CAN_BS2_2TQ;
    CanHandle.Init.Prescaler = 10;           //500 Mbps

    /*##-2- Configure the CAN Filter ###########################################*/
    sFilterConfig.FilterNumber = 0;
    sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
    sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
    sFilterConfig.FilterIdHigh = 0x0000;
    sFilterConfig.FilterIdLow = 0x0000;
    sFilterConfig.FilterMaskIdHigh = 0x0000;
    sFilterConfig.FilterMaskIdLow = 0x0000;
    sFilterConfig.FilterFIFOAssignment = 0;
    sFilterConfig.FilterActivation = ENABLE;
    sFilterConfig.BankNumber = 14;



    /*##-3- Configure Transmission process #####################################*/
    CanHandle.pTxMsg->StdId = 0x321;
    CanHandle.pTxMsg->ExtId = 0x01;
    CanHandle.pTxMsg->RTR = CAN_RTR_DATA;
    CanHandle.pTxMsg->IDE = CAN_ID_STD;
    CanHandle.pTxMsg->DLC = 8;

    HAL_CAN_Init(&CanHandle);
    HAL_CAN_ConfigFilter(&CanHandle, &sFilterConfig);

    HAL_CAN_Transmit(&CanHandle, 500);


    HAL_NVIC_SetPriority(CAN1_RX0_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(CAN1_RX0_IRQn);


}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef* CanHandle)
{
  RxMsgCNT++;

}

Und obwohl einige Nachrichten auf dem Bus sind, wird die 
„HAL_CAN_RxCpltCallback“- Routine nicht ausgelöst.
Kann mir jemand sagen was ich übersehen oder falsch gemacht habe?

Gruß
  Lega

[STM Apprentice (Gast)]

Lega schrieb:
> Womit kann ich bei HAL-Basiertem Programm abfabgen?

Aus meiner beschränkten Sichtweise heraus würde ich sagen
man richtet einen Receive Interrupt ein, aktiviert den
NVIC für diesen Interrupt und schon wird bei Eintreffen
von Daten der relevante IRQ-Handler angesprungen.

[Lega (Gast)]

Ich dachte mit

    HAL_NVIC_SetPriority(CAN1_RX0_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(CAN1_RX0_IRQn);

hätte ich es getan.
und mit

void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef* CanHandle){}

würde ich ihn abfangen.

[Stefan K. (stefan64)]

Lega schrieb:
> sFilterConfig.BankNumber = 14;

Ich denke, für CAN1 muss hier 0 stehen. 14 ist für CAN2.

Gruß, Stefan

[Lega (Gast)]

Hallo Stefan,

danke für deinen Hinweis, aber gerade ausprobiert: leider  keine 
Auswirkung.

Ich habe  „CanHandle.Init.Mode = CAN_MODE_NORMAL“ gesetzt, somit kann 
ich die Nachrichten mit „HAL_CAN_Receive(&CanHandle,CAN_FIFO0,10)“ 
abholen. Das funktioniert sowohl mit BankNumber=14 als auch mit 
BankNumber=0…

Die Routine “HAL_CAN_Receive_IT” kann ausgeführt werden, bei der ersten 
ankommenden Nachricht hängt sich aber der Kontroller auf.  So wie ich es 
verstanden habe, stößt „HAL_CAN_Receive_IT“ die Interrupt gesteuerte 
Nachrichtenempfang. Also fehlt da ein Interrupthander, oder?

Bin für jede Idee dankbar!
Gruß
Lega

[uint32_t clean_code = 0; (Gast)]

Lega schrieb:
> bei der ersten
> ankommenden Nachricht hängt sich aber der Kontroller auf

Haengt er sich tatsaechlich auf, oder wird nur nichts mehr empfangen? 
Wie sieht deine Applikation aus? Kann man davon ausgehen, das die 
Bitrate (500 kbps) bei allen teilnehmenden Nodes richtig eingestellt 
ist?

Deine Funktion HAL_CAN_RxCpltCallback wird aus CAN_Receive_IT aufgerufen 
(siehe stm32f4xx_hal_can.c). Dort wird der State des Handles entweder 
auf BUSY_TX oder READY gesetzt. Auch das FIFO0 message pending interrupt 
wird disabled. Das wird erst wieder in HAL_CAN_Receive_IT enabled.

Kann es sein, dass nach Empfangen einer Message letztgenannte Funktion 
stets erneut aufgerufen werden muss?

void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef* CanHandle)
{
  RxMsgCNT++; 
  (void)HAL_CAN_Receive_IT(CanHandle, CAN_FIFO0);
}

[Lega (Gast)]

Hallo,

uint32_t clean_code = 0; schrieb:
> Haengt er sich tatsaechlich auf, oder wird nur nichts mehr empfangen?

Der hängt sich wirklich auf, die „main“-Schleife wird auch nicht mehr 
abgearbeitet.
Es gibt nur noch einen aktiven Teilnehmer und der läuft mit 500kbps, 
sonst nur noch der CANalyser.

Mit dem „HAL_CAN_Receive_IT“- Aufruf in „HAL_CAN_RxCpltCallback“- 
Funktion werde ich mal ausprobieren. Auf jeden Fall: vielen Dank für die 
Anregung! Melde mich dann.

Gruß
  Lega

[Christopher J. (christopher_j23)]

Im Standard-Startup-Code den CubeMX ausspuckt zeigen die ganzen 
Interrupt- und Exception-Handler per "weak" auf den Default-Handler, 
d.h. wenn du den Interrupt scharf schaltest aber keinen Handler 
implementierst, dann landet der Controller im Default-Handler, was eben 
eine simple Endlosschleife ist. Das verhalten ist eben genau das gleiche 
wie standardmäßig bei den ganzen Fault-Handlern und es sieht so aus als 
ob sich der Controller aufgehängt hätte.

Im Klartext heißt das, dass du irgendwo eine Funktion 
CAN1_RX0_IRQHandler() implementieren musst, bzw. eine mit dem Namen, der 
zu dem passt was in deinem Startup-Code steht.