Suivi sur une ligne de production avec un encodeur .

Bonjour et bon début d'année a tous/toutes,

J'aurais besoin d'un petit coup de main pour un programme j'ai déjà une base en programmation mais je me heurte a un problème pour celui la . En fait je n'ai aucune idée comment arrivé à mes fin malgré mes recherche je ne trouve pas d'exemple.

Voilà nous avons une chaine de montage sur le quel j'ai fabriquer un encodeur avec une roue denté et un capteur . un tour complet de la ligne équivaut à 2500 pulse.

Sur cette ligne est accrocher des pièces à peindre.

Un bouton poussoir est en début de ligne est appuyé pour commencer les comptes lorsque que la première pièces d'une série est accrocher ie (les pièces de produit A).

Sur cette ligne il y a 5 station aux quel je doit envoyer un signal ( pulse de 1.5 seconde).

la station 1 est à 350 pulses output 1 la station 2 est à 425 pulses output 2 la station 3 est à 1100 pulses output 3 la station 4 est à 1600 pulses output 4 la station 5 est la fin de la ligne a 2500 pulses output 5

Jusque là ce n'est pas trop difficile le problème c'est qu'il est possible que j'ai a plus d'un produit à la fois sur la ligne . je veux dire par là qu’après avoir mis ma dernière pièce du produit A je voudrait pouvoir commencer une autre batch B sans avoir a vider la ligne et sans perdre le compte pour le produit A.

ie le produit A est a la position 473 et je commence une autre batch B je veux quand même avoir mes signaux de la station 3 ,4 et 5.

Quelque aurait une suggestion ?

J’espère que j'ai bien expliqué la situation n'hésitez pas si vous avez de question.

Merci beaucoup ..

Comment dites vous à l’arduino que c’est maintenant un produit B et plus un produit A Que vous allez rajouter ?

Bonjour merci de votre intérêt.

En fait ce n’est pas très important quel produit c’est . On a puis sur le bouton au début de la ligne (départ /batch) pour marquer le début d’une nouvelle série de pièces . Lorsque la première pièce d’un lot atteint une station,le output relié à cette station alimentent des relais qui sont relié à un autre system . Donc comme dans mon premier message : une fois que l’on a appuyé sur le bouton départ ou nouvelle batch, le compte commence une fois qu’il a atteint un des preset exemple: 350 pulse, le output 1 alimente le relais relié à l’autre system .

Notez qu’il pourrait y avoir plusieurs série en même temps sur la ligne j’ai mis A et B comme exemple mais il pourrait y avoir plus que 10 produits différents en file sur la ligne. La liste des produit est sur l’autre system ce dispositif ne servira qu’a Le faire passer d’un produit à l’autre au fur et à mesure qu’ils avance sur la ligne.

Est-ce plus clair?

Merci

Est-ce plus clair?

OK. Je réfléchis mieux avec des images

stations.png

Donc chaque station est équipée d’un détecteur d’arrivée de produit. Lorsqu’une station “voit” un produit arriver, ça déclenche un traitement puis le produit continue sur le convoyeur jusqu’à la prochaine station, qui là encore va le détecter et faire une autre opération ? etc jusqu’à la 5ème station. et lorsque vous démarrez un batch, vous appuyez sur le gros bouton rouge.

c’est cela ? ou alors il n’y a pas de détecteurs ? j’ai pas bien compris le comptage de “ticks” ?

et quel est votre objectif ? c’est de comptabiliser combien d’objets du batch X vous avez fait passer sur la chaîne, c’est cela ?

Bonjour, Non pas du tout en fait les stations ne servent pas à compter les pièces ce sont des points d’inspections. Il n’es pas possible d’installer des capteurs delà la difficulté. C’est pour ça que nous avons fabriqué un encoder à roue denté pour compter les impulsions et virtuellement suivre les pièces. En fai ce n’est que la première pièce du lot que l’on doit suivre . Si on commence un autre lot on doit pouvoir suivre le premier sans le perdre.

