ATXXMega128A1 und Hardware-SPI

[Bastel K. (bastel_k)]

Hallo Leute,

ich habe ein Problem mit meinem XMega und der SPI-Schnittstelle. An ihr 
ist ein Beschleunigungssensor angeschlossen, der auch wunderbar 
funktioniert, wenn die Bits von Hand rein und raus shifte.

Das Protokoll ist eigentlich recht einfach. Man shiftet 8 Bits rein, die 
das auszulesende Register beschreiben und dann kann man direkt 8 Bits 
raus shiften, die dann der Inhalt des entsprechenden Registers sind.

Dieses Vorgehen funktioniert auch wunderbar mit der XMega-eigenen SPI 
oder wenn man eben das SPI softwaremäßig macht.

Allerdings möchte ich um Zeit zu sparen einen Vorteil des SPI-Protokolls 
mit dem Beschleunigungssensors nutzen. Man kann nämlich durch Setzen von 
Bit 7 der Registeradresse dem Sensor sagen, dass man gleich mehrere 
aufeinander folgende Register raus shiften will. Das heißt ein Byte rein 
shiften und so viele man will raus shiften. Durch dieses Vorgehen kann 
ich Zeit sparen um alle drei Achsen des Sensors auszulesen. Jede Achse 
hat 16 Bit, d.h. ich muss ein Byte, die Registeradresse, rein shiften 
und dann 6 raus shiften.

Mit Software-SPI geht das auch wunderbar, aber um den Overhead der 
Bitmanipulationen zu verringern und in Zukunft dann auch noch DMA zu 
benutzen, brauche ich die Hardware-SPI. Leider will die mir immer nur 
ein Register auslesen und alle anderen sind dann einfach 0. In seltenen 
Fällen klappte es sogar, aber ich weiß nicht warum, weil ich nichts am 
Code geändert habe.

Neben der Initialisierung des SPI sieht der Code vereinfacht so aus:

#define USE_HW_SPI
#define USE_INTERRUPT
//#define USE_WORKAROUND

#ifdef USE_INTERRUPT
  volatile extern uint8_t spieTransferBusy;
  #define SPIE_BUSY() spieTransferBusy = true;
  #define SPIE_WAIT_BEGIN() while (spieTransferBusy);
  #define SPIE_WAIT_END()
  #define SPIE_WAIT() while (spieTransferBusy);
#else
  #define SPIE_BUSY()
  #define SPIE_WAIT_BEGIN()
  #define SPIE_WAIT_END() while (!(SPIE.STATUS & SPI_IF_bm));
  #define SPIE_WAIT() while (!(SPIE.STATUS & SPI_IF_bm));
#endif

#ifdef USE_INTERRUPT

volatile uint8_t spieTransferBusy = false;

ISR(SPIE_INT_vect) {
  spieTransferBusy = false;
}

#endif

#ifdef USE_HW_SPI
    uint8_t read(char register_address) {
      uint8_t read_address = ACC_RW_BIT | register_address;
      uint8_t register_value = 0;

      port->OUTCLR = _BV(CS);

      // Darauf warten, dass SPI bereit für neue Daten ist
      SPIE_WAIT_BEGIN(); SPIE_BUSY();
      // Registeradresse rein schreiben
      SPIE.DATA = read_address;
      // Darauf warten, dass SPI bereit für neue Daten ist
      SPIE_WAIT(); SPIE_BUSY();
      // 0 rein schreiben, weil wir nur lesen wollen
      SPIE.DATA = 0;
      // Darauf warten, dass SPI bereit für neue Daten ist
      SPIE_WAIT();
      // Daten auslesen
      register_value = SPIE.DATA;

      port->OUTSET = _BV(CS);

      return register_value;
    }

    void readXYZ(int16_t &x, int16_t &y, int16_t &z) {
      uint8_t read_address;
      read_address = ACC_RW_BIT | ACC_MB_BIT | ACC_DATAX0;


#  ifdef USE_WORKAROUND
      // Register einzeln auslesen
      read_address = ACC_DATAX0;
      x = read(read_address++);
      x |= read(read_address++) << 8;
      y = read(read_address++);
      y |= read(read_address++) << 8;
      z = read(read_address++);
      z |= read(read_address) << 8;
#  else
      // Aufeinander folgende Register nacheinander auslesen
      port->OUTCLR = _BV(CS);

      SPIE_WAIT_BEGIN(); SPIE_BUSY();
      SPIE.DATA = read_address;
      SPIE_WAIT(); SPIE_BUSY();
      SPIE.DATA = 0; SPIE_WAIT();
      x = SPIE.DATA; SPIE_BUSY();
      SPIE.DATA = 0; SPIE_WAIT();
      x |= SPIE.DATA << 8; SPIE_BUSY();
      SPIE.DATA = 0; SPIE_WAIT();
      y = SPIE.DATA; SPIE_BUSY();
      SPIE.DATA = 0; SPIE_WAIT();
      y |= SPIE.DATA << 8; SPIE_BUSY();
      SPIE.DATA = 0; SPIE_WAIT();
      z = SPIE.DATA; SPIE_BUSY();
      SPIE.DATA = 0; SPIE_WAIT();
      z |= SPIE.DATA << 8;

      port->OUTSET = _BV(CS);
#  endif
    }
