Hallo,

ich muss über modbus eine Schnittstelle bauen, die mehrere gleichartige Datentypen übertragen soll.

Also neuen Type definiert:

[code]TYPE BlindInterface :

STRUCT

bPos                :BYTE;

xIsMovingUp     :BOOL;

xIsMovingDown   :BOOL;

xIsAutoOn           :BOOL;

xMoveUp         :BOOL;

xMoveDown       :BOOL;

xAutoOn         :BOOL;

END_STRUCT

END_TYPE[/code]

und dann Variablen mit AT %MW0 und MW1 usw angelegt.

Prinzipiell dachte ich, dass die Struktur in ein Wort reinpasst, aber da bin ich wohl auf dem Holzweg, es sieht so aus, als ob diese Struktur ganze 7 Wörter braucht.

A) Ist das so?

B) wie kann man das eleganter lösen?

Danke & Gruss

Chris

Hi,

ich habe mal was mit nem Statusword für ne Rampensteuerung gemacht.

In der CoDeSys Hilfe nach "Adressierung von Bits in Variablen" suchen.

Erst mal einen Datentyp anlegen:

TYPE TYP_RAMP_STATUS :
STRUCT
(* Bitabbildung (Mapping) einer Wordvariablen für die Anzeige des Rampenstatus *)
   STATUSWORT : WORD;
{bitaccess EIN 0 ' Rampe Ein' }
{bitaccess RESET 1 ' Rampe Reset' }
{bitaccess LOADED 2 ' Rampe geladen ' }
{bitaccess START 3 ' Rampen Start'
{bitaccess RUN_1 4 ' Rampe läuft' }
{bitaccess HOLD_1 5 ' Sollwert halten' }
{bitaccess END_1 6 ' Rampe beendet' }
{bitaccess RUN_2 7 ' Rampe läuft' }
{bitaccess HOLD_2 8 ' Sollwert halten' }
{bitaccess END_2 9 ' Rampe beendet' }
{bitaccess RUN_3 10 ' Rampe läuft' }
{bitaccess HOLD_3 11 ' Sollwert halten' }
{bitaccess END_3 12 ' Rampe beendet' }
{bitaccess RUN_4 13 ' Rampe läuft' }
{bitaccess HOLD_4 14 ' Sollwert halten' }
{bitaccess END_4 15 ' Rampe beendet' }
END_STRUCT
END_TYPE

Dann brauchst du noch die globalen Konstanten dazu.

VAR_GLOBAL CONSTANT
(* Konstanten für Sollwertrampen-Status *)
EIN   : INT := 0;
RESET   : INT := 1;
LOADED   : INT := 2;
START   : INT := 3;   
RUN_1   : INT := 4;
HOLD_1   : INT := 5;   
END_1   : INT := 6;   
RUN_2   : INT := 7;
HOLD_2   : INT := 8;
END_2   : INT := 9;
RUN_3   : INT := 10;
HOLD_3   : INT := 11;
END_3   : INT := 12;
RUN_4   : INT := 13;
HOLD_4   : INT := 14;
END_4   : INT := 15;
END_VAR

und dann alles auf deine Adresse mappen.

TestBits AT %MWnn : TYP_RAMP_STATUS;

Gruß Nitro

Hi,

die Deklaration der Struktur ist OK. Es ist aber nicht unbedingt notwendig, der Struktur eine MW-Adresse zu geben, um darauf zugreifen zu können. Besser ist es, eine Variablendeklaration mit dem selbst deklarierten Datentyp zu verwenden. Liest sich erstens besser, und zweitens spielt dann die Grösse keine Rolle:

VAR
  Interface1: BlindInterface;
  Interface2: BlindInterface;
END_VAR

Kann beispielsweise in den globalen Variablen deklariert sein, dann sind sie projektweit bekannt. An die Einzelelemente kommt man heran durch z.B. usw.

Grösse der Struktur: Normalerweise belegt eine BOOL-Variable mindestens ein Byte auf der SPS. Bei aktuellen CPUs (32 oder 64 Bit) sind es vielleicht mehr. Das ist so, weil das Ansprechen eines einzelnen Bits viel mehr Rechenzeit verbraucht als das Ansprechen eines Bytes, Worts, Doppelworts ... Rechenzeit ist aber halt für eine SPS wichtiger als Speicherersparnis.

Höchstens solche Museumsstücke wie SIMATIC S5, die einen speziellen Bitprozessor an Bord haben, sind anders gestrickt.

Gruss Rolf

[quote="Rolf_Geisler"]

die Deklaration der Struktur ist OK. Es ist aber nicht unbedingt notwendig, der Struktur eine MW-Adresse zu geben, um darauf zugreifen zu können. Besser ist es, eine Variablendeklaration mit dem selbst deklarierten Datentyp zu verwenden. Liest sich erstens besser, und zweitens spielt dann die Grösse keine Rolle:

[/quote]

Hi Rolf,

auf Deine Art mache ich das ja schon an anderer Stelle. Aber die Idee dieser Struktur ist halt ein Transfer via Modbus und daher muss ich die (zumindest soweit ich das verstanden hab) auf Merker packen.

Muss mir das mal mit dem Bitaccess anschauen, oder ich gruppiere die Bools in MX Merker-Arrays. Geht das?

Gruss

Chris

Hi Chris,

kann sein dass Du für den Modbus eine absolute Merkeradresse brauchst. Kenn' mich da nicht aus, arbeite (fast) ausschliesslich über OPC.

Merkerarrays gehen sicher, ist aber ziemlich umständlich. Die Belastung der Kommunikation ist minimal, wenn Du alles was zu übertragen ist in ein ganzes Wort packst. Ein Wort hat 2 Byte, eines davon könnte bPos belegen, und auf die Bits des anderen Bytes kannst Du die xIsMovingUp & Co legen. Musst die Teile halt auf der anderen Seite wieder auseinandernehmen ...

http://www.geisler-controls.de herunter. Doku ist mit dabei.

Gruss Rolf