Il y a sûrement un moyen de mémoriser ces valeur qui continueraient à incrémenter à chaque fois que l’encoder pulse . Si une des valeur mémorisée atteint une des position prédéfini ie 1100 le output 3 s’active C’est certainement faisable Mais je n’ai aucune idée de la façon de faire. Vous comprenez?

Merci encore c’est vraiment apprécié

Utilise un tableau pour stocker la position de chaque pièce. A chaque pièce qui s'ajoute sur la ligne tu ajoutes un élément dans le tableau à chaque impulsion tu incrémentes le compteur de chacune des cases du tableau et tu sauras à tout moment où se trouve tes pièces sur la chaîne.

OK Je récapitule:

On se fiche des objets, ce qui compte c’est l’appui sur le bouton et la progression du tapis

Vous êtes capable de mesurer des ticks pour l’avancée du tapis.

Si on dit qu’à l’instant T0 on est au tick 0 et on appuie sur le bouton alors aux ticks T350 , T425, T1100, T1600 et T2500 l’objet se trouvera en face d’une station de contrôle et il faut que l’unique Arduino qui compte les ticks active un pin correspondant à la station à ce moment là.

Donc disons qu’on appuie sur le bouton à l’instant Tn, il faut alors mémoriser que à
Tn+350 on active la pin S1 pendant x ms pour le batch 1
Tn+425 on active la pin S2 pendant x ms pour le batch 1
Tn+1100 on active la pin S3 pendant x ms pour le batch 1
Tn+1600 on active la pin S4 pendant x ms pour le batch 1
Tn+2500 on active la pin S5 pendant x ms pour le batch 1

et suivre ces points clés. Quand un point clé est atteint, alors on traite l’action et on l’enlève de la liste des points clés.

Maintenant disons que j’appuie sur le bouton à l’instant Tp alors il faut rajouter à la liste des points clés que à
Tp+350 on active la pin S1 pendant x ms pour le batch 2
Tp+425 on active la pin S2 pendant x ms pour le batch 2
Tp+1100 on active la pin S3 pendant x ms pour le batch 2
Tp+1600 on active la pin S4 pendant x ms pour le batch 2
Tp+2500 on active la pin S5 pendant x ms pour le batch 2

et toujours comparer le tick courant avec la liste des ticks importants

p peut se produire avant n+2500 donc on a plusieurs batch possibles en cours

j’ai bon ce coup ci ??

→ si vous pouvez avoir 10 objets au max sur la chaîne, comme chaque objet génère 5 ticks à surveiller, ça veut dire que votre tableau des ticks à surveiller doit compter au max 5x10= 50 entrées.

le programme est alors assez simple, c’est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

  • le setup() initialise tout
  • la loop surveille les évènements: il y en a 2 importants:
  • Soit l’appui sur le bouton
  • Soit un nouveau tick

→ lors de l’appui sur le bouton, on passe au batch suivant et il faut rajouter à la liste des ticks à surveiller les 5 valeurs calculées en fonction du tick en cours

→ lors d’un nouveau tick, il faut comparer la valeur courante avec tous les ticks importants et activer la pin associée si c’est reconnu comme un tick critique et dans ce cas sortir ce tick de la liste des ticks à surveiller.

==> ça veut dire que le tableau (ou liste) des ticks à surveiller doit comporter au moins le N° séquentiel du tick qui le déclenchera, le N° de la station/pin à activer (et éventuellement un N° de batch). Donc ce serait un tableau de structure.

pour être simple et éviter de trier la liste ou sortir des objets de la liste, la structure pourrait contenir un booléen qui dit si cette entrée a été traitée. on le met à false au moment de la création puis quand on arrive à ce tick et qu’on a exécuté la commande on le passe à true. Cette entrée devient donc dispo pour la prochaine fois où on doit insérer quelque chose dans la liste. (la fonction d’insertion des 5 ticks importants parcours le tableau et regarde si cette position dans le tableau est encore active)

sans tout coder pour vous, ça pourrait ressembler à cela:

struct tickImportant_t {
  uint32_t tickDeclencheur;
  uint32_t numeroDuBatch;
  uint8_t numeroStation;
  boolean entreeDisponible;
};

