Auslesen von Magnetischem Encoder SPI

[Sebastian T. (sebastian_tsch)]

Hi,

Ich möchte über SPI einen AS5048A auslesen 
(http://ams.com/eng/Products/Magnetic-Position-Sensors/Angle-Position-On-Axis/AS5048A). 
Ich habe es mit und ohne DMA versucht und unterschiedliche Ergebnisse 
erhalten:

Ohne DMA scheint es mir den Korrekten Wert anzugeben, jedoch ist der 
Wert nur zwischen 8192 und 16384, also nur die halbe Auflösung. Dabei 
habe ich über die SPI Schnittstelle einfach ein 0x3FFF geschickt, was 
mir nach Datenblatt die 14Bit Auflösung zurückschicken sollte. Damit 
könnte ich aber noch leben.

Sobald ich aber den DMA verwende, passiert etwas merkwürdiges. Die 
Auflösung scheint zwischen 2 Werten hin und her zu springen (zufällig, 
manchmal auch 3mal einen Wert aus dem ersten Intervall etc.), ein Wert 
liegt im Intervall [0,8191], der andere im Intervall [8192,16384]. Was 
ich mache: Isch schreibe in meinen TX Buffer einfach ein 0x3FFF rein und 
lesen nach Bestätigung durch einen Interrupt den RX Buffer aus. Das 
Problem ist, dass ich nicht einfach +8192 für Werte aus dem ersten 
Intervall nehmen kann, da die Differenz zum zweiten Intervall nicht 
linear ist.

Im Datenblatt auf Seite 2 und 3 wird ja ein Vorgehen beschrieben, doch 
ich möchte eigentlich nur den Winkel und dafür sollte 0x3FFF reichen.

Jemand eine Idee?

Edit: Ich habe gerade gesehen, dass die Werte nicht nur zwischen den 
Intervallen springen, sondern auch innerhalb, z.B zwischen 10000 und 
15000.

Grüsse Sebastian T.

[MWS (Gast)]

Sebastian T. schrieb:
> Dabei
> habe ich über die SPI Schnittstelle einfach ein 0x3FFF geschickt, was
> mir nach Datenblatt die 14Bit Auflösung zurückschicken sollte.

Nach dem hier:

>> For a single READ command two transmission sequences are necessary.
>> The first package written to the AS5048 contains the READ command
>> (MSB-1 high) and the address the chip has to access,

entspricht ein 3fff dem Schreibkommando auf das Winkel-Register, statt 
zu lesen und der Rückgabewert ist demgemäß irgendwas.

> Im Datenblatt auf Seite 2 und 3 wird ja ein Vorgehen beschrieben, doch
> ich möchte eigentlich nur den Winkel und dafür sollte 0x3FFF reichen.

Da finde ich nichts. Ggf. anders DB?

[Sebastian T. (sebastian_tsch)]

MWS schrieb:
> Da finde ich nichts. Ggf. anders DB?

Ich verwende die Application Note:

http://ams.com/eng/content/view/download/318035

MWS schrieb:
> entspricht ein 3fff dem Schreibkommando auf das Winkel-Register, statt
> zu lesen und der Rückgabewert ist demgemäß irgendwas.

Ich bekomme eben ziemlich sinnvolle Daten, daher weiß ich nicht woher 
die Störung kommt. Ich habe es auch schon nach dem Application Note 
versucht und die 4x 16bit Befehle in den DMA Buffer geschrieben, doch es 
kam das gleiche raus.

[MWS (Gast)]

Sebastian T. schrieb:
> Ich bekomme eben ziemlich sinnvolle Daten

In die Leitplanke fahren, ist auch ziemlich auf der Straße :-)
Du würdest nicht fragen, wäre alles in Ordnung.

Gehst Du denn so wie in der AN vor? Also Read-Bit zu 3fff setzen, Parity 
daraus berechnen und per SPI senden. Nur ein 3fff rauszuklopfen reicht 
nicht.

[Klaus (Gast)]

