Forum automatisme

Bonjour a tous et meilleurs vœux
Je viens vers vous en ce début d'année car j'ai créé un petit programme pour enregistrer le poids d'une meule afin de l'enregistrer dans une BDD et de l'afficher a l’écran.
Le probleme c'est qu'a l’exécution d'une mesure, le programme rame avant de me donner un résultat dans la BDD; j'ai mis le programme dans la tache FAST mais je pense que je peux faire mieux et le laisser en MAST.
Voici le code en question (j'ai mis des commentaire

) :

Code : Tout sélectionner

(*Traitement du pesage des meules dans la BDD*)

IF BDD_poids.poids_mesure <= BDD_poids.Poids_a_vide AND En_auto (*Si aucune meule detecté, si la machine fonctionne, que la BDD n'est pas pleine*)
	THEN 	BDD_poids.Top_mesure := TRUE ; (*Alors, j'autorise la mesure*)
END_IF;

IF BDD_poids.index_nb_meule >= 1300
	THEN 	BDD_poids.BDD_poids_enregistrement[0] :=0;
		BDD_poids.index_nb_meule := 0;
END_IF;

IF  BDD_poids.poids_mesure > BDD_poids.Poids_a_vide AND (BDD_poids.poids_mesure < BDD_poids.Poids_coherent_min OR BDD_poids.poids_mesure > BDD_poids.Poids_coherent_max) OR BDD_poids.Poids_coherent_max = 0 OR BDD_poids.Poids_coherent_min = 0(*Si j'ai une mesure superieur au poids a vide et que la 
valeur n'est pas cohérente et que les variable de cohérence sont égale à 0*)
	THEN	BDD_poids.Discordance_mesure := TRUE; (*alors, j'active la variable de discordance*)
END_IF;

IF BDD_poids.Poids_a_vide >= BDD_poids.Poids_coherent_min
	THEN	BDD_poids.Poids_a_vide := BDD_poids.Poids_coherent_min - 0.1;
END_IF;

IF BDD_poids.poids_mesure > BDD_poids.Poids_a_vide AND BDD_poids.BDD_poids_enregistrement[BDD_poids.index_poids] = 0 AND BDD_poids.Top_mesure AND NOT BDD_poids.Discordance_mesure AND BDD_poids.Poids_stable
(*Si le poids mesuré est superieur au poids minimum attendu et si la valeur de la BDD correspondante est bien vide (a 0), que j'autorise une mesure, qu'il n'y a pas de defaut de discordence et que le poids est stable*)
	THEN 	BDD_poids.BDD_poids_enregistrement[BDD_poids.index_poids] := BDD_poids.poids_mesure; (*Alors, je mets le poids en cours dans la BDD*)
		BDD_poids.BDD_poids_enregistrement[BDD_poids.index_poids + 1] := 0;
		BDD_poids.Calcul_Nb_meule := TRUE; (*je demande un calcul du nombre de meule*)
		BDD_poids.Nb_meule_dans_BDD := 0; (*je mets a 0 le nombre de meule pour le recalcul*)
		BDD_poids.Top_mesure := FALSE; (*j'interdit une nouvelle mesure*)
		BDD_poids.index_poids := 0; (*Je remet l'index a 0*)

	ELSIF	BDD_poids.poids_mesure > BDD_poids.Poids_a_vide AND BDD_poids.BDD_poids_enregistrement[BDD_poids.index_poids] <> 0 AND BDD_poids.Top_mesure AND NOT BDD_poids.Discordance_mesure 
		(*Sinon, si le poids mesuré et superieur au poids a vide, que l'emplacement de la BDD n'est pas vide, que j'autorise la mesure mais que je n'est pas ni de discordance ni que la BDD est pleine*)
		THEN	BDD_poids.index_poids := BDD_poids.index_poids + 1; (*Alors, J'incremente l'index de 1*)
END_IF;

IF BDD_poids.BDD_poids_enregistrement[BDD_poids.index_nb_meule] <> 0 AND BDD_poids.Calcul_Nb_meule = TRUE (*Si l'emplacement de la BDD actuel est differant de 0 et que le Calcul de meule est actif*)
  	THEN	BDD_poids.Nb_meule_dans_BDD := BDD_poids.Nb_meule_dans_BDD + 1;(*Alors, J'incremente le nombre de meule de 1*)
		BDD_poids.index_nb_meule := BDD_poids.index_nb_meule + 1; (*J'incremente l'index de 1*)
		
	ELSE	BDD_poids.Calcul_Nb_meule := FALSE; (*Sinon, je desactive la demande de calcul de meule*)
		BDD_poids.Nb_occurence_BDD := BDD_poids.Nb_meule_dans_BDD;(*je transfert le nombre de meule calculé dans la variable d'affichage IHM*)
		BDD_poids.index_nb_meule := 0;(*je remet l'index a 0*)
		BDD_poids.Calcul_Nb_meule := FALSE;(*Je desactive le calcul de meule*)
END_IF;

IF  BDD_poids.RAZ_BDD (*A la demande de RAZ*)
	THEN 	MOVE_REAL_ARREAL(0.0,BDD_poids.BDD_poids_enregistrement);(*Met a 0 tout le tableau de la BDD*)
		BDD_poids.index_poids := 0;(*reset l'index*)
		BDD_poids.Nb_meule_dans_BDD := 0; (*RAZ nombre de meuledans BDD*)
		BDD_poids.Nb_occurence_BDD := 0;
		BDD_poids.RAZ_BDD := FALSE; (*reset la demande de RAZ*)
END_IF;

BDD_poids.Poids_total_BDD:= SUM_ARREAL(BDD_poids.BDD_poids_enregistrement); (*Calcul du poids total*)
BDD_poids.Poids_moyen_BDD:= SUM_ARREAL(BDD_poids.BDD_poids_enregistrement)/BDD_poids.Nb_occurence_BDD; (*Calcul du poids moyen*)

IF BDD_poids.Nb_occurence_BDD = 0
	THEN	BDD_poids.Poids_moyen_BDD := 0;
END_IF;

Peut-etre avec une boucle while ou for ou je ne sais quoi ? le ST c'est pas le truc que je maitrise le plus et je veux pas le faire en LD, je veux changer un peu ^^
Merci d'avance pour vos proposition

Salut,

Quelques propositions :

1. d'ordre cosmétique :
- tu as un style d'indentation assez propre, mais je te propose le mien qui, à mon sens, met davantage en évidence la structure des blocs conditionnés et les opérandes des équations. Dans les structures conditionnelles ou itératives, je mets les mots-clé les définissant au même niveau d'indentation ; les THEN, ELSE et ELSIF se trouvent alignés avec leurs IF et END_IF correspondants, de même si j'utilise les structures FOR .. END_FOR ou autres ;
- dans les équations logiques ou arithmétiques, je n'hésite pas à placer des parenthèses, même inutiles suivant la précédence des opérateurs, si elles consolident la compréhension de l'ordre d'évaluation de l'équation ; je place aussi des espaces entres les opérandes et les opérateurs et parenthèses, ce qui, pour mes petits yeux, améliore la lisibilité de l'équation, on distingue mieux les opérandes, surtout quand ceux-ci sont des éléments de structures de données ;
Ca donnerait quelque chose comme ça :

Code : Tout sélectionner

IF BDD_poids.Poids_a_vide >= BDD_poids.Poids_coherent_min
THEN
	BDD_poids.Poids_a_vide := BDD_poids.Poids_coherent_min - 0.1;
END_IF;

IF BDD_poids.poids_mesure > BDD_poids.Poids_a_vide AND BDD_poids.BDD_poids_enregistrement[BDD_poids.index_poids] = 0 AND BDD_poids.Top_mesure AND NOT BDD_poids.Discordance_mesure AND BDD_poids.Poids_stable
(*Si le poids mesuré est superieur au poids minimum attendu et si la valeur de la BDD correspondante est bien vide (a 0), que j'autorise une mesure, qu'il n'y a pas de defaut de discordence et que le poids est stable*)
THEN
 	BDD_poids.BDD_poids_enregistrement[BDD_poids.index_poids] := BDD_poids.poids_mesure; (*Alors, je mets le poids en cours dans la BDD*)
	BDD_poids.BDD_poids_enregistrement[BDD_poids.index_poids + 1] := 0;
	BDD_poids.Calcul_Nb_meule := TRUE; (*je demande un calcul du nombre de meule*)
	BDD_poids.Nb_meule_dans_BDD := 0; (*je mets a 0 le nombre de meule pour le recalcul*)
	BDD_poids.Top_mesure := FALSE; (*j'interdit une nouvelle mesure*)
	BDD_poids.index_poids := 0; (*Je remet l'index a 0*)
ELSIF	BDD_poids.poids_mesure > BDD_poids.Poids_a_vide AND BDD_poids.BDD_poids_enregistrement[BDD_poids.index_poids] <> 0 AND BDD_poids.Top_mesure AND NOT BDD_poids.Discordance_mesure 
		(*Sinon, si le poids mesuré et superieur au poids a vide, que l'emplacement de la BDD n'est pas vide, que j'autorise la mesure mais que je n'est pas ni de discordance ni que la BDD est pleine*)
THEN
	BDD_poids.index_poids := BDD_poids.index_poids + 1; (*Alors, J'incremente l'index de 1*)
END_IF;

IF BDD_poids.BDD_poids_enregistrement[BDD_poids.index_nb_meule] <> 0 AND BDD_poids.Calcul_Nb_meule = TRUE (*Si l'emplacement de la BDD actuel est differant de 0 et que le Calcul de meule est actif*)
THEN
	BDD_poids.Nb_meule_dans_BDD := BDD_poids.Nb_meule_dans_BDD + 1;(*Alors, J'incremente le nombre de meule de 1*)
	BDD_poids.index_nb_meule := BDD_poids.index_nb_meule + 1; (*J'incremente l'index de 1*)
ELSE
	BDD_poids.Calcul_Nb_meule := FALSE; (*Sinon, je desactive la demande de calcul de meule*)
	BDD_poids.Nb_occurence_BDD := BDD_poids.Nb_meule_dans_BDD;(*je transfert le nombre de meule calculé dans la variable d'affichage IHM*)
	BDD_poids.index_nb_meule := 0;(*je remet l'index a 0*)
	BDD_poids.Calcul_Nb_meule := FALSE;(*Je desactive le calcul de meule*)
END_IF;

IF  BDD_poids.RAZ_BDD (*A la demande de RAZ*)
THEN
	MOVE_REAL_ARREAL(0.0,BDD_poids.BDD_poids_enregistrement);(*Met a 0 tout le tableau de la BDD*)
	BDD_poids.index_poids := 0;(*reset l'index*)
	BDD_poids.Nb_meule_dans_BDD := 0; (*RAZ nombre de meuledans BDD*)
	BDD_poids.Nb_occurence_BDD := 0;
	BDD_poids.RAZ_BDD := FALSE; (*reset la demande de RAZ*)
END_IF;

BDD_poids.Poids_total_BDD:= SUM_ARREAL(BDD_poids.BDD_poids_enregistrement); (*Calcul du poids total*)
BDD_poids.Poids_moyen_BDD:= SUM_ARREAL( BDD_poids.BDD_poids_enregistrement ) / BDD_poids.Nb_occurence_BDD; (*Calcul du poids moyen*)

IF BDD_poids.Nb_occurence_BDD = 0
THEN
	BDD_poids.Poids_moyen_BDD := 0;
END_IF;

2. d'ordre technique :
Tu as placé ce code dans une tâche FAST, parce qu'il faut l'éxécuter plus rapidement qu'au rythme de la tâche MAST (i.e. plus _fréquemment_ ), ou parce que tu pensais que le temps d'éxécution du code serait _plus court_ que placé dans la tâche MAST ?
On est bien d'accord que la tâche FAST s'éxécute de façon périodique (toutes les 5 ms par exemple) pour traiter des choses qui sont plus fréquentes que ce la tâche MAST peut voir, avec un temps de cycle de l'ordre de 30 ms par exemple ?
Ce faisant, ce code en tâche FAST _interrompt_ l'éxécution de la tâche MAST toutes les 5 ms, puis la tâche MAST reprend là où elle en était, jusqu'à la dernière ligne de code MAST, avant d'entamer un nouveau cycle.
Si la tâche FAST est éxécutée toutes les 10 ms, elle interrompra la tâche MAST deux fois moins souvent, ce qui diminuera le temps de cycle global.

Tu connais sûrement déjà ce principe, mais je voulais être sûr qu'on se comprend bien.

3. d'ordre conceptuel :
On peut privilégier les équations logiques aux structures conditionnelles (IF .. END_IF), qui ne sont pas toujours équivalentes à une équation logique, et prennent une forme plus lourde dans le code. Par exemple :

Code : Tout sélectionner

IF BDD_poids.poids_mesure <= BDD_poids.Poids_a_vide AND En_auto (*Si aucune meule detecté, si la machine fonctionne, que la BDD n'est pas pleine*)
	THEN 	BDD_poids.Top_mesure := TRUE ; (*Alors, j'autorise la mesure*)
END_IF;

devrait plutôt être

Code : Tout sélectionner

BDD_poids.Top_mesure := BDD_poids.poids_mesure <= BDD_poids.Poids_a_vide AND En_auto;

Dans la structure conditionnelle :
- si la condition est vraie, BDD_poids.Top_mesure est calculée à TRUE (qui se trouve être la valeur de l'expression logique en condition);
- si la condition est fausse, BDD_poids.Top_mesure n'est pas calculée, et garde sa valeur !

Dans la forme "équation logique", BDD_poids.Top_mesure prend la valeur de l'équation logique à droite de l'opérateur ':=', TRUE ou FALSE, à chaque exécution du code.
La forme du code est plus concise, et on est sûr du fonctionnement.

La première forme peut être voulue ; en ladder, ça se traduirait par une bobine SET( BDD_poids.Top_mesure ) en fin de réseau de contacts, mais si c'est vraiment le fonctionnement souhaité, le code devrait faire apparaitre le traitement du cas par défaut, sous cette forme :

Code : Tout sélectionner

IF BDD_poids.poids_mesure <= BDD_poids.Poids_a_vide AND En_auto (*Si aucune meule detecté, si la machine fonctionne, que la BDD n'est pas pleine*)
THEN
 	BDD_poids.Top_mesure := TRUE ; (*Alors, j'autorise la mesure*)
ELSE
	; (* sinon, on ne fait rien, c'est l'équivalent d'une bobine SET() - ne pas oublier le ';' sinon ça ne compile pas à cause d'une erreur de syntaxe *)
 END_IF;

Même principe pour cette autre partie :

Code : Tout sélectionner

IF  BDD_poids.poids_mesure > BDD_poids.Poids_a_vide AND (BDD_poids.poids_mesure < BDD_poids.Poids_coherent_min OR BDD_poids.poids_mesure > BDD_poids.Poids_coherent_max) OR BDD_poids.Poids_coherent_max = 0 OR BDD_poids.Poids_coherent_min = 0(*Si j'ai une mesure superieur au poids a vide et que la 
valeur n'est pas cohérente et que les variable de cohérence sont égale à 0*)
	THEN	BDD_poids.Discordance_mesure := TRUE; (*alors, j'active la variable de discordance*)
END_IF;

devrait plutôt s'exprimer comme ça (on a le droit de faire des retours à la ligne pour améliorer la présentation du code, si on veut) :

Code : Tout sélectionner

BDD_poids.Discordance_mesure := BDD_poids.poids_mesure > BDD_poids.Poids_a_vide AND ( BDD_poids.poids_mesure < BDD_poids.Poids_coherent_min OR BDD_poids.poids_mesure > BDD_poids.Poids_coherent_max)
    OR BDD_poids.Poids_coherent_max = 0
    OR BDD_poids.Poids_coherent_min = 0;

Pour info, le temps de cycle du programme est de combien ?

Waoh ok merci pour le temps pris pour cela
Il est vrai que je fait beaucoup de IF car dans ma compréhension ça m'aide mais une simple égalité sur une ligne suffirai évidemment ^^
Pour le FAST j'ai mis a 20ms car en effet, pas besoin qu'il s’exécute non stop toute les 5 ms

Pour ce qui est de l’esthétique, j'ai pas pensé en effet a remettre a la ligne pour les OR et AND ; Je vais arranger cela
Par contre pour les mise a la ligne des IF THEN et ELSE, je prefere ma solution d'aligner les THEN et ELSE decalé du IF ^^

Bonjour,

Une tache FAST à 20ms n'a aucun sens ! la plupart des programmes en M340 tournent moitié plus vite à minima. On fait une tâche FAST pour piloter des mouvements qui en ont réellement besoin, et dans ce cas on associe les sorties à la tache FAST. Toi tu fait de la gestion de poids, pour moi ça n'a absolument rien à faire là.

JC

JC87 a écrit : ↑16 janv. 2024, 11:37 Bonjour,

Une tache FAST à 20ms n'a aucun sens ! la plupart des programmes en M340 tournent moitié plus vite à minima. On fait une tâche FAST pour piloter des mouvements qui en ont réellement besoin, et dans ce cas on associe les sorties à la tache FAST. Toi tu fait de la gestion de poids, pour moi ça n'a absolument rien à faire là.

JC

Oui mais le programme met un peu trop de temps a enregistrer un poids c'est pourquoi je poste ce sujet.

Bonjour,

Sans avoir étudier le code du tout, juste par expérience, est-ce que la lenteur ne viendrais pas d'une lenteur à avoir un poids stable ?

Si on enlève l'enregistrement, quel est le temps de cycle ?

Eric

Bonjour,

Laurent a écrit : ↑16 janv. 2024, 09:29 3. d'ordre conceptuel :
On peut privilégier les équations logiques aux structures conditionnelles (IF .. END_IF), qui ne sont pas toujours équivalentes à une équation logique, et prennent une forme plus lourde dans le code. Par exemple :
Code : Tout sélectionner
IF BDD_poids.poids_mesure <= BDD_poids.Poids_a_vide AND En_auto (*Si aucune meule detecté, si la machine fonctionne, que la BDD n'est pas pleine*)
	THEN 	BDD_poids.Top_mesure := TRUE ; (*Alors, j'autorise la mesure*)
END_IF;
devrait plutôt être
Code : Tout sélectionner
BDD_poids.Top_mesure := BDD_poids.poids_mesure <= BDD_poids.Poids_a_vide AND En_auto;

Attention, ce n'est pas la même chose !

Code : Tout sélectionner

IF BDD_poids.poids_mesure <= BDD_poids.Poids_a_vide AND En_auto (*Si aucune meule detecté, si la machine fonctionne, que la BDD n'est pas pleine*)
	THEN 	BDD_poids.Top_mesure := TRUE ; (*Alors, j'autorise la mesure*)
END_IF;

Si les conditions sont remplies, BDD_poids.Top_mesure passe à True et reste à True même si les conditions changent ensuite!

Code : Tout sélectionner

BDD_poids.Top_mesure := BDD_poids.poids_mesure <= BDD_poids.Poids_a_vide AND En_auto;

[/quote]
Si les conditions sont remplies, BDD_poids.Top_mesure passe à True, si elles disparaissent, BDD_poids.Top_mesure passe à False.

andala a écrit : ↑12 janv. 2024, 09:28 Le probleme c'est qu'a l’exécution d'une mesure, le programme rame avant de me donner un résultat dans la BDD

A la lecture du code, je n'y comprend rien. Peut-être peux-tu expliquer ce que tu veux faire si qui serait plus simple.

Si c'est pour effectuer une pesée, tu as juste a regarder si ton poids est dans une valeur attendue (exemple > poids vide + constante)
Pour savoir si le poids est stable tu compare avec la pesée antérieure du genre :
[/quote]
Delta := valeur_entière (Mesure - MesurePrecedente);(* j'ai plus entête l'instruction qui retourne la valeur entière*)
poidsStable := Delta <constante; (* Si le delta devient petit c'est que le poids s'est stabilisé*)
MesurePrecedente:= Mesure; (*Memo valeur pour le tour prog suivant*)
[/quote]

DurandO a écrit : ↑16 janv. 2024, 15:41 A la lecture du code, je n'y comprend rien. Peut-être peux-tu expliquer ce que tu veux faire si qui serait plus simple.

Pas faux.
Je souhaite, a l'arrivée d'une meule sur le tapis de pesée, enregistrer cette valeur dans une BDD (180 mesure par jour sur 1 semaine (1300 valeur real en tout))

DurandO a écrit : ↑16 janv. 2024, 15:41 Pour savoir si le poids est stable tu compare avec la pesée antérieure du genre :

Encore plus simple, la machine m’envoie un bit pour me dire si celui-ci est stable

Pour faire simple :
A l'arrivée d'une meule sur le tapis de pesée, attendre que la pesée soit stable (bit reçu de la machine de pesée), enregistrer cette valeur dans la BDD, attendre que le poids redescende en dessous d'une certaine valeur avant de réenregistré une nouvelle valeur.
J'ai besoin du nombre de meule présent dans la BDD et qu'en cas de dépassement de la BDD, ça efface la première valeur de celle-ci et inscrive la nouvelle valeur a la place

En passant, je pense que c'est surtout ce calcul la qui fait ramer car c'est depuis cette modif que j'ai commencer a voir la lenteur:

Code : Tout sélectionner

IF BDD_poids.BDD_poids_enregistrement[BDD_poids.index_nb_meule] <> 0 AND BDD_poids.Calcul_Nb_meule = TRUE (*Si l'emplacement de la BDD actuel est differant de 0 et que le Calcul de meule est actif*)
  	THEN	BDD_poids.Nb_meule_dans_BDD := BDD_poids.Nb_meule_dans_BDD + 1;(*Alors, J'incremente le nombre de meule de 1*)
		BDD_poids.index_nb_meule := BDD_poids.index_nb_meule + 1; (*J'incremente l'index de 1*)
		
	ELSE	BDD_poids.Calcul_Nb_meule := FALSE; (*Sinon, je desactive la demande de calcul de meule*)
		BDD_poids.Nb_occurence_BDD := BDD_poids.Nb_meule_dans_BDD;(*je transfert le nombre de meule calculé dans la variable d'affichage IHM*)
		BDD_poids.index_nb_meule := 0;(*je remet l'index a 0*)
		BDD_poids.Calcul_Nb_meule := FALSE;(*Je desactive le calcul de meule*)
END_IF;

PS : pour l'instant je ne fait qu'une simulation (l’appareil n'est pas branché)

andala a écrit : ↑16 janv. 2024, 16:57 Je souhaite, a l'arrivée d'une meule sur le tapis de pesée, enregistrer cette valeur dans une BDD (180 mesure par jour sur 1 semaine (1300 valeur real en tout))

Une Base De Données où simplement un tableau de 1300 valeurs réelles?

A l'arrivée d'une meule sur le tapis de pesée, attendre que la pesée soit stable (bit reçu de la machine de pesée), enregistrer cette valeur dans la BDD, attendre que le poids redescende en dessous d'une certaine valeur avant de réenregistré une nouvelle valeur.

Ta mesure est stable dans 2 cas : en présence d'une meule ou à vide.
Donc si tu contrôle que ta mesure est dans une plage > mesure à vide + constante et qu'elle est stabilisée alors tu la mémorise sur front.
Ok tu obtiens un tableau de ces mesures de x meules.
On ne sait pas si tu pèse plusieurs fois les mêmes meules, ni pourquoi tu as besoin du nombre !
A quoi te servent ces mesures ?
Veut-on connaitre l'ordre chronologique des pesées? Si oui, je le traiterai ainsi : créer une variable1 (un tableau de 1299 élements) à l'adresse %MF100 par exemple et une variable2 de même taille qui pointe sur le mot qui suit.
Insérer dans le tableau

Code : Tout sélectionner

Variable2:=Variable1;
Variable1[0]:=ValeurMesure;

J'ai besoin du nombre de meule présent dans la BDD et qu'en cas de dépassement de la BDD, ça efface la première valeur de celle-ci et inscrive la nouvelle valeur a la place

Ton index s'incrémente après chaque sauvegarde de valeur et s'il atteint nbMeule tu le remets à 0.

DurandO a écrit : ↑16 janv. 2024, 17:39
andala a écrit : ↑16 janv. 2024, 16:57 Je souhaite, a l'arrivée d'une meule sur le tapis de pesée, enregistrer cette valeur dans une BDD (180 mesure par jour sur 1 semaine (1300 valeur real en tout))
Une Base De Données où simplement un tableau de 1300 valeurs réelles?

Un tableau de 1300 valeur en real

A l'arrivée d'une meule sur le tapis de pesée, attendre que la pesée soit stable (bit reçu de la machine de pesée), enregistrer cette valeur dans la BDD, attendre que le poids redescende en dessous d'une certaine valeur avant de réenregistré une nouvelle valeur.
Ta mesure est stable dans 2 cas : en présence d'une meule ou à vide.

Dans mon programme, j'attend que la meule repasse par une valeur "a vide" avant d'autoriser une nouvelle pesée

On ne sait pas si tu pèse plusieurs fois les mêmes meules, ni pourquoi tu as besoin du nombre !

Je ne pèse qu'une seul fois chaque meule et j'ai besoin du nombre car il me faut une moyenne de poids total pesé

Forum automatisme

[M340] Code qui fait ramer le PLC

[M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC

Re: [M340] Code qui fait ramer le PLC