SPI - Probleme mit der MISO Leitung

[Felix D. (skyfox)]

Hallo zusammen,

ich habe ein kleines Problem mit SPI und ich hoffe Ihr könnt mir helfen.

Es geht um die Kommunikation eines AVR32 (AT32uc3c1512) und eines 
SPI-Slaves (ET1200 (EtherCAT)).

Der AVR32 sendet die Addresse des zu lesenden Registers (2 Byte) aber 
danach passiert nichts mehr. Ich schreibe ein DUMMY-Byte aber das kommt 
nicht an. Wähle ich ein anderes CS sendet der AVR32 zwei Mal 
hintereinander. Am Logic analyzer sehe ich, dass der Slave die 
MISO-Leitung unten hält. Das steht auch so im Datenblatt und ist nicht 
zu ändern.

Nun meine Frage:
Kann ich dem AVR32 irgendwie abgewöhnen auf de MISO-Leitung zu lauschen?

Würde es ausreichen wenn ich einfach das DUMMY-Byte in das TDR-Register 
schreibe?

Implementiert habe ich das ganze wie hier beschrieben 
http://asf.atmel.com/docs/latest/common.components.memory.sd_mmc.unit_tests.evk1100/html/avr32_drivers_spi_quick_start.html 
beschrieben, nur halt mit 16 statt 8 Bit.
In der while()-Schleife nach dem zweiten spi_put(...) bleibt er hängen. 
Auf der Leitung kommt nichts an.

Habt Ihr einen Tipp für mich?

Gruß
Felix

[Wolfgang (Gast)]

Felix D. schrieb:
> Kann ich dem AVR32 irgendwie abgewöhnen auf de MISO-Leitung zu lauschen?

Nein. Bei SPI laufen die Daten immer auf beiden Datenleitungen synchron.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Felix D. schrieb:
> Nun meine Frage:
> Kann ich dem AVR32 irgendwie abgewöhnen auf de MISO-Leitung zu lauschen?
Wozu sollte das gut sein? Dir ist das grundlegende Konzept des SPI mit 
den gekoppelten Schieberegistern bekannt? Es wird immer gleichzeitig 
gesendet und empfangen, mit jedem SCLK Takt ein Bit:
http://www.lothar-miller.de/s9y/categories/17-SPI

Ein Slave "sendet2 nicht von sich aus. Der Master muss vom Slave die 
Daten "abholen". Wenn du also von deinem Slave etwas willst, dann muss 
der SPI Takt weiterlaufen. Das wird gemacht, indem irgendwas vom Master 
zum Slave gesendet wird...


Allgemein: lies deine Frage mal so, wie wenn du von deinem Problem 
absolut NICHTS wüsstest. So geht es uns: wir kennen dein Problem 
nicht. Wenn dir dann klar wird, was gemeint ist, dann drücke auf den 
"Absenden"-Knopf. Wenn nicht, dann füge die nötige Information (Bilder 
vom LA, Code, Schaltplan,...) dazu.

[Felix D: (Gast)]

Hallo, danke für die Antworten und entschuldigt bitte meine 
missverständliche Ausdrucksweise. War spät gestern.

Da, die grundlegende Funktionsweise von SPI ist bekannt. Mein Problem 
ist halt, dass der AVR32 nicht weiter taktet. Ich habe mal Screenshots 
vom LA hinzugefügt. Ich hoffe Ihr seht was ich meine.

Bei dem zweiten Screenshot ist ein anderes CS ausgewählt.

Der verwendete Code ist der aus dem Link im ersten Post mit marginalen 
Änderungen auf das verwendete Pinout. Ich habe das Ganze um eine 
Statusfunktion erweitert, damit ich sehen kann wo es hängt.

Alle Chips, und auch der LA sprechen SPI-Mode 3.

extern "C"{
#include "spi.h"
#include "gpio.h"
#include "sysclk.h"
#include "scif_uc3c.h"
}

