STM32 -> SPI -> AD7142

[sakul (Gast)]

Hallo,
ich möchte gerne einen AD7142 über einen STM32F103RB auslesen. Das ganze 
soll mit SPI geschehen. An dem AD7142 hängen mehrere Touch-Sensoren.
Es scheitert leider schon an der SPI-Verbindung. Ich habe da leider 
wenig Erfahrung und würde mich freuen wenn sich das jemand anschauen 
könnte. Das ganze bleibt immer in der GetFlagStatus-Schleife hängen.

u16 testspi = 0;

void touchTask(void) 
{
  int i;
  SPI_InitTypeDef SPI_SPI1_InitStructure;
  GPIO_InitTypeDef GPIOSPI1_InitStructure;

  RCC_Configuration();  
  
  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;  // 5 = SPI1_SCK, 6 = SPI1_MISO, 7 = SPI1_MOSI
  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);
  
  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_4;             // 4 = SPI1_CS
  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);
  
  SPI_SPI1_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_SPI1_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_SPI1_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  SPI_SPI1_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_SPI1_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  SPI_SPI1_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_SPI1_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
  SPI_SPI1_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  
  SPI_Init(SPI1, &SPI_SPI1_InitStructure);
  
  SPI_Cmd(SPI1, ENABLE);
  
  for (i=0;i<4000;i++);    // delay
  
  for(;;) 
  {
    GPIO_ResetBits(GPIOA, GPIO_Pin_4);
    //Read Silicon versions to check communication, It should read 0xE622
    
    SPI_I2S_SendData(SPI1, 0x17);  
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);      
    testspi = SPI_I2S_ReceiveData(SPI1);
    GPIO_SetBits(GPIOA, GPIO_Pin_4);
    }
}

mfg
Lukas

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

Takte von GPIO und SPI eingeschaltet?

[THaala (Gast)]

Nur als TIPP:

ich hatte beim Einlesen des Touchcontroller-Baustein meines Panels auch 
zu kämpfen. Bei dem ADx(watweißichnoch) habe ich gesehen, dass die nicht 
sofort antworten.

Ich hatte dann zunächst einen Test gemacht, der explizit mit den 
Portpins wackelt, ehe ich dann auf die "highsophisticated" STM32-SPI 
"ichmacheallesfürdich" - Version umgestiegen bin.

Gruß Thilo.

P.S. Dein Chip - Select weist in deiner Schleife nur einen Spike nach 
"H" hin auf. eine kleine Pause wäre gut....

[sakul (Gast)]

Mit den Takten stimmte etwas nicht. Müsste jetzt aber passen:

void RCC_Configuration(void)
{
    /* RCC system reset(for debug purpose) */
    RCC_DeInit();

    /* Enable HSE */
    RCC_HSEConfig(RCC_HSE_ON);

    /* Wait till HSE is ready */
    HSEStartUpStatus = RCC_WaitForHSEStartUp();

    if (HSEStartUpStatus == SUCCESS)
    {
        /* HCLK = SYSCLK */
        RCC_HCLKConfig(RCC_SYSCLK_Div1);

        /* PCLK2 = HCLK/2 */
        RCC_PCLK2Config(RCC_HCLK_Div2);

        /* PCLK1 = HCLK/2 */
        RCC_PCLK1Config(RCC_HCLK_Div2);

        /* PLLCLK = 8MHz * 9 = 72 MHz */
        RCC_PLLConfig(0x00010000, RCC_PLLMul_9);

        /* Enable PLL */
        RCC_PLLCmd(ENABLE);

        /* Wait till PLL is ready */
        while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) {}

        /* Select PLL as system clock source */
        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

        /* Wait till PLL is used as system clock source */
        while (RCC_GetSYSCLKSource() != 0x08) {}
    }

    /* Enable peripheral clocks ----------------------------------------------*/
    /* GPIOA, GPIOB and SPI1 clock enable */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC
            | RCC_APB2Periph_SPI1, ENABLE);
    /* SPI2 Peripheral clock enable */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
}

Hängen bleiben tut er nun nicht mehr. Bekomme aber leider nichts vom AD 
zurück.
@Thilo: Hat es denn mit der "highsophisticated" STM32-SPI
"ichmacheallesfürdich" - Version geklappt? Eine kleine Pause habe ich 
drin.

[THaala (Gast)]

