Как сдвинуть байт через многобайтовый массив

Question

Я работаю над LED Tower, которая содержит 15 слоев, каждый из которых содержит 4 байта (32 светодиода). Я хотел бы иметь возможность сдвинуть байт справа налево. Однако существует проблема с несколькими байтами, не могу понять, как непрерывно переходить сдвиг.

Дополнительная информация:

void Invert_Display(void){
for (int y = 0; y < LAYERS; y++){
    for (int x = 0; x < BYTES; x++){
        LED_Buffer[y][x] ^= (0b11111111);
    }
}
Update_Display();

Где функция UpdateDisplay выглядит следующим образом:

void Update_Display(void){

    while(!TRMT);           // Wait until transmission register is empty

    for (int y = 0; y < LAYERS; y++){
        for (int x = 0; x < BYTES; x++){
        TXREG = LED_Buffer[y][x];
        while (!TRMT);
        }
    }

    LE = 1;                 // Data is loaded to the Output latch
    NOP();              
    LE = 0;                 // Data is latched into the Output latch

Ожидаемый результат прилагается ниже.

Answer 1

Следующий код сместит массив байтов влево.Число сдвигаемых битов должно составлять от 1 до 7. Для сдвига более чем на 7 потребуется дополнительный код.

void shiftArrayLeft(unsigned char array[], int length, int shift) // 1 <= shift <= 7
{
    unsigned char carry = 0;                        // no carry into the first byte
    for (int i = length-1; i >= 0; i--)
    {
        unsigned char temp = array[i];              // save the value
        array[i] = (array[i] << shift) | carry;     // update the array element
        carry = temp >> (8 - shift);                // compute the new carry
    }
}

Работает путем сохранения старого значения из массива.Затем обновите текущий элемент массива, сдвинув его и выполнив логическое ИЛИ перенос из предыдущего байта.Затем вычислите новый перенос (старшие биты исходного значения).

Функция может быть вызвана с кодом, подобным этому

unsigned char array[] = { 0x00, 0x00, 0x00, 0xAA };
int length = sizeof(array) / sizeof(array[0]);
shiftArrayLeft(array, length, 1);

, который изменит массив на { 0x00, 0x00, 0x01, 0x54 }

Answer 2

Печатает каждую строку на экране, сдвигая строки на один бит.
iterate и wrap позволяют изображению сдвигаться через несколько петель.
pattern добавляется к строке [7] по одному биту за раз, и последующие циклы расширяют шаблон до соседней строки, чтобы они содержали тот же шаблон, но один бит вправо.
Шаблон также смещен вниз и вправо.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

void show ( unsigned char *bank, size_t size) {
    for ( size_t byte = 0; byte < size; ++byte) {
        unsigned char mask = 0x80;
        for ( int bit = 0; bit < CHAR_BIT; ++bit) {
            mask & bank[byte] ? printf ( "*") : printf ( " ");
            mask >>= 1;
        }
    }
    printf ( "\r");
}

void shiftright ( unsigned char *bank, size_t size) {
    unsigned char carry = 0;
    for ( size_t byte = 0; byte < size; ++byte) {
        unsigned char mask = bank[byte] & 1;
        bank[byte] >>= 1;
        bank[byte] |= carry << ( CHAR_BIT - 1);
        carry = mask;
    }
}

void shiftleft ( unsigned char *bank, size_t size) {
    unsigned char carry = 0;
    for ( size_t byte = size; byte > 0; ) {
        byte--;
        unsigned char mask = bank[byte] & 0x80;
        bank[byte] <<= 1;
        bank[byte] |= carry >> ( CHAR_BIT - 1);
        carry = mask;
    }
}

void shiftdown ( size_t rows, size_t cols, unsigned char (*bank)[cols]) {
    for ( size_t height = rows; height > 1; ) {
        height--;
        memmove ( bank[height], bank[height - 1], cols);
    }
}

int main( void) {
    unsigned char bank[15][4] = { { 0}};

    printf ( "\n\n\n\n\n\n\n");

    unsigned char pattern = 0xaa;
    for ( int iterate = 3; iterate >= 0; --iterate) {
        for ( int slide = 0; slide < ( sizeof bank[0] * CHAR_BIT); ++slide) {
            for ( int row = 0; row < sizeof bank / sizeof bank[0]; ++row) {
                int wrap = bank[row][0] & 0x80;
                show ( bank[row], sizeof bank[row]);
                shiftleft ( bank[row], sizeof bank[row]);
                if ( wrap) {
                    bank[row][3] |= 1;
                }
                printf ( "\n");
            }
            //add pattern
            unsigned char bit;
            if ( pattern) {//add the pattern to row 7, bit by bit
                bit = 0x80 & pattern;
                if ( bit) {
                    bank[7][3] |= 1;
                }
                pattern <<= 1;
            }
            if ( slide < CHAR_BIT * 2) {//extend pattern to adjacent rows. one bit behind
                unsigned char mask = 0x01;
                for ( int length = 0; length < 7; ++length) {
                    bit = mask & bank[7][3];
                    for ( int height = 0; height < length; ++height) {//add bit to widening lines from center
                        bank[7 - height][3] |= bit;
                        bank[7 + height][3] |= bit;
                        bit >>= 1;
                    }
                    mask <<= 1;
                }
            }
            usleep ( 150000);
            printf ( "\n\n\n\n\n\n\n");
        }
    }
    for ( int iterate = 3; iterate >= 0; --iterate) {
        for ( int slide = 0; slide < sizeof bank / sizeof bank[0]; ++slide) {
            unsigned char wraprow[4];
            memmove ( wraprow, bank[14], sizeof wraprow);
            shiftdown ( sizeof bank / sizeof bank[0], sizeof bank[0], bank);
            memmove ( bank[0], wraprow, sizeof wraprow);
            for ( int row = 0; row < sizeof bank / sizeof bank[0]; ++row) {
                show ( bank[row], sizeof bank[row]);
                printf ( "\n");
            }
            usleep ( 150000);
            printf ( "\n\n\n\n\n\n\n");
        }
    }
    for ( int iterate = 3; iterate >= 0; --iterate) {
        for ( int slide = 0; slide < ( sizeof bank[0] * CHAR_BIT); ++slide) {
            for ( int row = 0; row < sizeof bank / sizeof bank[0]; ++row) {
                int wrap = bank[row][3] & 1;
                show ( bank[row], sizeof bank[row]);
                shiftright ( bank[row], sizeof bank[row]);
                if ( iterate && wrap) {
                    bank[row][0] |= 0x08;
                }
                printf ( "\n");
            }
            usleep ( 150000);
            printf ( "\n\n\n\n\n\n\n");
        }
    }
    printf ( "\n");
    return 0;
}