Merker wie bei einer SPS

[RUB]

Hi,

ich suche Funktionen um einfache Bit- Manipulationen wie bei einer SPS zu machen, wie etwa

U "Bedingung" // wenn Bedingung ein
= M10.0 // Merker Byte 10 Bit 0 ein
aber auch Byte und Word weisen zugriff


der AWL OP-Code ist folgendermaßen aufgebaut
Merker | Bit
Bit 15-3 | 2-0
1111111111111 | 111

M10.1
0000000001010 001 //Bitadresse 81
M10.2
0000000001010 010 //Bitadresse 82
also
Adresse := (Byte shl 3) or Bit


die Merker sind Byte weise aufgebaut
Merkerworte bestehen aus zwei Merkerbyte

L MW10 //lade Merkerwort 10
Zahl := Bit 80 bis 96 (MB10+MB11)


ich habe mir auch TBits angesehen aber da fehlt mir der Byte und Word weise zugriff

vielecht weiß jemand von euch wie man Bit- Manipulationen ähnlich einer SPS macht.

Grüße
Bernd

[Socke]

Was ist denn bitte eine SPS? (bei ungebräuchlichen Abkürzungen bitte eine kurze Erklärung dazu) Und wie arbeitet die mit Bits bzw. Bytes und Words?

Wenn du auf ein Word auch bitweise ohne Bitoperationen zugreifen möchtest, kannst du auch die alte Variante mit Records ausgraben:

Code: Alles auswählen

type
TMyRec = bitpacked record // hier ist das bitpacked nur für die dritte Variante nötig, sonst reicht ein einfaches packed
case Byte of
  0: (AsWord: Word);
  {$IFDEF ENDIAN_LOW}
  1: (LowByte, HighByte: Byte);
  {$ELSEIFDEF ENDIAN_BIG}
  1: (HighByte, LowByte: Byte);
  {$ENDIF}
  2: (AsBits: bitpacked array[0..15] of Boolean);
  3: (FirstPart: bitpacked array[0..13] of Boolean; SecondPart: bitpacked array[0..2] of Boolean); // hier musst du ggf. noch die Endianess berücksichtigen
end;

Wenn du eine ganze Reihe von deinen Daten hast, kannst du entweder einen Array dieser Records anlegen oder du definierst dir drei Arraytypen:

Code: Alles auswählen

const
  WordCount = 1;
type
  TThisBitArray = bitpacked array[0..WordCount*SizeOf(Byte)*8-1] of Boolean; // Dynamische bitgepackte Arrays sind nicht möglich
  TThisByteArray = packed array[0..WordCount*SizeOf(Byte) - 1] of Byte;
  TThisWordArray = packed array[0..WordCount] of Word;
var
  BitArr: TThisBitArray;
  ByteArr: TThisByteArray absolute BitArr;
  WordArr: TThisWordArray absolute BitArr;
  i: Integer;
begin
  fillbyte(ByteArr, length(ByteArr)*sizeof(ByteArr[0]),0); // mit 0 initalisieren
 
  WordArr[0] := %1010110110101101; // einen Wert zuweisen
 
  for i := Low(BitArr) to High(BitArr) do   // Zugriff Bitweise
    writeln(Format('%2d: %2s',[i, BoolToSTr(BitArr[i], True)]));
  writeln();
 
  for i := Low(ByteArr) to High(ByteArr) do  // Zugriff Byteweise
    writeln(Format('%2d: %2s',[i, IntToHex(ByteArr[i],2)]));
  writeln();
 
  for i := Low(WordArr) to High(WordArr) do  // Zugriff Wordweise
    writeln(Format('%2d: %2s',[i, hexStr(WordArr[i], 4)]));
end.

Das hat nur den Haken, dass du -- wie im Kommentar angemerkt -- die Anzahl deiner Bits schon im Voraus wissen musst. Aber natürlich kannst du alle Varianten mit allen Möglichkeiten und allen vorhandenen Typen kombinieren

[RUB]

Hi,

SPS heist Speicherprogrammierbare Steuerung http://de.wikipedia.org/wiki/Speicherpr ... _Steuerung oder auch Programmable Logic Controller (PLC).
Bei Solchen Programmen kenne ich mich auch etwas besser aus als unter Pascal.

ich werde mir dein Beispiel heute Abend ansehen.
Die Anzahl der Bits stehen vorher fest bei Byte sind es 8Bits (Bit 7 bis 0) bei Word sind es zwei Byte
wobei sich ein Word im Speicher mit zwei Byte überlaben
z.B. MW10 ist MB10+MB11
oder MW11 ist MB11+MB12

das Bit 7 bei MB oder Bit15 bei MW sind das Vorzeichen (wenn Integer) aber das brauche ich bei meiem Programm nicht


Grüße
Bernd

[af0815]

Ich arbeite jahrelang auf SPS'se (S5,S7,PC20,....) kenne auch Lösungen wo PCs mit Pascal als SPS Ersatz verwendet werden,... kurzum Maschinensteuerungen sind mir geläufig.

Die Frage was sich ergibt ist - was willst du eigentlich machen. Im ersten Moment habe daran gedacht, das du eine SPS unter Pascal machen willst.

zu den operationen kann man im 'Free Pascal Reference Guide' nachsehen.
Logische Operation sind hier zu finden
Boolsche Operationen sind hier zu finden