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

[Noname (Gast)]

Hallo,

ich versuche mir gerade eine Uhr zu programmieren.

Im Augenblick steuer ich die LEDs für jede einzelne Sekunde über eine 
einzelne switch case Abfrage an.

kleines Beispiel:

switch (sekunden)
  {
  case 1:
  SPI_MasterTransmit(0x01);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
    break;
  case 2:
  SPI_MasterTransmit(0x03);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
    break;
  case 3:
  SPI_MasterTransmit(0x07);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
  SPI_MasterTransmit(0x00);
    break;
  case 50:
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0x03);
  SPI_MasterTransmit(0x00);
    break;
  case 51:
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0xFF);
  SPI_MasterTransmit(0x07);
  SPI_MasterTransmit(0x00);
    break;
  }

Danach kommt noch die Ansteuerung für eine kleine Anzeige, daher muss 
ich immer 8 Byte senden und die restlichen LEDs, die wegen der Anzahl 
der Sekunden nicht an sein dürfen, auf 0 setzen.

Das funktioniert wunderbar, ich stell mir allerdings schon seit einer 
halben Ewigkeit die Frage, wie ich die Sekunden direkt mit den Anzahl 
der zu sendenden Bits verrechnen kann.

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?


Viele Grüße aus München

[Knauser (Gast)]

Du musst irgendwie die Berechnung von dem Array, was du da sendest in 
eine kurze Funktion packen.

Da du nicht genau beschriebst, was du da wirklich sendest etc kann man 
dir schwer helfen.

Vermutung: pro Sekunde soll eine LED angehen?

[Noname (Gast)]

genau, pro Sekunde soll eine LED angehen.

Der Code oben wird genau einmal pro Sekunde aufgerufen^^

[Magnus M. (magnetus)]

Der folgende Code sollte die Anforderungen erfüllen:

uint8_t temp;
uint8_t s = 1;

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

   for (uint8_t bit = 0; bit < 8; bit++)
   {
      if(sekunden >= s)
         temp += (1 << bit);

      s++;
   }

   SPI_MasterTransmit(temp);
}

[Johann L. (gjlayde)]

Du kannst doch direkt in einer Schleife ausgeben:

#include <stdint.h>

extern void SPI_MasterTransmit (uint8_t);

void send (uint8_t leds)
{
    for (uint8_t n = 0; n < 8; n++)
    {
        uint8_t val;
        
        if (leds >= 8)
        {
            val = 0;
            leds -= 8;
        }
        else
        {
            val = 1 << leds;
            leds = 0;
        }

        SPI_MasterTransmit (val-1);
    }
}

[Karl H. (kbuchegg)]

> 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.

void outSec( uint8_t sec )
{
  uint8_t nrFullBytes = sec / 8;
  uint8_t nrSingleBits = sec % 8;
  static uint8_t bitPattern[] = { 0x00, 0x01, 0x03, 0x03, 0x0F, 0x1F, 0x3F, 0x7F } ;

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

  SPI_MasterTransmit( bitPatterm[nrSingleBits] );

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

[Knauser (Gast)]

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

 kleiner Fehler ;-)

[Karl H. (kbuchegg)]

Knauser schrieb:
>

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

 kleiner Fehler ;-)


Ah, danke.