Cortex M3 ISR-Problem

[Joachim .. (joachim_01)]

Hallo Mädchen und Jungens,

hab hiern SAM3X8E mit zwei eingebauten CAN-Modulen der sich hartnäckig 
weigert per ISR auf ne Nachricht zu reagieren. Die ISR wird überhaupt 
nicht angesprungen. Ich habe das Beispiel aus der ASF für das SAM3X-EK 
Board von Atmel genommen. Mein Board, ein Arduino DUE hat genau den 
gleichen uC. Die Hardware bzgl. des CAN-Aufbaus ist ebenfalls ne 
1:1-Kopie aus dem Manual von Atmel. Mein Oszi bestätigt mir das 
Empfangen der Bits über den CAN-Bus am Port-Pin. Anschließend hab ich 
noch den Port auf Schaltfunktion (Taster + LED an anderem Portpin) 
getestet, das geht ebenfalls. Hardwaremäßig scheint das ganze wohl somit 
wasserdicht zu sein.

Trotzdem reagiert die ISR nicht.
Hab dann mal den Code nach logischen Fehlern abgesucht, mit dem Hilfe im 
ASF verglichen aber nix gefunden.

Das ganze dreht sich eigentlich um:

/* Enable CAN0 & CAN1 clock. */
pmc_enable_periph_clk(ID_CAN0);
pmc_enable_periph_clk(ID_CAN1);

/* Configure and enable interrupt of CAN1, as the tests will use 
receiver interrupt. */
NVIC_EnableIRQ(CAN1_IRQn);

später dann wird die Mailbox dazugeschaltet:

/* Enable CAN1 mailbox 0 interrupt. */
can_enable_interrupt(CAN1, CAN_IER_MB0);


Langsam weiß ich nicht mehr weiter. Im Nested Vectored Interrupt 
Controller gibt's noch ein 'Interrupt Set-pending Register' aber das hat 
laut Datenblatt keinen Einfluß auf den Empfang.


Den Code hab ich nicht komplett kopiert; eine Auswertung der 
CAN-Nachricht ist erstmal ned wichtig, einzig die ISR muß angesprungen 
werden. Es sind also eigentlich nur die Zeilen für das setzen der 
Interrupt-Enable-Bits wichtig.

 C-Code
#include <stdio.h>
#include <string.h>
#include "board.h"
#include "sysclk.h"
#include "exceptions.h"
#include "uart.h"
#include "pmc.h"
#include "gpio.h"
#include "can.h"
#include "stdio_serial.h"
#include "sn65hvd234.h"
#include "conf_board.h"
#include "conf_clock.h"

//prototypes
void showRegister(void);


#define STRING_EOL    "\r"

#define STRING_HEADER "-- CAN Example --\r\n" \
                      "-- "BOARD_NAME" --\r\n" \
                      "-- Compiled: "__DATE__" "__TIME__" --"STRING_EOL

#define CAN_MSG_TOGGLE_LED_0        0x11223344
#define CAN_MSG_TOGGLE_LED_1        0xAABBCCDD
#define CAN_MSG_DUMMY_DATA          0x55AAAA55

/** CAN frame max data length */
#define MAX_CAN_FRAME_DATA_LEN      8

/** CAN0 Transceiver */
sn65hvd234_ctrl_t can0_transceiver;

/** CAN1 Transceiver */
sn65hvd234_ctrl_t can1_transceiver;

/** CAN0 Transfer mailbox structure */
can_mb_conf_t can0_mailbox;

/** CAN1 Transfer mailbox structure */
can_mb_conf_t can1_mailbox;

/** Receive status */
volatile uint32_t g_ul_recv_status = 0;
] 

/**
 * \brief Default interrupt handler for CAN 1.
 */

/*- - - - - - - - - - - - - - - - - - - - - - */

