zweite SPI im SAM D mit Atmel Studio ASF hängt

[thomas (Gast)]

Moin,

ich benötige mehrere SPIs im SAMD21.
Beim Einbinden der zweiten SPI hängt das Programm im

startup_samd21.c

void Dummy_Handler(void)
{  while (1) {}
}

Einen SPI habe ich mit der RadioHead-Library in Verwendung:

Sercom* H_spiNumber=SERCOM3;

HardwareSPI::HardwareSPI(uint32_t spiPortNumber) :_spiPortNumber(spiPortNumber)
{  switch (spiPortNumber)
  {
  case 0: H_spiNumber=SERCOM0; break;
...bla...
  }
}

Die zweite SPI soll ein externes Flash AT25DFx bedienen. Wurde mit dem 
ASF generiert:

void EM_configure_spi_master(void)
{   struct at25dfx_chip_config  vat25dfx_chip_config;
    struct spi_config vat25dfx_spi_config;

   at25dfx_spi_get_config_defaults(&vat25dfx_spi_config);
   vat25dfx_spi_config.mode_specific.master.baudrate = AT25DFX_CLOCK_SPEED;
   vat25dfx_spi_config.mux_setting = SPI_SIGNAL_MUX_SETTING_D;
   vat25dfx_spi_config.pinmux_pad0 = PINMUX_PB02D_SERCOM5_PAD0;
   vat25dfx_spi_config.pinmux_pad1 = PINMUX_PB03D_SERCOM5_PAD1;
   vat25dfx_spi_config.pinmux_pad2 = PINMUX_UNUSED;
   vat25dfx_spi_config.pinmux_pad3 = PINMUX_PB23D_SERCOM5_PAD3;
   spi_init(&at25dfx_spi, EM_spiNumber, &vat25dfx_spi_config);
   spi_enable(&at25dfx_spi);
   vat25dfx_chip_config.type = AT25DFX_512B;
   vat25dfx_chip_config.cs_pin = PINMUX_PB23D_SERCOM5_PAD3;
   at25dfx_chip_init(&at25dfx_chip, &at25dfx_spi, &vat25dfx_chip_config);
}

Wenn ich den Code in EM_configure_spi_master() auskommentiere, läuft die 
Kiste an. Sobald der Code aktiv ist, endet es im Dummy_Handler() (s.o.)

Hat jemand eine Idee?


Kann jemand erklären, wie die Logik der Funktion __libc_init_array() im 
Reset_Handler() ist?
Mit dem Debugger komme ich da im Single Step nicht rein.

Mit aktivem EM_configure_spi_master() springt das Programm vom 
__libc_init_array() direkt in den Dummy_Handler(). Warum?

startup_samd21.c

void Reset_Handler(void)
{
... bla ...
        __libc_init_array();        /* Initialize the C library */
        main();             /* Branch to main function */
        while (1);        /* Infinite loop */
}

Vielen Dank für eine Hilfe :o)

[Andi (Gast)]

Hast du mal alle Fault-Handler, also UsageFault, BusFault etc., 
implementiert? Dann dürfte es etwas klarer werden, was für eine 
Exception auftritt, der Dummy-Handler ist nur eine Fallbacklösung und 
sagt relativ wenig aus. Die Fault-Handler müssen alle noch explizit 
aktiviert werden, das geschieht System Handler Control and State 
Register (SHCSR), welches (wenn ich mich recht erinner) im System 
Control Block (SCB) liegen dürfte.

[Andi (Gast)]

Nachtrag: Genauer Informationen zu der aufgetretenen Exception sind dann 
im Configurable Fault Status Register (CFSR) im SCB zu finden.

[Christopher J. (christopher_j23)]

thomas schrieb:
> Kann jemand erklären, wie die Logik der Funktion __libc_init_array() im
> Reset_Handler() ist?

Die Funktion ruft statische Konstruktoren auf. Das du im Dummy-Handler 
landest kann verschiedene Gründe haben, z.B. einen Bus-Fault oder aber 
auch ganz einfach das du im SPI-IRQ-Handler landest, der aber nicht 
implementiert ist und damit landest du im Dummy-Handler. Um das Problem 
weiter eingrenzen zu können sind die Tips von Andi sicher hilfreich. 
Ansonsten kann bei sowas auch ein Assembler-Listing nicht schaden.

[Thomas K. (technomicro)]

Danke Christopher und Andi,

ich habe den Dummy_Handler erweitert:

