STM32 F3 Discovery Probleme mit SPI und receive Interrupt

[Franky (Gast)]

Hallo,

ich versuche mit einem STM32F3Discovery zwei SN74HC165 Shiftregister mit 
dem SPI Peripheral anzusprechen. Dazu möchte ich 16bit Daten über den 
MISO-Pin einlesen, MOSI ist unbeschaltet.

Diese Funktionen habe ich dazu geschrieben:

//init spi gpio for digital input shift register
void dig_in_init(){
    gpio_pin_config(CS_PORT,CS_PIN,OUT|PP|MHZ_50);  //chip select, connected to clk_inhibit, always low
    gpio_pin_config(SH_LD_PORT,SH_LD_PIN,OUT|PP|MHZ_50); //shift/load
    CS_PORT->BRR = (1<<CS_PIN); //chip select, connected to clk_inhibit, always low

    gpio_pin_config(CLK_PORT,CLK_PIN,AF|PP);  //spi clk to alternate function push/pull
    gpio_pin_config(MISO_PORT,MISO_PIN,AF|PP); //spi miso to alternate function push/pull
    CLK_PORT->AFR[1] |= (5<<((CLK_PIN-8)*4));  //AF5 (SPI2 CLK)
    MISO_PORT->AFR[1] |= (5<<((MISO_PIN-8)*4)); //AF5 (SPI2 MISO)

    RCC->APB1ENR |= RCC_APB1ENR_SPI2EN; //enable clock for spi2

    SPI2->CR1 |= SPI_CR1_BR; //baudrate fPCLK/256
    SPI2->CR1 |= SPI_CR1_CPHA|SPI_CR1_CPOL; //clock 1 when idle, rising edge sample (to have some time between transmission start and first rising edge)
    SPI2->CR1 &= ~(SPI_CR1_BIDIMODE|SPI_CR1_RXONLY); //2-line mode, full duplex
    SPI2->CR2 |= SPI_CR2_DS; //16bit data size
    SPI2->CR1 &= ~SPI_CR1_LSBFIRST; //MSB first
    SPI2->CR1 &= ~SPI_CR1_SSM; //Software slave management disabled
    SPI2->CR2 &= ~SPI_CR2_SSOE; //disable SS output
    SPI2->CR2 &= ~SPI_CR2_FRF; //disable TI protocol
    SPI2->CR2 &= ~SPI_CR2_NSSP; //no NSS pulse mode
    SPI2->CR2 &= ~SPI_CR2_FRXTH; //FIFO threshold to 16bit
    SPI2->CR1 &= ~SPI_CR1_CRCEN; //no CRC
    SPI2->CR1 |= SPI_CR1_MSTR; //master mode
    SPI2->CR2 |= SPI_CR2_RXNEIE; //receive buffer not empty interrupt enable
    SPI2->CR1 |= SPI_CR1_SPE; //enable SPI
    NVIC_EnableIRQ(SPI2_IRQn); //enable SPI2 global Interrupt

    //start cycle
    dig_in_sr_state =  STATE_LOAD;
    SH_LD_PORT->BRR = (1<<SH_LD_PIN);  //shift/load to load
    SPI2->DR = 0xF0F0; //put dummy bytes into data register to start transmission
}

//spi2 ISR
void SPI2_IRQHandler(void){if(dig_in_sr_state==STATE_LOAD){
        not_used = SPI2->DR; //dummy read values from data register to reset interrupt
        SH_LD_PORT->BSRR = (1<<SH_LD_PIN);  //shift/load to shift
        SPI2->DR = 0x0F0F; //put dummy bytes into data register to start communication
        dig_in_sr_state=STATE_SHIFT;
    }
    else if(dig_in_sr_state==STATE_SHIFT){
        digital_values = SPI2->DR; //read values from data register (resets interrupt)
        SH_LD_PORT->BRR = (1<<SH_LD_PIN);  //shift/load to load
        SPI2->DR = 0xF0F0; //put dummy bytes into data register to start communication
        dig_in_sr_state=STATE_LOAD;
    }
}

