Rotation de la matrice d'octets dans le sens inverse des aiguilles d'une montre

Question

Avoir un tableau d'octets donné qui représente un "A" majuscule, qui se trouve sur le site approprié. (source)

Le résultat attendu est de faire pivoter le tableau d'octets dans le sens inverse des aiguilles d'une montre pour un "A" permanent.

Ma tentative de conversion du tableau donné en une version pivotée fonctionne mais n'est pas sympa. Quelque chose dans mon code n'est pas correct dans "loop()" à la partie de décalage de bits et de calcul. Pour cette raison, j'ai dû gérer x == 5 et x == 6 séparément.

Comment puis-je faire pivoter un tableau d'octets dans le sens inverse des aiguilles d'une montre d'une manière plus générique dans c?

Enfin, le tableau est affiché sur une matrice de LED 8x8 sur Arduino. Voir le code et la sortie ci-dessous.

Code:

#include "LedControl.h" 
LedControl lc=LedControl(12,11,10,4); 

void setup(){ 
    for (int addr=0; addr<lc.getDeviceCount(); addr++){ 
    lc.shutdown(addr,false); 
    lc.setIntensity(addr,0); 
    lc.clearDisplay(addr); 
    } 
} 

void loop(){ 
    // given 
    byte a[5]={B01111110,B00010001,B00010001,B01111110,B00000000}; 

    // expected 
    byte a2[8]={B01100000,B10010000,B10010000,B10010000,B11110000,B10010000,B10010000,B00000000}; 

    // rotated 
    byte a3[8]; 
    byte row; 
    for (int x = 0; x < 8; x++){ 
    row = B00000000; 
    for (int y = 0; y < 5; y++){ 
     if (x==0 || x==1 || x==2 || x==3 || x==4) { 
     row |= (a[y] & B00000001 << x) << 7-x-y; 
     } 
     if (x==5) { 
     row |= (a[0] & B00100000) << 2; 
     row |= (a[1] & B00100000) << 1; 
     row |= (a[2] & B00100000); 
     row |= (a[3] & B00100000) >> 1; 
     } 
     if (x==6) { 
     row |= (a[0] & B01000000) << 1; 
     row |= (a[1] & B01000000); 
     row |= (a[2] & B01000000) >> 1; 
     row |= (a[3] & B01000000) >> 2; 
     } 
    } 
    a3[x] = row; 
    } 

    // output 
    for(int i=0; i<8; i++){ 
    lc.setRow(0,i,a[i]); // given 
    lc.setRow(1,i,a2[i]); // expected 
    lc.setRow(2,i,a3[i]); // rotated 
    delay(100); 
    } 
} 

LED Sortie:

given a   expected a2 
        rotated a3 

_ o o o o o o _ _ o o _ _ _ _ _ 
_ _ _ o _ _ _ o o _ _ o _ _ _ _ 
_ _ _ o _ _ _ o o _ _ o _ _ _ _ 
_ o o o o o o _ o _ _ o _ _ _ _ 
_ _ _ _ _ _ _ _ o o o o _ _ _ _ 
_ _ _ _ _ _ _ _ o _ _ o _ _ _ _ 
_ _ _ _ _ _ _ _ o _ _ o _ _ _ _ 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

Answer 1

Votre code semble vraiment exagéré. Vous pouvez utiliser une boucle imbriquée, qui le fait tout chaque bit possible des données de source et définir des données de dest en conséquence (qui permute essentiellement des indices), quelque chose comme:

#include <stdio.h> 

typedef unsigned char byte; 

void printCharacter(const byte* data, size_t length) 
{ 
    for (size_t i = 0; i < length; ++i) 
    { 
    for (size_t j = 0; j < 8; ++j) 
    { 
     const unsigned char mask = 1 << j; 
     printf("%c ", data[i] & mask ? 'o' : '-'); 
    } 
    printf("\n"); 
    } 
} 

void rotate(const byte* source, byte* dest, size_t length) 
{ 
    /* for each bit position starting from first */ 
    for (size_t j = 0; j < 8; ++j) 
    { 
    /* this is the mask of the i-th bit in source data */ 
    const unsigned char mask = 1 << j; 

    /* for each row in source data (which will become column) */ 
    for (size_t i = 0; i < length; ++i) 
    { 
     /* if j-th bit of i-th row set */ 
     if (source[i] & mask) 
     /* then set i-th bit of j-th row */ 
     dest[j] |= 1 << i; 
    } 
    } 
} 

int main() { 
    byte a[5]= { 0b01111110,0b00010001,0b00010001,0b01111110,0b00000000 }; 
    byte b[8]= { 0 }; 
    printCharacter(a, 5); 
    rotate(a, b, 5); 
    printCharacter(b, 8); 
    return 0; 
} 

Maintenant cette commande affiche

- o o o o o o - 
o - - - o - - - 
o - - - o - - - 
- o o o o o o - 
- - - - - - - - 

- o o - - - - - 
o - - o - - - - 
o - - o - - - - 
o - - o - - - - 
o o o o - - - - 
o - - o - - - - 
o - - o - - - - 
- - - - - - - - 

qui n'est pas exactement ce que vous cherchez, mais vous avez juste besoin d'ajuster le masque/index pour commencer à partir du premier/dernier bit en fonction de la rotation que vous voulez.