Discussion :

[Nicodu2929]

Bonjour à tous,
Actuellement en stage en automatisme, j'utilise SCADA Basic avec PC vue 2009. Je rencontre quelques difficultés car je ne connais pas encore toutes les fonctions déjà éxistante et j'apprends peu à peu à coder (non sans quelques lacunes mais avec motivation).
Le but de la manoeuvre est de parcourir un fichier varex ligne apres ligne, d'identifier la où il y a le caractère A puis de stocker celui ci et ce qui vient avant le A dans la ligne dans un tableau. J'arrive à ouvrir le fichier, à parcourir les lignes puis à fermer le fichier. En revanche, je ne vois pas du tout comment faire pour sortir le caractère et ce qui vient avant. Et comment faire pour le stocker. Ce n'est pas de la mauvaise volonté, croyez moi mais je nage depuis ce matin sur cette quesion... En esperant que vous puissiez m'aider, je vous remercie par avance.

Voici le début de mon code:

SUB MAIN()

DIM intResult as integer;

DIM intEOF as integer;

DIM StrAccess as Str;

DIM StrFilename as Str;

DIM StrLine as Str;

DIM str1 as Str;

DIM nbr as integer;

DIM sortir as integer;

DIM Intval as integer;


@ESI.PRE.POCEDURE.CPT = @ESI.PRE.POCEDURE.CPT + 1 ;
print("On est bien dedans");

StrFilename = "C:\\STAGIAIRE_NICOLAS.txt"; 'nom du fichier a ouvrir
'For a full path put "\\" instead of "\" => "C:\\SV\\test.txt" '


StrAccess = "r"; 'ouvre en mode lecture

intResult = FOPEN(StrFilename , StrAccess); ' ouvre le fichier

IF (intResult ==1) THEN

PRINT("Opening of file ", StrFilename," succeeded");

END IF

'***************************************************************************************************************

' Il faut lire ligne apres ligne, en commencant par le bout de la ligne et remonter
' de virgule en virgule si jamais on est sur une ligne qui nous interresse

'***************************************************************************************************************

'StrVal = FGETS(Filename, Num); Lit une chaîne de caractères dans un fichier.

'IntVal = FEOF(Filename); Détermine si la fin de fichier a été atteinte.

'LongVal = FWRITE(Filename, Handle, Size, N); Ecrit un nombre n de données de même type dans un fichier à partir de données stockées
'dans un buffer précédemment alloué par ALLOC_BUFFER.

'IntVal = FSEEK(Filename, Offset, Origin); Déplace le pointeur d'un fichier vers une nouvelle position.
'Type de retour : INTEGER

'LongVal = ALLOC_BUFFER(N); Alloue une zone mémoire de n octets.


'**************************************************************************************************************

WHILE(FEOF(StrFilename ) == 0)

L = FGETS(StrFilename ,100);
PRINT(L);

WEND


'************************************************************************************************************

'intResult = FCLOSE(StrFilename); 'fermeture du fichier

IF (intResult ==1) THEN

PRINT("Closure of file ", StrFilename," succeeded");

END IF

END SUB

[belsion]

Bonjour,

Pour la lecture de fichier je n'utilise pas les fonctions FOPEN & Co, mais plutôt les buffers.

Tu commences par mettre le fichier dans un buffer avec FILETOBUFF, puis tu lis le fichier ligne par ligne avec SEQ_BUFFER en utilisant le mode "NEXT_FIELD" et "\n" comme séparateur de champs.
Le truc, c'est d'utiliser un autre buffer pour stocker la ligne (que tu alloues au début de la fonction avec ALLOC_BUFFER) et l'analyser soit de nouveau avec SEQ_BUFFER, soit avec ASCIIFIELD.

Et tu finis en libérant les buffers avec FREE_BUFFER.

Voilà un exemple qui vient de l'aide de PcVue

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
DIM Hdl As Long; ' Contains the string to process
DIM Hdl2 As Long; ' Contains the current line
DIM Hdl3 As Long; ' Contains the current value

SUB Main ()
  hdl = 0;
  hdl2 = 0;
  hdl3 = 0;
END SUB  

SUB ReadFields()
  DIM i As Integer;
  DIM j As Integer;
  DIM p As Str;
  DIM sep As Str;
  DIM sep2 As Str;

  If ( hdl == 0 ) Then
    hdl = ALLOC_BUFFER ( 16000 );
  End If

  sep = "\n";
  sep2 = ",";
  
  If ( hdl2 == 0 ) Then
    hdl2 = ALLOC_BUFFER ( 1000 );
  End If

  If ( hdl3 == 0 ) Then
    hdl3 = ALLOC_BUFFER ( 1000 );
  End If

  SEQ_BUFFER ( "BEGIN" , hdl ); ' Start position
  i = 1;

  While ( i != 0) ' Read the lines
    i = SEQ_BUFFER ( "NEXTFIELD" , hdl , sep , hdl2, 1000);

    If ( i == 0 ) Then
      Break;
    End If

    j = SEQ_BUFFER ( "BEGIN" , hdl2 );
    j = 1;

    While ( j != 0)
      j = SEQ_BUFFER ( "NEXTFIELD" , hdl2 , sep2 , hdl3 , 1000 );
      p = CGET_BUFFER ( hdl3 , 0 , 255 );
      PRINT ( p ) ;
    Wend
  Wend
