C > Anzahl an Words von übergebenen Bytes berechnen?

[Jan H. (janiiix3)]

Nabend,

kleine Verständnisfrage an euch:
Was genau soll diese Berechnung machen?
Soll sie ermitteln wie viel Words aus den übergebenen Bytes gebildet 
werden können?

  uint32_t words = (bytes + 3) / 4;  //16 max

static void __spiTransferBytes(spi_t *spi, const uint8_t *data, uint8_t *out, uint32_t bytes) {
  if (!spi) {
    return;
  }
  uint32_t i;

  if (bytes > 64) {
    bytes = 64;
  }

  uint32_t words = (bytes + 3) / 4;  //16 max

  uint32_t wordsBuf[16] = {
    0,
  };
  uint8_t *bytesBuf = (uint8_t *)wordsBuf;

  if (data) {
    memcpy(bytesBuf, data, bytes);  //copy data to buffer
  } else {
    memset(bytesBuf, 0xFF, bytes);
  }

  spi->dev->mosi_dlen.usr_mosi_dbitlen = ((bytes * 8) - 1);
  spi->dev->miso_dlen.usr_miso_dbitlen = ((bytes * 8) - 1);

  for (i = 0; i < words; i++) {
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2 || CONFIG_IDF_TARGET_ESP32P4
    spi->dev->data_buf[i].val = wordsBuf[i];  //copy buffer to spi fifo
#else
    spi->dev->data_buf[i] = wordsBuf[i];  //copy buffer to spi fifo
#endif
  }

#if !defined(CONFIG_IDF_TARGET_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2)
  spi->dev->cmd.update = 1;
  while (spi->dev->cmd.update);
#endif
  spi->dev->cmd.usr = 1;

  while (spi->dev->cmd.usr);

  if (out) {
    for (i = 0; i < words; i++) {
#if CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2 || CONFIG_IDF_TARGET_ESP32P4
      wordsBuf[i] = spi->dev->data_buf[i].val;  //copy spi fifo to buffer
#else
      wordsBuf[i] = spi->dev->data_buf[i];  //copy spi fifo to buffer
#endif
    }
    memcpy(out, bytesBuf, bytes);  //copy buffer to output
  }
}

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

Jan H. schrieb:
> uint32_t words = (bytes + 3) / 4;  //16 max
>
> Soll sie ermitteln wie viel Words aus den übergebenen Bytes gebildet
> werden können?
Ja, sie ermittelt, wieviele 32-Bit-Worte für eine bestimmte Anzahl Bytes 
nötig sind. Spiel das doch einfach mal mit ein paar Werten für bytes 
(z.B. von 0..12) durch und denk daran: bei der Integerdivision /4 wird 
einfach der Rest abgeschnitten.

bytes   |   words
--------+---------
  0     |    0
  1     |    1
  2     |    1
  3     |    1
  4     |    1
  5     |    2
  6     |    2
  :     |    :

[Jan H. (janiiix3)]

Lothar M. schrieb:
> Jan H. schrieb:
>> uint32_t words = (bytes + 3) / 4;  //16 max
>> Soll sie ermitteln wie viel Words aus den übergebenen Bytes gebildet
>> werden können?
>
> Ja, sie ermittelt, wieviele 32-Bitworte für eine bestimmte Anzahl Bytes
> nötig sind. Spiel das doch einfach mal mit ein paar Werten für bytes
> (z.B. von 0..12) durch und denk daran: bei der Integerdivision /4 wird
> einfach der Rest abgeschnitten.

Habe ich schon gemacht jedoch bin ich bei einer ungeraden Zahl an Bytes 
stutzig geworden.
Wenn ich jetzt z.B 3 Bytes übertragen möchte, errechnet die Funktion ja 
nur ein Word was ja auch richtig ist, in der for Schleife wird dann das 
dritte Byte nicht mehr beachtet oder habe ich da einen Denkfehler?