#endif

Es ist jetzt schwer einen komplett lauffähigen Code aus dem ganzen 
Projekt heraus zu nehmen. Wenn das so nicht reicht, kann ich's aber 
versuchen und das ganze auch als ZIP anhängen.

Sieht jemand irgendwo das Problem? Denn manchmal, zum Beispiel gerade 
eben, geht es ja und manchmal nicht. Wenn ich das Projekt nur kompiliere 
und auf den XMega lade, geht es manchmal und manchmal nicht. Das ist 
sehr verwirrend. Ich hab schon so viel ausprobiert. Aber da es ja 
manchmal geht, sollte am Code ja nichts falsch sein. Hat vielleicht der 
XMega da auch manchmal so seine Macken? Das wäre natürlich fatal...

Grüße,
Nicolas

[Timmo H. (masterfx)]

Also ich nutze den SPI bei meinem Xmega so:

void SPI_init(){  
  PORTC.DIR = (1<<PIN4) | (1<<PIN5) | (1<<PIN7); //SS & MOSI & SCK
  PORTC.OUTCLR = (1<<PIN7);
  SPIC.CTRL = (1<<SPI_MASTER_bp) | (1<<SPI_ENABLE_bp) | SPI_PRESCALER_DIV64_gc; //prescaler 64 => 500 kHz

}

unsigned char SPI_transfer( unsigned char value )
{

  SPIC.DATA = value;
  /* Wait for transmission complete */
  while(!(SPIC.STATUS & SPI_IF_bm));
  return SPIC.DATA;
}

void SPI_Write_Reg(uint8_t reg, uint8_t value)                 
{

  CSN_ON();

  SPI_transfer(reg);  // select register
  SPI_transfer(value);        // ..and write value to it..

  CSN_OFF();
}      

uint8_t SPI_Read_Reg(uint8_t reg)                               
{                                                           
  uint8_t value;

  CSN_ON();

  SPI_transfer(reg);            // Select register to read from..
  value = SPI_transfer(0);    // ..then read register value

  CSN_OFF();


  return(value);        // return register value
}   

void SPI_Read_Buf(uint8_t reg, uint8_t *pBuf, uint8_t length)     
{                                                           
  uint8_t status,byte_ctr;  

    CSN_ON();                                                

  status = SPI_transfer(reg);           // Select register to write, and read status UINT8
                                                            
  for(byte_ctr=0;byte_ctr<length;byte_ctr++)           
    pBuf[byte_ctr] = SPI_transfer(0);    // Perform SPI_RW to read UINT8 from RFM70 
                                         
  CSN_OFF();
               
}     

void SPI_Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t length)    
{                                                           
  uint8_t status, byte_ctr;                              

  CSN_ON();

  status = SPI_transfer(reg);    // Select register to write to and read status UINT8

  for(byte_ctr=0; byte_ctr<length; byte_ctr++) // then write all UINT8 in buffer(*pBuf) 
    SPI_transfer(*pBuf++); 
    
                                  
  CSN_OFF();

}

Das wars auch schon

[Bastel K. (bastel_k)]

Ja, ungefähr den selben Code habe ich schon an vielen Stellen gefunden. 
Aber um später DMA benutzen zu können, braucht man auf jeden Fall einen 
Interrupt. Der wird in deinem Code ja nicht benutzt.

Ansonsten macht mein Code im Grunde genau das selbe wie deine. Ich lese 
bloß SPIx.DATA nicht aus, wenn ich es auch nicht brauche. Ich versuche 
das mal mit einer 'dummy'-Variablen zu umgehen.

Muss denn vor dem nächsten Schreiben in SPIx.DATA immer daraus gelesen 
werden?

Nach den ersten Tests geht es zumindest ohne Interrupt immer. Aber mit 
Interrupt ging es noch gar nicht, obwohl das auch mal zumindest 
sporadisch geklappt hatte. :-/

[Timmo H. (masterfx)]

Dann schau dir doch mal "AVR1309: Using the XMEGA SPI" an. Da sind auch 
Interrupt-Beispiele.
Mir war die Lib immer zu fett, darum nutze ich das von mir abgespeckte.

[Basti M. (counterfeiter)]

DMA und Interrupt ist nicht das selbe... der DMA nutzt zwar die 
Interruptquelle als Trigger, aber der Interrupt muss deswegen nichts 
abgearbeitet werden... sonst macht das ja keinen Sinn...
Außerdem geht Interrupt aufn XMega eh nur mit dem USART... also gleich 
mal damit versuchen, wenns später eh noch DMA werden soll...
Die Pins sind jetzt leider falsch belegt, aber ich denke, man kann sie 
in den neuen U Typen einfach ummappen...

Grüße

Basti

[Gerhard G. (g_g)]

Hallo,

schau dir mal den Code an: Auslesen eines LTC2400 24 Bit

SPI kann mit oder ohne Interrupt verendet werden (#define SPID_USEINT)

Deine 32 Bit sind dann kein Problem mehr.


http://www.basteln-mit-avr.de/atxmega128a3.html#PT1000

Gruß G.G.

[Bastel K. (bastel_k)]

G. G. schrieb:
> schau dir mal den Code an: Auslesen eines LTC2400 24 Bit

Danke, das schau ich mir mal an.