Ja, hat es!

Allerdings benutze ich ChibiOS. Die haben einen eigenen HAL, der es noch 
einfacher machen soll.

Wenn du dich zwei bis drei Stunden geduldest kann ich Dir beide 
Varianten hier posten.

Gruß Thilo

[sakul (Gast)]

Da Gedulde ich mich gerne :)

[Matthias K. (matthiask)]

>  SPI_SPI1_InitStructure.SPI_DataSize = SPI_DataSize_16b;

sicher?

[sakul (Gast)]

>>  SPI_SPI1_InitStructure.SPI_DataSize = SPI_DataSize_16b;
>
> sicher?

ja, Seite 31:
http://www.analog.com/static/imported-files/data_sheets/AD7142.pdf

[Gnubbel (Gast)]

sakul schrieb:

> GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;  // 5 = SPI1_SCK, 6 = SPI1_MISO, 7 = SPI1_MOSI
>   GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
>   GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
>   GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);

Den MOSI als PP zu konfigurieren wird bestimmt nich richtig sein.

Versuch mal das:

//MISO
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;       
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;              
    GPIO_Init(GPIOA, &GPIO_InitStructure);

[vaid (Gast)]

Gnubbel schrieb:
> Den MOSI als PP zu konfigurieren wird bestimmt nich richtig sein.

Ist aber richtig!

[vaid (Gast)]

Hab den Code noch mal mit meinem funktionierenden SPI-Code verglichen. 
Sowohl Initialisierung als auch Ansteuerung sehen korrekt aus.

Ich tippe auf eine falsche Ansteuerung des AD...

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

Gnubbel schrieb:

> Den MOSI als PP zu konfigurieren wird bestimmt nich richtig sein.

Verwechselst du hier SPI mit I2C? PP ist für SPI richtig.

[sakul (Gast)]

> Ich tippe auf eine falsche Ansteuerung des AD...
siehe PDF

[vaid (Gast)]

sakul schrieb:
> siehe PDF

So meinte ich das nicht ;-)

Leitungen scheinen richtig angeschlossen zu sein (hatte mal einen bösen 
Fehler, weil die MISO/MOSI Leitung zu einer SD-Karte vertauscht war...).

Ich meinte, dass die Einstellung des SPI vielleicht nicht richtig ist.

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

Yep, der AD scheint dem Datasheet nach zu schliessen eher CPOL=1/CPHA=1 
zu bevorzugen.

[THaala (Gast)]

Falls es Dich noch interessiert:

Das hier ist der Controller:

http://www.ti.com/lit/ds/symlink/ads7843.pdf

und hier der minimal-code für das SPI bitbanging:

#define  CHX   0x90
#define  CHY   0xD0

#define ADS7843_CS_LOW()     GPIO_ResetBits(GPIO_ADS7843_CS_PORT, RCC_ADS7843_CS)
#define ADS7843_CS_HIGH()    GPIO_SetBits(GPIO_ADS7843_CS_PORT, RCC_ADS7843_CS)

#define SPI1_SCK_LOW()       GPIO_ResetBits(SPI1_PORT, SPI1_SCK)
#define SPI1_SCK_HIGH()      GPIO_SetBits(SPI1_PORT, SPI1_SCK)

#define SPI1_MISO_READ()     GPIO_ReadInputDataBit(SPI1_PORT, SPI1_MISO)

#define SPI1_MOSI_LOW()      GPIO_ResetBits(SPI1_PORT, SPI1_MOSI)
#define SPI1_MOSI_HIGH()     GPIO_SetBits(SPI1_PORT, SPI1_MOSI)

static void ADS7843_SPI_Start( void )
{
    ADS7843_CS_HIGH();
    SPI1_MOSI_HIGH();
    SPI1_SCK_LOW();
    ADS7843_CS_LOW();
}

static void SPI_MOSI(u8 data)
{
    if(data)
        SPI1_MOSI_HIGH();
    else
        SPI1_MOSI_LOW();
}

static void ADS7843_WrCmd(u8 cmd)
{
    u8 buf, i;

    for( i = 0; i < 8; i++ ){
        buf = (cmd >> (7-i)) & 0x1 ;
        SPI_MOSI(buf);
        SPI1_SCK_HIGH();
        SPI1_SCK_LOW();
    }

}