/* Connection of the AUDIO sensor */
#define EXAMPLE_SPI_INSTANCE            1
#define EXAMPLE_SPI1          (&AVR32_SPI1)
#define EXAMPLE_SPI_MISO_PIN            AVR32_SPI1_MISO_PIN
#define EXAMPLE_SPI_MISO_FUNCTION    AVR32_SPI1_MISO_FUNCTION
#define EXAMPLE_SPI_MOSI_PIN      AVR32_SPI1_MOSI_PIN
#define EXAMPLE_SPI_MOSI_FUNCTION    AVR32_SPI1_MOSI_FUNCTION
#define EXAMPLE_SPI_CLK          AVR32_SPI1_SCK_PIN
#define EXAMPLE_SPI_CLK_FUNCTION    AVR32_SPI1_SCK_FUNCTION
#define EXAMPLE_SPI_NPCS_0_PIN      AVR32_SPI1_NPCS_0_1_PIN
#define EXAMPLE_SPI_NPCS_0_FUNCTION    AVR32_SPI1_NPCS_0_1_FUNCTION
#define EXAMPLE_SPI_NPCS_1_PIN      AVR32_SPI1_NPCS_1_1_PIN
#define EXAMPLE_SPI_NPCS_1_FUNCTION    AVR32_SPI1_NPCS_1_1_FUNCTION
#define EXAMPLE_SPI_PRESCALER_CLOCK     FOSC0 / 2

#define EXAMPLE_SPI_CHIP_NUMBER      1
#define EXAMPLE_SPI_BAUDRATE      100000
#define EXAMPLE_SPI_BITS_PER_CHAR    16
#define EXAMPLE_SPI_CLK_PULSE_DELAY    32
#define EXAMPLE_SPI_TRANSFER_DELAY    16
#define EXAMPLE_SPI_STAY_ACTIVE      1
#define EXAMPLE_SPI_MODE        SPI_MODE_3
#define EXAMPLE_SPI_MODE_FAULT_DETECT  0
#define EXAMPLE_SPI_ET1200_SLAVE    0

#define LED_FAULT              AVR32_PIN_PB03
#define LED_OK                AVR32_PIN_PB02

static void init_gclk(void)
{
    // Setup Sampling Rate
    // Sampling Rate = (115200/100) = 1152Hz
    // Setup the generic clock for EVENT
    scif_gc_setup(AVR32_SCIF_GCLK_GCLK2_EVENT,
            scif_gcctrl_oscsel_t{SCIF_GCCTRL_SLOWCLOCK},
            AVR32_SCIF_GC_DIV_CLOCK,
            100);

    // Now enable the generic clock
    scif_gc_enable(AVR32_SCIF_GCLK_GCLK2_EVENT);
}

const spi_options_t spi1_options {
  EXAMPLE_SPI_CHIP_NUMBER,
  EXAMPLE_SPI_BAUDRATE,
  EXAMPLE_SPI_BITS_PER_CHAR,
  EXAMPLE_SPI_CLK_PULSE_DELAY,
  EXAMPLE_SPI_TRANSFER_DELAY,
  EXAMPLE_SPI_STAY_ACTIVE,
  EXAMPLE_SPI_MODE,
  EXAMPLE_SPI_MODE_FAULT_DETECT
};

uint16_t data[] = {
    0x0000
};

uint16_t address1 = {
    0b0000101000000010    // 0x0a02
};

uint16_t address2 = {
    0x0000
};




void enable_gpios(void) {
  gpio_disable_pin_pull_up(LED_OK);
  gpio_enable_gpio_pin(LED_OK);
  gpio_set_pin_low(LED_OK);
  gpio_disable_pin_pull_up(LED_FAULT);
  gpio_enable_gpio_pin(LED_FAULT);
  gpio_set_pin_low(LED_FAULT);
}

void set_fl(void) {
   gpio_enable_pin_pull_up(LED_FAULT);
   gpio_set_pin_high(LED_FAULT);
}

void set_ol(void) {
  gpio_enable_pin_pull_up(LED_OK);
  gpio_set_pin_high(LED_OK);
}

void clear_fl(void) {
  gpio_disable_pin_pull_up(LED_FAULT);
  gpio_set_pin_low(LED_FAULT);
}

void clear_ol(void) {
  gpio_disable_pin_pull_up(LED_OK);
  gpio_set_pin_low(LED_OK);
}

void set_status(spi_status_t pStatus) {
  clear_ol();
  clear_fl();
  switch (pStatus) {
  case SPI_OK:
    set_ol();
    break;
  case SPI_ERROR:
    set_fl();
    break;
  case SPI_ERROR_TIMEOUT:
    set_fl();
    set_ol();
    break;
  default:
    break;
  }
}

void spi_init_module(void)
{
  spi_status_t status = SPI_ERROR;
  set_status(status);
  status = SPI_OK;
  //Init SPI module as master
  status = spi_initMaster(EXAMPLE_SPI1,&spi1_options);
  set_status(status);
  //Setup configuration for chip connected to CS1
  status = spi_setupChipReg(EXAMPLE_SPI1,&spi1_options,sysclk_get_pba_hz());
  set_status(status);
  //Allow the module to transfer data
  spi_enable(EXAMPLE_SPI1);
}