const uint8_t pinDesStations[] = {3, 4, 5, 6, 7};
const uint8_t nombreDeStations = sizeof(pinDesStations) / sizeof(pinDesStations[0]);
const uint16_t ticksRelatifDesStations[nombreDeStations] = {350u, 425u, 1100u, 1600u, 2500u};
const uint32_t dureeActivationStation = 20ul; // 20ms

const uint8_t nombreMaxDeBatchEnCours = 10;
const uint8_t nombreDeTicksASurveiller = nombreDeStations * nombreMaxDeBatchEnCours;
tickImportant_t tableauDesTicksASurveiller[nombreDeTicksASurveiller];

uint32_t bacthCourant;
uint32_t tickCourant;


void nouveauTick()
{
  boolean attenteNecessaire = false;

  tickCourant++;

  // a-t-on des éléments à traiter
  for (uint8_t indexTick = 0; indexTick < nombreDeTicksASurveiller; indexTick++) {
    if (tableauDesTicksASurveiller[indexTick].entreeDisponible == false) {
      if (tickCourant >= tableauDesTicksASurveiller[indexTick].tickDeclencheur) {

        Serial.print(F("Batch "));
        Serial.print(tableauDesTicksASurveiller[indexTick].numeroDuBatch);
        Serial.print(F(" arrive station "));
        Serial.println(tableauDesTicksASurveiller[indexTick].numeroStation);

        attenteNecessaire = true;
        digitalWrite(pinDesStations[tableauDesTicksASurveiller[indexTick].numeroStation], HIGH);
        tableauDesTicksASurveiller[indexTick].entreeDisponible = true; // on l'a traité
      }
    }
  }

  if (attenteNecessaire) {
    // on a activé au moins une pin on attend un peu puis on éteint toutes les pins sans se poser de question, c'est plus simple
    delay(dureeActivationStation);
    for (uint8_t i = 0; i < nombreDeStations; i++) digitalWrite(pinDesStations[i], LOW);
  }
}


void setup() {
  Serial.begin(115200);
  bacthCourant = 0;
  tickCourant = 0;

  for (uint8_t i = 0; i < nombreDeStations; i++) {
    pinMode(pinDesStations[i], OUTPUT);
    digitalWrite(pinDesStations[i], LOW);
  }

  // tous les éléments du tableau sont dispo
  for (uint8_t indexTick = 0; indexTick < nombreDeTicksASurveiller; indexTick++) {
    tableauDesTicksASurveiller[indexTick].entreeDisponible = true; // dispo
  }
}

void loop() {

}

un appel à la fonction nouveauTick() doit se faire quand vous avez un nouveau tick comme son nom l’indique. la fonction parcourt le tableau des ticks à suivre et fait l’action si nécessaire puis attend un peu (s’il le faut) et libère toutes les pins

(on peut bien sûr simplifier car les 5 entrées associées à une pression sur le bouton sont déterminée par le premier tick, donc on pourrait aussi n’avoir que 10 entrées dans le tableau et calculer les ticks importants à chaque fois, ça évite d’avoir à insérer 5 éléments qui se ressemblent dans le tableau, on n’en met qu’un seul et on en déduit les autres)

Bonjour , M. fsufnews Oui c’es bien Ça que je cherche à faire mais je ne sais pas comment. Un collègue m’a parlé de ça hier . Mais j’aurais besoin de voir un exemple pour comprendre . On est loin de mon niveau connaissances très basic

taktin: Bonjour , M. fsufnews Oui c’es bien Ça que je cherche à faire mais je ne sais pas comment. Un collègue m’a parlé de ça hier . Mais j’aurais besoin de voir un exemple pour comprendre . On est loin de mon niveau connaissances très basic

lisez mes explications et mon bout de code qui vous montre un peu comment parourir le tableau.

vous reste du boulot quand même :)

Bonjour Merci J-M-L Je regarde ça et je vous donne des nouvelles Merci 1000 fois

Bonjour;