Ich verwende den kleinen Bruder, den AS5040, und der liefert wunderbar 
stabile Werte. Er hat ein nicht ganz so komplexes Interface wie der 
5048, der sollte aber genauso funktionieren, wenn man nur den Winkel 
will. Ich hab das in SW gemacht, war mir schnell genug.

Also: CS auf low, 16 mal mit dem Clock wackeln und dabei nach 
Timingdiagram MISO einlesen, CS wieder high. Dabei MOSI immer high 
lassen oder gleich einen Pullup. Die erste Messung nach einem Reset ist 
Rotte, ab dann läufts. Die untersten 14 Bits sind dann der Winkel, die 
beiden oberen Parity und Errorflag. Sollte man beide auswerten, um z.B. 
zu sehen, ob der Magnet passend sitzt.

Das sollte mit dem 5048 genauso funktionieren, wenn ich das Datenblatt 
richtig verstanden habe.

MfG Klaus

[Sebastian T. (sebastian_tsch)]

Klaus schrieb:
> Ich verwende den kleinen Bruder, den AS5040, und der liefert wunderbar
> stabile Werte. Er hat ein nicht ganz so komplexes Interface wie der
> 5048, der sollte aber genauso funktionieren, wenn man nur den Winkel
> will. Ich hab das in SW gemacht, war mir schnell genug.
>
> Also: CS auf low, 16 mal mit dem Clock wackeln und dabei nach
> Timingdiagram MISO einlesen, CS wieder high. Dabei MOSI immer high
> lassen oder gleich einen Pullup. Die erste Messung nach einem Reset ist
> Rotte, ab dann läufts. Die untersten 14 Bits sind dann der Winkel, die
> beiden oberen Parity und Errorflag. Sollte man beide auswerten, um z.B.
> zu sehen, ob der Magnet passend sitzt.
>
> Das sollte mit dem 5048 genauso funktionieren, wenn ich das Datenblatt
> richtig verstanden habe.
>
> MfG Klaus

Danke, das scheint zu funktionieren. Ich bin mir sicher, das ich das 
schon vorher so gemacht habe und es hat nicht geklappt, aber jetzt geht 
es.

Grüsse Sebastian

[MWS (Gast)]

Sebastian T. schrieb:
> Danke, das scheint zu funktionieren.

Kein Wunder, bei Dauer-High ist auch das Read-Bit gesetzt und so schrieb 
ich's bereits.

Damit es wenigstens weitere Suchende verstehen:
Du hast 0x3fff geschickt, das ist die Winkeladresse mit Read=0, somit 
ein Schreibbefehl, dass da Unsinn rauskommt, war klar. Nur eben Dir 
nicht.

Sebastian T. schrieb:
> habe ich über die SPI Schnittstelle einfach ein 0x3FFF geschickt

[Sebastian T. (sebastian_tsch)]

MWS schrieb:
> Du hast 0x3fff geschickt, das ist die Winkeladresse mit Read=0, somit
> ein Schreibbefehl, dass da Unsinn rauskommt, war klar. Nur eben Dir
> nicht.

Ich habe eben auch vorher schon 0xFFFF gesendet und dann mit &=0x3FFF 
die Parity Bits abgeschnitten und trotzdem nur die Hälfte empfangen. 
Warum es jetzt geht ist mir noch immer nicht klar, ich habe verschiedene 
neue Projekte erstelle, welche ich nun durchsuche um den Fehler zu 
finden.

[MWS (Gast)]

Sebastian T. schrieb:
> Ich habe eben auch vorher schon 0xFFFF gesendet und dann mit &=0x3FFF
> die Parity Bits abgeschnitten

Du hast keine Parity-Bit*s* abgeschnitten, da gibt es nur eines, Du hast 
damit das Read-Bit gelöscht und einen Schreib- statt eines Lesebefehls 
auf das Winkelregister geschickt.

Und ein 0xffff entspräche einem Dauer-High, also dem 3 wire mode,  der 
ja offenbar funktioniert, also hätte es auch mit 0xffff geklappt.

[Sebastian T. (sebastian_tsch)]