void CAN1_Handler(void)  // stellt sich tot
{
  uint32_t ul_status;
  printf("\rDEBUG: \(1a\) in CAN1_Handler\r");

  ul_status = can_get_status(CAN1);
    printf("\rDEBUG: \(1a_a\) in CAN1_Handler\r");
  if (ul_status & GLOBAL_MAILBOX_MASK) {
    printf("\rDEBUG: \(1b\) in CAN1_Handler ul_status \& GLOBAL_MAILBOX_MASK\r");    
    for (uint8_t i = 0; i < CANMB_NUMBER; i++) {
      ul_status = can_mailbox_get_status(CAN1, i);
      if ((ul_status & CAN_MSR_MRDY) == CAN_MSR_MRDY) {
      printf("\rDEBUG: \(1c\) in CAN1_Handler ul_status \& CAN_MSR_MRDY\r");      
        can1_mailbox.ul_mb_idx = i;
        can1_mailbox.ul_status = ul_status;
        can_mailbox_read(CAN1, &can1_mailbox);
        g_ul_recv_status = 1;
        break;
      }
    }
  }
}
/*- - - - - - - - - - - - - - - - - - - - - - */

/**
 * \brief Decode CAN messages.
 *
 *  \param p_mailbox Pointer to CAN Mailbox structure.
 */
static void decode_can_msg(can_mb_conf_t *p_mailbox)
{
  int a;
  uint32_t ul_led_Ctrl = p_mailbox->ul_datal;
  if (p_mailbox->ul_datal == CAN_MSG_TOGGLE_LED_0) a=1;
  

  puts("CAN message:" STRING_EOL);
  if (ul_led_Ctrl == CAN_MSG_TOGGLE_LED_0) {
    puts("  Toggle LED 0" STRING_EOL);
    gpio_toggle_pin(LED0_GPIO);  //PB27 PWM13 Arduino::13
  } else if (ul_led_Ctrl == CAN_MSG_TOGGLE_LED_1) {
    puts("  Toggle LED 1" STRING_EOL);
    gpio_toggle_pin(LED1_GPIO);  //PC21 PWM9 Arduino::9
  }
}

/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/**
 * \brief Reset mailbox configure structure.
 *
 *  \param p_mailbox Pointer to mailbox configure structure.
 */
static void reset_mailbox_conf(can_mb_conf_t *p_mailbox)
{
  p_mailbox->ul_mb_idx = 0;
  p_mailbox->uc_obj_type = 0;
  p_mailbox->uc_id_ver = 0;
  p_mailbox->uc_length = 0;
  p_mailbox->uc_tx_prio = 0;
  p_mailbox->ul_status = 0;
  p_mailbox->ul_id_msk = 0;
  p_mailbox->ul_id = 0;
  p_mailbox->ul_fid = 0;
  p_mailbox->ul_datal = 0;
  p_mailbox->ul_datah = 0;
}

#define TEST1_CAN_COMM_MB_IDX    0
#define TEST1_CAN_TRANSFER_ID    0x07
#define TEST1_CAN0_TX_PRIO       15

/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/**
 *  \brief Test the transmission from CAN0 Mailbox 0 to CAN1 Mailbox 0.
 */