void Dummy_Handler(void)
{  volatile int i,j,p;
  
  HardFault_HandlerAsm();
    while (1) {
    i=__get_IPSR();
    j=__get_APSR();
    p=__get_xPSR();
  }
}
/**
 * HardFault_HandlerAsm:
 * Alternative Hard Fault handler to help debug the reason for a fault.
 * To use, edit the vector table to reference this function in the HardFault vector
 * This code is suitable for Cortex-M3 and Cortex-M0 cores
 */

// Use the 'naked' attribute so that C stacking is not used.
__attribute__((naked))
void HardFault_HandlerAsm(void)
{        /*
         * Get the appropriate stack pointer, depending on our mode,
         * and use it as the parameter to the C handler. This function
         * will never return
         */

        __asm(  ".syntax unified\n"
                        "MOVS   R0, #4  \n"
                        "MOV    R1, LR  \n"
                        "TST    R0, R1  \n"
                        "BEQ    _MSP    \n"
                        "MRS    R0, PSP \n"
                        "B      HardFault_HandlerC      \n"
                "_MSP:  \n"
                        "MRS    R0, MSP \n"
                        "B      HardFault_HandlerC      \n"
                ".syntax divided\n") ;
}

/**
 * HardFaultHandler_C:
 * This is called from the HardFault_HandlerAsm with a pointer the Fault stack
 * as the parameter. We can then read the values from the stack and place them
 * into local variables for ease of reading.
 * We then read the various Fault Status and Address Registers to help decode
 * cause of the fault.
 * The function ends with a BKPT instruction to force control back into the debugger
 */
void HardFault_HandlerC(unsigned long *hardfault_args){
        volatile unsigned long stacked_r0 ;
        volatile unsigned long stacked_r1 ;
        volatile unsigned long stacked_r2 ;
        volatile unsigned long stacked_r3 ;
        volatile unsigned long stacked_r12 ;
        volatile unsigned long stacked_lr ;
        volatile unsigned long stacked_pc ;
        volatile unsigned long stacked_psr ;
        volatile unsigned long _CFSR ;
        volatile unsigned long _HFSR ;
        volatile unsigned long _DFSR ;
        volatile unsigned long _AFSR ;
        volatile unsigned long _BFAR ;
        volatile unsigned long _MMAR ;

        stacked_r0 = ((unsigned long)hardfault_args[0]) ;
        stacked_r1 = ((unsigned long)hardfault_args[1]) ;
        stacked_r2 = ((unsigned long)hardfault_args[2]) ;
        stacked_r3 = ((unsigned long)hardfault_args[3]) ;
        stacked_r12 = ((unsigned long)hardfault_args[4]) ;
        stacked_lr = ((unsigned long)hardfault_args[5]) ;
        stacked_pc = ((unsigned long)hardfault_args[6]) ;
        stacked_psr = ((unsigned long)hardfault_args[7]) ;

        // Configurable Fault Status Register
        // Consists of MMSR, BFSR and UFSR
        _CFSR = (*((volatile unsigned long *)(0xE000ED28))) ;   

        // Hard Fault Status Register
        _HFSR = (*((volatile unsigned long *)(0xE000ED2C))) ;

        // Debug Fault Status Register
        _DFSR = (*((volatile unsigned long *)(0xE000ED30))) ;

        // Auxiliary Fault Status Register
        _AFSR = (*((volatile unsigned long *)(0xE000ED3C))) ;

        // Read the Fault Address Registers. These may not contain valid values.
        // Check BFARVALID/MMARVALID to see if they are valid values
        // MemManage Fault Address Register
        _MMAR = (*((volatile unsigned long *)(0xE000ED34))) ;
        // Bus Fault Address Register
        _BFAR = (*((volatile unsigned long *)(0xE000ED38))) ;

        __asm("BKPT #0\n") ; // Break into the debugger

}
/**
 * \brief Default interrupt handler for unused IRQs.
  __get_IPSR();:
    ISR_NUMBER (IPSR[8:0])
        =0 Thread mode
        =1 Reserved
        =2 NMI
        =3 HardFault
        =4 MemManage
        =5 BusFault
        =6 UsageFault
        =7-10 Reserved
        =11 SVCall
        =12 Reserved for Debug
        =13 Reserved
        =14 PendSV
        =15 SysTick
        =16 IRQ0
        ...
        =n+15 IRQ(n-1)


 */

Beim Steppen fiel mir dann ein HardFault auf.
Nachdem ich den

//RHReliableDatagram  rf95reliable(rf95, rf95CLIENT_ADDRESS);

auskommentiert hatte, ging es.

Scheint eine Kollision zwischen RHReliableDatagram und ASF:AT25FFx zu 
sein. Das bedarf noch weitere Forschung.