Bitfeld-Array zusammenfassen?

[C-Fragensteller (Gast)]

Hi,

ich bin gerade dabei einen 3x3x3 LED-Würfel zu programmieren und 
entwerfe gerade die dazugehörigen Datenstrukturen. Angefangen hatte ich 
mit einem stinknormalen 3x3 Array. Das dazugehörige Programm sieht dann 
in etwa so aus:

#include <avr/io.h>
#include <stdbool.h>

uint8_t frame1[3][3];
uint8_t frame2[3][3];
volatile uint8_t *currentFrame = &frame1[0][0];
volatile uint8_t *nextFrame = &frame2[0][0];
volatile bool frameReady = false;

int main(void) {
  while(1);
  return 0;
}

Folgender Platz wird benötigt:

avr-size --format=berkeley -t LEDCube3x3x3.elf
   text     data      bss      dec      hex  filename
    144        4       19      167       a7  LEDCube3x3x3.elf
    144        4       19      167       a7  (TOTALS)

Allerdings werden dabei ja 5 Bits pro Byte verschwendet. Mittlerweile 
habe ich folgendes Konstrukt:

#include <stdbool.h>

struct frameLayer_t {
  bool LED_1:1;
  bool LED_2:1;
  bool LED_3:1;
  bool LED_4:1;
  bool LED_5:1;
  bool LED_6:1;
  bool LED_7:1;
  bool LED_8:1;
  bool LED_9:1;
};

struct frame_t {
  struct frameLayer_t layer[3];
};

struct frame_t frame1;
struct frame_t frame2;
volatile struct frame_t *currentFrame = &frame1;
volatile struct frame_t *nextFrame = &frame2;
volatile bool frameReady = false;

int main(void) {
  while(1);
  return 0;
}

 Das benötigt laut avr-size folgenden Platz:

avr-size --format=berkeley -t LEDCube3x3x3.elf
   text     data      bss      dec      hex  filename
    144        4       13      161       a1  LEDCube3x3x3.elf
    144        4       13      161       a1  (TOTALS)

Das ist aber deswegen unflexibel, weil ich die Member LED1 - LED9 
benannt habe und nicht einfach darüber iterieren kann.

Daher dachte ich jetzt an Folgendes:

#include <stdbool.h>

struct LED_t {
  bool LED:1;
};

struct frameLayer_t {
  struct LED_t LED[9];
};

struct frame_t {
  struct frameLayer_t layer[3];
};

struct frame_t frame1;
struct frame_t frame2;
volatile struct frame_t *currentFrame = &frame1;
volatile struct frame_t *nextFrame = &frame2;
volatile bool frameReady = false;

int main(void) {
  while(1);
  return 0;
}

Das wiederum benötigt aber relativ viel Platz (gerade in der BSS 
Sektion):

avr-size --format=berkeley -t LEDCube3x3x3.elf
   text     data      bss      dec      hex  filename
    144        4       55      203       cb  LEDCube3x3x3.elf
    144        4       55      203       cb  (TOTALS)

Gibt es denn eine Möglichkeit das Ganze im letzten Fall irgendwie 
zusammenzufassen? Ich habe schon ein wenig mit dem Type Attribute 
"packed" herumgespielt, aber geändert hat das nichts :(. Zu welcher 
Datenstruktur würdet ihr mir raten?

Vielen Dank!

[Oliver (Gast)]

Kurzer Ausflug in Programmiertechniken:
Wie strukturiert man seine Software? Wie unterteilt man die Software? 
Wie bricht man die Komplexität herunter?
Antwort: Immer dann wenn man sich fragt, wie man was programmieren soll 
(wenn man eine sogenannte "design decision" treffen muss), dann hat man 
eine Schnittstelle gefunden, an der man sein Programm unterteilen kann.

In deinem Falle: Halte Dich nicht zu lage mit obiger Frage auf, 
vielmehr, schreibe dein Programm so, dass Du die Umsetzung später noch 
ändern kannst.
Programmiere ein Interface:

void setze_bit(uint8_t x, uint8_t y, uint8_t z, uint8_t wert);

uint8_t lese_bit(uint8_t x, uint8_t y, uint8_t z);

Hinter diesen beiden Funktionen kapselst Du dein Problem. Ich plädiere 
hier für eine einfache Lösung (uint8_t cube[3][3][3]). Wenn Du später 
merkst, dass Du zu wenig Speicher hast, ändere es.

also etwa so:
void setze_bit(uint8_t x, uint8_t y, uint8_t z, uint8_t wert)
{
  cube[x][y][z] = wert;
}
und
uint8_t lese_bit(uint8_t x, uint8_t y, uint8_t z)
{
  return cube[x][y][z];
}

Erfunden hat das übrigens der David Parnas, der damit der Begründer der 
modernen Softwareentwicklung geworden ist 
(http://en.wikipedia.org/wiki/David_Parnas)

Grüße,
Oliver

[holger (Gast)]

>Gibt es denn eine Möglichkeit das Ganze im letzten Fall irgendwie
>zusammenzufassen?

Theoretischer Unsinn. Schreib dein Programm mal zuende
und du wirst feststellen das Programm Nummer 1 weniger Flash braucht als
der ganze Quatsch den du danach verzapft hast. Dein uC ist rechnet am
besten mit 8Bit Werten. Pfeif auf die verlorenen 5 Bits.