LTC2949 gibt keine Rückmeldung auf isoSPI

[Robert (Firma: NautiTronix) (robertntx)]

Moin liebes Forum,

ich möchte euch gerne um Mithilfe bitten.

Ich bin gerade dabei ein BMS mit einem LTC2949 und einigen LTC6811-2 zu 
realisieren.
Das ganze ist mit isoSPI als Multidrop aufgebaut.
Der Master ist ein STM32F3 mit einem LTC6820 als Wandler.
Leider ist der IC noch recht neu und es findet sich quasi nichts im Netz 
zu dem Thema.

Nunja, ich habe aber das Problem, dass sich weder die 6811, noch der 
2949 angesprochen fühlen. Die Reaktion ist einfach mal gar keine. Die 
Adern vom isoSPI habe ich probehalber getauscht.

Im Anhang befinden sich der Schaltplan und ein paar Messungen von Pin 30 
zu 29 am LTC2949.
Die Signale kommen dem Datenblatt entsprechend am IC an, wie man sieht. 
Es macht auch keinen Unterschied, ob ich den LTC2949 durch einen 
Kurzschluss von SCL auf Masse vom sleep-Status abhalte.

Saft liegt an:

AVCC = DVCC = 12V

BYP1 = 2,5V

BYP2 = 3,3V

IBIAS = 2V

ICMP = 0,8V

Mir ist nur aufgefallen, dass das Quarz nicht arbeitet, beide Pins haben 
0V.

Ein wiederholtes Senden des Frames macht keinen Unterschied.
Das Frame habe ich zu Beginn auch stumpf aus dem Datenblatt kopiert, um 
Fehler ausschließen zu können, siehe Anhang (Seite 44)

Ich habe das Gefühl, ich sehe den Wald vor lauter Bäumen nicht.

Beste Grüße
Robert

[Harald A. (embedded)]

Das der Quarz nicht schwingt könnte schon daran liegen, dass der 
Baustein zunächst einmal seinen IDLE Modus verlassen muss. In der 
überwiegenden Zeit, wo nicht gemessen wird, dürfte der Quarz nicht 
schwingen, das wäre verschwendete Energie.

Weiterhin: An Deiner Stelle würde ich zunächst einmal eine Brücke 
zwischen zwei LTC6820 aufbauen, ob das überhaupt funktioniert. Das wäre 
ja der einfachste Anwendungsfall von isoSPI.

[Robert (Firma: NautiTronix) (robertntx)]

Danke für die Rückmeldung. Das mit dem idle und dem Quarz ist gut 
möglich und kann zeigen, warum keine Rückmeldung kommt. Der 2949 käme 
demnach nicht aus dem idle. Dann stellt sich die Frage nach dem Warum. 
Sleep habe ich ja bereits sichergestellt, sonst wären BYP 1 und 2 auch 
aus.

Das Verwenden eines zweiten 6820 habe ich schon probiert. Dort werden 
die Signale vom Bus sauber ausgegeben. Die iso SPI Übertragung selbst 
scheint wohl nicht das Problem zu sein.

[Pferd O. (pferdo)]

Mit dem 2949 habe ich keine Erfahrung. Aber bei 6812-1 (Sollte sehr 
ähnlich sein) sind beliebt:
* Nicht richtig aufgeweckt (siehe Pulse im Linduino code)
* PEC nicht richtig berechnet oder Endianess?

[Robert (Firma: NautiTronix) (robertntx)]

Wie so oft saß das Problem vor dem Bildschirm.
Ich hatte das 5. Byte beim DCMD Kommando falsch, also lesen und 
schreiben vertauscht.
Das Schreiben des Registers REGSCTRL ist nicht unbedingt nötig, da die 
Standardwerte nach dem Start passen. Es schafft nur eine eindeutige 
Ausgangssituation.

Warum ich das Frame direkt aus dem Datenblatt nicht zum Laufen bekommen 
habe, verstehe ich rückwirkend auch nicht mehr.

Jetzt läufts.
Für andere mit dem gleichen Problem anbei ein Beispiel. Der DMA muss 
natürlich nicht genutzt werden. Ich nutze ihn später und habe ihn gerade 
erstmal als Platzhalter im Code.

Konfiguration der Schnittstelle

  hspi3.Init.Mode = SPI_MODE_MASTER;
  hspi3.Init.Direction = SPI_DIRECTION_2LINES;
  hspi3.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi3.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi3.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi3.Init.NSS = SPI_NSS_SOFT;
  hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32; // 1Mbaud
  hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB;