Comment sont déplacé les pièces? Sont elles sur chariots indépendants ou sur une chaine? Sont elles à égale distance les une des autres ? Quelle est la largeur d'une pièce ? Quelle est la largeur d'un poste (encombrement de manœuvre) ?

(Je suppose que c'est une chaine sur les quels sont accrochés les pièces à égale distance.)

Pourquoi ces question: Tu n'a pas des positions de postes régulier. 350/425/1100/1600/2500 => Soit en delta de position de poste 350/75/675/500/900. (ça complique le positionnement aux postes!!)

"fdufnews" => Utilise un tableau pour stocker la position de chaque pièce. A chaque pièce qui s'ajoute sur la ligne tu ajoutes un élément dans le tableau à chaque impulsion tu incrémentes le compteur de chacune des cases du tableau et tu sauras à tout moment où se trouve tes pièces sur la chaîne.

C'est la bonne méthode. Et utilisé en industrie. En jargon on appel cela un "tracking" qui veux dire en français "suivis".

Si tes pièces sont accroché à égale distances sur ton transfert. Pour que tes pièces soit en place à chaque postes lors d'une demande d'avance. Il te faut, suivant tes données, un pas d'avance de 25 top codeur pour chaque positions de postes. Soit si l'on considère les deltas ci dessus cité. (75/25 = 3; ect...) 14/3/27/20/36 Cela te fait 100 position de "tracking" à crée dans ton tableau. En gros la première pièces fera 100 pas d'avance pour arriver en bout de ligne. Ce pas est important pour que tu puisse positionner tes pièces à tes 5 postes en même temps à chaque pas -commande- d'avance. Mais cela sera t'il techniquement possible suivant la grandeur des pièces? Si non il te faudrait ou multiplier ton pas d'avance par 2 ou modifier l'espace entre les pièces et ou recalculer le pas d'avance en prenant en compte la largeur d'une pièce. Mais d’expérience on se fie aux points d'accroches comme repères de positionnements normalement situé dans l'axe des pièces et qui prends en compte l'encombrement de chacune d'elles.

Note: Pourquoi 25 ? C'est le multiple suivant la valeur qui contient l'unité et la dizaine la plus petite. Soit 425. Et par chance tes postes sont à des valeurs en multiple de 5.

Salutations.

@manumanu - j'ai pas l'impression que ce soit le besoin. Au début je pensais comme vous mais @taktin a dit:

En fait ce n'est que la première pièce du lot que l'on doit suivre . Si on commence un autre lot on doit pouvoir suivre la premiere sans la perdre.

--> d'où ma proposition

en fait ce qu'il fait ressemble à un séquenceur - on donne de temps en temps des ordres à effectuer dans le futur et le logiciel enregistre et effectue ces ordres au bon moment

J-M-L: @manumanu - j'ai pas l'impression que ce soit le besoin. Au début je pensais comme vous mais @taktin a dit: --> d'où ma proposition

en fait ce qu'il fait ressemble à un séquenceur - on donne de temps en temps des ordres à effectuer dans le futur et le logiciel enregistre et effectue ces ordres au bon moment

Bonsoir JML C'est aussi ce que j'ai à peu prés "compris" en l’état des "petites" explications :grin:

Il existe déjà de la bonne littérature d'apprentissage au "concept d'insertion unitaire" avec points de reports "finis" :D

  • En "3D" voir du coté de l'insertion en contrôle aérien

  • En "2D" voir du coté contrôle des voies ferroviaires

Salut -Oui et là c’est en 1D - juste les ticks - donc asssez simple

Bonjour;

Ok je suis à coté de la plaque donc !! :confused: La conception machine m'échappe donc.

J'aimerais tout de même savoir comment tout cela fonctionne!!

Salutations.

bonjour, Oui manumanu, J-M-L a bien compris ce que je cherche à faire. Donc ditent moi si ça fait du sens mais si je pouvait mettre les valeurs dans un tableau dont chaque case incrémentent de 1 à chaque pulse d’encoder . Donc si je met une nouvelle première pièce d’un lot sur la ligne j’appuie sur le bouton départ

Une nouvelle case ce met en fonction en la mettenant à 1

Chaque pulse d’encoder augmente de 1 chaque case qui n’est pas à zéro

Une fois atteint la valeur d’un tour complet 2500 pulse la case se met à 0 et n’incrémente plus .

Si une des case atteint la valeur d’une position d’une station exemple : 425 pulse (station2) une action ce produit

Est-ce que ça ferait du sens ?

taktin: Chaque pulse d’encoder augmente de 1 chaque case qui n’est pas à zéro Une fois atteint la valeur d’un tour complet 2500 pulse la case se met à 0 et n’incrémente plus . Si une des case atteint la valeur d’une position d’une station exemple : 425 pulse (station2) une action ce produit Est-ce que ça ferait du sens ?

Pourquoi pas, oui ça peut marcher aussi comme cela - c’est proche de ce que je disais en fin de post #6

(on peut bien sûr simplifier car les 5 entrées associées à une pression sur le bouton sont déterminée par le premier tick, donc on pourrait aussi n'avoir que 10 entrées dans le tableau et calculer les ticks importants à chaque fois, ça évite d'avoir à insérer 5 éléments qui se ressemblent dans le tableau, on n'en met qu'un seul et on en déduit les autres)

La j avoue que je pige pas le principe !!

Salutations.

Vous avez un tableau initialement “vide” et une fonction qui insère pour chaque appui sur le bouton une nouvelle entrée mise au départ à T0

À chaque tick reçu, on parcourt le tableau pour toutes les entrées valides et augmente de 1 le compteur. Si le compteur de ticks vaut T350 , T425, T1100, T1600 et T2500 l’objet se trouvera en face d’une station de contrôle et il faut que l’Arduino active une pin correspondant à la station à ce moment là. Ensuite Si le compte atteint T2500 vous désactivez cette entrée dans le tableau pour faire une place pour un prochain click sur le bouton

Bonjour;

Je comprends pour l'exécution du tableau au niveau programme. Pour moi cela est ok si les chariot de transfert sont indépendant et navigue d'un poste à l'autre.

Mais qu'en est il des pièces qui suivent la première si elle se situent à intervalle régulier? :roll_eyes: Dans ce cas je ne passe qu'une seul pièce ou j'ai encore pas compris?

Notez qu'il pourrait y avoir plusieurs série en même temps sur la ligne j'ai mis A et B comme exemple mais il pourrait y avoir plus que 10 produits différents en file sur la ligne. La liste des produit est sur l'autre system ce dispositif ne servira qu'a Le faire passer d'un produit à l'autre au fur et à mesure qu'ils avance sur la ligne.

On ne sait toujours pas comment avance les pièces. Quelle mode de transfert?

taktin n'a pas répondu aux questions...

Comment sont déplacé les pièces? Sont elles sur chariots indépendants ou sur une chaine? Sont elles à égale distance les une des autres ? Quelle est la largeur d'une pièce ? Quelle est la largeur d'un poste (encombrement de manœuvre) ?

J'aimerais bien connaitre ton retour taktin !

Car dans le cas de chaine a distance fixe j'ai proposé le principe "d'avance d'un pas" pour positionner les pièces à chaque postes au même moment lors d'un appuie sur bouton. Si tu a le bon pas d'avance tu fait 5 contrôles en même temps.

Cela permet aussi de numéroter et suivre toute les pièces en fonction du lot. A chaque changement de lot on raz une ou deux position de séparation. (via séquence changement de lot et anti-mélanges) Ex: 9-8-7-6-5-4-3-2-1-0-0-455-454-453-452-451-540-439

Il pourrait aller plus loin en créant un tableau à deux dimension pour y inscrire les données de chaque pièces.((code)client/N°commande/(code)couleur/(code)état de production/(code)qualité). Bien-sur ces données sont à introduire en communication série -ou autre- dans le prog. de l'Arduino au moment du changement de "lot".

Désolé si je suis dur -ou mou- du bulbe :D Mais j'aimerais comprendre comment on transfert les pièces.

Salutations.