END SUB

[Nicodu2929]

Je te remercie belsion, je vais travailler ce matin la dessus! Bonne journée

[Nicodu2929]

J'ai toujours de grosses difficultés à réaliser mon projet... J'arrive a lire les lignes de mon fichiers, que je stocke dans un buffer pour traitement de la ligne. ET, c'est la que je bloque! En effet, j'ai de grosses lacunes à utiliser les fonctions de SACADA BASICS (je n'arrive pas à me servire de SEQ_BUFFER, soit avec ASCIIFIELD). Dans l'idée, je récupère des lignes comme celle-ci:

CMD;157589;J_FI;W_ESI;T410;A410_1;F_OFF;SECU;LED;FAULT;;;;LED;;J_FI;TKJ90;;;;E;0;0;0;0;0;1;0;0;0;0;FI_LSERV1;FI_LCLIE1;1;PCJ0

Le but de mon programme est d'identifier dans chaque ligne une consigne de forçage tel que F_OFF ou F_ON (s'il y en a une). Une fois identifié cette commande, il faut que je récupère les 3 champs entre ; avant cette commande de forçage. Ainsi dans la ligne au dessus, il faudrait que je récupère W_ESI;T410;A410_1;F_OFF et que je stock tout ça dans un tableau. La encore je me représente mal la représentation et le stockage dans un tableau. Il y a quelques 192 000 lignes à traiter et parmi elles, environ 4000 items qui nous intéressent et qui sont à mettre dans le tableau. J'espère avoir été le plus clair possible. J'essaye de me former à Scada Basics et j'aimerai de l'aide pour réaliser mon code et mieu comprendre ce que je fais. En espérant que quelqu'un pourra m'aider...

[maxpeigne]

Réponse un peu tardive, mais si cela peut aider...