dig_in_init wird in Main aufgerufen und soll den SPI initialisieren und 
eine Übertragung starten. Wenn die Übertragung beendet ist soll in der 
ISR wieder eine Übertragung gestartet werden, sodass das ganze im 
Hintergrund weiterläut und immer wieder Daten aus den Shiftregistern 
ausließt und in der Variable digital_values speichert.

Jedoch werden scheinbar nie daten empfangen und es wird daher nie ein 
Interrupt ausgelöst.

Woran könnte das liegen?

liebe Grüße
Franky

[holger (Gast)]

>Woran könnte das liegen?

Nimm ein Osci und miss nach ob die Clockleitung
auch Takte ausgiebt.

[Franky (Gast)]

Nein, keine Takte auf der Clockleitung.
Das könnte natürlich an meiner gpio_pin_config Funktion liegen, die den 
Pin nicht richtig auf Alternate Function setzt aber selbst wenn sie 
nicht Funktioniert sollte der SPI doch nach 16 Flanken (die dann hald 
nicht bis zum Pin kommen) den Interrupt auslösen, oder?

[Franky (Gast)]

Ich habe auch probiert folgenden Code am Ende der dig_in_init Funktion 
einzufügen:

while( !(SPI2->SR & 128) ); // wait until busy

Laut Debugger bleibt der Controller in dieser Schleife hängen, was mMn. 
zeigt dass keine Übertragung begonnen wird.

[Walleby (Gast)]

Hat das einen bestimmten Grund, dass du die einzelnen Register manuell 
setzt? ST bietet doch sehr komfortable libries für z. B. den SPI.

MfG

Walleby

[Franky (Gast)]

Der einzige Grund ist eigentlich dass ich es so gewohnt bin (habe vorher 
AVR verwendet) und es "zwingt" mich, mich mehr mit der Funktionsweise 
des Controllers zu beschäftigen.

Die vorher gepostete Zeile sollte eigentlich so aussehen:

while( !(SPI2->SR & SPI_SR_BSY) ); // wait until busy

[Walleby (Gast)]

Hast du denn die Taktversorgung für die GPIO's und den SPI aktiviert?
Bei dem Umstieg von AVR zu STM vergisst man leicht, dass die einzelnen 
Komponenten generell nicht versorgt werden.

[Franky (Gast)]

GPIO-Clock ist aktiviert (Pins ansteuern funktioniert auch):

RCC -> AHBENR |= RCC_AHBENR_GPIOAEN | //enable clock for GPIOA
                 RCC_AHBENR_GPIOBEN | //enable clock for GPIOB
                 RCC_AHBENR_GPIOCEN | //enable clock for GPIOC
                 RCC_AHBENR_GPIODEN | //enable clock for GPIOD
                 RCC_AHBENR_GPIOEEN | //enable clock for GPIOE
                 RCC_AHBENR_GPIOFEN ; //enable clock for GPIOF

Den SPI2-Clock aktiviere ich in der oben gezeigten Funktion mit 
folgender Zeile:

RCC->APB1ENR |= RCC_APB1ENR_SPI2EN; //enable clock for spi2

Passt das so?

[Walleby (Gast)]

Ich kenne die einzelnen Register des STM32f3 zwar nicht, sieht aber 
jedenfalls nicht falsch aus. Um sicher zu gehen, könntest du einen Blick 
in FW-Lib werfen.

Wenn du keinen Takt am SPI_CLK hast, kann es eigentlich nurnoch eine 
Fehlgescheschlagene Initialisierung bzw. Start haben.

Was mir auffällt ist:

 SPI2->CR1 &= ~(SPI_CR1_BIDIMODE|SPI_CR1_RXONLY); //2-line mode, full duplex

Solltest du nicht noch in dem Register das Senden aktivieren, oder habe 
ich das übersehen?

[Franky (Gast)]

Das Senden sollte im 2-Line Full-Duplex-Mode, den ich verwende, aktiv 
sein. Für den Half-Duplex-Mode kann man das Senden Deaktivieren um in 
den Empfangsmodus zu wechseln.

Den Software Slave select habe ich jetzt aktiviert (das war vorher 
falsch, denke ich), das Problem bleibt aber:

SPI2->CR1 |= SPI_CR1_SSM; //Software slave select management enabled

[Walleby (Gast)]

Besteht denn das Problem noch, dass du kein SPI_CLOCK bekommst? Wenn das 
so ist, hast du glaube ich noch Konfigurationsprobleme mit deinem SPI.

Kommst du mit dem Oszi an die MOSI-Leitung? Dann könntest du zur 
Funktionsprüfung Daten senden. Wenn du dann nichts siehst, liegt der 
Fehler in der Konf.

[Franky (Gast)]

So, jetzt funktioniert alles!
Das software slave select management muss aktiviert sein, wie in meinem 
letzten Post schon vermutet. Zusätzlich muss man folgendes Bit setzen:

SPI2->CR1 |= SPI_CR1_SSI; //enable internal slave select

Scheinbar wird nichts gesendet, wenn nicht irgendwo der Slave aktiviert 
wird.

der Init-Code sieht jetzt so aus (CPOL und CPHA hab ich noch an den 
Slave angepasst):

void dig_in_init(){
    gpio_pin_config(CS_PORT,CS_PIN,OUT|PP|MHZ_50);  //chip select, connected to clk_inhibit, always low
    gpio_pin_config(SH_LD_PORT,SH_LD_PIN,OUT|PP|MHZ_50); //shift/load
    CS_PORT->BRR = (1<<CS_PIN); //chip select, connected to clk_inhibit, always low

    gpio_pin_config(CLK_PORT,CLK_PIN,AF|PP);  //spi clk to alternate function push/pull
    gpio_pin_config(MISO_PORT,MISO_PIN,AF|PP); //spi miso to alternate function push/pull
    CLK_PORT->AFR[1] |= (5<<((CLK_PIN-8)*4));  //AF5 (SPI2 CLK)
    MISO_PORT->AFR[1] |= (5<<((MISO_PIN-8)*4)); //AF5 (SPI2 MISO)

    RCC->APB1ENR |= RCC_APB1ENR_SPI2EN; //enable clock for spi2

    SPI2->CR1 &= ~SPI_CR1_SPE; //disable SPI
    SPI2->I2SCFGR &= ~SPI_I2SCFGR_I2SMOD; //switch peripheral to spi mode
    SPI2->CR1 |= SPI_CR1_BR; //baudrate fPCLK /256 TODO optimize
    SPI2->CR1 &= ~SPI_CR1_CPOL; //sample on first edge
    SPI2->CR1 &= ~SPI_CR1_CPHA;//clock low while idle
    SPI2->CR1 &= ~(SPI_CR1_BIDIMODE|SPI_CR1_RXONLY); //2-line mode, full duplex
    SPI2->CR2 |= SPI_CR2_DS; //16bit data size
    SPI2->CR1 |= SPI_CR1_LSBFIRST; //LSB first
    SPI2->CR1 |= SPI_CR1_SSM; //Software slave select management enabled
    SPI2->CR1 |= SPI_CR1_SSI; //enable internal slave select
    SPI2->CR2 &= ~SPI_CR2_SSOE; //disable SS output
    SPI2->CR2 &= ~SPI_CR2_FRF; //disable TI protocol
    SPI2->CR2 &= ~SPI_CR2_NSSP; //no NSS pulse mode
    SPI2->CR2 &= ~SPI_CR2_FRXTH; //FIFO threshold to 16bit
    SPI2->CR1 &= ~SPI_CR1_CRCEN; //no CRC
    SPI2->CR1 |= SPI_CR1_MSTR; //master mode
    SPI2->CR2 |= SPI_CR2_RXNEIE; //receive buffer not empty interrupt enable
    SPI2->CR1 |= SPI_CR1_SPE; //enable SPI
    NVIC_EnableIRQ(SPI2_IRQn); //enable SPI2 global Interrupt

    //start cycle
    dig_in_sr_state =  STATE_LOAD;
    SH_LD_PORT->BRR = (1<<SH_LD_PIN);  //shift/load to load
    SPI2->DR = 0xF0F0; //put dummy bytes into data register to start transmission
}

Danke für die Ideen!