[Achim M. (minifloat)]

Jan H. schrieb:
> in der for Schleife wird dann das dritte Byte nicht mehr beachtet oder
> habe ich da einen Denkfehler?

Im Fall von words == 3 zählt die for-Schleife 0,1,2 und das sind 3 
Schleifendurchläufe.

Informatiker am Bahnhof: 0,1,2 ... Mist, wo ist mein dritter Koffer!?

mfg mf

[Jan H. (janiiix3)]

Ich habe das eben noch mal mit dem "onlinegdb" durchgespielt.
Wenn ich der Funktion als bsp.

        uint8_t buff[] = {1,2,3,4};
        spi_write_bytes( buff, 4 );

übergebe, ist das gebildete Word "67305985 Dec."
Das währe dann in Bytes "0x04, 0x03, 0x02, 0x01 Hex."

Die Funktion zum schreiben der Daten auf dem SPI Bus ist auf MSB_First 
eingestellt. Das würde bedeuten das zuerst die "0x04" dann die "0x03" 
usw. gesendet werden müsste, richtig?

Jedoch ist komplett anders (siehe Foto)..
So wie ich das jetzt verstanden habe, passen meine zu sendenen Bytes in 
ein 32 Bit Word. Da das SPI Senderegister 32 Bit breit ist, sollte es 
eigentlich der o.g. Reihenfolge gesendet werden oder=

[Harald K. (kirnbichler)]

Jan H. schrieb:
> Die Funktion zum schreiben der Daten auf dem SPI Bus ist auf MSB_First
> eingestellt.

Richtig, sie sendet das höherwertige Bit der übertragenen Bytes 
zuerst.

Jan H. schrieb:
> Das würde bedeuten das zuerst die "0x04" dann die "0x03"
> usw. gesendet werden müsste, richtig?

Nö, um das Umsortieren von Bytes müsstest Du Dich schon selbst kümmern, 
das hat mit SPI nichts mehr zu tun.

[Jan H. (janiiix3)]

Harald K. schrieb:
> Jan H. schrieb:
>> Die Funktion zum schreiben der Daten auf dem SPI Bus ist auf MSB_First
>> eingestellt.
>
> Richtig, sie sendet das höherwertige Bit der übertragenen Bytes
> zuerst.
>
> Jan H. schrieb:
>> Das würde bedeuten das zuerst die "0x04" dann die "0x03"
>> usw. gesendet werden müsste, richtig?
>
> Nö, um das Umsortieren von Bytes müsstest Du Dich schon selbst kümmern,
> das hat mit SPI nichts mehr zu tun.

Wie "Nö"? Wenn meine 0x04 das MSB von uint32_t bildet, wird das doch 
zuerst gesendet?

[Jan H. (janiiix3)]

Habe gerade versucht einen uint32_t zu senden mit 0x000001.
Laut LA kommt 0x000100 an.
Scheint also irgendwas mit dem Registerzugriff nicht zu passen..

    while (1)
    {    
        //uint8_t buff[] = {1,2,3,4};
        //spi_write_bytes( buff, 4 );

          spi_write_dword( 0x000001 );
    }

void spi_write_dword( uint32_t _data )
{
  REG_WRITE( SPI_MS_DLEN_REG, 32 -1 );
  
  //#define REG_WRITE(_r, _b)      (*(volatile uint32_t*)(_r)) = (_b) 
  //##define SPI_Wn_REG(n)         SPI2_REG((0x98+(n*4))) 
  REG_WRITE( SPI_Wn_REG(0), _data );

  REG_SET_BIT( SPI_CMD_REG, SPI_UPDATE_bm );
  while ( REG_READ( SPI_CMD_REG ) & SPI_UPDATE_bm ){};

  REG_SET_BIT( SPI_CMD_REG, SPI_USR_bm );
  while ( REG_READ( SPI_CMD_REG ) & SPI_USR_bm ){};    
}