static void test_1(void)
{
  can_reset_all_mailbox(CAN0);
  can_reset_all_mailbox(CAN1);

  printf("In Test1: CAN0 Mailbox 0 transmitting to CAN1 Mailbox 0\r");



  /* Init CAN1 Mailbox 0 to Reception Mailbox. */
  reset_mailbox_conf(&can1_mailbox);
  can1_mailbox.ul_mb_idx = TEST1_CAN_COMM_MB_IDX;
  can1_mailbox.uc_obj_type = CAN_MB_RX_MODE;
  can1_mailbox.ul_id_msk = CAN_MAM_MIDvA_Msk | CAN_MAM_MIDvB_Msk;
  can1_mailbox.ul_id = CAN_MID_MIDvA(TEST1_CAN_TRANSFER_ID);
  can_mailbox_init(CAN1, &can1_mailbox);

  /* Init CAN0 Mailbox 0 to Transmit Mailbox. */
  reset_mailbox_conf(&can0_mailbox);
  can0_mailbox.ul_mb_idx = TEST1_CAN_COMM_MB_IDX;
  can0_mailbox.uc_obj_type = CAN_MB_TX_MODE;
  can0_mailbox.uc_tx_prio = TEST1_CAN0_TX_PRIO;
  can0_mailbox.uc_id_ver = 0;
  can0_mailbox.ul_id_msk = 0;
  can_mailbox_init(CAN0, &can0_mailbox);

  /* Write transmit information into mailbox. */
  can0_mailbox.ul_id = CAN_MID_MIDvA(TEST1_CAN_TRANSFER_ID);
  can0_mailbox.ul_datal = CAN_MSG_TOGGLE_LED_0;
  can0_mailbox.ul_datah = CAN_MSG_DUMMY_DATA;
  can0_mailbox.uc_length = MAX_CAN_FRAME_DATA_LEN;
  can_mailbox_write(CAN0, &can0_mailbox);

    printf("DEBUG: Transmit information written into mailbox\r");
  //showRegister();
    
  
  
  
  /* Enable CAN1 mailbox 0 interrupt. */
  can_enable_interrupt(CAN1, CAN_IER_MB0);
  
  /* Send out the information in the mailbox. */
    can_global_send_transfer_cmd(CAN0, CAN_TCR_MB0);

  printf("\rDEBUG: \(1\) g_ul_recv_status = %d\r",g_ul_recv_status);
  
  //Ab hier passiert nix mehr weil Abarbeitung in Empfänger-ISR:
   while (!g_ul_recv_status);  /////////////////////////////////////////////////////////////

  printf("DEBUG: \(2\) g_ul_recv_status = %d\r\r",g_ul_recv_status);
  printf("DEBUG: still in Test 1\r\r");
  if ((can1_mailbox.ul_datal == CAN_MSG_TOGGLE_LED_0) &&
    (can1_mailbox.uc_length == MAX_CAN_FRAME_DATA_LEN)) {
    puts("Test1 passed" STRING_EOL);
    decode_can_msg(&can1_mailbox);
  } else {
    puts("Test1 ERROR" STRING_EOL);
  }
}



/**
 *  Configure UART for debug message output.
 */
static void configure_console(void)
{
  const usart_serial_options_t uart_serial_options = {
    .baudrate = CONF_UART_BAUDRATE,
    .paritytype = CONF_UART_PARITY
  };
  
  /* Configure console UART. */
  sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
  stdio_serial_init(CONF_UART, &uart_serial_options);
}



/**
 *  \brief can_example application entry point.
 *
 *  \return Unused (ANSI-C compatibility).
 */
