En utilisant le tableau de caractères comme un tableau de longues ints

Question

Sur mon AVR j'ai un tableau de caractères qui contiennent des informations d'intensité de couleur sous la forme de {R, G, B, X, R, G, B, x, ...} (x étant un octet utilisé). Est-il un moyen simple d'écrire un long int (32 bits) à char myArray[4*LIGHTS] donc je peux écrire un numéro 0x00BBGGRR facilement?

Mon transtypage est rude, et je ne sais pas comment l'écrire. Je devine juste faire un pointeur vers un type long int et définir que l'égalité mon_tableau, mais je ne sais pas comment dire arbitrairement pour définir le groupe x à myColor.

uint8_t myLights[4*LIGHTS];
uint32_t *myRGBGroups = myLights; // ?

*myRGBGroups = WHITE; // sets the first 4 bytes to WHITE
                      // ...but how to set the 10th group?

Edit:? Je ne sais pas si transtypage est même le terme approprié, comme je pense que ce serait si juste tronqué le nombre 32 bits à 8 bits

Answer 1

typedef union {
    struct {
         uint8_t    red;
         uint8_t    green;
         uint8_t    blue;
         uint8_t    alpha;
    }          rgba;
    uint32_t   single;
} Color;

Color    colors[LIGHTS];

colors[0].single = WHITE;
colors[0].rgba.red -= 5;

NOTE: Sur un système petit-boutiste, l'octet de poids faible de la valeur de 4 octets sera la valeur alpha; alors qu'elle sera la valeur rouge sur un système big-endian.

Answer 2

Votre code est parfaitement valide. Vous pouvez utiliser myRGBGroups comme réseau régulier, pour ainsi accéder à 10 pixel vous pouvez utiliser

myRGBGroups[9]

Answer 3

Pensez à utiliser l'union C, où le premier champ de l'union est un int32 et le second vecteur de 4 * caractères. Mais, pas sûr si cela est la meilleure façon pour vous.

Answer 4

Vous devez tenir compte du boutisme de uint32_t sur l'AVR pour vous assurer que les composants sont stockées dans l'ordre correct (déréférencement ultérieurement via tableau myLights) si vous allez le faire. Un Google rapide semble indiquer que stocker des données dans AVRs little-endian mémoire, mais d'autres registres varient en boutisme.

Quoi qu'il en soit, en supposant que vous avez fait, vous pouvez déréférencer myRGBGroups en utilisant l'indexation de tableau (où chaque index référence à un bloc de 4 octets). Ainsi, pour définir le groupe 10, vous pouvez juste faire myRGBGroups[ 9 ] = COLOR.

Answer 5

si peut utiliser l'arithmétique sur myRGBgroup, par exemple myRGBgroups ++ donnera groupe suivant, de même que vous pouvez utiliser plus, moins, etc. opérateurs operators.those fonctionnent avec des tailles de type, plutôt que seul octet

myRGBgroups[10] // access group as int
((uint8_t*)(myRGBgroups + 10)) // access group as uint8 array

Answer 6

Union d'une struct et uint32_t est une bien meilleure idée que de faire une uint8_t de taille 4 * FEUX. Une autre façon de faire assez commun est d'utiliser des macros ou des fonctions en ligne qui font l'arithmétique nécessaire pour créer bitwise la uint32_t correcte:

#define MAKE_RGBA32(r,g,b,a) (uint32_t)(((r)<<24)|((g)<<16)|((b)<<8)|(a))
uint32_t colors[NUM_COLORS];
colors[i] = MAKE_RGBA32(255,255,255,255);

En fonction de votre boutisme les valeurs peuvent devoir être placés dans l'int dans un ordre différent. Cette technique est commune parce que les anciens formats de couleur 16bpp comme RGBA5551 ou RGB565, il est plus logique de penser des couleurs en termes de l'arithmétique que dans les unités binaire d'octets.

Answer 7

Vous pouvez effectuer quelque chose de similaire en utilisant l'affectation struct - ce contourne le problème endian:

typedef struct Color {
    unsigned char r, g, b, a;
} Color;

const Color WHITE   = {0xff, 0xff, 0xff, 0};
const Color RED     = {0xff, 0, 0, 0};
const Color GREEN   = {0, 0xff, 0, 0};

Color colors[] = {WHITE, RED};
Color c;

colors[1] = GREEN;
c = colors[1];

Cependant la comparaison n'est pas définie dans la norme, vous ne pouvez pas utiliser c == GREEN et vous ne pouvez pas utiliser le raccourci {} dans l'affectation (seule initialisation) afin c = {0, 0, 0, 0} échouerait.

Gardez aussi à l'esprit que si c'est un 8 bits AVR (par opposition à un AVR32 dire), alors vous avez probablement ne voir aucun avantage de la performance de ces deux techniques.