Step 7 SCL - AT Befehl in einer STRUCT - ich verzweifle :(

don_looney

Level-1
Beiträge
94
Reaktionspunkte
5
Zuviel Werbung?
-> Hier kostenlos registrieren
Moin Moin

Ich habe ein Problem und mit der Hilfe kann ich leider nichts dazu finden. Mit SCL habe ich gerade angefangen und hänge leider ein bisschen an der Syntax, bei der Definition der statischen Variablen in einer Struktur.

Ich möchte innerhalb einer Struktur ein ARRAY OF CHAR weiter mit dem AT Befehl aufteilen.

Wenn ich es so anlege, bekomme ich immer einen Fehler das die Datentypspezifikation nicht korrekt ist.

Code:
CONST                               // konstanten
    UserBereich  := 64;
END_CONST
VAR_TEMP                            // temporäre Variablen
    StatusLesen                         :INT;  
    StatusSchreiben                     :INT;
    StatusKopieren                      :INT;
    ScannerReady                        :BOOL;    
    forSchleifeCharToString             :INT; 
    stringChar                          :STRING[1]; 
END_VAR
VAR                                 // statische Variablen    
    AdresseHW                               :ARRAY[1..16] OF WORD;
    Scanner                                 :STRUCT
        In                                  :STRUCT
            Handshake                       :STRUCT
                Error                       :BOOL;
                ResultDataAvailable         :BOOL;
                ResultDataStrobe            :BOOL;
                Bit3                        :BOOL;
                Bit4                        :BOOL;
                Bit5                        :BOOL;
                BufferOverflow              :BOOL;
                GeneralError                :BOOL;
                END_STRUCT;
            Completion                      :STRUCT
                ReadComplete                :BOOL;
                Bit1                        :BOOL;
                Bit2                        :BOOL;
                Bit3                        :BOOL;
                Bit4                        :BOOL;
                Bit5                        :BOOL;
                Bit6                        :BOOL;
                Bit7                        :BOOL;
                END_STRUCT;
            Terminal                        :STRUCT
                Bit0                        :BOOL;
                Bit1                        :BOOL;
                Bit2                        :BOOL;
                Bit3                        :BOOL;
                OUT1Status                  :BOOL;
                OUT2Status                  :BOOL;
                OUT3Status                  :BOOL;
                Bit7                        :BOOL;
                END_STRUCT;
            OperationResult                 :ARRAY[1..20] OF BYTE;
            ResultDataReadyCount            :WORD;
            ResultDataUpdateCount           :WORD;
            ReserveWord                     :WORD;
            ResultDataSize                  :WORD;
            ResultDataIN                    :ARRAY[1..UserBereich] OF CHAR;
                ResultData: AT ResultDataIN :STRUCT
                    Data01                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data02                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data03                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data04                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data05                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data06                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data07                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data08                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data09                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data10                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data11                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data12                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data13                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data14                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data15                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    Data16                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
                    END_STRUCT; 
        END_STRUCT;
        Out                                 :STRUCT
            ErrorClear                      :STRUCT
                Bit0                        :BOOL;
                ResultDataLatch             :BOOL;
                Bit2                        :BOOL;
                Bit3                        :BOOL;
                Bit4                        :BOOL;
                Bit5                        :BOOL;
                Bit6                        :BOOL;
                Clear                       :BOOL;
                END_STRUCT;
            CompletionClear                 :STRUCT
                ReadCompleteClear           :BOOL;
                Bit1                        :BOOL;
                Bit2                        :BOOL;
                Bit3                        :BOOL;
                Bit4                        :BOOL;
                Bit5                        :BOOL;
                Bit6                        :BOOL;
                Bit7                        :BOOL;
                END_STRUCT;
        END_STRUCT;  
    END_STRUCT;

Lege ich das ganze jedoch nicht in eine STRUCT funktioniert es einwandfrei.

Code:
 tempResultDataIN                    :ARRAY[1..UserBereich] OF CHAR;
        ResultData AT tempResultDataIN  :STRUCT
            Data01                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data02                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data03                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data04                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data05                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data06                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data07                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data08                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data09                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data10                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data11                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data12                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data13                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data14                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data15                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            Data16                       :ARRAY[1..(UserBereich / 16)] OF CHAR;
            END_STRUCT;

Ich würde gerne wissen was ich falsch mache oder ob das generell gar nicht geht. Danke vorab schonmal.

Grüße
 
Wie du schon richtig vermutest geht es in der Struktur nicht.
Du kannst eine AT-Sicht immer nur auf das Haupt-Element legen - gilt auch für Array ...
Lediglich muß deine AT-Sicht nicht mehr unbedingt den ganzen Bereich des Originals abdecken (es geht auch, nur einen Teil davon zu nehmen - aber eben immer vom Anfang her).

Gruß
Larry
 
Zurück
Oben