int main(void)
{
  uint32_t ul_sysclk;
  uint8_t uc_char;

  /* Initialize the SAM system. */
  sysclk_init();
  board_init();

#ifdef CONF_BOARD_CAN0
/* Configure the CAN0 TX and RX pins. */
gpio_configure_pin(PIN_CAN0_RX_IDX, PIN_CAN0_RX_FLAGS);
gpio_configure_pin(PIN_CAN0_TX_IDX, PIN_CAN0_TX_FLAGS);
/* Configure the transceiver0 RS & EN pins. */
gpio_configure_pin(PIN_CAN0_TR_RS_IDX, PIN_CAN0_TR_RS_FLAGS);
gpio_configure_pin(PIN_CAN0_TR_EN_IDX, PIN_CAN0_TR_EN_FLAGS);
#endif

#ifdef CONF_BOARD_CAN1
/* Configure the CAN1 TX and RX pin. */
gpio_configure_pin(PIN_CAN1_RX_IDX, PIN_CAN1_RX_FLAGS);
gpio_configure_pin(PIN_CAN1_TX_IDX, PIN_CAN1_TX_FLAGS);
/* Configure the transceiver1 RS & EN pins. */
gpio_configure_pin(PIN_CAN1_TR_RS_IDX, PIN_CAN1_TR_RS_FLAGS);
gpio_configure_pin(PIN_CAN1_TR_EN_IDX, PIN_CAN1_TR_EN_FLAGS);
#endif





  /* Configure UART for debug message output. */
  configure_console();

  /* Output example information. */
  puts(STRING_HEADER);




//Test PB15 CAN1 RX

while (0){
// - - - - - - - - - - - - - - - - - - - - -
//eine LED mit Taster einschalten, 01.03.2013

pmc_enable_periph_clk(PIN_PUSHBUTTON_1_ID);
pio_pull_up(PIN_PUSHBUTTON_1_PIO, PIN_PUSHBUTTON_1_MASK, PIO_PULLUP);  //pmc_enable_periph_clk nicht vergessen!

while (1) {
  
  if (!( pio_get(PIN_PUSHBUTTON_1_PIO, PIO_INPUT, PIN_PUSHBUTTON_1_MASK) ))
        gpio_set_pin_high(LED0_GPIO);
  else  gpio_set_pin_low(LED0_GPIO);
}


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
}







  /* Initialize CAN0 Transceiver. */
  sn65hvd234_set_rs(&can0_transceiver, PIN_CAN0_TR_RS_IDX);
  sn65hvd234_set_en(&can0_transceiver, PIN_CAN0_TR_EN_IDX);
  /* Enable CAN0 Transceiver. */
  sn65hvd234_disable_low_power(&can0_transceiver);
  sn65hvd234_enable(&can0_transceiver);

  /* Initialize CAN1 Transceiver. */
  sn65hvd234_set_rs(&can1_transceiver, PIN_CAN1_TR_RS_IDX);
  sn65hvd234_set_en(&can1_transceiver, PIN_CAN1_TR_EN_IDX);
  /* Enable CAN1 Transceiver. */
  sn65hvd234_disable_low_power(&can1_transceiver);
  sn65hvd234_enable(&can1_transceiver);

  /* Enable CAN0 & CAN1 clock. */
  pmc_enable_periph_clk(ID_CAN0);
  pmc_enable_periph_clk(ID_CAN1);

  ul_sysclk = sysclk_get_cpu_hz();
  if (can_init(CAN0, ul_sysclk, CAN_BPS_1000K) &&    //1000K
    can_init(CAN1, ul_sysclk, CAN_BPS_1000K)) {    //1000K
    puts("CAN initialization is completed." STRING_EOL);

    /* Disable all CAN0 & CAN1 interrupts. */
    can_disable_interrupt(CAN0, CAN_DISABLE_ALL_INTERRUPT_MASK);
    can_disable_interrupt(CAN1, CAN_DISABLE_ALL_INTERRUPT_MASK);

    /* Configure and enable interrupt of CAN1, as the tests will use receiver interrupt. */
    NVIC_EnableIRQ(CAN1_IRQn);



    /* Run tests. */
    //while (1) {
    //  puts("Press any key to start test" STRING_EOL);
    //  while (uart_read(CONSOLE_UART, &uc_char)) {  };
    //}    

    puts("Test1 beginnt" STRING_EOL);
    test_1(); 
    g_ul_recv_status = 0;

    puts("Test2 beginnt: Press any key to continue..." 
    //...
                //... weitere Tests
    
}

(Mod.: abschliessendes [ / c ] ergänzt)

[Dr. Sommer (Gast)]

Führst du überhaupt jemals (indirekt?) "cpsie i" aus um die Behandlung 
von Interrupts einzuschalten? Wo ist überhaupt deine Hauptschleife? Mal 
im Debugger geschaut ob der Interrupt "Pending" wurde (im entsprechenden 
NVIC_ISPRn Register, siehe S.757 im ARMv7M Architecture Reference 
Manual) aber lediglich die ISR nicht ausgeführt wurde?
Außerdem überprüft ob sich das CAN-Modul auch auf den Bus synchronisiert 
(die CAN-Module vom STM32 zB müssen 11 sukzessive rezessive Bits sehen)? 
Oszilloskopbild vom Bus? Die Status-Register vom CAN mal im Debugger 
angeschaut ob was empfangen wurde bzw. per einfachem Polling im Code?

Joachim ... schrieb:
> /* Disable all CAN0 & CAN1 interrupts. */
>     can_disable_interrupt(CAN0, CAN_DISABLE_ALL_INTERRUPT_MASK);
>     can_disable_interrupt(CAN1, CAN_DISABLE_ALL_INTERRUPT_MASK);
hö???

PS: Dein Code ist chaotisch und schlecht eingerückt.

[Joachim .. (joachim_01)]

Danke, ich werd's mir morgen mal genauer anschauen. Hab leider keinen 
Debugger, werd aber in die Register schauen.

Seltsamerweise funktioniert die C-Formatierung nicht, deswegen gibt's 
hier auch kein Einrücken. Hm.
An sich sieht's nur chaotisch aus, weil unwichtiger Code fehlt.



Das hier:
> /* Disable all CAN0 & CAN1 interrupts. */
>     can_disable_interrupt(CAN0, CAN_DISABLE_ALL_INTERRUPT_MASK);
>     can_disable_interrupt(CAN1, CAN_DISABLE_ALL_INTERRUPT_MASK);

das passt wohl schon (ist original Atmel Code), der CAN0 wird in test1() 
kurz darauf wieder in eingeschaltet.


Das hier ist die Warteschleife:
 while (!g_ul_recv_status);

g_ul_recv_status kommt aus der nicht funktionsfähigen ISR...

[Dr. Sommer (Gast)]

Joachim ... schrieb:
> Danke, ich werd's mir morgen mal genauer anschauen. Hab leider
> keinen
> Debugger, werd aber in die Register schauen.
Leg dir mal einen zu, die sind enorm hilfreich... Die Tage an Arbeit 
die dir erspart bleiben sind die paar €uros wert.
>
> Seltsamerweise funktioniert die C-Formatierung nicht, deswegen gibt's
> hier auch kein Einrücken.
Du hast das [/c] am Ende vergessen. Alternativ kann man Code auch 
anhängen...

[Joachim .. (joachim_01)]

>Führst du überhaupt jemals (indirekt?) "cpsie i" aus um die Behandlung
>von Interrupts einzuschalten?
Hm...
zumindest wird "cpsie" im assemblierten Code nicht gefunden...
Werd morgen mal weiter graben....

N8.

[Lothar (Gast)]

Joachim ... schrieb:
> "cpsie"

In C üblicherweise:

__disable_interrupt();
NVIC_EnableIRQ(CAN1_IRQn);
__enable_interrupt();

[Dr. Sommer (Gast)]

Lothar schrieb:
> In C üblicherweise:
Achja, er verwendet ja die CMSIS. Streng genommen ist das dann kein C 
mehr, denn der C-Standard verbietet Bezeichnern außerhalb der Standard 
Libraries mit __ zu beginnen... Aber niemand hat behauptet die CMSIS sei 
C-compliant oder gar "gut programmiert" :-)
> __disable_interrupt();
> NVIC_EnableIRQ(CAN1_IRQn);
> __enable_interrupt();
Die Interrupts sind ja von Anfang an deaktiviert, von daher ist das 
disable dort unnötig; falls es nötig wäre sollte es wenn schon ganz an 
den Anfang und nicht nach die sonstige Initialisierung.

[Joachim .. (joachim_01)]

Sooo...
>Achja, er verwendet ja die CMSIS.
Gibt's denn in diesem Zusammenhang auch was anderes? Er hat noch nicht 
so viel Erfahrung mit ARM.

Nunja. Das hat ihm jetzt doch keine Ruhe gelassen. Mittlerweile ist es 
halb vier - und es funktioniert. Offensichtlich ist ihm durch das hin- 
und herkopieren und dem allgemeinen Rumfuscheln die ein oder andere 
Zeile kaputtgegangen. Mit nem neuen Projekt und ein paar Anpassungen 
geht's nun.

[Dr. Sommer (Gast)]

Joachim ... schrieb:
> Sooo...
>>Achja, er verwendet ja die CMSIS.
> Gibt's denn in diesem Zusammenhang auch was anderes? Er hat noch nicht
> so viel Erfahrung mit ARM.
Weiß nicht, ich hab mir den Zugriffslayer selbst geschrieben weil ich 
die CMSIS hässlich fand... Aber okay sie funktioniert.

Spricht er von sich selbst in der dritten Person? :-D

> Nunja. Das hat ihm jetzt doch keine Ruhe gelassen. Mittlerweile ist es
> halb vier - und es funktioniert. Offensichtlich ist ihm durch das hin-
> und herkopieren und dem allgemeinen Rumfuscheln die ein oder andere
> Zeile kaputtgegangen. Mit nem neuen Projekt und ein paar Anpassungen
> geht's nun.
Oha... Mit "cpsie i"?

[Joachim (Gast)]

Dr. Sommer schrieb:
>Achja, er verwendet ja die CMSIS.

Joachim schrieb:
>Spricht er von sich selbst in der dritten Person? :-D
Du hast mit der dritten schließlich angefangen ;-)