static u16 ADS7843_Read(void)
{
    u16 buf = 0 ;
    u8 i;

    SPI1_SCK_HIGH(); 
    SPI1_SCK_LOW();
    for( i = 0; i < 12; i++ ){
        buf = buf << 1 ;
        SPI1_SCK_HIGH();
        if ( SPI1_MISO_READ() ){
            buf = buf + 1 ;
        }
        SPI1_SCK_LOW();
    }
    for( i = 0; i < 3; i++ ){
        SPI1_SCK_HIGH();
        SPI1_SCK_LOW();
    }
    return( buf ) ;
}

ich nehme an das Dir der endgültige ChibiOS-Code nichts nutzt. Wenn Du 
Ihn doch haben willst dann melde dich nochmals.

Gruß Thilo

[sakul (Gast)]

Habe CPOL/CPHA angepasst. Ich erzeuge nun auch das richtige 
Controll-Word, doch leider bekomme ich noch immer nichts zurück :(

u16 ControlValue;
u16 Register;
u16 testspi = 0xAAAA;

void touchTask(void) 
{
  int i;  

  SPI_InitTypeDef SPI_SPI1_InitStructure;
  GPIO_InitTypeDef GPIOSPI1_InitStructure;

  RCC_Configuration();

  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;  // 5 = SPI1_SCK, 6 = SPI1_MISO, 7 = SPI1_MOSI
  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);
  
  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_4;             // 4 = SPI1_CS
  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);
  
  SPI_SPI1_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_SPI1_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_SPI1_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  SPI_SPI1_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_SPI1_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_SPI1_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_SPI1_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
  SPI_SPI1_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  
  SPI_Init(SPI1, &SPI_SPI1_InitStructure);
  
  SPI_Cmd(SPI1, ENABLE);

  //Read Silicon versions to check communication, It should read 0xE622

  //Create the 16-bit header   
  Register = 0x17;                    // I.D. Register  
  ControlValue   = 0xE400 | (Register & 0x03FF);      
        //   = 0xE417   =   1110 0100 0001 0111
        // [15:11] = 11100  -> enable word
        // [10] = 0  -> R/W
        // [9:0] = [AD9, AD8, AD7, AD6, AD5, AD4, AD3, AD2, AD1, AD0] (STARTING MSB JUSTIFIED REGISTER ADDRESS)        
  
  for (i=0;i<4000;i++);    // delay
  
  for(;;) 
  {
    GPIO_ResetBits(GPIOA, GPIO_Pin_4);
    SPI_I2S_SendData(SPI1, ControlValue);  
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);  
    testspi = SPI_I2S_ReceiveData(SPI1);      // should read 0xE622 
    GPIO_SetBits(GPIOA, GPIO_Pin_4);
    }
}

Gruß
Lukas

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

sakul schrieb:

> Habe CPOL/CPHA angepasst.

Aber ob richtig? Es gibt 4 Möglichkeiten, 3 davon sind falsch.

[sakul (Gast)]

Ich habe vorsichtshalber alle 4 durchgetanzt

[Gnubbel (Gast)]

A. K. schrieb:
> Verwechselst du hier SPI mit I2C? PP ist für SPI richtig.

Nee, denn MISO heißt Master-Input und sollte somit im Regelfall kein
Push-Pull-Ausgang sein. Aber gemäß der Doku zur Library ist das hier 
i.O. .

@sakul

Bist du sicher ob alle Leitungen :
 1. Im Schaltplan korrekt angeschlossen sind? (bewege ggf. mal die 
beiden Bausteine hin und her, dann siehst du das)
2. Im Board geroutet sind? (Layer angezeigt)

Was steht denn im Eingangsbuffer? 0xFFFF, 0x0000?

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

Gnubbel schrieb:

> Nee, denn MISO heißt Master-Input und sollte somit im Regelfall kein
> Push-Pull-Ausgang sein.

Nur hattest du oben moniert, dass MOSI OD sein solle, nicht MISO:
Beitrag "Re: STM32 -> SPI -> AD7142"

MISO wiederum sollte m.E. weder PP noch OD sein, sondern ein Eingang.

[THaala (Gast)]

Du hast auf CS noch immer kaum einen "H" - Zustand.

Mach zwischen Schreiben des Kommandos und dem Einlesen des Ergebnisses 
mal eine Pause!

