Accedere Ai Dati Locali Precedenti

[GDA]

Ciao a tutti, avrei bisogno di aiuto in merito al metodo da utilizzare per riuscire ad accedere a dei dati locali precedenti (local data V) da una FC che sto attualmente sviluppando. Tali dati sono ricavabili da un ingresso di tipo ANY dell'FC, vorrei sapere SE e COME è possibile accedervi. Premetto che ho già scomposto l'ingresso di tipo ANY. Ho già provato a cercare nei vecchi post, ma non ho trovato nulla di sufficientemente esaustivo al fine della mia applicazione. Vorrei riuscirci senza dover ricorrere alla funzione FILL o BLOCKMOVE.

Grazie a tutti per l'attenzione e confido nel vostro aiuto

[STEU]

Potresti spiegare un po' meglio quello che ti serve?

Io non ho capitro molto se fai qualche esempio vedro' se riusciro' esserti utile.

[GDA]

Ciao STEU, scusa se magari non sono stato molto chiaro, è che non è molto semplice spiegare il mio problema. Allego parti del codice della mia funzione, che spero potranno aiutarti a capire. Il mio problema è quando mi trovo nel mio ANY in ingresso dei dati provenienti da area "V", il che può succedere se mi connettono una temporanea della funzione chiamante.

Ho aggiunto dei commenti che spero aiutino a capire un pò...

FUNCTION XXXFC : INT
VAR_INPUT
    sourceInAn:ANY;    //Source area
END_VAR
VAR_TEMP
    //Source area ANY informations
    srcDataTypeTpBy:BYTE;
    srcAreaDBNOTpWo:WORD;
    srcRepFactTpWo:WORD;
    srcMemAreaTpBy:BYTE;
    srcAreaAddrTpDw:DWORD;

    //Single data value
    singleDataValTpDw:DWORD;