>Oha... Mit "cpsie i"?

Hm. Hab eben nochmals im Assembler-Listing geschaut. Weder der Befehl 
"cpsid" noch "cpsie" wird mit Strg + F gefunden. Stattddessen wird zB. 
das hier erzeugt:

C-Code

/* Enable CAN1 mailbox 0 interrupt. */
can_enable_interrupt(CAN1, CAN_IER_MB0);
   816de:  4628        mov  r0, r5
   816e0:  4649        mov  r1, r9
   816e2:  f240 33d1   movw  r3, #977  ; 0x3d1
   816e6:  f2c0 0308   movt  r3, #8
   816ea:  4798        blx  r3

Scheinbar führen auch hier verschiedene Wege nach Rom.

[(prx) A. K. (prx)]

Joachim schrieb:
> Scheinbar führen auch hier verschiedene Wege nach Rom.

Die in diesem Code aufgerufene Funktion wird wohl den Interrupt vom CAN1 
einschalten (NVIC), wird aber wahrscheinlich nicht den Interrupt des 
Cores einschalten (CPSIE).

[(prx) A. K. (prx)]

Joachim ... schrieb:
> zumindest wird "cpsie" im assemblierten Code nicht gefunden...

Von allein landet das evtl. auch nicht darin. Oft ist es so, dass man im 
Rahmen der eigenen Initialisierung irgendwann den Prozessor-Interrupt 
explizit freigibt. Geschieht das nicht, dann gibts auch keinen 
Interrupt.