Ich versuche nun alle Register zu empfangen, um mit den parity bits die 
eine Fehlerhafte Übertragung zu erkennen, was etwa alle 100-200 samples 
vorkommt. Das Problem ist, dass ich irgendwie immer falsche parity bits 
empfange und daher die Daten, auch wenn Sie korrekt sein mögen, falsch 
sind. Hier mein Code:

#include "SPI_DMA.h"

uint16_t SPIBufferRX[BUFFER_SIZE] = {0};
uint16_t SPIBufferTX[BUFFER_SIZE] = {0};
uint16_t Data_Buffer[4] = {0};
uint8_t dataReady=1;
uint8_t transferReady=1;
uint8_t transferState = 1;

void init_SPI_DMA_All() {
  init_SPI_RCC();
  init_SPI_GPIO();
  init_SPI_SPI();
  init_SPI_DMA();
}

void setTXBuffer(uint8_t s) {
  uint16_t dat;
  switch(s) {
    case 1:
      dat = SPI_CMD_READ | SPI_REG_AGC;
      dat |= spiCalcEvenParity(dat) << 15;
      SPIBufferTX[0]=dat;
      break;
    case 2:
      dat = SPI_CMD_READ | SPI_REG_MAG;
      dat |= spiCalcEvenParity(dat) << 15;
      SPIBufferTX[0]=dat;
      break;
    case 3:
      dat = SPI_CMD_READ | SPI_REG_DATA;
      dat |= spiCalcEvenParity(dat) << 15;
      SPIBufferTX[0]=dat;
      break;
    case 4:
      dat = 0x0000; // NOP command.
      SPIBufferTX[0]=dat;
      break;
    default:
      break;
  }
}

uint8_t spiCalcEvenParity(uint16_t value) {
  uint8_t cnt = 0;
  uint8_t i;
  for (i = 0; i < 16; i++) {
    if (value & 0x1) cnt++;
    value >>= 1;
  }
  uint8_t parity = cnt & 0x1;
  return parity;
}

void init_SPI_RCC() {
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
}

void init_SPI_GPIO() {
  GPIO_InitTypeDef GPIO_InitStructure;

  GPIO_StructInit(&GPIO_InitStructure);
  GPIO_InitStructure.GPIO_Pin = SCK_PIN | MISO_PIN | MOSI_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_Init(SPI_PORT, &GPIO_InitStructure);

  GPIO_PinAFConfig(SPI_PORT, GPIO_PinSource3, GPIO_AF_SPI3);
  GPIO_PinAFConfig(SPI_PORT, GPIO_PinSource4, GPIO_AF_SPI3);
  GPIO_PinAFConfig(SPI_PORT, GPIO_PinSource5, GPIO_AF_SPI3);

  GPIO_InitStructure.GPIO_Pin = SS_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(SPI_PORT, &GPIO_InitStructure);

  GPIO_SetBits(SPI_PORT, SS_PIN);        // Set SS pin
}

void init_SPI_SPI() {
  SPI_InitTypeDef SPI_InitStructure;

  SPI_StructInit(&SPI_InitStructure);
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;//MSB
  SPI_InitStructure.SPI_CRCPolynomial = 0;
  SPI_Init(SPI3, &SPI_InitStructure);
}

