Scorrimento Bit All'interno Di 1 Array

[bonibellid]

Buongiorno...

Ho creato una DB con all'interno un'arrey di 10000 elementi BOOL.

Vorrei far scorrere tutti i bit partendo dal primo a "destra" (verso il più significativo) di 1 con il fronte di salita di un'ingresso.

Le istruzioni che mette a disposizione SIEMENS sono solo di scorrimento a 16 e 32 Bit, ma non vedo un'istruzione paragonabile a SFT Register di OMRON (come esempio).

Dove posso trovare un'istruzione di questo tipo?

Oppure esiste un manuale con delle istruzioni sugli array?

Grazie mille per eventuali risposte.

[Livio Orsini]

Se i 10000 bit sono tutti adiacenti ppi usare incascata più istruzioni di scorrimento di 32 in 32.

Anche usare 2 puntatori sfalzati di un bit con un leggi e con l'altro scrivi, parti dalla locazione del bit più significativo -1 che leggi e scrivi alla locazione del più significativo, poi decrementi e ripeti il tutto con un loop.

[bonibellid]

Si i bit sono tutti consecutivi....

Questo lo dovrei fare in SCL, dove posso mettere una variabile al posto dell'indice array...

Mi sembra che in AWL non si possa fare, dico bene?

Grazie per la risposta.

Modificato: 23 febbraio 2015 da bonibellid

[ken]

così diretto no.

Ci sono poi molti metodi per farlo. Leggi quello che ti hanno già proposto.

[bonibellid]

Utilizzando i puntatori Any sono riuscito a fare quello che volevo.

Per ordinare un po' il codice avrei bisogno di un'informazione.

Volevo creare Un FC in AWL che mi compone il puntatore ANY con 4 parametri di ingresso, 1 Variabile Interna Tipo Any Chiamata "INDEX" e 1 parametro in uscita tipo Any Chiamata "INDEX_OUT".

Per comporre la variabile Any ho utilizzato gli indirizzi assoluti della variabile interna "INDEX", ora come faccio a trasferire il codice "INDEX" dentro al codice "INDEX_OUT"?

Non posso utilizzare le istruzioni Load And Transfer, devo forse utilizzare AR1 e AR2?

Grazie.

[ken]

leggi quella discussione.

[batta]

Non è vero che non esiste una funzione per shiftare un numero a piacere di bit, solo che non è facile sapere dove cercarla.

Si tratta di FC92 "SHRB" che si trova in Standard Lybrary --> TI-S7 Converting Blocks --> Blocks.

Non mi sento però di consigliarne l'uso per uno shift così lungo, perché significa elaborare 10 mila volte lo spostamento di un bit, con istruzioni su puntatori.

Il richiamo di questa funzione rischia di allungare a dismisura il tempo di scansione.

Se a qualcuno interessa, ho scritto una funzione dove anziché fare lo spostamento bit per bit, utilizzo lo shift di una doppia word.

In questo modo, il loop per 10000 bit non è più di 10000 cicli ma di 313.

Unica limitazione, è che l'area di bit da shiftare deve essere un multiplo di 32 (313 * 32 = 10016, in questo caso).

La funzione non effettua controlli sulla validità dei parametri. Per esempio, richiamare la funzione con zero come numero di word causerebbe lo stop della cpu.

Per generare la funzione, basta copiare il seguente codice in un file sorgente e compilarlo.

ATTENZIONE!!!

La compilazione crea FC105. Se nel progetto esiste già una FC105, questa verrà sovrascritta.

Mi farebbe piacere che non venisse cambiato il nome dell'autore.

FUNCTION FC 105 : VOID
TITLE =Shift a sinistra di un bit
AUTHOR : batta
VERSION : 0.1


VAR_INPUT
  Shift : BOOL ;	
  Reset : BOOL ;	
  Dato : BOOL ;	
  AdrStart : POINTER ;	
  NR_Dword : INT ;	
END_VAR
VAR_TEMP
  NrDB : INT ;	
  id : INT ;	
  New : BOOL ;	
  PrimoCicloFatto : BOOL ;	