int8_t LTC2949_Wakeup_isoSpi (LTC2949_t *dev)
{
  uint8_t data = 0x00;

  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_RESET);
  HAL_SPI_Transmit(dev->spi, &data, 1, 1);
  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_SET);

  return 0;
}


int8_t LTC2949_Read_Reg (LTC2949_t *dev, uint8_t *data, uint8_t address, uint8_t length)
{
  // Compute the frame length and PECC
  uint8_t frame_length = 5 + length + 2;
  uint8_t pecc = length - 1;

  // Set pointers to various parts of the buffers
  uint8_t *tx_data_1 = dev->tx_buff;
  uint8_t *rx_data = dev->rx_buff + 5;
  uint16_t *tx_pec_1 = (uint16_t*) (dev->tx_buff + 2);
  uint16_t *rx_pec = (uint16_t*) (dev->rx_buff + 5 + length);

  // Variables for storing the received PEC and checking for errors
  uint16_t rx_pec_calc;
  uint8_t rx_pec_error = 0;

  // Configure the MOSI frame
  tx_data_1[0] = 0xFE; // Direct Read/Write Command
  tx_data_1[1] = address;
  *tx_pec_1 = swap_bytes(pec15(tx_data_1, 2));

  tx_data_1[4] = (1 << 7) + (0 << 6); // read command
  tx_data_1[4] += (((pecc >> 3) & 0x1) ^ ((pecc >> 2) & 0x1)) << 5;
  tx_data_1[4] += ((pecc >> 3) & 0x1) << 4;
  tx_data_1[4] += ((pecc >> 2) & 0x1) << 3;
  tx_data_1[4] += (((pecc >> 1) & 0x1) ^ ((pecc >> 0) & 0x1)) << 2;
  tx_data_1[4] += ((pecc >> 1) & 0x1) << 1;
  tx_data_1[4] += ((pecc >> 0) & 0x1) << 0;


  // Transmit and receive the data using DMA
  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_RESET);
  HAL_SPI_TransmitReceive_DMA(dev->spi, dev->tx_buff, dev->rx_buff, frame_length);

  // Wait for the DMA transfer to complete
  while(dev->spi->hdmatx->State != HAL_DMA_STATE_READY || dev->spi->hdmarx->State
      != HAL_DMA_STATE_READY);

  // Release the CS pin
  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_SET);

  // Copy the received data to the output buffer
  memcpy(data, rx_data, length);

  // Compute RX PEC to compare it with the transmitted
  rx_pec_calc = swap_bytes(pec15(rx_data, length));
  if(*rx_pec != rx_pec_calc) rx_pec_error = 1;


  // Return error code if PEC error occurred, otherwise return success
  if(rx_pec_error)
    return -1;
  else
    return 0;
}

int8_t LTC2949_Write_Reg (LTC2949_t *dev, uint8_t *data, uint8_t address, uint8_t length)
{
  // Compute the frame length and PECC
  uint8_t frame_length = 5 + length + 2;
  uint8_t pecc = length - 1;

  // Set pointers to various parts of the buffers
  uint8_t *tx_data_1 = dev->tx_buff;
  uint8_t *tx_data_2 = dev->tx_buff + 5;
  uint8_t *rx_data = dev->rx_buff + 5;
  uint16_t *tx_pec_1 = (uint16_t*) (dev->tx_buff + 2);
  uint16_t *tx_pec_2 = (uint16_t*) (dev->tx_buff + 5 + length);
  uint16_t *rx_pec = (uint16_t*) (dev->rx_buff + 5 + length);

  // Variables for storing the received PEC and checking for errors
  uint16_t rx_pec_calc;
  uint8_t rx_pec_error = 0;

  // Configure the MOSI frame
  tx_data_1[0] = 0xFE; // Direct Read/Write Command
  tx_data_1[1] = address;
  *tx_pec_1 = swap_bytes(pec15(tx_data_1, 2));

  tx_data_1[4] = (0 << 7) + (1 << 6); // write command
  tx_data_1[4] += (((pecc >> 3) & 0x1) ^ ((pecc >> 2) & 0x1)) << 5;
  tx_data_1[4] += ((pecc >> 3) & 0x1) << 4;
  tx_data_1[4] += ((pecc >> 2) & 0x1) << 3;
  tx_data_1[4] += (((pecc >> 1) & 0x1) ^ ((pecc >> 0) & 0x1)) << 2;
  tx_data_1[4] += ((pecc >> 1) & 0x1) << 1;
  tx_data_1[4] += ((pecc >> 0) & 0x1) << 0;

  // Copy the data to the transmit buffer
  memcpy(tx_data_2, data, length);

  // Compute the PEC for the second part of the transmit buffer
  *tx_pec_2 = swap_bytes(pec15(tx_data_2, length));

  // Transmit and receive the data using DMA
  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_RESET);
  HAL_SPI_TransmitReceive_DMA(dev->spi, dev->tx_buff, dev->rx_buff, frame_length);

  // Wait for the DMA transfer to complete
  while(dev->spi->hdmatx->State != HAL_DMA_STATE_READY || dev->spi->hdmarx->State
      != HAL_DMA_STATE_READY);

  // Release the CS pin
  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_SET);

  // Compute RX PEC to compare it with the transmitted
  rx_pec_calc = swap_bytes(pec15(rx_data, length));
  if(*rx_pec != rx_pec_calc) rx_pec_error = 1;


  // Return error code if PEC error occurred, otherwise return success
  if(rx_pec_error)
    return -1;
  else
    return 0;
}


