STM32F4 und LTC6803-4, Probleme mit dem SPI und der Antwort des LTC

[Max H. (Gast)]

Hallo uC-Community,

ich stehe vor einem Problem und sehe wahrscheinlich den Wald vor lauter 
Bäumen nicht. Ich versuche einen LTC6803-4 über (isolierten) SPI 
anzusprechen. Die Initialisierung vom SPI sollte passen denn auf dem 
Logic Analyser sehe ich SCLK, MOSI und CS sowohl vor als auch nach dem 
Optokoppler. Das Problem liegt in der Antwort vom LTC6803. Dieser sendet 
mir absolut keine Daten und macht auch sonst keinen Mucks.

Meine Deklarationen:

/** @defgroup STM32F4_HARDWARE_LTC6803
  * @{
  */
uint8_t LTC6803_RX[LTC6803_NBR_BYTES] = {0};
uint8_t LTC6803_PEC = 0x00;
static uint8_t CRC8_Table[256];    // 8-bit table for PEC calc

#define LTC6803_NBR_BYTES 16

#define LTC6803n                        4

/* PB12 - SPI2_NSS */
#define LTC6803_CS_PIN                  GPIO_Pin_12
#define LTC6803_CS_PIN_SOURCE           GPIO_PinSource12
#define LTC6803_CS_GPIO_PORT            GPIOB
#define LTC6803_CS_GPIO_CLK             RCC_AHB1Periph_GPIOB

/* PB14 - SPI2_MISO */
#define LTC6803_DOUT_PIN                 GPIO_Pin_14
#define LTC6803_DOUT_PIN_SOURCE         GPIO_PinSource14
#define LTC6803_DOUT_GPIO_PORT           GPIOB
#define LTC6803_DOUT_GPIO_CLK            RCC_AHB1Periph_GPIOB
  
/* PB15 - SPI2_MOSI */
#define LTC6803_DIN_PIN                  GPIO_Pin_15
#define LTC6803_DIN_PIN_SOURCE          GPIO_PinSource15
#define LTC6803_DIN_GPIO_PORT            GPIOB
#define LTC6803_DIN_GPIO_CLK             RCC_AHB1Periph_GPIOB

/* PB13 - SPI2_SCK */
#define LTC6803_SCLK_PIN                GPIO_Pin_13
#define LTC6803_SCLK_PIN_SOURCE         GPIO_PinSource13
#define LTC6803_SCLK_GPIO_PORT          GPIOB
#define LTC6803_SCLK_GPIO_CLK           RCC_AHB1Periph_GPIOB

/* LTC6803 address A0 A1 A2 and A3 are connected to GND */
#define LTC6803_ADDR                    0x80
/* Write Configuration Register Group */
#define WRCFG                            0x01
#define WPEC                            0xC7
/* Read Configuration Register Group */
#define RDCFG                            0x02
#define RCPEC                            0xCE
/* Poll Interrupt Status */
#define PLINT                            0x50
#define PIPEC                            0x77
/* Start Diagnose and Poll Status */
#define DAGN                            0x52
#define DAPEC                            0x79
/* Read Diagnostic Register */
#define RDDGNR                          0x54
#define RDAPEC                          0x6B

/* Read All Cell Voltage Group */
#define RDCV                            0x04
#define RVPEC                            0xDC
/* Start Cell Voltage ADC Conversions and Poll Status */
#define STCVAD                          0x10
#define SCVPEC                          0xB0

#define CFG1R0                          0x11
#define CFG1R1                          0x00
#define CFG1R2                          0x00
#define CFG1R3                          0x00
#define CFG1R4                          0x00
#define CFG1R5                          0x00
#define CFGPEC                          0x3B

/**
  * @}
  */

Meine Initialisierung des LTC6803 via SPI2 und die dazugehörigen 
Funktionen:

/**
  * @brief  Configures LTC6803 SPI
  * @param  None
  * @retval None
  */