void init_SPI_DMA(void) {

  NVIC_InitTypeDef NVIC_InitStructure;
  DMA_InitTypeDef DMA_InitStructure;

  DMA_Cmd(DMA_STREAM_TX, DISABLE);
  DMA_Cmd(DMA_STREAM_RX, DISABLE);
  DMA_DeInit(DMA_STREAM_TX);
  DMA_DeInit(DMA_STREAM_RX);

  //RX
  DMA_StructInit(&DMA_InitStructure);
  DMA_InitStructure.DMA_Channel = DMA_CHANNEL;                                   //SPI3 Tx DMA is DMA1/Stream4/Channel0
  DMA_InitStructure.DMA_PeripheralBaseAddr  = (uint32_t)&(SPI3->DR);             //Set the SPI3 Tx
  DMA_InitStructure.DMA_Memory0BaseAddr  = (uint32_t)SPIBufferRX;                //Set the memory location
  DMA_InitStructure.DMA_DIR  = DMA_DIR_PeripheralToMemory;                       //Sending data from memory to the peripheral's Tx register
  DMA_InitStructure.DMA_BufferSize  = BUFFER_SIZE;                              //Define the number of bytes to send
  DMA_InitStructure.DMA_PeripheralInc  = DMA_PeripheralInc_Disable;             //Don't increment the peripheral 'memory'
  DMA_InitStructure.DMA_MemoryInc  = DMA_MemoryInc_Enable;                        //Increment the memory location
  DMA_InitStructure.DMA_PeripheralDataSize  = DMA_PeripheralDataSize_HalfWord;    //Byte size memory transfers
  DMA_InitStructure.DMA_MemoryDataSize  = DMA_MemoryDataSize_HalfWord;           //Byte size memory transfers
  DMA_InitStructure.DMA_Mode  = DMA_Mode_Normal;                                   //Normal mode (not circular)
  DMA_InitStructure.DMA_Priority  = DMA_Priority_High;                           //Priority is high to avoid saturating the FIFO since we are in direct mode
  DMA_InitStructure.DMA_FIFOMode  = DMA_FIFOMode_Disable;                         //Operate in 'direct mode' without FIFO
  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  DMA_Init(DMA_STREAM_RX, &DMA_InitStructure);
  DMA_ITConfig(DMA_STREAM_RX, DMA_IT_TC, ENABLE);

  //TX
  DMA_InitStructure.DMA_Channel = DMA_CHANNEL;                                //SPI3 Tx DMA is DMA1/Stream4/Channel0
  DMA_InitStructure.DMA_PeripheralBaseAddr  = (uint32_t)&(SPI3->DR);             //Set the SPI3 Tx
  DMA_InitStructure.DMA_Memory0BaseAddr  = (uint32_t)SPIBufferTX;                 //Set the memory location
  DMA_InitStructure.DMA_DIR  = DMA_DIR_MemoryToPeripheral;                      //Sending data from memory to the peripheral's Tx register
  DMA_InitStructure.DMA_BufferSize  = BUFFER_SIZE;                              //Define the number of bytes to send
  DMA_InitStructure.DMA_PeripheralInc  = DMA_PeripheralInc_Disable;             //Don't increment the peripheral 'memory'
  DMA_InitStructure.DMA_MemoryInc  = DMA_MemoryInc_Enable;                        //Increment the memory location
  DMA_InitStructure.DMA_PeripheralDataSize  = DMA_PeripheralDataSize_HalfWord;    //Byte size memory transfers
  DMA_InitStructure.DMA_MemoryDataSize  = DMA_MemoryDataSize_HalfWord;           //Byte size memory transfers
  DMA_InitStructure.DMA_Mode  = DMA_Mode_Normal;                                 //Normal mode (not circular)
  DMA_InitStructure.DMA_Priority  = DMA_Priority_High;                           //Priority is high to avoid saturating the FIFO since we are in direct mode
  DMA_InitStructure.DMA_FIFOMode  = DMA_FIFOMode_Disable;                         //Operate in 'direct mode' without FIFO
  DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
  DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  DMA_Init(DMA_STREAM_TX, &DMA_InitStructure);
  DMA_ITConfig(DMA_STREAM_TX, DMA_IT_TC, ENABLE);

  //Interrupt
  DMA_ClearITPendingBit(DMA_STREAM_RX, DMA_IT_RX_FLAG);
  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream0_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  DMA_ClearITPendingBit(DMA_STREAM_TX, DMA_IT_TX_FLAG);
  NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream5_IRQn;
  NVIC_Init(&NVIC_InitStructure);

  SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Tx, ENABLE);
  SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Rx, ENABLE);
  SPI_Cmd(SPI3, ENABLE);
}

int SPI_DMA_getData() {
  if(transferReady) {
    uint16_t data=Data_Buffer[3]&0x3FFF;
    dataReady=1;

    if (((Data_Buffer[1] & 0x4000) || (Data_Buffer[2]  & 0x4000) || (Data_Buffer[3]  & 0x4000))) {
      return -1;
    } else {
      return data;
    }
  }
  return -1;
}

