uint8 number=0b11101100;
uint8 a, b;

a = (number >> 4 ) | (number << 4); //разменя местата на всеки 2 съседни четворки бита, сега в а имаме 0b11001110;
a = (a & 0xCC) >> 2 | (a & 0x33) << 2; //разменя местата на всеки 2 съседни двойки бита, сега в а имаме 0b00111011;
a = (a & 0xAA) >> 1 | (a & 0x55) << 1; //разменя местата на всеки 2 съседни бита, сега в a имаме 0b00110111;
b = (a & 0x0F) << 4 //в b отиват долните 4 бита, качени в горните 4, или в b имаме 0b01110000
a &= 0xF0; //изчистване на долните 4 бита, така че да останат само горните, или в a имаме 0b00110000;

uint8 number=0b11101100;
uint8 a, b;
а=number;
a = (a & 0xCC) >> 2 | (a & 0x33) << 2; //разменя местата на всеки 2 съседни двойки бита, сега в а имаме 0b10110011;
a = (a & 0xAA) >> 1 | (a & 0x55) << 1; //разменя местата на всеки 2 съседни бита, сега в a имаме 0b01110011;
b = a & 0xF0; //в b отиват горните 4 бита, тоест в b имаме 0b01110000
a <<= 4; //в а остават долните 4 бита, вдигнати горе, тоест  0b00110000;

SPIWrite(table(a>>4));  //SPIWrite e примерно име на функция, която ти праща байт към SPI-то.
SPIWrite(table[a&0x0F]);

const uint8_t a[16] = {
           
            0b00000000, //0
            0b10000000, //1
            0b01000000, //2
            0b11000000, //3
            0b00100000, //4
            0b10100000, //5
            0b01100000, //6
            0b11100000, //7
            0b00010000, //8
            0b10010000, //9
            0b01010000, //10
            0b11010000, //11
            0b00110000, //12
            0b10110000, //13
            0b01110000, //14
            0b11110000, //15
           
            };
   

SPI_Exchange8bit(a[1]);
SPI_Exchange8bit(0b00100000);

c = ... ; //ASCII кода на символа
l = c & 0x0F; //младшите 4 бита
h = (c & 0xF0) >>4; //старшите 4 бита

SPI_Exchange8bit(a[l]);
SPI_Exchange8bit(a[h]);

c = ... ; //ASCII кода на символа
SPI_Exchange8bit(a[c & 0x0F]);
SPI_EXchenge8bit(a[c >> 4]);

uint8_t SPI_Exchange8bit(uint8_t data)
{
    // Clear the Write Collision flag, to allow writing
    SSP1CON1bits.WCOL = 0;

    SSPBUF = data;

    while(SSP1STATbits.BF == SPI_RX_IN_PROGRESS)
    {
    }

    return (SSPBUF);
}

uint8_t SPI_Exchange8bitBuffer(uint8_t *dataIn, uint8_t bufLen, uint8_t *dataOut)
{
    uint8_t bytesWritten = 0;

    if(bufLen != 0)
    {
        if(dataIn != NULL)
        {
            while(bytesWritten < bufLen)
            {
                if(dataOut == NULL)
                {
                    SPI_Exchange8bit(dataIn[bytesWritten]);
                }
                else
                {
                    dataOut[bytesWritten] = SPI_Exchange8bit(dataIn[bytesWritten]);
                }

                bytesWritten++;
            }
        }
        else
        {
            if(dataOut != NULL)
            {
                while(bytesWritten < bufLen )
                {
                    dataOut[bytesWritten] = SPI_Exchange8bit(DUMMY_DATA);

                    bytesWritten++;
                }
            }
        }
    }

    return bytesWritten;
}

bool SPI_IsBufferFull(void)
{
    return (SSP1STATbits.BF);
}

bool SPI_HasWriteCollisionOccured(void)
{
    return (SSP1CON1bits.WCOL);
}

void SPI_ClearWriteCollisionStatus(void)
{
    SSP1CON1bits.WCOL = 0;
}