void LTC6803_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  SPI_InitTypeDef SPI_InitStructure;
  
  SPI_I2S_DeInit(SPI2); 
  
  /* Enable the LTC6803_CS clock */
  RCC_AHB1PeriphClockCmd(LTC6803_CS_GPIO_CLK, ENABLE);
  /* Configure the LTC6803_CS as output */
  GPIO_InitStructure.GPIO_Pin = LTC6803_CS_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(LTC6803_CS_GPIO_PORT, &GPIO_InitStructure);
  /* LTC6803_!CS as high (not active) */
  GPIO_WriteBit(LTC6803_CS_GPIO_PORT, LTC6803_CS_PIN, Bit_SET);
  
  /* Enable the LTC6803_SCLK clock */
  RCC_AHB1PeriphClockCmd(LTC6803_SCLK_GPIO_CLK, ENABLE);
  /* Configure the LTC6801_NSOUT as input */
  GPIO_InitStructure.GPIO_Pin = LTC6803_SCLK_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(LTC6803_SCLK_GPIO_PORT, &GPIO_InitStructure);
  
  /* Enable the LTC6803_DOUT (MISO) clock */
  RCC_AHB1PeriphClockCmd(LTC6803_DOUT_GPIO_CLK, ENABLE);
  /* Configure the LTC6803_DOUT (MISO) as SPI2 DOUT */
  GPIO_InitStructure.GPIO_Pin = LTC6803_DOUT_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(LTC6803_DOUT_GPIO_PORT, &GPIO_InitStructure);
  
  /* Enable the LTC6803_DIN (MOSI) clock */
  RCC_AHB1PeriphClockCmd(LTC6803_DIN_GPIO_CLK, ENABLE);
  /* Configure the LTC6803_DIN (MOSI) as SPI2 DIN */
  GPIO_InitStructure.GPIO_Pin = LTC6803_DIN_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(LTC6803_DIN_GPIO_PORT, &GPIO_InitStructure);
  
  /* Connect LTC6803 SPI pins to AF5 */
  GPIO_PinAFConfig(LTC6803_DIN_GPIO_PORT, LTC6803_DIN_PIN_SOURCE, GPIO_AF_SPI2);
  GPIO_PinAFConfig(LTC6803_SCLK_GPIO_PORT, LTC6803_SCLK_PIN_SOURCE, GPIO_AF_SPI2);
  GPIO_PinAFConfig(LTC6803_DOUT_GPIO_PORT, LTC6803_DOUT_PIN_SOURCE, GPIO_AF_SPI2);
  
  /* Enable the SPI2 clock */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);

  /* Configure the SPI2 bus */
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128; // 42MHz/128 = 328kHz
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 8;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  
  /* Initialize the SPI2 bus */
  SPI_Init(SPI2, &SPI_InitStructure);
  SPI_Cmd(SPI2, ENABLE);
  
  /* Calculates the table for PEC data */
  CRC8_Init();
}

/**
  * @brief  Sends data through the SPI interface and return the data received
  *         from the SPI bus.
  * @param  data: data to send.
  * @retval The value of the received data.
  */
uint8_t SPI2_SendReceive(uint8_t data)
{
  /*!< Loop while DR register in not empty */
  while ((SPI2->SR & SPI_I2S_FLAG_TXE) == RESET);

  /*!< Send data through the SPI2 peripheral */
  SPI2->DR = data;

  /*!< Wait to receive data */
  while ((SPI2->SR & SPI_I2S_FLAG_RXNE) == RESET);
  
  return SPI2->DR;
}

/**
  * @brief  CRC8_Init calculates the CRC8 table for PEC calc
  *         Cite: http://www.rajivchakravorty.com/source-code/uncertainty/multimedia-sim/html/crc8_8c.html
  * @param  None
  * @retval None
  */
static void CRC8_Init(void)
{
  uint16_t i, j;
  uint8_t crc;
  for (i = 0; i < 256; i++)
  {
    crc = i;
    for (j = 0; j < 8; j ++)
    {
      crc = (crc << 1) ^ ((crc & 0x80) ? 0x07 : 0);
    }
    CRC8_Table[i] = crc & 0xFF;
  }
}