END_VAR
BEGIN
######################################
######################################
SCOMPONGO L'ANY
######################################
######################################


    L P#sourceInAn; LAR1;
    L B[AR1, P#1.0]; T srcDataTypeTpBy;
    L W[AR1, P#2.0]; T srcRepFactTpWo;
    L W[AR1, P#4.0]; T srcAreaDBNOTpWo;
    L B[AR1, P#6.0]; T srcMemAreaTpBy;
    L D[AR1, P#6.0]; L DW#16#FFFFFF; UD; T srcAreaAddrTpDw;

######################################
######################################
CARICO SU AR2 IL PUNTATORE AD UNA DWORD TEMPORANEA
######################################
######################################
    //Clear source data value and store its address to AR2
    L 0; T singleDataValTpDw;
    L P#singleDataValTpDw; LAR2;

######################################
######################################
COPIO DALL'AREA SPECIFICATA ALL'INTERNO DELL'ANY
######################################
######################################

    L srcMemAreaTpBy; L B#16#0F; UW;
    SPL SAUN;    //>7    Memory area unknown
    SPA    SAUN;    //=0    Memory area unknown
    SPA    SAI;    //=1    Memory area INPUT
    SPA    SAO;    //=2    Memory area OUTPUT
    SPA    SAM;    //=3    Memory area BIT MEMORY
    SPA    SADB;    //=4    Memory area DATA BLOCK
    SPA    SADI;    //=5    Memory area INSTANCE DATA BLOCK
    SPA    SAT;    //=6    Memory area TEMPORARY
    SPA    SAV;    //=7    Memory area PREVIOUS TEMPORARY

SAUN: SPA EUN;
//Input
SAI:    L bytesNoTpIt; L 4; <>I; SPB SD1;
  L ED[AR1,P#0.0]; T LD[AR2,P#0.0]; SPA SSRD;
  SD1:L bytesNoTpIt; L 2; <>I; SPB SW1;
  L EW[AR1,P#0.0]; T LW[AR2,P#0.0]; SPA SSRD;
  SW1:L bytesNoTpIt; L 1; <>I; SPB SB1;
  L EB[AR1,P#0.0]; T LB[AR2,P#0.0]; SPA SSRD;
  SB1:L boolNoTpIt; L 0; ==I; SPB ESA;
  U E[AR1,P#0.0]; = L[AR2,P#0.0]; SPA SSRD;
//Output
SAO:    L bytesNoTpIt; L 4; <>I; SPB SD2;
  L AD[AR1,P#0.0]; T LD[AR2,P#0.0]; SPA SSRD;
  SD2:L bytesNoTpIt; L 2; <>I; SPB SW2;
  L AW[AR1,P#0.0]; T LW[AR2,P#0.0]; SPA SSRD;
  SW2:L bytesNoTpIt; L 1; <>I; SPB SB2;
  L AB[AR1,P#0.0]; T LB[AR2,P#0.0]; SPA SSRD;
  SB2:L boolNoTpIt; L 0; ==I; SPB ESA;
  U A[AR1,P#0.0]; = L[AR2,P#0.0]; SPA SSRD;
//Memory
SAM:    L bytesNoTpIt; L 4; <>I; SPB SD3;
  L MD[AR1,P#0.0]; T LD[AR2,P#0.0]; SPA SSRD;
  SD3:L bytesNoTpIt; L 2; <>I; SPB SW3;
  L MW[AR1,P#0.0]; T LW[AR2,P#0.0]; SPA SSRD;
  SW3:L bytesNoTpIt; L 1; <>I; SPB SB3;
  L MB[AR1,P#0.0]; T LB[AR2,P#0.0]; SPA SSRD;
  SB3:L boolNoTpIt; L 0; ==I; SPB ESA;
  U M[AR1,P#0.0]; = L[AR2,P#0.0]; SPA SSRD;
//Data Block
SADB:   AUF DB[areaDBNOTpWo];
  L bytesNoTpIt; L 4; <>I; SPB SD4;
  L DBD[AR1,P#0.0]; T LD[AR2,P#0.0]; SPA SSRD;
  SD4:L bytesNoTpIt; L 2; <>I; SPB SW4;
  L DBW[AR1,P#0.0]; T LW[AR2,P#0.0]; SPA SSRD;
  SW4:L bytesNoTpIt; L 1; <>I; SPB SB4;
  L DBB[AR1,P#0.0]; T LB[AR2,P#0.0]; SPA SSRD;
  SB4:L boolNoTpIt; L 0; ==I; SPB ESA;
  U DBX[AR1,P#0.0]; = L[AR2,P#0.0]; SPA SSRD;
//Instance Data Block
SADI:   AUF DI[areaDBNOTpWo];
  L bytesNoTpIt; L 4; <>I; SPB SD5;
  L DID[AR1,P#0.0]; T LD[AR2,P#0.0]; SPA SSRD;
  SD5:L bytesNoTpIt; L 2; <>I; SPB SW5;
  L DIW[AR1,P#0.0]; T LW[AR2,P#0.0]; SPA SSRD;
  SW5:L bytesNoTpIt; L 1; <>I; SPB SB5;
  L DIB[AR1,P#0.0]; T LB[AR2,P#0.0]; SPA SSRD;
  SB5:L boolNoTpIt; L 0; ==I; SPB ESA;
  U DIX[AR1,P#0.0]; = L[AR2,P#0.0]; SPA SSRD;
######################################
######################################
TEMPORANEE DELLA FUNZIONE (NON CI SONO PROBLEMI AD ACCEDERLE)
######################################
######################################
//Temporary
SAT:    L bytesNoTpIt; L 4; <>I; SPB SD6;
  L LD[AR1,P#0.0]; T LD[AR2,P#0.0]; SPA SSRD;
  SD6:L bytesNoTpIt; L 2; <>I; SPB SW6;
  L LW[AR1,P#0.0]; T LW[AR2,P#0.0]; SPA SSRD;
  SW6:L bytesNoTpIt; L 1; <>I; SPB SB6;
  L LB[AR1,P#0.0]; T LB[AR2,P#0.0]; SPA SSRD;
  SB6:L boolNoTpIt; L 0; ==I; SPB ESA;
  U L[AR1,P#0.0]; = L[AR2,P#0.0]; SPA SSRD;
######################################
######################################
TEMPORANEE DELLA FUNZIONE PRECEDENTE (COME SI ACCEDONO???)
######################################
######################################
//Previous Temporary
SAV: SPA ETE;
SSRD: NOP 0;

[Federico Milan]

Ciao, piuttostoc he utilizzare i dati precedenti, seppur il metodo è più lento, passali direttamente alla FC. Se i dati come presumo, sono molti, utilizza un apogggio tipo DB ...

Così sei sicuro di limitare gli errori ...

ciao

[GDA]

Ma sapete se è possibile accedere ai dati precedenti in qualche modo? Essendo questo blocco una funzione standard, preferirei non costringere l'utilizzatore ad appoggiare i dati su altri ingressi...

[JohnMcClane]

... e usare un fb?

[GDA]

Non credo possa cambiare tanto con un'FB, visto che comunque prevedevo di utilizzare un ingresso di tipo ANY, e quindi che sia FB o FC non cambia molto credo..

[LaRocca]

Perche non fai un generatore di Puntero ANY, nel manuale di sistema S7 ce un essempio, io ho fatto uno molto meglio ancora, ti posso dare una idea.

      L     P##POINTER_ANY  // Puntero ANY IN/OUT
      LAR1                              // DIR INICIAL PUNTERO ANY FUENTE EN AR1
      L     'B'                         //COMPRUEBA SI DATOS TIPO BYTE
      L     #TIPO_B_W
      <>I   
      U(    
      L     'b'
      <>I   
      )     
      SPB   UPS1
      L     W#16#1002                   //CARGA IDENTS7,TIPO BYTE
      T     W [AR1,P#0.0]
      L     #LONGITUD                   ORIGEN
      T     W [AR1,P#2.0]
      L     #DB_ORG
      T     W [AR1,P#4.0]               //NR DB ORIGEN EN APUNTADOR
      L     0                           //AREA ORIGEN ES M,E,A?
      >I    
      T     W [AR1,P#4.0]               //NR DB ORIGEN EN CERO


puoi continuare tu.. ma la idea iniziale cé   :blink: 

una vista generale piu meno forsi cosi;

      CALL  "GENERATOREANY"                   
       DB_ORG      :=              //ORIGINE
       BYTEWORD_ORG:=              //Data W or B_INI
       LONGITUD    :=              //LONG
       TIPO_B_W    :='W'
       RET_VAL     :=#RESULTADOINT_1
       POINTER_ANY :=#Pointer_Fatto

[GDA]

Grazie del suggerimento.. ma non capisco come potrei implementarlo per risolvere il mio problema.. Io dispongo già del puntatore ANY, e l'ho già scomposto nei suoi elementi, vorrei riuscire a leggere i dati tramite ad esempio un'istruzione "L", nel caso mi mettano una temporanea nel mio ingresso di tipo ANY. Ad es se nella chiamata alla mia funzione nel mio ingresso mi viene passata "LW1", come posso risalire al contenuto di LW1 della funzione chiamante dalla funzione chiamata? (Qundi dal puntatore ANY che contiene l'indirizzo all'area V)