Je réalise un projet similaire au tiens.
Je viens lire différents paramètres d'un fichier texte (chacun séparé d'un point virgule), sur différentes lignes (chacune finies par un #). Pour vérifier l'intégrité du fichier texte, celui ci se termine par un $.
Le but est de récupérer dans un automate chacune des lignes du fichier (envoyées une par une, on attend l'autorisation de l'automate pour renvoyer la suivante).

Je stocke donc l'intégralité de mon fichier texte dans un tableau, puis j'envoie a l'automate la ligne que celui ci me demande.

Voici le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
'**********************************************************************
'* 																	  *
'* 					Lecture du fichier des series			 		  *
'* 																	  *
'**********************************************************************
'-------------------------------------------------------------------------------------------------------------------------------

'lecture_serie()	-------- Fonction principale
'ouverture_fichier()	---- Gestion de l'ouverture du fichier
'verif()	---------------- Verification de l'integrité du fichier texte
'destruction_fichier()	---- Suppression du fichier texte

'-------------------------------------------------------------------------------------------------------------------------------
	
'********************************************************
'*														*
'*				FONCTIONS	PRINCIPALES					*
'*					LECTURE_SERIE						*		
'*														*
'********************************************************


sub lecture_serie()

' ------------------- DECLARATIONS -------------------

	'Variables de travail de recupération de données
	dim iPointvirgule as Integer;
	dim sTampon as str;
	dim sPv as str;
		
	'Variables necessaires aux boucles
	
	dim sTableau[40][40] as str;
	dim iIndex as integer;
	dim iIndexss as integer;
	dim sFindeligne as str;
	dim iFdl as integer;
	dim iIndex_ligne as integer;
	
	'Variables de test
	dim iResultfeof as integer;
	dim iResultatverification as integer;
	
' ------------------- PROGRAMME -------------------	
	'Ouverture du fichier
	ouverture_fichier();
	
	'Initialisation
	iIndex=0;
	sPv=";";
	sTampon="0";
	iIndexss=0;
	sFindeligne="#";
	iFdl=1;
	iResultfeof=0;
	
	' Verification de l'integrite du fichier
	iResultatverification=verif();
	
	if (iResultatverification==0) then
		Print(" Presence du dollar!");
		'-----Boucle incrementant les series
		FSEEK("t:\\series\\serie.txt", 0,0);
		Print(" Debut de l'acquisition des lignes...");	
		WHILE (iResultfeof==0)
			iFdl=1;
			iIndexss=0;	
			'-----Boucle incrémentant les sous series
			While (iFdl!=0 && iResultfeof==0)		
				'-----Boucle incrémentant les champs d'une sous serie
				iPointvirgule=1;
				sTampon="0";
				WHILE (iPointvirgule!=0 && iFdl!=0 && iResultfeof==0)				
					if (iFdl!=0) then
					sTableau[iIndex][iIndexss]=ADDSTRING(sTableau[iIndex][iIndexss],sTampon);
					end if
					sTampon=FGETC("t:\\series\\serie.txt");				
					iResultfeof=FEOF("t:\\series\\serie.txt");	'Test de fin fichier
					iPointvirgule = CmpString(sTampon, sPv);
					iFdl = CmpString(sTampon, sFindeligne);	
				WEND		
				iIndexss=iIndexss+1;				
			WEND
		iIndex=iIndex+1;		
		iResultfeof=FEOF("t:\\series\\serie.txt");	
		WEND
		Print(" Acquisition des lignes terminees!");	
	else	
		Print("! ! ! PAS DE DOLLAR, fichier non termine ! ! !");	
	end if
	
	'Envoi du nombre de ligne a l'automate
	UF.PROG.TAMPON.NBRE_DE_LIGNE=sval(toc(iIndex));
	
	' Envoi de la ligne demandée a l'automate	
	iIndex_ligne=toi(UF.PROG.TAMPON.INDEX);
	
	print("Envoi vers l'automate de la ligne Numero: ",iIndex_ligne," ...");
	'Serie 
	'test sur jour
	print("Ancienne valeur de la variable jour: ",UF.PROG.TAMPON.JOUR);
	Print("(avant)Tableau jour ", sTableau[iIndex_ligne][0]);
	UF.PROG.TAMPON.JOUR=SVAL(sTableau[iIndex_ligne][0]);
	Print("(apres)Tableau jour ", sTableau[iIndex_ligne][0]);
	print("Nouvelle valeur de la variable jour: ",UF.PROG.TAMPON.JOUR);
	'fin du test
	
	UF.PROG.TAMPON.SERIE=SVAL(sTableau[iIndex_ligne][1]);
	Print("Tableau serie ", sTableau[iIndex_ligne][1]);
	print("Nouvelle valeur de la variable serie: ",UF.PROG.TAMPON.SERIE);
	UF.PROG.TAMPON.SOUS_SERIE=SVAL(sTableau[iIndex_ligne][2]);
	UF.PROG.TAMPON.NATURE=SVAL(sTableau[iIndex_ligne][3]);
	UF.PROG.TAMPON.COULEUR=SVAL(sTableau[iIndex_ligne][4]);
	UF.PROG.TAMPON.GRAMMAGE_GCS=SVAL(sTableau[iIndex_ligne][5]);
	UF.PROG.TAMPON.GRAMMAGE_GCI=SVAL(sTableau[iIndex_ligne][6]);
	UF.PROG.TAMPON.GRAMMAGE_RI=SVAL(sTableau[iIndex_ligne][7]);
	UF.PROG.TAMPON.GRAMMAGE_RS=SVAL(sTableau[iIndex_ligne][8]);
	UF.PROG.TAMPON.CSG_COUPEUR_INF=SVAL(sTableau[iIndex_ligne][9]);
	UF.PROG.TAMPON.CSG_COUPEUR_SUP=SVAL(sTableau[iIndex_ligne][10]);
	UF.PROG.TAMPON.VANNE_RESINE_INF=SVAL(sTableau[iIndex_ligne][11]);
	UF.PROG.TAMPON.VANNE_RESINE_SUP=SVAL(sTableau[iIndex_ligne][12]);
	UF.PROG.TAMPON.LARGEUR_MOULEE=SVAL(sTableau[iIndex_ligne][13]);
	UF.PROG.TAMPON.LARGEUR_FINIE=SVAL(sTableau[iIndex_ligne][14]);
	UF.PROG.TAMPON.LONGUEUR=SVAL(sTableau[iIndex_ligne][15]);
	UF.PROG.TAMPON.NBRE_PNX=SVAL(sTableau[iIndex_ligne][16]);

	print("Transfert vers l'automate terminee!");
	fclose("t:\\series\\serie.txt");

end sub

'********************************************************
'*														*
'*				FONCTIONS	COMPLEMENTAIRES				*		
'*														*
'********************************************************

' ----------------- Ouverture du fichier -----------------

sub ouverture_fichier()

	dim iResult_fopen as integer;
	
	iResult_fopen=0;
	print("Demande d'ouverture du fichier texte...");
	WHILE(iResult_fopen == 0)
		iResult_fopen=fopen("t:\\series\\serie.txt","r+");
		print("Tentative d'ouverture du fichier texte...");
	WEND
	print("Ouverture du fichier reussie!");	
	FSEEK("t:\\series\\serie.txt", 0,0);

end sub

' ----------------- Lecture de la clé de fin de programme -----------------

sub verif()

	dim sDollar	as str;
	dim iResult as integer;

	FSEEK("t:\\series\\serie.txt", -1,2);
	sDollar=fgetc("t:\\series\\serie.txt");
	iResult = CmpString(sDollar, "$");
	print("Resultat du test de la presence d'un $: ",iResult, " (0 si OK)");
	
	return iResult;
	
end sub

' ----------------- Suppression du fichier "Serie.txt" -----------------
sub destruction_fichier()

	IF (UNLINK("t:\\series\\serie.txt")==1) THEN

     PRINT ("Le fichier a ete supprime ! ! !");

	END IF

end sub

Tu peux peut etre t'en inspirer en ne stockant que les 10 dernieres variables dans un tableau, et lorsque tu détectes F_OFF ou F_ON, tu transferts tes 3 dernieres variables ou tu le souhaites.