/**
  * @brief  CalcPEC_Byte calculates the PEC for the given byte
  * @param  Data: byte for which the PEC should be calculated
  * @retval calculated PEC byte
  */
uint8_t CalcPEC_Byte(uint8_t Data)
{
  /* Initialize PECbyte */
  uint8_t crc = 0x41;
  return CRC8_Table[(crc) ^ Data];
}

/**
  * @brief  CalcPEC_Packet calculates the PEC for the data in LTC6803_RX
  * @param  Len: number of bytes which are relevant in LTC6803_RX
  * @retval calculated PEC byte
  */
uint8_t CalcPEC_Packet(uint8_t Len)
{
  uint16_t i;
  /* Initialize PECbyte */
  uint8_t crc = 0x41;
  for (i = 0; i < Len; i++)
  {
    crc = CRC8_Table[(crc) ^ LTC6803_RX[i]];
  }
  return crc;
}

Meine main-Routine:

/* Write Configuration Registers (Broadcast Write) */
/* Set LTC6803_!CS to low (activate) */
GPIO_WriteBit(LTC6803_CS_GPIO_PORT, LTC6803_CS_PIN, Bit_RESET);

/* Send board address */
SPI2_SendReceive(LTC6803_ADDR);
SPI2_SendReceive(CalcPEC_Byte(LTC6803_ADDR));

/* Fill buffer for PEC calculation */
LTC6803_RX[0] = CFG1R0;
LTC6803_RX[1] = CFG1R1;
LTC6803_RX[2] = CFG1R2;
LTC6803_RX[3] = CFG1R3;
LTC6803_RX[4] = CFG1R4;
LTC6803_RX[5] = CFG1R5;
  
/* Send WRCFG command and its PEC byte */
SPI2_SendReceive(WRCFG);
SPI2_SendReceive(WPEC);

/* Send CFGR0 byte, then CFGR1, …CFGR5, PEC byte */
SPI2_SendReceive(CFG1R0);
SPI2_SendReceive(CFG1R1);
SPI2_SendReceive(CFG1R2);
SPI2_SendReceive(CFG1R3);
SPI2_SendReceive(CFG1R4);
SPI2_SendReceive(CFG1R5);
SPI2_SendReceive(CalcPEC_Packet(6));

/* Set LTC6803_!CS to high (deactivate) */
GPIO_WriteBit(LTC6803_CS_GPIO_PORT, LTC6803_CS_PIN, Bit_SET);

/* Insert 10us delay */
Delay_1us(10);

/* Read Configuration Registers (Broadcast Write) */
/* Set LTC6803_!CS to low (activate) */
GPIO_WriteBit(LTC6803_CS_GPIO_PORT, LTC6803_CS_PIN, Bit_RESET);

SPI2_SendReceive(LTC6803_ADDR);       // send board address
SPI2_SendReceive(CalcPEC_Byte(LTC6803_ADDR));          // send PECbyte of board address

/*  Send RDCFG command and its PEC byte */
SPI2_SendReceive(RDCFG);
SPI2_SendReceive(RCPEC);

/* Read CFGR0 byte, then CFGR1, ... CFGR5 and PEC byte */
for (i = 0; i < 6; i++)
{
   LTC6803_RX[i] = SPI2_SendReceive(0x00);
} 
LTC6803_PEC = SPI2_SendReceive(0x00);

/* Set LTC6803_!CS to high (deactivate) */
GPIO_WriteBit(LTC6803_CS_GPIO_PORT, LTC6803_CS_PIN, Bit_SET);

/* Insert 20us delay */
Delay_1us(20);

/* Print data when PEC is correct */
if (LTC6803_PEC == CalcPEC_Packet(6))
{
  printf("LTC6803 Address: %d\n", LTC6803_ADDR);
  printf("Config[0...5]: %d %d %d %d %d %d\n", LTC6803_RX[0], LTC6803_RX[1], LTC6803_RX[2], LTC6803_RX[3], LTC6803_RX[4], LTC6803_RX[5]);
}

