Mit 3Bits arbeiten, andere Möglichkeit?

[Bernds (Gast)]

Ich möchte einen Kreis aus 8 Leds machen. Am besten möchte ich alles 
einfach nur hochzählen und runterzählen. Wenn ich bei 0 herunterzähl 
gelange ich auf -1. Das soll dann die 8. Led sein (7). Gibt es eine 
einfachere Möglichkeit wie das hier?

 
const uint8_t numleds = 8;
 if (led < 0) return (numleds - led);
  else return led % numleds;

[Peter II (Gast)]

Bernds schrieb:
> Gibt es eine
> einfachere Möglichkeit wie das hier?

einfach nur die letzen 3 bits verwenden.

Das < 0 brauchst du nicht beachten, wenn die variabel unsigned ist.

uint8_t wert = 1;

...
wert++;
...

und beim abfragen einfach


(wert & 7)

machen.

[_C_ (Gast)]

return led & 0x07;

[BirgerT (Gast)]

Meine Vorposter haben scheinbar nicht gelesen, dass der Wert auf und ab 
gezählt werden soll?!..

Wenn Du eine von 8 LEDs von links nach rechts und wieder zurück leuchten 
lassen möchtest, müssen die ja an einem Port hängen (AVR tippe ich mal).

Wie sollen den aus dem Zähler heraus die Pins gesetzt werden?

Soll der Zähler ein Index für ein Array sein?

[Peter II (Gast)]

BirgerT schrieb:
> Meine Vorposter haben scheinbar nicht gelesen, dass der Wert auf und ab
> gezählt werden soll?!..

und warum soll es nicht herunterzählen gehen? Wenn man nur die drei 
letzten Bits verwendet ist es egal wie gezählt wird. Du kannst sogar 
multiplizieren.

[_C_ (Gast)]

Der TE hat bei seinem Code den er einfacher will scheinbar auch 
vergessen, dass der Wert auf und ab gezählt werden soll?!..

[BirgerT (Gast)]

Peter II schrieb:
> BirgerT schrieb:
>> Meine Vorposter haben scheinbar nicht gelesen, dass der Wert auf und ab
>> gezählt werden soll?!..
>
> und warum soll es nicht herunterzählen gehen? Wenn man nur die drei
> letzten Bits verwendet ist es egal wie gezählt wird. Du kannst sogar
> multiplizieren.

_C_ schrieb:
> Der TE hat bei seinem Code den er einfacher will scheinbar auch
> vergessen, dass der Wert auf und ab gezählt werden soll?!..

Im Grunde habt Ihr ja recht..

Aber habt Ihr Euch den Code mal genauer angesehen?
Damit (led < 0) sein kann, müsste es ein int8_t sein, oder?
Und was wird zurück gegeben, wenn led == -1 ist? (8 -(-1)) = ?

Also ist da vermutlich schonmal in der Denke von Bernd etwas verkehrt.
Also erstmal fragen was er wie vorhat..

[Wolfgang (Gast)]

Bernds schrieb:
> Am besten möchte ich alles einfach nur hochzählen und runterzählen.
Warum möchtest du überhaupt zählen? Meinst du vielleicht "schieben"?

[Gerald G. (gerald_g)]

Wenn die 8 LEDs an einem Port hängen, würde ich mit 8 Bit rechnen.
Also einfach:
If (rechtsherum)
return (LEDport <<1) | (LEDport & 0b10000000)
else
return  (LEDport >>1) | (LEDport & 0b00000001)

[BirgerT (Gast)]

Na Gut, mein Vorschlag für die LED-Animation:
Nix vor und zurückzählen, sondern ein Array mit den Bitmustern der 
einzuschaltenden LEDs verwenden, und dann ein Byte nach dem anderen  auf 
den Port mit den LEDs ausgeben.
Das Array kann auf 256 Bitmuster erweitert werden, wenn's größer werden 
soll, dann uint16_t für lr verwenden (bis zu 32767 = max. Arraygröße).

//
uint8_t lr = 0;      // "Statusmerker" Leds rot
uint8_t lg = 0;      // "Statusmerker" Leds grün
uint8_t lt = 0;      // ein Led-"Timer"

// ..auch Konstanten sind variabel ;-)
uint8_t const lpattern[] PROGMEM = {
    0b10000000,
    0b11000000,
    0b01100000,
    0b00110000,
    0b00011000,
    0b00001100,
    0b00000100,
    0b00001100,
    0b00011000,
    0b00110000,
    0b01100000,
    0b11000000,
    0b10000000
};
// Anzahl der Einträge im Array lpattern
#define LPATTERN (uint8_t)(sizeof(lpattern)/sizeof(lpattern[0]))  


// die Bitmuster aus lpattern[] an die roten Leds vorne ausgeben
// Diese Funktion jenach gewünschter Geschwindigkeit alle 10..200ms
// aus der main_loop heraus aufrufen
void led_player() {
  LED_RD_PORT = pgm_read_byte(&lpattern[lr]);
  if (++lr >= LPATTERN) {
    lr = 0;
  }
}