64Bit Senden, funktioniert zwar, aber wie kann mans effizienter gestallten?

Der folgende Code sollte die Anforderungen erfüllen:

1

uint8_t temp;

2

uint8_t s = 1;

3

4

for (uint8_t byte = 0; byte < 8; byte++)

5

{

6

   temp = 0;

7

8

   for (uint8_t bit = 0; bit < 8; bit++)

9

   {

10

      if(sekunden >= s)

11

         temp += (1 << bit);

12

13

      s++;

14

   }

15

16

   SPI_MasterTransmit(temp);

17

}

Du kannst doch direkt in einer Schleife ausgeben:

1

#include <stdint.h>

2

3

extern void SPI_MasterTransmit (uint8_t);

4

5

void send (uint8_t leds)

6

{

7

    for (uint8_t n = 0; n < 8; n++)

8

    {

9

        uint8_t val;

10

11

        if (leds >= 8)

12

        {

13

            val = 0;

14

            leds -= 8;

15

        }

16

        else

17

        {

18

            val = 1 << leds;

19

            leds = 0;

20

        }

21

22

        SPI_MasterTransmit (val-1);

23

    }

24

}

> Prinzipiell muss ich ja nur dafür sorgen, dass bei 50 Sekunden,
> 50 High Bits gesendet werden und 14 Low Bits.
>
> Eine Idee die mir durch den Kopf geht, wäre mit (64 - sekunden) / 8
> die Anzahl der Highbits zu berechnen und dann den Rest mit Lows
> aufzufüllen, aber ob das so ideal ist?

Kannst du natürlich machen.

Im Allgemeinen ist doch der Ablauf so:

   sende eine entsprechende Anzahl an 0xFF für alle 8-er
   Gruppen die vollständig leuchten sollen. Diese Anzahl
   kann natürlich auch 0 sein.

   Danach kommt ein Byte bei dem 0 bis 7 LED leuchten sollen

   Und dann braucht es noch eine Anzahl 0x00 Bytes, um auf die
   insgesammt 8 zu sendenden Bytes zu kommen. Diese Anzahl kann
   natürlich auch 0 sein.

Wenn du also 20 LED einschalten musst, dann musst du

    2 Bytes   0xFF senden, dennn 2 * 8 sind 16 Bits denn 16
        ist die größte 8-er Zahl kleiner 20.

    Es bleiben 20 - 16 -> 4 Bits überig, für die du 1 Byte
        brauchst, in dem 4 Bits gesetzt sind  (das kann man
        zb sich aus einem Array holen, in die für jede Anzahl
        von Bits das entsprechende zu sendende Byte enthalten ist

    Bis jetzt hast du 2 + 1, also 3 Bytes ausgegeben, also musst du
    noch 5 Bytes mit lauter 0x00 nachschieben, damit in Summe wieder
    8 Bytes ausgegeben werden.


Das ganze ist einfach nur ein bischen (einfache) Rechnerei, 2 Schleifen, 
eine direkte Ausgabe und 1 Arrayzugriff.

1

void outSec( uint8_t sec )

2

{

3

  uint8_t nrFullBytes = sec / 8;

4

  uint8_t nrSingleBits = sec % 8;

5

  static uint8_t bitPattern[] = { 0x00, 0x01, 0x03, 0x03, 0x0F, 0x1F, 0x3F, 0x7F } ;

6

7

  for( uint8_t i = 0; i < nrFullBytes; i++ )

8

    SPI_MasterTransmit( 0xFF );

9

10

  SPI_MasterTransmit( bitPatterm[nrSingleBits] );

11

12

  for( uint8_t i = 0; i < 8 - 1 - nrFullBytes; i++ )

13

    SPI_MasterTransmit( 0x00 );

14

}

Knauser schrieb:
>

1

>   static uint8_t bitPattern[] = { 0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F,

2

> 0x3F, 0x7F } ;

3

>

 kleiner Fehler ;-)


Ah, danke.