int main(void)
{
  enable_gpios();
  spi_status_t status = SPI_ERROR;
  set_status(status);
  status = SPI_OK;
    // GPIO pin/SPI-function map
    gpio_map_t SPI1_GPIO_MAP = {
        {EXAMPLE_SPI_MISO_PIN, EXAMPLE_SPI_MISO_FUNCTION},
        {EXAMPLE_SPI_MOSI_PIN, EXAMPLE_SPI_MOSI_FUNCTION},
        {EXAMPLE_SPI_CLK, EXAMPLE_SPI_CLK_FUNCTION},
        {EXAMPLE_SPI_NPCS_0_PIN, EXAMPLE_SPI_NPCS_0_FUNCTION},
        {EXAMPLE_SPI_NPCS_1_PIN, EXAMPLE_SPI_NPCS_1_FUNCTION}
    };

    // Initialize the system clocks
    sysclk_init();

    // Assign and enable GPIO pins to the SPI function
    gpio_enable_module(SPI1_GPIO_MAP, sizeof(SPI1_GPIO_MAP) /
            sizeof(SPI1_GPIO_MAP[0]));

    // Initialize Generic Clock
    init_gclk();

    spi_init_module();

  status = spi_selectChip(EXAMPLE_SPI1,EXAMPLE_SPI_CHIP_NUMBER);
  //Wait for the transmitter to be ready
  while(!spi_is_tx_ready(EXAMPLE_SPI1)) {};

  uint16_t tx_data = 0x0a02;
  spi_put(EXAMPLE_SPI1,tx_data);

  while(!spi_is_tx_empty(EXAMPLE_SPI1)) {};

//  set_status(SPI_ERROR_TIMEOUT);
  while(!spi_is_tx_ready(EXAMPLE_SPI1)) {};

  tx_data = 0x0000;
  spi_put(EXAMPLE_SPI1,tx_data);
  set_status(SPI_ERROR);
  while(!spi_is_tx_empty(EXAMPLE_SPI1)) {
    set_status(SPI_ERROR_TIMEOUT);
  };
  uint16_t rx_data = 0x0000;
  rx_data = spi_get(EXAMPLE_SPI1);
  if(rx_data == 0x1100) {
    set_status(SPI_OK);
  } else {
    set_status(SPI_ERROR);
  }

  spi_unselectChip(EXAMPLE_SPI1,EXAMPLE_SPI_CHIP_NUMBER);

    while(true)
    {
      ;
    }
}

In der vorletzten while()-Schleife, also da wo das SPI_ERROR_TIMEOUT 
gesetzt wird, bleibt er hängen. Das setzen des Status bedeutet bei mir 
nur, dass meine beiden Status-LEDs beide leuchten.

Ich hoffe damit den Problemnebel der Glaskugel ein wenig gelichtet zu 
haben.

[Rainer U. (r-u)]

Schreib Dir ein ganz einfaches Programm, dass 3 Bytes in das SPDR 
schreibt (immer schön auf das SPIF warten zwischendurch). Dann sollte 
die Clock-Leitung 3x8 = 24 mal zappeln.

Wenn nicht, hast Du ein Verständnisproblem.
Wenn es klappt, guck was Dien Programm anders macht.

[Felix D. (skyfox)]

Ich hab's :-)

Das Problem saß, wie zu erwarten, wieder zwischen Stuhl und Tastatur.

Den define für die Mode fault detection disable habe ich blöde benahmt, 
es handelt sich ja schließlich um einen disable.

#define EXAMPLE_SPI_MODE_FAULT_DETECT  1

brachte das gewünschte Ergebnis.

Ich hab's dann auch gleich anders genannt.

Vielen Dank an alle die sich darüber Gedanken gemacht haben.

Nächstes Mal bemühe ich mich die Fragen von Anfang an präziser zu 
stellen.

Das Bild zeigt, wie es jetzt am LA aussieht.

Gruß

Felix

[Meckerziege (Gast)]

Felix D: schrieb:
> War spät gestern.

Und noch ein Tip. Achte auf die Bildformate: JPEG ist für Photos 
optimiert. In Graphiken entstehen bei dieser Kompressionsmethode 
häßliche Artefakte, weil der Algorithmus mit scharfen Linien und 
harten Kanten soetwas von überhaupt nicht gut zurecht kommt.

PNG ist für solche Dinge das Format der Wahl. Und weder die Icons vom 
Programm, noch die ungenutze schwarze Fläche des Fensters interessieren 
hier irgend jemand. Fokusiere deine Darstellung auf den wesentlichen 
Teil.

Und längeren Code kann man in einen Anhang packen. So bekommt man vom 
Scrollen fast wunde Finger.