END_VAR
BEGIN
NETWORK
TITLE =

      UN    #Shift; 
      UN    #Reset; 
      BEB   ; 

      L     P##AdrStart; // Carica indirizzo variabile pointer
      LAR1  ; // nel registro indirizzi AR1

      L     W [AR1,P#0.0]; // Estrai il numero del DB
      T     #NrDB; 
      AUF   DB [#NrDB]; // Apri il DB

      L     D [AR1,P#2.0]; // Estrai l'indirizzo, 
      LAR1  ; // e caricalo in AR1

      U     #Reset; 
      SPB   RST; 

NETWORK
TITLE =Loop per SHIFT

      CLR   ; 
      =     #PrimoCicloFatto; 

      L     #NR_Dword; 
NXTS: T     #id; 

      U     #PrimoCicloFatto; 
      SPB   M000; 
      S     #PrimoCicloFatto; 
      U     #Dato; // Se è il primo ciclo, imposta come nuovo dato
      =     #New; // lo stato del bit in ingresso alla funzione
M000: NOP   0; 

      L     D [AR1,P#0.0]; // Leggi DWord puntata da AR1
      TAD   ; // swap bytes per mettere il byte basso a destra
      SLD   1; // shift a sx di un bit
      TAD   ; // swap byte per ripristinare giusto ordine
      T     D [AR1,P#0.0]; 

      U     #New; 
      =      [AR1,P#0.0]; // Imposta valore del bit a destra

      SPP   UNO; // L'istruzione SLD scrive in A1 lo stato del bit uscito
      CLR   ; // N.B.: dopo SLD non ci devono essere altre istruzioni
      SPA   M001; // che influenzino i bit di stato A0 e A1
UNO:  SET   ; 
M001: =     #New; // Appoggio lo stato del uscito bit a variabile temporanea

//Incremnenta registro AR1 di una DWord
      +AR1  P#4.0; 

      L     #id; 
      LOOP  NXTS; 

      BEA   ; 


NETWORK
TITLE =Loop per RESET

RST:  L     #NR_Dword; 
NXTR: T     #id; 
      L     DW#16#0; 
      T     D [AR1,P#0.0]; 
      +AR1  P#4.0; 
      L     #id; 
      LOOP  NXTR; 

END_FUNCTION

[STEU]

prova a vedere se questo ti va bene puoi copiarti fb1 , db10 è il db di istanza e db1 è il db con l'array

DATA_BLOCK DB 1

TITLE =

VERSION : 0.1

STRUCT

bit : ARRAY [0 .. 999 ] OF //Variabile jolly provvisoria

BOOL := FALSE;

END_STRUCT ;

BEGIN

bit[0] := FALSE;

bit[1] := FALSE;

bit[2] := FALSE;

bit[3] := FALSE;

bit[4] := FALSE;

bit[5] := FALSE;

bit[6] := FALSE;

bit[7] := FALSE;

bit[8] := FALSE;

bit[9] := FALSE;

bit[10] := FALSE;

bit[11] := FALSE;

bit[12] := FALSE;

bit[13] := FALSE;

bit[14] := FALSE;

bit[15] := FALSE;

bit[16] := FALSE;

bit[17] := FALSE;

bit[18] := FALSE;

bit[19] := FALSE;

bit[20] := FALSE;

bit[21] := FALSE;

bit[22] := FALSE;

bit[23] := FALSE;

bit[24] := FALSE;

bit[25] := FALSE;

bit[26] := FALSE;

bit[27] := FALSE;

bit[28] := FALSE;

bit[29] := FALSE;

bit[30] := FALSE;

bit[31] := FALSE;

bit[32] := FALSE;

bit[33] := FALSE;

bit[34] := FALSE;

bit[35] := FALSE;

bit[36] := FALSE;

bit[37] := FALSE;

bit[38] := FALSE;

bit[39] := FALSE;

bit[40] := FALSE;

bit[41] := FALSE;

bit[42] := FALSE;

bit[43] := FALSE;

bit[44] := FALSE;

bit[45] := FALSE;

bit[46] := FALSE;

bit[47] := FALSE;

bit[48] := FALSE;

bit[49] := FALSE;

bit[50] := FALSE;

bit[51] := FALSE;

bit[52] := FALSE;

bit[53] := FALSE;

bit[54] := FALSE;

bit[55] := FALSE;

bit[56] := FALSE;

bit[57] := FALSE;

bit[58] := FALSE;

bit[59] := FALSE;

bit[60] := FALSE;

bit[61] := FALSE;

bit[62] := FALSE;

bit[63] := FALSE;

bit[64] := FALSE;

bit[65] := FALSE;

bit[66] := FALSE;

bit[67] := FALSE;

bit[68] := FALSE;

bit[69] := FALSE;

bit[70] := FALSE;

bit[71] := FALSE;

bit[72] := FALSE;

bit[73] := FALSE;

bit[74] := FALSE;

bit[75] := FALSE;

bit[76] := FALSE;

bit[77] := FALSE;

bit[78] := FALSE;

bit[79] := FALSE;

bit[80] := FALSE;

bit[81] := FALSE;

bit[82] := FALSE;

bit[83] := FALSE;

bit[84] := FALSE;

bit[85] := FALSE;

bit[86] := FALSE;

bit[87] := FALSE;

bit[88] := FALSE;

bit[89] := FALSE;

bit[90] := FALSE;

bit[91] := FALSE;

bit[92] := FALSE;

bit[93] := FALSE;

bit[94] := FALSE;

bit[95] := FALSE;

bit[96] := FALSE;

bit[97] := FALSE;

bit[98] := FALSE;

bit[99] := FALSE;

bit[100] := FALSE;

bit[101] := FALSE;

bit[102] := FALSE;

bit[103] := FALSE;

bit[104] := FALSE;

bit[105] := FALSE;

bit[106] := FALSE;

bit[107] := FALSE;

bit[108] := FALSE;

bit[109] := FALSE;

bit[110] := FALSE;

bit[111] := FALSE;

bit[112] := FALSE;

bit[113] := FALSE;

bit[114] := FALSE;

bit[115] := FALSE;

bit[116] := FALSE;

bit[117] := FALSE;

bit[118] := FALSE;

bit[119] := FALSE;

bit[120] := FALSE;

bit[121] := FALSE;

bit[122] := FALSE;

bit[123] := FALSE;

bit[124] := FALSE;

bit[125] := FALSE;

bit[126] := FALSE;

bit[127] := FALSE;

bit[128] := FALSE;

bit[129] := FALSE;

bit[130] := FALSE;

bit[131] := FALSE;

bit[132] := FALSE;

bit[133] := FALSE;

bit[134] := FALSE;

bit[135] := FALSE;

bit[136] := FALSE;

bit[137] := FALSE;

bit[138] := FALSE;

bit[139] := FALSE;

bit[140] := FALSE;

bit[141] := FALSE;

bit[142] := FALSE;

bit[143] := FALSE;

bit[144] := FALSE;

bit[145] := FALSE;

bit[146] := FALSE;

bit[147] := FALSE;

bit[148] := FALSE;

bit[149] := FALSE;

bit[150] := FALSE;

bit[151] := FALSE;

bit[152] := FALSE;

bit[153] := FALSE;

bit[154] := FALSE;

bit[155] := FALSE;

bit[156] := FALSE;

bit[157] := FALSE;

bit[158] := FALSE;

bit[159] := FALSE;

bit[160] := FALSE;

bit[161] := FALSE;

bit[162] := FALSE;

bit[163] := FALSE;

bit[164] := FALSE;

bit[165] := FALSE;

bit[166] := FALSE;

bit[167] := FALSE;

bit[168] := FALSE;

bit[169] := FALSE;

bit[170] := FALSE;

bit[171] := FALSE;

bit[172] := FALSE;

bit[173] := FALSE;

bit[174] := FALSE;

bit[175] := FALSE;

bit[176] := FALSE;

bit[177] := FALSE;

bit[178] := FALSE;

bit[179] := FALSE;

bit[180] := FALSE;

bit[181] := FALSE;

bit[182] := FALSE;

bit[183] := FALSE;

bit[184] := FALSE;

bit[185] := FALSE;

bit[186] := FALSE;

bit[187] := FALSE;

bit[188] := FALSE;

bit[189] := FALSE;

bit[190] := FALSE;

bit[191] := FALSE;

bit[192] := FALSE;

bit[193] := FALSE;

bit[194] := FALSE;

bit[195] := FALSE;

bit[196] := FALSE;

bit[197] := FALSE;

bit[198] := FALSE;

bit[199] := FALSE;

bit[200] := FALSE;

bit[201] := FALSE;

bit[202] := FALSE;

bit[203] := FALSE;

bit[204] := FALSE;

bit[205] := FALSE;

bit[206] := FALSE;

bit[207] := FALSE;

bit[208] := FALSE;

bit[209] := FALSE;

bit[210] := FALSE;

bit[211] := FALSE;

bit[212] := FALSE;

bit[213] := FALSE;

bit[214] := FALSE;

bit[215] := FALSE;

bit[216] := FALSE;

bit[217] := FALSE;

bit[218] := FALSE;

bit[219] := FALSE;

bit[220] := FALSE;

bit[221] := FALSE;

bit[222] := FALSE;

bit[223] := FALSE;

bit[224] := FALSE;

bit[225] := FALSE;

bit[226] := FALSE;

bit[227] := FALSE;

bit[228] := FALSE;

bit[229] := FALSE;

bit[230] := FALSE;

bit[231] := FALSE;

bit[232] := FALSE;

bit[233] := FALSE;

bit[234] := FALSE;

bit[235] := FALSE;

bit[236] := FALSE;

bit[237] := FALSE;

bit[238] := FALSE;

bit[239] := FALSE;

bit[240] := FALSE;

bit[241] := FALSE;

bit[242] := FALSE;

bit[243] := FALSE;

bit[244] := FALSE;

bit[245] := FALSE;

bit[246] := FALSE;

bit[247] := FALSE;

bit[248] := FALSE;

bit[249] := FALSE;

bit[250] := FALSE;

bit[251] := FALSE;

bit[252] := FALSE;

bit[253] := FALSE;

bit[254] := FALSE;

bit[255] := FALSE;

bit[256] := FALSE;

bit[257] := FALSE;

bit[258] := FALSE;

bit[259] := FALSE;

bit[260] := FALSE;

bit[261] := FALSE;

bit[262] := FALSE;

bit[263] := FALSE;

bit[264] := FALSE;

bit[265] := FALSE;

bit[266] := FALSE;

bit[267] := FALSE;

bit[268] := FALSE;

bit[269] := FALSE;

bit[270] := FALSE;

bit[271] := FALSE;

bit[272] := FALSE;

bit[273] := FALSE;

bit[274] := FALSE;

bit[275] := FALSE;

bit[276] := FALSE;

bit[277] := FALSE;

bit[278] := FALSE;

bit[279] := FALSE;

bit[280] := FALSE;

bit[281] := FALSE;

bit[282] := FALSE;

bit[283] := FALSE;

bit[284] := FALSE;

bit[285] := FALSE;

bit[286] := FALSE;

bit[287] := FALSE;

bit[288] := FALSE;

bit[289] := FALSE;

bit[290] := FALSE;

bit[291] := FALSE;

bit[292] := FALSE;

bit[293] := FALSE;

bit[294] := FALSE;

bit[295] := FALSE;

bit[296] := FALSE;

bit[297] := FALSE;

bit[298] := FALSE;

bit[299] := FALSE;

bit[300] := FALSE;

bit[301] := FALSE;

bit[302] := FALSE;

bit[303] := FALSE;

bit[304] := FALSE;

bit[305] := FALSE;

bit[306] := FALSE;

bit[307] := FALSE;

bit[308] := FALSE;

bit[309] := FALSE;

bit[310] := FALSE;

bit[311] := FALSE;

bit[312] := FALSE;

bit[313] := FALSE;

bit[314] := FALSE;

bit[315] := FALSE;

bit[316] := FALSE;

bit[317] := FALSE;

bit[318] := FALSE;

bit[319] := FALSE;

bit[320] := FALSE;

bit[321] := FALSE;

bit[322] := FALSE;

bit[323] := FALSE;

bit[324] := FALSE;

bit[325] := FALSE;

bit[326] := FALSE;

bit[327] := FALSE;

bit[328] := FALSE;

bit[329] := FALSE;

bit[330] := FALSE;

bit[331] := FALSE;

bit[332] := FALSE;

bit[333] := FALSE;

bit[334] := FALSE;

bit[335] := FALSE;

bit[336] := FALSE;

bit[337] := FALSE;

bit[338] := FALSE;

bit[339] := FALSE;

bit[340] := FALSE;

bit[341] := FALSE;

bit[342] := FALSE;

bit[343] := FALSE;

bit[344] := FALSE;

bit[345] := FALSE;

bit[346] := FALSE;

bit[347] := FALSE;

bit[348] := FALSE;

bit[349] := FALSE;

bit[350] := FALSE;

bit[351] := FALSE;

bit[352] := FALSE;

bit[353] := FALSE;

bit[354] := FALSE;

bit[355] := FALSE;

bit[356] := FALSE;

bit[357] := FALSE;

bit[358] := FALSE;

bit[359] := FALSE;

bit[360] := FALSE;

bit[361] := FALSE;

bit[362] := FALSE;

bit[363] := FALSE;

bit[364] := FALSE;

bit[365] := FALSE;

bit[366] := FALSE;

bit[367] := FALSE;

bit[368] := FALSE;

bit[369] := FALSE;

bit[370] := FALSE;

bit[371] := FALSE;

bit[372] := FALSE;

bit[373] := FALSE;

bit[374] := FALSE;

bit[375] := FALSE;

bit[376] := FALSE;

bit[377] := FALSE;

bit[378] := FALSE;

bit[379] := FALSE;

bit[380] := FALSE;

bit[381] := FALSE;

bit[382] := FALSE;

bit[383] := FALSE;

bit[384] := FALSE;

bit[385] := FALSE;

bit[386] := FALSE;

bit[387] := FALSE;

bit[388] := FALSE;

bit[389] := FALSE;

bit[390] := FALSE;

bit[391] := FALSE;

bit[392] := FALSE;

bit[393] := FALSE;

bit[394] := FALSE;

bit[395] := FALSE;

bit[396] := FALSE;

bit[397] := FALSE;

bit[398] := FALSE;

bit[399] := FALSE;

bit[400] := FALSE;

bit[401] := FALSE;

bit[402] := FALSE;

bit[403] := FALSE;

bit[404] := FALSE;

bit[405] := FALSE;

bit[406] := FALSE;

bit[407] := FALSE;

bit[408] := FALSE;

bit[409] := FALSE;

bit[410] := FALSE;

bit[411] := FALSE;

bit[412] := FALSE;

bit[413] := FALSE;

bit[414] := FALSE;

bit[415] := FALSE;

bit[416] := FALSE;

bit[417] := FALSE;

bit[418] := FALSE;

bit[419] := FALSE;

bit[420] := FALSE;

bit[421] := FALSE;

bit[422] := FALSE;

bit[423] := FALSE;

bit[424] := FALSE;

bit[425] := FALSE;

bit[426] := FALSE;

bit[427] := FALSE;

bit[428] := FALSE;

bit[429] := FALSE;

bit[430] := FALSE;

bit[431] := FALSE;

bit[432] := FALSE;

bit[433] := FALSE;

bit[434] := FALSE;

bit[435] := FALSE;

bit[436] := FALSE;

bit[437] := FALSE;

bit[438] := FALSE;

bit[439] := FALSE;

bit[440] := FALSE;

bit[441] := FALSE;

bit[442] := FALSE;

bit[443] := FALSE;

bit[444] := FALSE;

bit[445] := FALSE;

bit[446] := FALSE;

bit[447] := FALSE;

bit[448] := FALSE;

bit[449] := FALSE;

bit[450] := FALSE;

bit[451] := FALSE;

bit[452] := FALSE;

bit[453] := FALSE;

bit[454] := FALSE;

bit[455] := FALSE;

bit[456] := FALSE;

bit[457] := FALSE;

bit[458] := FALSE;

bit[459] := FALSE;

bit[460] := FALSE;

bit[461] := FALSE;

bit[462] := FALSE;

bit[463] := FALSE;

bit[464] := FALSE;

bit[465] := FALSE;

bit[466] := FALSE;

bit[467] := FALSE;

bit[468] := FALSE;

bit[469] := FALSE;

bit[470] := FALSE;

bit[471] := FALSE;

bit[472] := FALSE;

bit[473] := FALSE;

bit[474] := FALSE;

bit[475] := FALSE;

bit[476] := FALSE;

bit[477] := FALSE;

bit[478] := FALSE;

bit[479] := FALSE;

bit[480] := FALSE;

bit[481] := FALSE;

bit[482] := FALSE;

bit[483] := FALSE;

bit[484] := FALSE;

bit[485] := FALSE;

bit[486] := FALSE;

bit[487] := FALSE;

bit[488] := FALSE;

bit[489] := FALSE;

bit[490] := FALSE;

bit[491] := FALSE;

bit[492] := FALSE;

bit[493] := FALSE;

bit[494] := FALSE;

bit[495] := FALSE;

bit[496] := FALSE;

bit[497] := FALSE;

bit[498] := FALSE;

bit[499] := FALSE;

bit[500] := FALSE;

bit[501] := FALSE;

bit[502] := FALSE;

bit[503] := FALSE;

bit[504] := FALSE;

bit[505] := FALSE;

bit[506] := FALSE;

bit[507] := FALSE;

bit[508] := FALSE;

bit[509] := FALSE;

bit[510] := FALSE;

bit[511] := FALSE;

bit[512] := FALSE;

bit[513] := FALSE;

bit[514] := FALSE;

bit[515] := FALSE;

bit[516] := FALSE;

bit[517] := FALSE;

bit[518] := FALSE;

bit[519] := FALSE;

bit[520] := FALSE;

bit[521] := FALSE;

bit[522] := FALSE;

bit[523] := FALSE;

bit[524] := FALSE;

bit[525] := FALSE;

bit[526] := FALSE;

bit[527] := FALSE;

bit[528] := FALSE;

bit[529] := FALSE;

bit[530] := FALSE;

bit[531] := FALSE;

bit[532] := FALSE;

bit[533] := FALSE;

bit[534] := FALSE;

bit[535] := FALSE;

bit[536] := FALSE;

bit[537] := FALSE;

bit[538] := FALSE;

bit[539] := FALSE;

bit[540] := FALSE;

bit[541] := FALSE;

bit[542] := FALSE;

bit[543] := FALSE;

bit[544] := FALSE;

bit[545] := FALSE;

bit[546] := FALSE;

bit[547] := FALSE;

bit[548] := FALSE;

bit[549] := FALSE;

bit[550] := FALSE;

bit[551] := FALSE;

bit[552] := FALSE;

bit[553] := FALSE;

bit[554] := FALSE;

bit[555] := FALSE;

bit[556] := FALSE;

bit[557] := FALSE;

bit[558] := FALSE;

bit[559] := FALSE;

bit[560] := FALSE;

bit[561] := FALSE;

bit[562] := FALSE;

bit[563] := FALSE;

bit[564] := FALSE;

bit[565] := FALSE;

bit[566] := FALSE;

bit[567] := FALSE;

bit[568] := FALSE;

bit[569] := FALSE;

bit[570] := FALSE;

bit[571] := FALSE;

bit[572] := FALSE;

bit[573] := FALSE;

bit[574] := FALSE;

bit[575] := FALSE;

bit[576] := FALSE;

bit[577] := FALSE;

bit[578] := FALSE;

bit[579] := FALSE;

bit[580] := FALSE;

bit[581] := FALSE;

bit[582] := FALSE;

bit[583] := FALSE;

bit[584] := FALSE;

bit[585] := FALSE;

bit[586] := FALSE;

bit[587] := FALSE;

bit[588] := FALSE;

bit[589] := FALSE;

bit[590] := FALSE;

bit[591] := FALSE;

bit[592] := FALSE;

bit[593] := FALSE;

bit[594] := FALSE;

bit[595] := FALSE;

bit[596] := FALSE;

bit[597] := FALSE;

bit[598] := FALSE;

bit[599] := FALSE;

bit[600] := FALSE;

bit[601] := FALSE;

bit[602] := FALSE;

bit[603] := FALSE;

bit[604] := FALSE;

bit[605] := FALSE;

bit[606] := FALSE;

bit[607] := FALSE;

bit[608] := FALSE;

bit[609] := FALSE;

bit[610] := FALSE;

bit[611] := FALSE;

bit[612] := FALSE;

bit[613] := FALSE;

bit[614] := FALSE;

bit[615] := FALSE;

bit[616] := FALSE;

bit[617] := FALSE;

bit[618] := FALSE;

bit[619] := FALSE;

bit[620] := FALSE;

bit[621] := FALSE;

bit[622] := FALSE;

bit[623] := FALSE;

bit[624] := FALSE;

bit[625] := FALSE;

bit[626] := FALSE;

bit[627] := FALSE;

bit[628] := FALSE;

bit[629] := FALSE;

bit[630] := FALSE;

bit[631] := FALSE;

bit[632] := FALSE;

bit[633] := FALSE;

bit[634] := FALSE;

bit[635] := FALSE;

bit[636] := FALSE;

bit[637] := FALSE;

bit[638] := FALSE;

bit[639] := FALSE;

bit[640] := FALSE;

bit[641] := FALSE;

bit[642] := FALSE;

bit[643] := FALSE;

bit[644] := FALSE;

bit[645] := FALSE;

bit[646] := FALSE;

bit[647] := FALSE;

bit[648] := FALSE;

bit[649] := FALSE;

bit[650] := FALSE;

bit[651] := FALSE;

bit[652] := FALSE;

bit[653] := FALSE;

bit[654] := FALSE;

bit[655] := FALSE;

bit[656] := FALSE;

bit[657] := FALSE;

bit[658] := FALSE;

bit[659] := FALSE;

bit[660] := FALSE;

bit[661] := FALSE;

bit[662] := FALSE;

bit[663] := FALSE;

bit[664] := FALSE;

bit[665] := FALSE;

bit[666] := FALSE;

bit[667] := FALSE;

bit[668] := FALSE;

bit[669] := FALSE;

bit[670] := FALSE;

bit[671] := FALSE;

bit[672] := FALSE;

bit[673] := FALSE;

bit[674] := FALSE;

bit[675] := FALSE;

bit[676] := FALSE;

bit[677] := FALSE;

bit[678] := FALSE;

bit[679] := FALSE;

bit[680] := FALSE;

bit[681] := FALSE;

bit[682] := FALSE;

bit[683] := FALSE;

bit[684] := FALSE;

bit[685] := FALSE;

bit[686] := FALSE;

bit[687] := FALSE;

bit[688] := FALSE;

bit[689] := FALSE;

bit[690] := FALSE;

bit[691] := FALSE;

bit[692] := FALSE;

bit[693] := FALSE;

bit[694] := FALSE;

bit[695] := FALSE;

bit[696] := FALSE;

bit[697] := FALSE;

bit[698] := FALSE;

bit[699] := FALSE;

bit[700] := FALSE;

bit[701] := FALSE;

bit[702] := FALSE;

bit[703] := FALSE;

bit[704] := FALSE;

bit[705] := FALSE;

bit[706] := FALSE;

bit[707] := FALSE;

bit[708] := FALSE;

bit[709] := FALSE;

bit[710] := FALSE;

bit[711] := FALSE;

bit[712] := FALSE;

bit[713] := FALSE;

bit[714] := FALSE;

bit[715] := FALSE;

bit[716] := FALSE;

bit[717] := FALSE;

bit[718] := FALSE;

bit[719] := FALSE;

bit[720] := FALSE;

bit[721] := FALSE;

bit[722] := FALSE;

bit[723] := FALSE;

bit[724] := FALSE;

bit[725] := FALSE;

bit[726] := FALSE;

bit[727] := FALSE;

bit[728] := FALSE;

bit[729] := FALSE;

bit[730] := FALSE;

bit[731] := FALSE;

bit[732] := FALSE;

bit[733] := FALSE;

bit[734] := FALSE;

bit[735] := FALSE;

bit[736] := FALSE;

bit[737] := FALSE;

bit[738] := FALSE;

bit[739] := FALSE;

bit[740] := FALSE;

bit[741] := FALSE;

bit[742] := FALSE;

bit[743] := FALSE;

bit[744] := FALSE;

bit[745] := FALSE;

bit[746] := FALSE;

bit[747] := FALSE;

bit[748] := FALSE;

bit[749] := FALSE;

bit[750] := FALSE;

bit[751] := FALSE;

bit[752] := FALSE;

bit[753] := FALSE;

bit[754] := FALSE;

bit[755] := FALSE;

bit[756] := FALSE;

bit[757] := FALSE;

bit[758] := FALSE;

bit[759] := FALSE;

bit[760] := FALSE;

bit[761] := FALSE;

bit[762] := FALSE;

bit[763] := FALSE;

bit[764] := FALSE;

bit[765] := FALSE;

bit[766] := FALSE;

bit[767] := FALSE;

bit[768] := FALSE;

bit[769] := FALSE;

bit[770] := FALSE;

bit[771] := FALSE;

bit[772] := FALSE;

bit[773] := FALSE;

bit[774] := FALSE;

bit[775] := FALSE;

bit[776] := FALSE;

bit[777] := FALSE;

bit[778] := FALSE;

bit[779] := FALSE;

bit[780] := FALSE;

bit[781] := FALSE;

bit[782] := FALSE;

bit[783] := FALSE;

bit[784] := FALSE;

bit[785] := FALSE;

bit[786] := FALSE;

bit[787] := FALSE;

bit[788] := FALSE;

bit[789] := FALSE;

bit[790] := FALSE;

bit[791] := FALSE;

bit[792] := FALSE;

bit[793] := FALSE;

bit[794] := FALSE;

bit[795] := FALSE;

bit[796] := FALSE;

bit[797] := FALSE;

bit[798] := FALSE;

bit[799] := FALSE;

bit[800] := FALSE;

bit[801] := FALSE;

bit[802] := FALSE;

bit[803] := FALSE;

bit[804] := FALSE;

bit[805] := FALSE;

bit[806] := FALSE;

bit[807] := FALSE;

bit[808] := FALSE;

bit[809] := FALSE;

bit[810] := FALSE;

bit[811] := FALSE;

bit[812] := FALSE;

bit[813] := FALSE;

bit[814] := FALSE;

bit[815] := FALSE;

bit[816] := FALSE;

bit[817] := FALSE;

bit[818] := FALSE;

bit[819] := FALSE;

bit[820] := FALSE;

bit[821] := FALSE;

bit[822] := FALSE;

bit[823] := FALSE;

bit[824] := FALSE;

bit[825] := FALSE;

bit[826] := FALSE;

bit[827] := FALSE;

bit[828] := FALSE;

bit[829] := FALSE;

bit[830] := FALSE;

bit[831] := FALSE;

bit[832] := FALSE;

bit[833] := FALSE;

bit[834] := FALSE;

bit[835] := FALSE;

bit[836] := FALSE;

bit[837] := FALSE;

bit[838] := FALSE;

bit[839] := FALSE;

bit[840] := FALSE;

bit[841] := FALSE;

bit[842] := FALSE;

bit[843] := FALSE;

bit[844] := FALSE;

bit[845] := FALSE;

bit[846] := FALSE;

bit[847] := FALSE;

bit[848] := FALSE;

bit[849] := FALSE;

bit[850] := FALSE;

bit[851] := FALSE;

bit[852] := FALSE;

bit[853] := FALSE;

bit[854] := FALSE;

bit[855] := FALSE;

bit[856] := FALSE;

bit[857] := FALSE;

bit[858] := FALSE;

bit[859] := FALSE;

bit[860] := FALSE;

bit[861] := FALSE;

bit[862] := FALSE;

bit[863] := FALSE;

bit[864] := FALSE;

bit[865] := FALSE;

bit[866] := FALSE;

bit[867] := FALSE;

bit[868] := FALSE;

bit[869] := FALSE;

bit[870] := FALSE;

bit[871] := FALSE;

bit[872] := FALSE;

bit[873] := FALSE;

bit[874] := FALSE;

bit[875] := FALSE;

bit[876] := FALSE;

bit[877] := FALSE;

bit[878] := FALSE;

bit[879] := FALSE;

bit[880] := FALSE;

bit[881] := FALSE;

bit[882] := FALSE;

bit[883] := FALSE;

bit[884] := FALSE;

bit[885] := FALSE;

bit[886] := FALSE;

bit[887] := FALSE;

bit[888] := FALSE;

bit[889] := FALSE;

bit[890] := FALSE;

bit[891] := FALSE;

bit[892] := FALSE;

bit[893] := FALSE;

bit[894] := FALSE;

bit[895] := FALSE;

bit[896] := FALSE;

bit[897] := FALSE;

bit[898] := FALSE;

bit[899] := FALSE;

bit[900] := FALSE;

bit[901] := FALSE;

bit[902] := FALSE;

bit[903] := FALSE;

bit[904] := FALSE;

bit[905] := FALSE;

bit[906] := FALSE;

bit[907] := FALSE;

bit[908] := FALSE;

bit[909] := FALSE;

bit[910] := FALSE;

bit[911] := FALSE;

bit[912] := FALSE;

bit[913] := FALSE;

bit[914] := FALSE;

bit[915] := FALSE;

bit[916] := FALSE;

bit[917] := FALSE;

bit[918] := FALSE;

bit[919] := FALSE;

bit[920] := FALSE;

bit[921] := FALSE;

bit[922] := FALSE;

bit[923] := FALSE;

bit[924] := FALSE;

bit[925] := FALSE;

bit[926] := FALSE;

bit[927] := FALSE;

bit[928] := FALSE;

bit[929] := FALSE;

bit[930] := FALSE;

bit[931] := FALSE;

bit[932] := FALSE;

bit[933] := FALSE;

bit[934] := FALSE;

bit[935] := FALSE;

bit[936] := FALSE;

bit[937] := FALSE;

bit[938] := FALSE;

bit[939] := FALSE;

bit[940] := FALSE;

bit[941] := FALSE;

bit[942] := FALSE;

bit[943] := FALSE;

bit[944] := FALSE;

bit[945] := FALSE;

bit[946] := FALSE;

bit[947] := FALSE;

bit[948] := FALSE;

bit[949] := FALSE;

bit[950] := FALSE;

bit[951] := FALSE;

bit[952] := FALSE;

bit[953] := FALSE;

bit[954] := FALSE;

bit[955] := FALSE;

bit[956] := FALSE;

bit[957] := FALSE;

bit[958] := FALSE;

bit[959] := FALSE;

bit[960] := FALSE;

bit[961] := FALSE;

bit[962] := FALSE;

bit[963] := FALSE;

bit[964] := FALSE;

bit[965] := FALSE;

bit[966] := FALSE;

bit[967] := FALSE;

bit[968] := FALSE;

bit[969] := FALSE;

bit[970] := FALSE;

bit[971] := FALSE;

bit[972] := FALSE;

bit[973] := FALSE;

bit[974] := FALSE;

bit[975] := FALSE;

bit[976] := FALSE;

bit[977] := FALSE;

bit[978] := FALSE;

bit[979] := FALSE;

bit[980] := FALSE;

bit[981] := FALSE;

bit[982] := FALSE;

bit[983] := FALSE;

bit[984] := FALSE;

bit[985] := FALSE;

bit[986] := FALSE;

bit[987] := FALSE;

bit[988] := FALSE;

bit[989] := FALSE;

bit[990] := FALSE;

bit[991] := FALSE;

bit[992] := FALSE;

bit[993] := FALSE;

bit[994] := FALSE;

bit[995] := FALSE;

bit[996] := FALSE;

bit[997] := FALSE;

bit[998] := FALSE;

bit[999] := FALSE;

END_DATA_BLOCK

FUNCTION_BLOCK FB 1

TITLE =

VERSION : 0.1

VAR_INPUT

fronte : BOOL ;

END_VAR

VAR_IN_OUT

shift : ANY ;

END_VAR

VAR

. : BOOL ;

END_VAR

VAR_TEMP

db_n : INT ;

ripet : DINT ;

count : INT ;

END_VAR

BEGIN

NETWORK

TITLE =

U #fronte;

FP #.;

SPB ok;

BEA ;

ok: LAR1 P##shift;

L B [AR1,P#1.0];

L W [AR1,P#2.0];

T #ripet;

L W [AR1,P#4.0];

T #db_n;

AUF DB [#db_n];

L #ripet;

alg: T #count;

L #count;

L L#1;

-D ;

LAR1 ;

U DBX [AR1,P#0.0];

= DBX [AR1,P#0.1];

L #count;

LOOP alg;

END_FUNCTION_BLOCK

DATA_BLOCK DB 10

TITLE =

VERSION : 0.0

FB 1

BEGIN

fronte := FALSE;

. := FALSE;

END_DATA_BLOCK

ORGANIZATION_BLOCK OB 1

TITLE = "Main Program Sweep (Cycle)"

VERSION : 0.1

VAR_TEMP

OB1_EV_CLASS : BYTE ; //Bits 0-3 = 1 (Coming event), Bits 4-7 = 1 (Event class 1)

OB1_SCAN_1 : BYTE ; //1 (Cold restart scan 1 of OB 1), 3 (Scan 2-n of OB 1)

OB1_PRIORITY : BYTE ; //Priority of OB Execution

OB1_OB_NUMBR : BYTE ; //1 (Organization block 1, OB1)

OB1_RESERVED_1 : BYTE ; //Reserved for system

OB1_RESERVED_2 : BYTE ; //Reserved for system

OB1_PREV_CYCLE : INT ; //Cycle time of previous OB1 scan (milliseconds)

OB1_MIN_CYCLE : INT ; //Minimum cycle time of OB1 (milliseconds)

OB1_MAX_CYCLE : INT ; //Maximum cycle time of OB1 (milliseconds)

OB1_DATE_TIME : DATE_AND_TIME ; //Date and time OB1 started

END_VAR

BEGIN

NETWORK

TITLE =

CALL FB 1 , DB 10 (

fronte := M 0.0,

shift := P#DB1.DBX 0.0 BOOL 1000);

END_ORGANIZATION_BLOCK

[STEU]

      U     #fronte
      FP    #.
      SPB   ok
      BEA   

ok:   LAR1  P##shift
      L     W [AR1,P#2.0]
      T     #ripet
      L     W [AR1,P#4.0]
      T     #db_n

      AUF   DB [#db_n]

      L     #ripet
      L     L#1
      -I    

alg:  T     #count

      L     #count
      L     L#1
      -D    
      LAR1  

      U     DBX [AR1,P#0.0]
      =     DBX [AR1,P#0.1]
      L     #count
      LOOP  alg

Se vuoi essere preciso correggi il codice del fb1 così , non so perché ma non mi accetta h e l p e scrive .# alla seconda riga di codice

Modificato: 24 febbraio 2015 da STEU

[bonibellid]

Grazie per le risposte...

Scusa Ken ma nella discussione ho trovato come creare il puntatore Any o come scrivere del codice ma, non ho trovato come spostarlo nella variabile di uscita di un FC.

Quando creo una variabile temp mi viene generato un'indirizzo assoluto esempio 0.0, ma per le variabili di uscita questo mi manca,

Se la variabile di uscita è un BOOL uso "Assegnazione", se Byte/Word/Dword/Real Uso "L" e se la variabile è Any cosa uso?

Ciao.

[ken]

sfc20

[STEU]

Any non è una variabile , ma un puntatore la cui lunghezza è di 10 byte, in questi byte ci sono tutte le informazioni che ti servono, tipo di dato, fattore di ripetizione , indirizzo, andando a leggere i valori di questi byte hai tutte le informazioni che ti servono.

Ad esempio se osservi il codice che ho postato io per ultimo, (chiedo scusa per la lunghezza e per come è stato postato il primo codice) vedi che il fattore di ripetizione del puntatore è la word n. 2 mentre il numero di DB è la word 4.

Comunque se sull . in linea di step7 scrivi "Puntatori any" e avrai le idee più chiare.

per ultimo se provi il codice che ti ho scritto ho verificato ieri sera e funziona

[batta]

se provi il codice che ti ho scritto ho verificato ieri sera e funziona

Di questo sono convinto ma, come ho già scritto, il problema dell'operare in questo modo (coma fa anche la funzione di libreria Siemens) è che si effettua lo shift bit per bit.

Una decina di righe di codice per ogni bit e con un registro di 10 mila bit diventano 100 mila istruzioni.

Anche per una CPU veloce, 100 mila istruzioni sono pur sempre 100 mila istruzioni.

[STEU]

Si batta hai perfettamente ragione , ma credo che il problema si di carattere didattico e non un' applicazione reale. Altrimenti mi piacerebbe sapere che applicazione è e cosa dovrebbe fare un array di 10000 bit (inizialmente avevo visto 1000, che non sono comunque pochi).

Modificato: 27 febbraio 2015 da STEU

[Livio Orsini]

Si batta hai perfettamente ragione , ma credo che il problema si di carattere didattico e non un' applicazione reale

A maggior ragione, se è di tipo didattico è meglio imparare facendo le cose al meglio.

[batta]

Altrimenti mi piacerebbe sapere che applicazione è e cosa dovrebbe fare un array di 10000 bit

Su questo sono pienamente d'accordo.

forse, se c'è bisogno di un registro da 10000 bit, lo shift non è il metodo migliore per risolvere il problema.

Se consideriamo i tempi delle attuali CPU (per esempio, una 315-2EH14 elabora operazioni booleane in 0,05 microsecondi e operazioni a parola in circa 0,1 microsecondi), anche 100 mila operazioni potrebbero non essere un grosso problema, soprattutto se riduciamo il registro a una più realistica dimensione di 1000 bit al posto di 10000.

Per farmi un'idea (a puro scopo didattico, non certo per fare a gara), ho provato a fare lo shift di 10000 bit con il metodo bit per bit a confronto col metodo con shift a oppia word.

Non avendo una cpu a disposizione, ho usato il simulatore.

Non ho iea di quanto possa essere veritiero il tempo di ciclo con il simulatore, ma credo che il confronto possa comunque essere indicativo.

Risultato: in entrambi i casi, il tempo di elaborazione delle funzioni shift non era misurabile.

Allora ho messo il richiamo delle funzioni all'interno di un loop di 1000 cicli.

In questo modo, la differenza si nota: sfruttando lo shift a doppia word (313 cicli per 10016 bit) per elaborare 1000 volte la funzione rilevo un tempo di circa 12 ms, con lo shift bit per bit il tempo diventa di circa 390 ms.

Devo dire che il risultato va molto oltre quello che mi sarei aspettato, perché è vero che 390 è circa 32 volte 313, ma per fare lo shift a doppia word è richiesta qualche operazione in più per ogni ciclo.

Insomma, io mi sarei aspettato un rapporto di circa 1/20, e non 1/32.

Ripeto, non so quanto possa essere affidabile questo test fatto col simulatore.

Modificato: 27 febbraio 2015 da batta

[Livio Orsini]

la funzione rilevo un tempo di circa 12 ms, con lo shift bit per bit il tempo diventa di circa 390 ms.

32 *12 = 384. Significa che shiftare una parola da 32 bits si impiega praticamente il tempo necessario per shiftare un solo bit alla volta.

Non per niente nel mio primo messaggio, come prima ipotesi suggerivo di shiftare usando la doppia word.

Modificato: 28 febbraio 2015 da Livio Orsini

[bonibellid]

Buongiorno.

Nessuna didattica.

Devo ritrasmettere uno stato on/off generato nel punto di partenza dello shift a vari punto posti sullo shift, ad ogni trigger di shift corrisponde un'avanzamento del pezzo.

i 10000 bit sono dati dalla lunghezza del processo e dalla precisione che voglio ottenere, inoltre lo stato on/off può variare anche ogni trigger di shift.

Lo shift non può essere fatto a più scansioni perché viene generato all'interno di un task a interrupt OB40.

Non vedo molte altre soluzioni per fare ciò!

Utilizzando 2 SC20 e 20 righe di codice sono riuscito a far scorrere 10000 BYTE ma mi occupano un sacco di memoria inutile.

Se riuscissi come già detto a trasferire dentro un FC la variabile "Any Temp" dentro la variabile "Any Out" secondo me riesco a farlo anche a BIT.

Grazie.

Ah scusate... volevo inserire un'immagine con il codice ma non sono riuscito.

Quando mi si apre la PopUp dell'immagine mi si blocco il forum.

Saluti.

[STEU]

FUNCTION_BLOCK FB 1
TITLE =
VERSION : 0.1


VAR_INPUT
  fronte : BOOL ;	
END_VAR
VAR_IN_OUT
  shift : ANY ;	
END_VAR
VAR
  . : BOOL ;	
END_VAR
VAR_TEMP
  db_n : INT ;	
  ripet : DINT ;	
  count : INT ;	
END_VAR
BEGIN
NETWORK
TITLE =

      U     #fronte; 
      FP    #.; 
      SPB   ok; 
      BEA   ; 

ok:   LAR1  P##shift; 
      L     W [AR1,P#2.0]; 
      T     #ripet; 
      L     W [AR1,P#4.0]; 
      T     #db_n; 

      AUF   DB [#db_n]; 

      L     #ripet; 
      L     L#1; 
      -I    ; 

alg:  T     #count; 

      L     #count; 
      L     L#1; 
      -D    ; 
      LAR1  ; 

      U     DBX [AR1,P#0.0]; 
      =     DBX [AR1,P#0.1]; 
      L     #count; 
      LOOP  alg; 

END_FUNCTION_BLOCK

      CALL  FB     1 , DB10
       fronte:=M0.0
       shift :=P#DB1.DBX 0.0 BOOL 10000

Se ho capito bene il tuo problema , se hai bisogno di 10000 bit non devi usare 10000 byte,

Qui sopra c'è come fare chiamare un parametro any con un fb ed il sorgente per shiftare 10000 bit.

DB10 è il DB di istanza di fb1 e DB1 il DB dove avviene lo shift a partire dal bit DBX0.0.

Se hai problemi di memoria prendi in considerazione i merker, e ti conviene sicuramente utilizzare la soluzione di batta,

Comunque se vuoi avere un aiuto migliore dovresti fornire maggiori informazioni a partire dalla CPU che stai utilizzando.

Ricorda che ho chiamato una variabile H E L P che il non si visualizza che il forum automaticamente cambia in . (punto)

Modificato: 2 marzo 2015 da STEU

[dan64100]

Ciao,

tanto per parlarne, siamo quì apposta..

Devo ritrasmettere uno stato on/off generato nel punto di partenza dello shift a vari punto posti sullo shift, ad ogni trigger di shift corrisponde un'avanzamento del pezzo.

i 10000 bit sono dati dalla lunghezza del processo e dalla precisione che voglio ottenere, inoltre lo stato on/off può variare anche ogni trigger di shift.

Se non ho capito male, è solo l'uno logico che scorre nell'array e poi hai varie condizioni logiche "alimentate" dai singoli bit dell'array => dove c'è l'uno c'è il pezzo o il processo è stato incrementato di 1.

Non ti era più comodo incrementare un intero e mettere in serie (a monte) a ogni condizione un comparatore ?

Per saltare N operazioni (non so se è possibile nella tua architettura) devi effettuare N shift, con l'intero lo incrementi della costante che ti pare.

Ciao

[bonibellid]

Ciao.

Si se avessi avuto solo 1 stato da mantenere in ingresso per la lunghezza dei 10000 avrei fatto così.

ma la sequenza dello stato alterna in ingresso da off a on in modo random.

Per capire l'applicazione metto un esempio

1) 0

[Livio Orsini]

Tu hai scritto

Si i bit sono tutti consecutivi....

QUindi puoi benissimo suddeviderli in DW ed usare lo shift a sx di una DW.

Così facendo dovrai iterare il loop solo 313 volte invece che 10000

[dan64100]

1) 0 non è che mi illumini molto

Comunque credo di aver capito il tuo Array contiene una specie di PCM, quindi il numero degli "uno" è variabile e random.

Probabilmente lo "shiftone" è l'unica soluzione, e ti consiglio anch'io di lavorare per word.

Dev'essere un'applicazione interessante...

Ciao

[batta]

Lo shift non può essere fatto a più scansioni perché viene generato all'interno di un task a interrupt OB40.

Utilizzando 2 SC20 e 20 righe di codice sono riuscito a far scorrere 10000 BYTE ma mi occupano un sacco di memoria inutile

Tanto per cominciare, queste due affermazioni sono in contrasto tra loro.

SFC20 potrebbe infatti richiedere più di un ciclo per la completa esecuzione.

Pe essere sicuro che tutto venga fatto in un unico richiamo, devi usare SFC81 "UBLKMOV".

Ma questa soluzione, ti sei già accorto che ha dei limiti: l'indirizzo delle aree deve partire sempre dal bit zero, quindi non riesci a fare un registro di scorrimento di bit, ma devi usare i byte, con lo spreco che ne consegue.

Se riuscissi come già detto a trasferire dentro un FC la variabile "Any Temp" dentro la variabile "Any Out" secondo me riesco a farlo anche a BIT.

No, per quanto scritto sopra: alla SFC20 (o SFC81), non puoi passare un indirizzo DB10.DBX100.1. Devi sempre partire con un byte intero.

Però, quello che non capisco è che la soluzione ti è stata fornita. Puoi usare lo spostamento bit per bit di STEU, oppure sfruttare lo shift a doppia word che ho suggerito io.

Nella mia funzione, oltre allo shift dei bit, hai anche la possibilità di comandare l'azzeramento di tutto il registro e di stabilire se il bit che entra deve essere alto o basso.

L'indirizzo dell'area e la sua dimensione le passi alla funzione scrivendo l'indirizzo di partenza e il numero di DWord che compongono il registro (ma bastano poche modifiche se vuoi per forza passare il dato in formato ANY).

Oppure, se non ti fidi delle nostre funzioni, puoi usare lo shift che trovi nella libreria Siemens,

Perché ti ostini a non prendere in considerazione queste soluzioni?

Modificato: 2 marzo 2015 da batta

[bonibellid]

Scusa Batta...

Hai ragione, penso che mercoledì testerò le soluzione che mi sono state proposte.

Capiscimi faccio un po' fatica a copiare e incollare del codice, preferisco di solito ascoltare opinioni, valutare e arrivare a una conclusione per poi condividerla.

Il fatto che SFC20 non funzioni mi mancava, dai test che ho fatto lo shift lo eseguiva anche dentro a OB40 ma ho simulato a banco utilizzando un'interruttore, comunque andrò a leggere la differenza tra SFC20 e SFC81.

Grazie.