Hast Du ein Oszilloskop ? Regen sich irgendwelche Pins ?
Oder mindestens einen Debugger ? Dann könntest Du auch explizit mit den 
Pins wackeln.

Bist Du sicher das das Wort genau so rausgeht ?
Unter ChibiOS wurde DMA genutzt. Dabei waren High und Low vertauscht.
Teste mal 0x17E4....

Gruß Thilo

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

sakul schrieb:

>   GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 |
> GPIO_Pin_7;  // 5 = SPI1_SCK, 6 = SPI1_MISO, 7 = SPI1_MOSI
>   GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
>   GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
>   GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);

An der Stelle hat Gnubbel auf falsche Art Recht: Solange der Eingang 
MISO ein Ausgang ist wird das sicher nix werden.

[THaala (Gast)]

Gnubbel hat Recht,

MISO is ein Input!

Gruß

[sakul (Gast)]

Habe den MISO nun als GPIO_Mode_IN_FLOATING. Auf was muss ich 
SPI_BaudRatePrescaler stellen?

> Mach zwischen Schreiben des Kommandos und dem Einlesen des Ergebnisses
> mal eine Pause!
Wie lange?

[THaala (Gast)]

Ich weiß das auch nicht - was sage das Datenblatt dazu ?

Ich habe Dir oben den Pintoggle - trivial - code gepostet. Tritt mal 
einen Schritt zurück und versuche nicht gleich das Maximum 
hinzubekommen. Schön wenn man sofort fertig ist, aber meistens läuft es 
nicht so.

Wäre es nicht gut erst mal irgendeine Reaktion von dem Chip zu bekommen 
- und sei es nur das der MISO mal auf Low geht ?

Nochmal die Frage - was hast du für Hilfsmittel ?
OSKAR ? DEBUGGER ? Kannst Du sehen ob auf dem MOSI überhaupt was 
rausgeht ? Siehst Du denn Clock - Signale ?

Es gibt für SPI keine Baudratenuntergrenze. Du kannst die Zeiten 
beliebig groß ziehen - sogar so groß das Du LED's zur Kontrolle 
anbringen kannst.

Wenn du mal eine Reaktion des Chips bekommst - dann melde dich wieder! 
Wenn wir dann zusammen nach der richtigen SPI - Konfiguration suchen 
wissen wir wenigstens das die Hardwaresignale richtig geschaltet sind!

Gruß Thilo

[Gnubbel (Gast)]

Natürlich meinte ich MISO, aber ich habe nochmal in der Doku zur Library 
nachgeschaut, und das Beispiel welches ich gesehen habe hat tatsächlich 
den Eingang als AF_PP konfiguriert.
Es kann natürlich auch sein dass in den Beispielen der Library ein 
Fehler ist.

IN_FLOATING ist aber auch nicht unbedingt richtig, da es ja eine 
alternative Funktion-> AF sein soll, nämlich nicht GPIO sondern SPI.

Ich benutze wie oben angegeben AF_OD und das funktioniert definitiv.

RM0008 S.157: For alternate function inputs, the port must be configured 
in Input mode (floating, pull-
up or pull-down) and the input pin must be driven externally.

[THaala (Gast)]

Gnubbel hat mal wieder Recht,

mindestens drei SPI - Pins müssen auf den Alternate - Mode (5) 
geschaltet sein. Sonst rühren die sich nicht. Es sind MOSI, MISO und 
CLK...

Trotzdem bleibe ich dabei - Mach erst mal den Toggle - Pin - Test. Wenn 
da eine Antwort kommt weiß man mehr....

[sakul (Gast)]

Ich schaue mir das morgen mal an einem Oszilloskop an und gebe Bescheid 
was dabei rauskam.

Gruß
Lukas

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

Gnubbel schrieb:

> IN_FLOATING ist aber auch nicht unbedingt richtig, da es ja eine
> alternative Funktion-> AF sein soll, nämlich nicht GPIO sondern SPI.
>
> RM0008 S.157: For alternate function inputs, the port must be configured
> in Input mode (floating, pull-up or pull-down) and the input pin must be
> driven externally.

Ähm... und in diesen beiden Aussagen siehst du keinen Widerspruch? Du 
behauptest, die Programmierung als Input sei nicht unbedingt richtig - 
und die Referenz behauptet, es wäre genau richtig.