int8_t LTC2949_Init (LTC2949_t *dev, SPI_HandleTypeDef *spi, GPIO_TypeDef *cs_port,
              uint16_t cs_pin)
{
  // Store parameters in device struct
  dev->spi = spi;
  dev->cs_port = cs_port;
  dev->cs_pin = cs_pin;
  dev->address = 0x0F; // Constant for every LTC2949

  // Initialize PEC15 table
  init_PEC15_Table();

  // Set CS pin high, low, high to wake up LTC249 core
  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_SET);
  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_RESET);
  HAL_GPIO_WritePin(dev->cs_port, dev->cs_pin, GPIO_PIN_SET);

  uint32_t start = HAL_GetTick();
  while(1)
  {
    // Check if initialization has taken longer than 120ms
    if(start + 120 <= HAL_GetTick()) return -1;

    uint8_t data = 0x00;

    // Wake up the LTC2949 twice to ensure it's responsive
    LTC2949_Wakeup_isoSpi(dev);
    LTC2949_Wakeup_isoSpi(dev);

    // Set page 0 and direct read mode in REGSCTRL register
    data = 0 + (1 << 7);
    LTC2949_Write_Reg(dev, &data, 0xFF, 1);

    // Read OPCTRL register to check if the LTC2949 core is in sleep mode
    LTC2949_Read_Reg(dev, &data, 0xF0, 1);

    // Continue looping if sleeping
    if((data & 0x01) != 0) continue;

    // Disable sleep mode
    data = 0x00;
    LTC2949_Write_Reg(dev, &data, 0x70, 1);
    break;
  }
  return 0;
}

[Harald A. (embedded)]

Ich finde es lobenswert, dass Du überhaupt eine Rückmeldung gibst, die 
Beiträge hier sind recht gut bei Google auffindbar.
Ist es denn tatsächlich so, dass der Quarz erst aktiv wird, wenn das 
Device korrekt angesprochen wird?

[Robert (Firma: NautiTronix) (robertntx)]

Ich habe hier auch schon Vieles gefunden, dann möchte ich auch etwas 
zurückgeben. Und ja, Google macht den Rest :)

Das Quarz schwingt nicht einmal beim Ansprechen, wohl erst beim Messen. 
Also erst bei dem Wechsel in den Status measure. Der Status standby ist 
etwas missverständlich. Er ist eher als "aktiv ohne zu Messen" zu 
interpretieren.

Das Messen ist der nächste Punkt auf dem Zettel.

[Harald A. (embedded)]

Hatte mich gefragt, wozu der Baustein dann überhaupt einen Quarz 
braucht. Habe mal ins Datenblatt geschaut.

An on-chip oscillator provides a 1% precise time base for calculating 
total charge, energy and time. If higher accuracy is required, a 4MHz 
crystal connected between pin CLKI and CLKO or an external clock can be 
used.

[Pferd O. (pferdo)]

Ich habe mal von einem Vögelchen gehört, dass da ein 8051 drin ist, der 
so verschiedene Funktionen (zum Beispiel das akkumulieren) übernimmt ;-)

[Pferd O. (pferdo)]

Was mir nun eingefallen ist, hast due den 2949 bereits? Weil die 
Nachfolger adbms295x eigentlich auch verfügbar sind. Vielleicht ist das 
noch eine interessante Information...