SSI Schnittstelle LM3S1968 (Luminary Cortex M3)

[Harald H. (mirona)]

Ich habe ein Problem mit der SSI Schnittstelle des LM3S1968 (Cortex M3 
von TI).
Es handelt sich um ein Board von TI.
Programmiert wird mit Crossworks for ARM 2.0.7.

Was wird bezweckt?
  Ich möchte ein TFT Display EA eDIPTFT43-A über seine SPI Schnittstelle
  ansprechen.
Was funktioniert?
  Die Ausgabe eines Kommandostrings an das Display funktioniert.
  Das Display antwortet mit 0x06 (Acknowledge).
Was funktioniert nicht?
  Der Prozessor liest die Antwort 0x06 nicht ein.
Woher weiß ich daß?
  Ich habe an der SSI Schnittstelle des Boards einen Logicanalyzer
  angeschlossen, der mir die Daten anzeigt, die an der Schnittstelle
  ankommen.

Für die Bedienung der Schnittstellen werden die Prozeduren aus der 
Luminary Library genutzt.

So nun zum eigentlichen Problem.
Betroffen ist eigentlich nur die Funktion "read_char".

Wie schon gesagt, liest der Prozessor das Acknowledge nicht ein.
Bis auf eine Ausnahme. Im Schrittbetrieb (step-over, d.h. die Funktionen 
werden als Ganzes ausgeführt) erscheint nach dem zweiten Befehl/zweiter 
Funktion die 0x06 im SSI0_DR (Datenregister der SSI Schnittstelle).
Die Stelle an der der Wert erscheint habe ich mit einem Kommentar 
versehen (ist unmittelbar nach dem return (dat)).
Lege ich einen Breakpoint an diese Stelle und lasse das Programm bis 
dahin durchlaufen, steht im Register 0xfe.
Füge ich zwei zusätzliche Befehle (z.B. zwei Additionen) nach der 
Empfangsfunktion (SSIDataGet) ein, sehe ich das
Acknowledge diese zwei Funktionen eher.

Ersetze ich die Luminary-Funktionen durch die unmittelbaren 
Registerzugriffe ändert sich am Verhalten nichts.

Gibt es jemanden, der sich mit dem LM3S auskennt und etwas zur SSI 
Schnittstelle sagen kann?

Hinsichtlich der SSI Schnittstelle gibt es kein Errata von TI.

#include <hw_types.h>
#include <driverlib/sysctl.h>
#include <driverlib/ssi.h>
#include <hw_memmap.h>
#include <driverlib/gpio.h>

#include "system.h"
#include "comm.h"
#include "spi.h"
#include "timer.h"

#define softSPI  0  // SPI Übertragung durch Soft-SPI wenn 1

#if softSPI
//#define SDC_CLK    GPIOPinWrite (GPIO_PORTA_BASE, SPI0_CLK, 0);
//#define SDC_DI    GPIOPinWrite (GPIO_PORTA_BASE, SPI0_MISO, 0);
//#define SDC_DO    GPIOPinWrite (GPIO_PORTA_BASE, SPI0_MOSI, 0);
#endif

unsigned long uldat;

void write_char (char c) {

#if SPI

#if softSPI
  volatile char a;
  unsigned int i;

  for (a = 8; a > 0; a--) {
//    SDC_CLK = 0;          // 380 ns
                GPIOPinWrite (GPIO_PORTA_BASE, SPI0_CLK, 0);
//    wait_usec (1);
    for (i=0;i<20;i++);
//    SDC_DO = (dat & (1 << (a - 1))) ? 1 : 0;  // 540 ns
    GPIOPinWrite (GPIO_PORTA_BASE, SPI0_MOSI, (c & (1 << (a - 1))) ? 1 : 0);//    SDC_CLK = 1;          // 200 ns
                GPIOPinWrite (GPIO_PORTA_BASE, SPI0_CLK, 1);
//    wait_usec (1);
    for (i=0;i<200;i++);
  }
//  SDC_CLK = 0;
  GPIOPinWrite (GPIO_PORTA_BASE, SPI0_CLK, 0);
//  SDC_DI = 1;
  GPIOPinWrite (GPIO_PORTA_BASE, SPI0_MOSI, 1);

#else
  SSIDataPut (SSI0_BASE, c);
#endif

#elif UART

#endif
}

char read_char (void) {
  volatile unsigned char dat;
//  unsigned long uldat;
  volatile unsigned int a, b;

  a = 0;
  b = 0;
  uldat = 0xff;
  dat = 0;

#ifdef SPI
  SSIDataPut (SSI0_BASE, 0x55);
  SSIDataGet (SSI0_BASE, &uldat);
#elif UART

#endif

// zwei Dummy Befehle
  a = a + 6;
  b = a + 8;
// Wenn diese beiden Dummy Befehle eingefügt werden, sehe ich das
// Acknowledge nach dem nachfolgenden Befehl "dat = ..."

  dat = (unsigned char)uldat;
  return (dat);
}  // ohne Dummy-Befehle sehe ich hier die 0x06 im SPI Empfangsregister

char acknowledge (void) {
  char ack;
  volatile unsigned int i;

  for (i = 0; i < 100; i++) {
  }

  ack = read_char ();
  return (ack);
}

char write_cmd (char *cmd) {
  char ack;
  unsigned char i;

//  CS_LOW;
  GPIOPinWrite (GPIO_PORTA_BASE, SPI0_CS, 0);

  for (i = 0; i < (cmd[1] + 3); i++) {
    write_char (cmd[i]);
  }

//  ack = acknowledge ();
  ack = read_char ();

//  CS_HIGH;
  GPIOPinWrite (GPIO_PORTA_BASE, SPI0_CS, SPI0_CS);

  return ack;
}