Ich sende zuerst die Addresse 0x80 (alle A0..3 liegen auf GND) und das 
entsprechende PEC byte, dann das Command zum schreiben der CFG und 
anschliessend will ich die CFG auslesen, genau hier passiert, wie im 
Analyser zu sehen, einfach gar nichts.
Die Taktrate mit etwa 330kHz sollte der LTC locker mitmachen, laut 
Datenblatt ist bis 1Mhz alles möglich. Ich bin echt am verzweifeln, 
vielleicht sieht einer den Fehler auf die Schnelle, vielleicht kann ein 
anderer auch etwas mit den Codeschnipseln anfangen.
Vielen Dank auf jeden Fall fürs lesen und die Mühen.

Grüße #Max

[Peter L. (Gast)]

vielleicht drehen die Optokoppler deine Signale um (Schaltplan wäre 
hifreich)

[Funko B. (funkobongrip)]

hab schon viel mit den ics gemacht, also mal geraten.
ohne jetzt den ganzen post gelesen zu haben:
pull-up an sdo vom ltc?
die pec berechnung sieht irgendwie anders aus als ich sie gemacht habe
ansonsten: schaltplan her

[Jürgen Liegner (Gast)]

Ich habe mir mal deine Signale angesehen. Was sich zu meiner 
Implementierung auf einem LPC1114 unterscheidet ist die SPI Betriebsart. 
Die Register beim LPC sind z.B.

CPOL Clock Out Polarity. This bit is only used in SPI mode. 0
   0 SPI controller maintains the bus clock low between frames.
   1 SPI controller maintains the bus clock high between frames.

CPHA Clock Out Phase. This bit is only used in SPI mode. 0
   0 SPI controller captures serial data on the first clock transition
     of the frame, that is, the transition away from the inter-frame
     state of the clock line.
   1 SPI controller captures serial data on the second clock
     transition of the frame, that is, the transition back to the
     inter-frame state of the clock line.

Bei mir sind beide Bits auf 1.

Bei dir dürfte das die Stelle sein:

  SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;

Ich weigere mich aber bis jetzt standhaft mich mit dieser unsäglichen 
Stm32lib auseinander zu setzen. Deshalb musst du selbst rausfinden was 
bei dir richtig ist. Auf alle Fälle hast du erst mal einen Ansatzpunkt.

Was hast du da für Optokoppler verbaut? Die sollten schon schnell sein. 
Ich habe dafür den ADUM1401 benutzt. Der kostet bei Reichelt zwar 3.85€, 
ist aber besser als jeder Optokoppler für diesen Zweck.

[Jürgen (jliegner)]

Die PECs sind definitiv richtig, auch wenn ich sie ebenfalls anders 
berechne.

uint8_t CalcPec(uint8_t *pIn, int len)
{
  uint8_t pec = 0x41;
  for (int i=0; i<len; i++) 
    {
    pec=pec^pIn[i];
    for (int j=0; j<8; j++) 
      {
      if (pec & 0x80) 
        pec = (pec << 1) ^ 0x07; // if leftmost (most significant) bit is set
      else 
        pec = pec << 1;
      }
    }
  return pec;
}

[Max H. (Gast)]

Holla die Waldfee, das ging schnell!

Jürgen Liegner schrieb:
> Bei mir sind beide Bits auf 1.
>
> Bei dir dürfte das die Stelle sein:
>
>   SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
>   SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;

Bei mir sind auch beide Bits auf 1 so wie es der LTC laut Datenblatt 
will. Hier steht auf Seite 17:
> The  LTC6803  SPI  compatible interface is configured to operate in a
> system using CPHA = 1 and CPOL = 1. Consequently, data on SDI must be
> stable during the rising edge of SCKI.

Habe trotzdem die anderen Kombinationen ausprobiert, leider ohne Erfolg.

Jürgen Liegner schrieb:
> Die PECs sind definitiv richtig, auch wenn ich sie ebenfalls anders
> berechne.

Das glaube ich auch, vielleicht ist die CFGPEC in den Deklarationen 
nicht mehr ganz richtig aber die nutze ich auch nicht mehr.

David Brandt schrieb:
> pull-up an sdo vom ltc?