void SPI_DMA_continue(uint8_t s) {
  s++;
  if(s<=4) {
    transferState=s;
    setTXBuffer(transferState);

    Data_Buffer[s-2]=SPIBufferRX[0];

    DMA_SetCurrDataCounter(DMA_STREAM_RX, BUFFER_SIZE);
    DMA_SetCurrDataCounter(DMA_STREAM_TX, BUFFER_SIZE);

    GPIO_WriteBit(SPI_PORT, SS_PIN, RESET);
    DMA_Cmd(DMA_STREAM_TX, ENABLE);
    DMA_Cmd(DMA_STREAM_RX, ENABLE);

    SPI_Cmd(SPI3, ENABLE);

  } else {
    Data_Buffer[3]=SPIBufferRX[0];
    transferReady=1;
  }

}

void SPI_DMA_start(void) {
  if(transferReady && dataReady) {
    transferReady=0;
    dataReady=0;

    transferState=1;
    setTXBuffer(transferState);

    while((DMA_GetCmdStatus(DMA_STREAM_TX) == ENABLE) || (DMA_GetCmdStatus(DMA_STREAM_RX) == ENABLE)){

    }

    DMA_SetCurrDataCounter(DMA_STREAM_RX, BUFFER_SIZE);
    DMA_SetCurrDataCounter(DMA_STREAM_TX, BUFFER_SIZE);

    GPIO_WriteBit(SPI_PORT, SS_PIN, RESET);
    DMA_Cmd(DMA_STREAM_TX, ENABLE);
    DMA_Cmd(DMA_STREAM_RX, ENABLE);

    SPI_Cmd(SPI3, ENABLE);
  }
}

void DMA1_Stream0_IRQHandler(void){ //RX
  if(DMA_GetITStatus(DMA_STREAM_RX, DMA_IT_RX_FLAG))  {
    DMA_ClearITPendingBit(DMA_STREAM_RX, DMA_IT_RX_FLAG);

    SPI_Cmd(SPI3, DISABLE);
    GPIO_WriteBit(SPI_PORT, SS_PIN, SET);
    DMA_Cmd(DMA_STREAM_RX, DISABLE);
    DMA_Cmd(DMA_STREAM_TX, DISABLE);

    SPI_DMA_continue(transferState);

  }
}

void DMA1_Stream5_IRQHandler(void){ //TX
  if(DMA_GetITStatus(DMA_STREAM_TX, DMA_IT_TX_FLAG))  {
    DMA_ClearITPendingBit(DMA_STREAM_TX, DMA_IT_TX_FLAG);

  }
}

[Klaus (Gast)]

Wow!

Wenn ich da meinen Code anschaue kriege ich ja richtig 
Minderwertigkeitskomplexe

    unsigned int result = 0;

    AS_CLK = 1;
    AS_CS = 0;
    __delay_us(1);
    for (i = 0; i < 16; i++) {
        AS_CLK = 0;
        __delay_us(1);
        AS_CLK = 1;
        __delay_us(1);
        result <<= 1;
        if (AS_DO == 1) {
            result |= 1;
        }
    }
    AS_CS = 1;

Wobei man bei 100ns Cycletime die delay_us je nach Prozessor weglassen 
oder durch ein Nop() ersetzen kann. Dann ist das Ganze in wenigen µs 
abgehandelt.

MfG Klaus

[Sebastian T. (sebastian_tsch)]

Klaus schrieb:
> Wenn ich da meinen Code anschaue kriege ich ja richtig
> Minderwertigkeitskomplexe

Da wird aber weder der DMA verwendet noch die parity bit Kontrolle 
ausgeführt. Wenn ich das ganze ohne DMA und ohne parity bit Kontrolle 
mache, komme ich auf ähnliches.

[Sebastian T. (sebastian_tsch)]

Der Parity Check scheint nur für die Werte aus [8192,16384] zu gehen, 
dann bei kleineren Winkelwerten leaken irgendwelche Daten durch.