[Joachim (Gast)]

Einen hübschen NVIC hab ich noch, der hier schaltet das Modul für den 
Empfang ein. Ist aber auch ohne "cpsie" erzeugt.

C-Code

    /* Configure and enable interrupt of CAN1, as the tests will use receiver interrupt. */
    NVIC_EnableIRQ(CAN1_IRQn);

ergibt:

  \param [in]      IRQn  External interrupt number. Value cannot be negative.
 */
__STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
{
  NVIC->ISER[((uint32_t)(IRQn) >> 5)] = (1 << ((uint32_t)(IRQn) & 0x1F)); /* enable interrupt */
   815ec:  f44f 4361   mov.w  r3, #57600  ; 0xe100
   815f0:  f2ce 0300   movt  r3, #57344  ; 0xe000
   815f4:  f44f 5280   mov.w  r2, #4096  ; 0x1000
   815f8:  605a        str  r2, [r3, #4]

Der Code besteht scheinbar zu 99% aus load, move und store. Vielleicht 
ist das ne Schwäche vom Compiler...

[Dr. Sommer (Gast)]

Joachim schrieb:
> Du hast mit der dritten schließlich angefangen ;-)
Naja die Antwort war ja an Lothar gerichtet ;-)

Joachim schrieb:
> Scheinbar führen auch hier verschiedene Wege nach Rom.
Das kann eigentlich nicht. Vielleicht sind die Interrupts doch 
standardmäßig eingeschaltet. NVIC_EnableIRQ schaltet nur einen 
bestimmten Interrupt ein, und um die allgemeine Behandlung von 
Interrupts überhaupt einzuschalten braucht man zusätzlich ein 
__enable_interrupt(); was ich auf jeden Fall einbauen würde.

Joachim schrieb:
> Der Code besteht scheinbar zu 99% aus load, move und store. Vielleicht
> ist das ne Schwäche vom Compiler...
Naja bei der Initialisierung der Hardware-Module macht man ja auch 
nichts anderes als vordefinierte Werte in die entsprechenden Register zu 
schreiben, daher sieht der Code nunmal so aus. Wenn du mit -Os 
kompilierst wird dieser Code kürzer (aber langsamer) und besteht nur 
noch aus "ldr" und "str".