Es gibt bei den Pins keinen Modus für AF-Input. Der ist auch nicht 
erforderlich, weil der Input-Zweig des Pins auch ohne explizite Schalte 
zum Funktionsmodul geleitet wird. Nur bei Ausgängen muss man die interne 
Signalquelle umschalten. Kann man recht hübsch in Chapter 9 Figure 13 
erkennen.

THaala schrieb:

> mindestens drei SPI - Pins müssen auf den Alternate - Mode (5)
> geschaltet sein. Sonst rühren die sich nicht. Es sind MOSI, MISO und
> CLK...

Seltsamerweise funktionierte SPI bei mir auch dann, wenn MISO als 
normaler Input geschaltet ist.

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

Update: Bei SPI besteht für die Pinfunktion die Besonderheit, dass 
SCLK/MOSI/MISO durch die Master/Slave-Umschaltung ihre Richtung 
wechseln. Es wird also so sein, dass im Fall von SPI auch AF-Output für 
den Eingang spezifiziert werden kann und die vom SPI-Modul kommende 
AF-Steuerung dafür sorgt, dass der Ausgangstreiber bei Funktion als 
Eingang automatisch abgeschaltet wird.

sakul kann also weitersuchen, ob er MISO als Eingang oder Ausgang 
konfiguriert ist bei einem reinen SPI-Master egal.

[Gnubbel (Gast)]

A. K. schrieb:
> Es gibt bei den Pins keinen Modus für AF-Input. Der ist auch nicht
> erforderlich, weil der Input-Zweig des Pins auch ohne explizite Schalte
> zum Funktionsmodul geleitet wird.

Ja OK, da gebe ich mich mal geschlagen.

Bleiben aber immernoch folgende Fragen offen:

Bist du sicher ob alle Leitungen :
 1. Im Schaltplan korrekt angeschlossen sind? (bewege ggf. mal die
beiden Bausteine hin und her, dann siehst du das)
2. Im Board geroutet sind? (Layer angezeigt)

Was steht denn im Eingangsbuffer? 0xFFFF, 0x0000?

[sakul (Gast)]

> 1. Im Schaltplan korrekt angeschlossen sind? (bewege ggf. mal die
> beiden Bausteine hin und her, dann siehst du das)
> 2. Im Board geroutet sind? (Layer angezeigt)
beides Ok, habe Vcc,Gnd,CS,CLK,Miso,Mosi durchgeklingelt -> passt
> Was steht denn im Eingangsbuffer? 0xFFFF, 0x0000?
0x0000

Ich denke in ein paar stunden weiss ich dank Oszilloskop mehr.

Gruß
Lukas

[THaala (Gast)]

Wenn es um die generelle Vorgehensweise geht ist ST selbst die beste 
Quelle.

z.B die Resource für deren EVAL Board 3210B
http://www.st.com/internet/evalboard/product/176090.jsp

in der Demonstration Firmware findest Du mehr als eine SPI - Config - 
Funktion.

Schaust Du hier:
um0435.zip\STM3210B-EVAL_FW_V2.0.0\Project\Demo\src\stm3210b_lcd.c
Funktion LCD_SPIConfig();

oder....
um0435.zip\STM3210B-EVAL_FW_V2.0.0\Project\Demo\src\spi_flash.c
void SPI_FLASH_Init(void);

Gruß Thilo

[vaid (Gast)]

Ich möchte nochmal betonen... hab den SPI mit den oben beschriebenen 
Einstellungen am Laufen. AF-PP ist definitiv die richtige Konfiguration.

Schau dir die Datenübertragung auf dem Oszilloskop an. Ich tippe darauf, 
dass das Datenwort bereits gesendet wird während der Chip Select noch 
nicht aktiv ist.

[Gnubbel (Gast)]

Wenn du kein Oszi hast kannst du ja den Eingang mal als
GPIO anlegen und den Pin dann ständig abfragen und die Led einschalten 
wenn sich der Pegel ändert.

[Gnubbel (Gast)]

Nicht erschlagen bitte,

aber hast du vielleicht einen AD7142-1?

[sakul (Gast)]

> aber hast du vielleicht einen AD7142-1?
Ne, ist wirklich der mit SPI. Gerade nochmal nachgeschaut.

[sakul (Gast)]

Habe nun am Oskar gesehen, dass der Clock nur während des Sendens da 
ist. Beim Empfangen ist er Null. Woran kann das liegen?

