shift_left()?

[Helmut K. (Gast)]

Hallo ich hab da ei kleines Problem ich benutze den C18 Compiler und 
beötige eine funktion vom CCS-Compiler.

Ich komme irgendwie nicht alleine daruf??

shift_left(address,bytes,wert);

Die Funktion verschiebt ein Bit in einem Array oder Struktur nach links. 
address kann ein Array oder eine Adresse zu einer Struktur (z.B. wie 
&data). bytes gibt an, mit wievielen Bytes gearbeitet. wert gibt den 
Inhalt des Bits an, entweder 0 oder 1.

Hier noch ein Beispiel zur Anwendung:

byte buffer[3];
for (i=0;i<=24;++i) {
// Wait for clock high
while (!input(PIN_A2));
shift_left(buffer,3,INPUT(PIN_A3));
// Wait for clock low
while (input(PIN_A2));
}
// reads 24 bits from pin A3, each
// bit is read on a low to high on pin // A2

Kann mir jemand die Funktionsbeschreibung geben??

Besten Dank im vorraus
MfG Helmut

[Läubi .. (laeubi)]

Also ich weiß nicht wie man das in C macht das man das Carry 
reinschiebt.
Aber im Prinzip wird hier nur buffer einmal nach Links geschoben (jedes 
byte einmal deshalb die 3) und beim ersten byte eine 1 oder 0 
reingeschoben.

Ich würde das einfach so umschreiben:

int buffer = 0;
for (i=0;i<=24;++i) {
 // Wait for clock high
 while (!input(PIN_A2));
 buffer = (buffer << 1) | INPUT(PIN_A3));
 // Wait for clock low
 while (input(PIN_A2));
}

ggf könnte man auch ne Union nutzen wenn man auf die einzelnen bytes 
zugreifen will.

[Karl H. (kbuchegg)]

Da du in C an das Carry Bit des Prozessors so nicht
vernünftig ran kommst, muss man das in Software simulieren

void shift_left( byte* address, size_t bytes, byte wert )
{
  size_t i;
  byte Carry;
  byte PrevCarry = ( Wert != 0 );

  for( i = 0; i < bytes; ++i )
    Carry = adress[i] & 0x80;    // dieses Bit wird rausfallen, also
                                 // sichern, damit es beim nächsthöheren
                                 // Byte eingesetzt werden kann
    adress[i] <<= 1;
    adress[i] |= PrevCarry;

    PrevCarry = ( Carry != 0 );
  }
}

Eine andere Möglichkeit wäre beim Höchstwertigen Byte mit der
Schieberei anzufangen. Hier sind 2 Fälle zu unterscheiden:
Das höchstwertige Byte wird einfach nur geschoben. Was links rausfällt,
fällt raus. Bei allen anderen Bytes wird das Bit 7 in das nächsthöhere
Byte übertragen.

void shift_left( byte* address, size_t bytes, byte wert )
{
  size_t i;

  adress[ bytes - 1 ] <<= 1;    // Höchstwertige Byte schieben

  for( i = bytes - 1; bytes > 0; --i ) {
                                // muss eine 1 vom Bit7 zum Bit0 eine
                                // Stelle höher übertragen werden?
    if( adress[ i - 1 ] & 0x80 != 0 )
      adress[ i ] |= 0x01;

                                // dieses Byte jetzt um 1 Position schieben
    adress[ i - 1 ] <<= 1;
  }

  if( wert )
    adress[0] |= 0x01;
}

Disclaimer: Ich habe keine der Funktionen getestet. Sie sollten aber
zumindest keine gravierenden Fehler aufweisen.

[Simon K. (simon)]

In dem ersten Code fehlt eine geschweifte geöffnete Klammer nach <for>

[Karl H. (kbuchegg)]

Simon K. wrote:
> In dem ersten Code fehlt eine geschweifte geöffnete Klammer nach <for>

Merci.
Hätte es doch durch den Compiler laufen lassen sollen :-)