Nein dummerweise nicht, habe nachträglich einen 220pF an die isolierte 
Seite der MISO gelegt (blau) jedoch ohne Verbesserung. Die relevanten 
Schaltpläne sind angehängt, hoffentlich einigermaßen übersichtlich.

Vielen Dank für eure Hilfe!!

[Funko B. (funkobongrip)]

Max H. schrieb:
> David Brandt schrieb:
>> pull-up an sdo vom ltc?
>
> Nein dummerweise nicht, habe nachträglich einen 220pF an die isolierte
> Seite der MISO gelegt (blau) jedoch ohne Verbesserung. Die relevanten
> Schaltpläne sind angehängt, hoffentlich einigermaßen übersichtlich.

Da zitier ich mal das Datenblatt:
"SDO (Pin 43): Serial Data Output. The SDO pin is an NMOS open-drain 
output. A pull-up resistor is needed on SDO. See Serial Port in the 
Applications Information section."

Ohne Pull-Up wird das also nix.

Ansonsten hat Jürgen glaube ich was richtiges angesprochen.
SCK sollte HIGH sein im Idle Zustand, dann kommt Flanke runter und dann 
das erste Bit bei Flanke hoch. So ist es im Datenblatt gezeigt und bei 
mir macht das der uC auch so.

Beim SCK Verhalten bin ich mir nicht sicher, aber der Pull-Up verhindert 
die Funktion ganz sicher.

Das mit dem SCK könnte nur ungewolltes Verhalten erzeugen, weil der LTC 
dann ggfs. in einem Wartezustand hängt. Weil ihn nur SCK=High Idle ist.

[Jürgen (jliegner)]

David Brandt schrieb:
> aber der Pull-Up verhindert
> die Funktion ganz sicher.

Das ist wohl richtig. Meinen Prototypen ziert auch ein zusätzlicher R 
direkt an Beinen des ADUM....

[Max H. (Gast)]

David Brandt schrieb:
> Da zitier ich mal das Datenblatt:
> "SDO (Pin 43): Serial Data Output. The SDO pin is an NMOS open-drain
> output. A pull-up resistor is needed on SDO. See Serial Port in the
> Applications Information section."
>
> Ohne Pull-Up wird das also nix.

Oh man, die üblichen Fehler :) Ihr hattet natürlich recht, 5k Pull-Up 
und schon bekomm ich eine tolle Antwort! Jetzt kann ich beruhigt in den 
Feierabend.
Morgen teste ich die restlichen Funktionen, wenn alles klappt schick ich 
euch meine "Lösung".
Viele Grüße und Danke euch Allen!

[Joe A. (joe1057)]

Hallo zusammen,

ich weiß dass der Post schon sehr alt ist, ich habe aber genau das 
gleiche Problem. Fakt ist nur dass ich den 5k Pullup schon eingebaut 
habe. Dennoch sendet mir der LTC nichts zurück. SDO ist immer auf 5V.
Habt ihr eventuell noch weitere Ideen was man da machen kann.
Also mC benutze ich einen XC2000 von Infineon. Problem ist hier dass 
direkt nach dem senden der Config und PEC Bytes das CS wieder auf high 
geht. Ich habe noch keine möglichkeit gefunden dieses von Hand zu 
steuern.
Sitze hier schon lange an dem Problem und würde mich freuen wenn einer 
von euch Ideen hierzu hat.

Gruß Joe

[Joe A. (joe1057)]

Anbei eine Aufzeichnung vom Oszi.
CLK
MISO
MOSI
CS

[Joe A. (joe1057)]

Problem gelöst. I musste noch 18 Dummy-Bytes anhängen da sonst das CLK 
Signal für die Antwort vom Slave nicht mehr gegeben war. Jetzt 
funktioniert es.

[Stani (Gast)]

"Morgen teste ich die restlichen Funktionen, wenn alles klappt schick 
ich
euch meine "Lösung"."

Hi, könntest du deine Lösung bereitstellen? Ich nutze den identischen 
Chip für ein Bastelprojekt.

Besten Dank