/* -----------------------------------------------------------
                          array_shift.c

     Bitweises Verschieben Byte-Arrays nach links oder rechts

     13.10.2024     R. Seelig
   ----------------------------------------------------------- */

#include <stdio.h>
#include <stdint.h>

#define arranz   9

uint8_t myarray[arranz] = { 0x81, 0x0c, 0x55, 0xaa, 0x01, 0x02, 0x04, 0x08, 0x01 };


/* -----------------------------------------------------------
     printbin

     gibt den Inhalt einer 8-Bitvariable binaer aus.

     Eine 1 wird als 'x', eine 0 als '.' dargestellt.
   ----------------------------------------------------------- */
void printbin(uint8_t val)
{
  uint8_t mask, i;

  mask= 0x80;
  for (i= 0; i<8; i++)
  {
    if (val & mask) { printf("x"); } else { printf("."); }
    mask= mask >> 1;
  }
}

/* -----------------------------------------------------------
     shiftarray_left

     verschiebt alle Bits eines Byte-Arrays (uint8_t) um eine
     Bitposition nach links. Hierbei erfolgt die Uebernahme
     von MSB *parray nach LSB *(parray-1)

     Uebergabe:

           anz:     Anzahl Elemente des Arrays
           carryin: bestimmt, ob am letzten Element
                    *(parray+anz-1) eine 1 oder eine 0 ein-
                    geschoben wird
           *parray: Zeiger auf das Byte-Array

     Rueckgabe:
           Ein Carry-Out Bit wird zurueckgegeben, wenn das
           MSB von *parray 1 ist (ausgeschobenes Bit)
   ----------------------------------------------------------- */
uint8_t shiftarray_left(uint8_t anz, uint8_t carryin, uint8_t *parray)
{
  uint8_t i, cf;
  uint8_t carryout;

  carryin &= 0x01;                       // "saeubern des carry-in Flags
  carryout= ((*parray & 0x80)) >> 7;     // ausgeschobenes Bit nach carryout
  parray += (anz-1);                     // letzes Element adressieren
  for (i= 0; i< anz; i++)
  {
    cf= (*parray >> 7) & 0x01;           // Carry-Flag fuer das naechste Element sichern
    *parray= (*parray << 1) | carryin;   // Alle Bits eines Bytes verschieben und Carry des
                                         // Vorgaengers als LSB setzen
    carryin= cf;                         // Carry-Flag fuer den Nachfolger
    parray--;                            // naechstes Element
  }
  return carryout;
}


/* -----------------------------------------------------------
     shiftarray_right

     verschiebt alle Bits eines Byte-Arrays (uint8_t) um eine
     Bitposition nach rechts. Hierbei erfolgt die Uebernahme
     von LSB *parray nach MSB *(parray+1)

     Uebergabe:

           anz:     Anzahl Elemente des Arrays
           carryin: bestimmt, ob am 0 - Element
                    *parray eine 1 oder eine 0 an MSB ein-
                    geschoben wird
           *parray: Zeiger auf das Byte-Array

     Rueckgabe:
           Ein Carry-Out Bit wird zurueckgegeben, wenn das
           LSB von *(parray+anz-1) 1 ist (ausgeschobenes Bit)
   ----------------------------------------------------------- */
uint8_t shiftarray_right(uint8_t anz, uint8_t carryin, uint8_t *parray)
{
  volatile uint8_t i, cf;
  volatile uint8_t carryout;

  if (carryin) cf= 0x80; else cf= 0x00;  // saeubern des carryin - Flags
                                         // und als Carry-Flag uebernehmen
  for (i= 0; i< anz; i++)
  {
    carryin = (*parray & 0x01);
    carryout= carryin;                   // carryout erstellen
    carryin = carryin << 7;              // carryin - Flag fuer den Nachfolger erstellen
    *parray= (*parray >> 1) | cf;        // alle Bits eines Bytes verschieben und
                                         // das Carryflag an LSB einfuegen
    parray++;                            // naechstes Element setzen
    cf= carryin;                         // Carryflag fuer naechstes Element
  }
  return carryout;
}

/* ------------------------------------------------------------
                                main
   ------------------------------------------------------------ */
int main( int argc, char **argv )
{
  uint8_t i,x;
  uint8_t cf = 0;
  uint8_t co;

  co= 0;

  printf("\n\r   shiftarray_left\n\n\r");

  printf("   Arrayelemente: ");
  for (x= 0; x< (arranz); x++)
  {
    printf("0x%02x, ",myarray[x]);
  }


  printf("\n\n\r%d  ",co);
  for (x= 0; x< (arranz); x++)
  {
    printbin(myarray[x]);
  }
  printf("\n\n\r   ");
  for (i= 0; i< (arranz*8); i++)
  {
    printf("-");
  }
  printf("\n\r");
  co= 0;

  for (i= 0; i<16; i++)
  {
    printf("\n\r%d  ",co);
    for (x= 0; x< (arranz); x++)
    {
      printbin(myarray[x]);
    }
    co= shiftarray_left(arranz, co, &myarray[0]);
  }
  printf("\n\n\r");

/*
  for (i= 0; i<16; i++)
  {
    co= shiftarray_right(arranz, co, &myarray[0]);
    printf("\n\r%x  ",co);
    for (x= 0; x< (arranz); x++)
    {
      printbin(myarray[x]);
    }
  }
  printf("\n\r");
  printf("\n\r");
*/

}