[THaala (Gast)]

Schon mal nachgesehene was SPI_I2S_ReceiveData()
so macht ?

uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx)
{
  /* Check the parameters */
  assert_param(IS_SPI_ALL_PERIPH(SPIx));
  
  /* Return the data in the DR register */
  return SPIx->DR;
}

siehst Du auch den Pointer im Prototype ?

Gruß T.

[THaala (Gast)]

In den Beispielen die ich ganannt habe wird das Senden immer abgewartet 
mit der Prüfung auf _BSY

[c]
    SPI_I2S_SendData(SPI2, 0xFF);
    while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) != RESET)
    {
    }
    /* One byte of invalid dummy data read after the start byte */
    while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)
    {
    }
    SPI_I2S_ReceiveData(SPI2);
  }

  SPI_I2S_SendData(SPI2, 0xFF);
  /* Read upper byte */
  while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) != RESET)
  {
  }
  /* Read lower byte */
  while(SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)
  {
  }
  tmp = SPI_I2S_ReceiveData(SPI2);
[/c}

gruß T.
P.S. Vergiss das mit dem Pointer - ich habe mich da vertan!

[sakul (Gast)]

Habe ich angepasst:

  for(;;) 
  {
    GPIO_ResetBits(GPIOA, GPIO_Pin_4);
    SPI_I2S_SendData(SPI1, ControlValue);
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET){}  
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
    testspi = SPI_I2S_ReceiveData(SPI1);      // should read 0xE622 
    GPIO_SetBits(GPIOA, GPIO_Pin_4);
    }

Leider immer noch nur ein CLK beim Senden

[THaala (Gast)]

Ja Moment, aus den Beispielen lese ich, das Du selbst für das Clocking 
sorgst, indem Du ein 0xFF (bzw 0xFFFF in deinem Fall) schreibst. Die 
Konsequenz:
Clock Zappelt, MOSI beleibt auf 1 und MISO rappelt - oder ?

Gruß T.

[THaala (Gast)]

P.S.

Du hast noch immer kein vernünftiges High auf deinem CS.
Bau doch mal ganz unten ein kleines Warten ein!

Gruß T.

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

sakul schrieb:

> Habe nun am Oskar gesehen, dass der Clock nur während des Sendens da
> ist. Beim Empfangen ist er Null. Woran kann das liegen?

An der Arbeitsweise von SPI. Es gibt darin kein getrenntes Senden und 
Empfangen. Wann immer gesendet wird, wird auch gleichzeitig empfangen.

Wenn man also 16 Bits senden und anschliessend als Antwort 16 Bits 
empfangen will, dann werden insgesamt 32 Bits gesendet und 32 Bits 
empfangen.

[THaala (Gast)]

Also:

  for(;;) 
  {
    GPIO_ResetBits(GPIOA, GPIO_Pin_4);
    SPI_I2S_SendData(SPI1, ControlValue);
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET){}  
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
    testspi = SPI_I2S_ReceiveData(SPI1); // read trash.....

    WarteBisDerChipDieAntwortHat_fallsNoetig();

    SPI_I2S_SendData(SPI1, 0xFFFF);
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET){}  
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
    testspi = SPI_I2S_ReceiveData(SPI1); // read expected data.....
    GPIO_SetBits(GPIOA, GPIO_Pin_4);
    WarteEinBischenHier(); // CS mal auf High gehen lassen....
  }

[sakul (Gast)]

Es funktioniert! :) Vielen Dank für die Hilfe!!!
Dann werde ich mal loslegen und mich mit dem Parametrieren von dem Ding 
rumschlagen

[vaid (Gast)]

Viel Erfolg! :-)

[sakul (Gast)]

So um das ganze zu vervollständigen, hier der funktionierende Code:

SPI-Initialisierung:

void spi1init(void) 
{  
  SPI_InitTypeDef SPI_SPI1_InitStructure;
  GPIO_InitTypeDef GPIOSPI1_InitStructure;

  RCC_Configuration();

  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;  // 5 = SPI1_SCK, 6 = SPI1_MISO, 7 = SPI1_MOSI
  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);
  
  GPIOSPI1_InitStructure.GPIO_Pin = GPIO_Pin_4;      // 4 = SPI1_CS
  GPIOSPI1_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIOSPI1_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIOSPI1_InitStructure);
  
  SPI_I2S_DeInit(SPI1);

  SPI_SPI1_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_SPI1_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_SPI1_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  SPI_SPI1_InitStructure.SPI_CPOL = SPI_CPOL_High;
  SPI_SPI1_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  SPI_SPI1_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_SPI1_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
  SPI_SPI1_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_SPI1_InitStructure.SPI_CRCPolynomial = 7;  
  
  SPI_Init(SPI1, &SPI_SPI1_InitStructure);  
  SPI_Cmd(SPI1, ENABLE);
}

Clock-Konfiguration:

void RCC_Configuration(void)
{
    /* RCC system reset(for debug purpose) */
    RCC_DeInit();

    /* Enable HSE */
    RCC_HSEConfig(RCC_HSE_ON);

    /* Wait till HSE is ready */
    HSEStartUpStatus = RCC_WaitForHSEStartUp();

    if (HSEStartUpStatus == SUCCESS)
    {
        /* HCLK = SYSCLK */
        RCC_HCLKConfig(RCC_SYSCLK_Div1);

        /* PCLK2 = HCLK/2 */
        RCC_PCLK2Config(RCC_HCLK_Div2);

        /* PCLK1 = HCLK/2 */
        RCC_PCLK1Config(RCC_HCLK_Div2);

        /* PLLCLK = 8MHz * 9 = 72 MHz */
        RCC_PLLConfig(0x00010000, RCC_PLLMul_9);

        /* Enable PLL */
        RCC_PLLCmd(ENABLE);

        /* Wait till PLL is ready */
        while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) {}

        /* Select PLL as system clock source */
        RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

        /* Wait till PLL is used as system clock source */
        while (RCC_GetSYSCLKSource() != 0x08) {}
    }

    /* Enable peripheral clocks ----------------------------------------------*/
    /* GPIOA enable */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
    /* SPI1 enable */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
}

Lesen/Schreiben:

void ReadFromAD7142ViaSpi(const u16 RegisterStartAddress, const u8 NumberOfRegisters, u16 *DataBuffer, const u16 OffsetInBuffer)
{
  u16 ControlValue;
  u8 i,j, RegisterIndex;
  u16 InputValue;
  
  ControlValue = 0xE400 | (RegisterStartAddress & 0x03FF);    //Create the 16-bit header
  
  for (i=0;i<100;i++);    // delay

  //Write out the control word
  GPIO_ResetBits(GPIOA, GPIO_Pin_4);    // CS low
  SPI_I2S_SendData(SPI1, ControlValue);
  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET);  
  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
  InputValue = SPI_I2S_ReceiveData(SPI1);   // Read dummy

  //Copy each register in the buffer contiguously.
  //Read data in.
  for (RegisterIndex=0; RegisterIndex<NumberOfRegisters; RegisterIndex++)
  {
    SPI_I2S_SendData(SPI1, 0xFFFF);
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET); 
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
    InputValue = SPI_I2S_ReceiveData(SPI1);   // read data
    *(DataBuffer+OffsetInBuffer+RegisterIndex)=(u16)InputValue;
  }
  GPIO_SetBits(GPIOA, GPIO_Pin_4);    // CS high
  for (j=0;j<5;j++);      // delay
}

void WriteToAD7142ViaSpi(const u16 RegisterAddress, const u8 NumberOfRegisters, u16 *DataBuffer, const u8 OffsetInBuffer)
{
  u16 ControlValue;
  u16 ValueToWrite;
  u16 RegisterIndex;
  u8 j;
  
  ControlValue = 0xE000 | (RegisterAddress & 0x03FF);    //Create the 16-bit header

  //Write out the control word
  GPIO_ResetBits(GPIOA, GPIO_Pin_4);    // CS low
  SPI_I2S_SendData(SPI1, ControlValue);
  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET);  
  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  //And then the data
  for (RegisterIndex=0; RegisterIndex<NumberOfRegisters; RegisterIndex++)
  {
    ValueToWrite= *(DataBuffer+RegisterIndex+OffsetInBuffer);
    SPI_I2S_SendData(SPI1, ValueToWrite);
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) != RESET); 
    while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
  }
  GPIO_SetBits(GPIOA, GPIO_Pin_4);    // CS high
  for (j=0;j<5;j++);            // delay
}