C-> Größe eines Array in einem Union initalisieren?!

#5838591
Lesenswert?

Moin,

ist es möglich, ohne das ich jetzt die ganzen Bytes zählen muss, die 
Größe von dem Array zu bestimmen beim übersetzen?

1
union __flash 
2
{
3
  const uint8_t fontData[] =
4
  {
5
    0x0E, 0xF9, // size
6
    0x11, // width
7
    0x18, // height
8
    0x30, // first char
9
    0x0B, // char count
10
    
11
    // char widths
12
    0x10, 0x0D, 0x0F, 0x0F, 0x11, 0x0F, 0x10, 0x10, 0x10, 0x10,
13
    0x04,
14
    
15
    // font data
16
    0x80, 0xF0, 0xFC, 0x7E, 0x0E, 0x0F, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E,
17
    0x7E, 0xFC, 0xF0, 0x80, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
18
    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x01, 0x0F, 0x3F, 0x7E,
19
    0x70, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xF0, 0x70, 0x7E, 0x3F, 0x0F, 0x01, //48 '0'
20
    
21
    0x38, 0x38, 0x38, 0x38, 0x3C, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
22
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
23
    0x00, 0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFF, 0xFF, 0xFF, 0xE0, 0xE0,
24
    0xE0, 0xE0, 0xE0,                                                        // 49 '1'
25
    
26
    0x00, 0x1E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E, 0xFE,
27
    0xFC, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0,
28
    0x78, 0x3E, 0x1F, 0x07, 0x01, 0x00, 0xF0, 0xF8, 0xFC, 0xFE, 0xEF, 0xE7,
29
    0xE3, 0xE1, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,                    // 50 '2'
30
    
31
    0x00, 0x1E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E,
32
    0xFE, 0xFC, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x1C, 0x1C, 0x1C,
33
    0x1E, 0x36, 0x77, 0xF3, 0xE1, 0xC0, 0x78, 0x70, 0x70, 0xF0, 0xE0, 0xE0,
34
    0xE0, 0xE0, 0xE0, 0xF0, 0x70, 0x78, 0x3F, 0x1F, 0x0F,                   // 51 '3'
35
    
36
    0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xF0, 0xF8, 0x7C, 0x1E, 0xFF,
37
    0xFF, 0xFF, 0x00, 0x00, 0x00, 0xE0, 0xF0, 0xFC, 0xFE, 0xDF, 0xC7, 0xC3,
38
    0xC1, 0xC0, 0xC0, 0xC0, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0x01, 0x01,
39
    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0xFF,
40
    0x01, 0x01, 0x01,                                                       // 52 '4'
41
    
42
    0x00, 0xFF, 0xFF, 0xFF, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
43
    0x07, 0x07, 0x07, 0x00, 0x1F, 0x1F, 0x0F, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E,
44
    0x1E, 0x1C, 0x3C, 0xF8, 0xF8, 0xE0, 0x78, 0x70, 0x70, 0xF0, 0xE0, 0xE0,
45
    0xE0, 0xE0, 0xE0, 0xF0, 0x70, 0x7C, 0x3F, 0x1F, 0x07,                    // 53 '5'
46
    
47
    0x00, 0xC0, 0xF0, 0xF8, 0x3C, 0x1E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x07,
48
    0x07, 0x0F, 0x00, 0x00, 0xFE, 0xFF, 0xFF, 0x1C, 0x1C, 0x0E, 0x0E, 0x0E,
49
    0x0E, 0x0E, 0x0E, 0x1E, 0x3C, 0xF8, 0xF8, 0xE0, 0x03, 0x0F, 0x3F, 0x7C,
50
    0x78, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0x70, 0x78, 0x3F, 0x1F, 0x07, //54 '6'
51
    
52
    0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x87,
53
    0xE7, 0xFF, 0x7F, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0,
54
    0xF0, 0xFC, 0x3F, 0x0F, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0,
55
    0xF8, 0xFC, 0x3F, 0x0F, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //55 '7'
56
    
57
    0x00, 0xF0, 0xFC, 0xFE, 0x0E, 0x0F, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E,
58
    0xFE, 0xFC, 0xF8, 0x00, 0x80, 0xE0, 0xF3, 0x77, 0x1F, 0x0E, 0x0E, 0x0C,
59
    0x1C, 0x1C, 0x1C, 0x3E, 0x77, 0xF3, 0xE0, 0x80, 0x0F, 0x1F, 0x3F, 0x78,
60
    0x70, 0xF0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0x70, 0x78, 0x3F, 0x1F, 0x0F, //56 '8'
61
    
62
    0xE0, 0xF8, 0xFC, 0x1E, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1E,
63
    0x3E, 0xFC, 0xF0, 0xC0, 0x07, 0x1F, 0x1F, 0x3C, 0x78, 0x70, 0x70, 0x70,
64
    0x70, 0x70, 0x70, 0x38, 0x38, 0xFF, 0xFF, 0x7F, 0x00, 0x00, 0xF0, 0xE0,
65
    0xE0, 0xE0, 0xE0, 0xE0, 0x70, 0x70, 0x78, 0x3C, 0x1F, 0x0F, 0x03, 0x00, //57 '9'
66
    
67
    0xC0, 0xC0, 0xC0, 0xC0, 0x03, 0x03, 0x03, 0x03, 0xF0, 0xF0, 0xF0, 0xF0 // 58 ':'
68
    
69
  };
70
    
71
  struct
72
  {
73
    uint16_t _size;
74
    uint8_t _width;
75
    uint8_t _height;
76
    uint8_t _firstChar;
77
    uint8_t _charCount;
78
      
79
    uint8_t _widths[11];
80
    uint8_t _fontData[sizeof(fontData)];
81
  };
82
};
Gast #5838626
Lesenswert?

