Forum: Mikrocontroller und Digitale Elektronik C-> Größe eines Array in einem Union initalisieren?!


von Jan H. (janiiix3)


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
};

von GEKU (Gast)


Lesenswert?

Jan H. schrieb:
> fontData

Ich würde einmal im Listfile nach fontData suchen.

von Jan H. (janiiix3)


Lesenswert?

GEKU schrieb:
> Jan H. schrieb:
>> fontData
>
> Ich würde einmal im Listfile nach fontData suchen.
?

von zitter_ned_aso (Gast)


Lesenswert?

Mit Zeigerdifferenz könntest du ermitteln wieviele Elemente dazwischen 
liegen.

von Jan H. (janiiix3)


Lesenswert?

zitter_ned_aso schrieb:
> Mit Zeigerdifferenz könntest du ermitteln wieviele Elemente dazwischen
> liegen.
Das würde nur zur Laufzeit funktionieren..

von mh (Gast)


Lesenswert?

Wofür brauchst du diese union? Die struct sollte doch reichen.

von zitter_ned_aso (Gast)


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?

von zitter_ned_aso (Gast)


Lesenswert?

zitter_ned_aso schrieb:

> dann (X-Y) / sizeof(uint8_t)

Eigentlich nur X-Y

uint8_t ist ja nur 1Byte lang.

von g457 (Gast)


Angehängte Dateien:

Lesenswert?

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

HF

von Jan H. (janiiix3)


Lesenswert?

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.
>
> HF
Auch mit Union?

von Sebastian S. (amateur)


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.

von g457 (Gast)


Lesenswert?

> Auch mit Union?

Ja, natürlich geht das ebenfalls. Aber wie in so vielen anderen Fällen 
ist auch hier eine Union fehl am Platz.

von Johann L. (gjlayde) Benutzerseite


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.

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.