Jan H. schrieb:
> uint16_t _size;
>     uint8_t _width;
>     uint8_t _height;
>     uint8_t _firstChar;
>     uint8_t _charCount;
>
>     uint8_t _widths[11];

Aber hier hast du doch schon gerechnet.

X = die größe gesamten Arrays
y = sizeof(_width)+sizeof(_height)+....+sizeof(-widths)

dann (X-Y) / sizeof(uint8_t)

Vielleich so?
#5838643
Lesenswert?

Wenn Dein Compiler nicht allzu sehr am Alignment herumfummelt, sollte 
eine Konstante, direkt hinter "fontData" gehen.
Du subtrahierst dann einfach die Adresse von fontData von der der 
Hilfskonstanten hast Du den Salat. Natürlich nur zur Laufzeit.

Ich glaube aber nicht, dass Du mit Deinem Ansatz glücklich werden wirst, 
da Du ja kein homogenes Array produzierst.
Die 0 hat 48 Bytes;
die 1 macht Kurzarbeit; und
die 4 sogar Überstunden; für
den Doppelpunkt lohnt es sich kaum aufzustehen.

Um auf die Punktmuster zugreifen zu können, musst Du sowieso irgendwo 
die "Anfänge" der einzelnen Punktmuster (als Konstante) ablegen. Zu 
diesen Konstanten noch die Länge des Doppelpunktes hinzuzurechnen sollte 
aber machbar sein.

Übrigens: Sollten die Konstanten "char widhts" irgendwie mit der 
Blockgröße zusammenhängen, so definiere sie doch einfach mittels 
"define". Dann kann der Compiler sie addieren und Du brauchst nur noch 
die Länge des Doppelpunktes im Auge behalten.
Persönliche Seite #5839027
Lesenswert?

Eine Möglichkeit ist ein Codegenerator, der die Zusatzdaten / 
Informationen konsistent erzeugt, was aber extra Programm für den PC 
erfordert.

Oder indem man die Größe direkt aus den Daten bestimmt — nicht 
sonderlich schön — nach dem Muster:
1
#define DATA 1, 2, 3,
2

3
typedef struct
4
{
5
    int data[sizeof ((int[]) { DATA })];
6
} font_t;
7

8
const font_t font = 
9
{
10
    .data = { DATA }
11
};
Man könnte die Daten aus DATA auch in eine Datei auslagern und includen 
wo gebraucht; auch nicht wirklich hipp:
1
typedef struct
2
{
3
    int data[sizeof ((int[])
4
    {
5
#include "data.def"
6
    })];
7
} font_t;
8

9
const font_t font = 
10
{
11
    .data =
12
    {
13
#include "data.def"
14
    }};



g457 schrieb:
>> ist es möglich, ohne das ich jetzt die ganzen Bytes zählen muss, die
>> Größe von dem Array zu bestimmen beim übersetzen?
>
> Natürlich. Und man kann Quellcode sogar anhängen.
> const uint8_t* pFontData;

Was aber eine andere Datenstruktur ist; ein Zeiger ist kein Array.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren