appareil mesure longueur cartons

Bonjour à tous,

travaillant actuellement en logistique, j'ai un petit projet qui m'est venu en tête.

Ma mission est de déterminer une nouvelle zone de picking des cartons, et les approvisionner sur les lignes de production. Pour déterminer cette zone il me faut la dimensionner (combien de racks allons nous avoir besoin pour stocker tous les cartons), et pour cela je souhaite d'abord déterminer les longueurs de chaque carton livré par notre fournisseur ( environ 300 réfs différentes)

plutôt que de les mesurer à la main, j'ai eu l'idée de placer dans notre service de réception un appareil pour mesurer Longueur, Largeur et Hauteur de chaque carton. Sur le carton, nous disposons d'une étiquette pour identifier ce qu'il y a dans le carton, il faudrait donc coupler un lecteur code barre

Cela me permettrait de faire de l'acquisition de donnée et récupérer l'ensemble des formats de cartons et ainsi avoir une idée du volume que cela représente pour la zone de picking.

J'ai pensé à utilisé des capteurs à ultrasons, qui seront branchés à la carte arduino et qui me semble assez précis pour l'utilisation que je veux en faire.

Ma question sur l'aspect technique que j'aimerais vous poser:

Est-il possible de déclencher soi-même la prise de mesure des capteurs ( par exemple en appuyant sur un bouton poussoir). En fait j'aimerais que le carton soit d'abord mis en butée dans un coin de l'appareil, et seulement après déclencher la mesure. Je vous pose cette question car j'ai cherché sur internet, et il me semblait que pour faire de l'acquisition de données on était obligé de déterminer une fréquence, ce qui fait qu'on récupère les nouvelles données toutes les x secondes ( ce que je ne veux pas)..

Je vous remercie pour votre aide,

Raphaël

Bonjour et Bienvenue !

/!\ Bien lire les fichiers épinglés en tête de forum , en particulier la Règle de Fonctionnement

Ou poser les questions ? comment les poser? Qu'attendre du forum........

De toute évidence ton projet ne peut pas encore être qualifié de FINI :wink:

-> Demander au Modérateur (lien "Report to Moderator" en bas à gauche) le déplacement du fil de discussion à l'endroit ou l'on doit poser les questions.

Sujet déplacé

et il me semblait que pour faire de l’acquisition de données on était obligé de déterminer une fréquence, ce qui fait qu’on récupère les nouvelles données toutes les x secondes ( ce que je ne veux pas)…

Ne pas généraliser à partir de quelques exemples particuliers qui demandent une mesure à intervalle de temps régulier.
En général on a totalement la main sur les ordres envoyés à un capteur à ultra sons, on fait appale à lui quand on veut pour une mesure ponctuelle.

Bonjour, merci pour vos réponses !

j’ai pu avancer sur le code de mon projet. Pour vous expliquer un peu plus en détail ma façon de procéder pour ce projet:

J’ai pour l’instant 3 capteurs à ultrasons qui vont me permettre de mesurer la largeur et la longueur d’un carton. On imagine que le carton est placé au centre de ces 3 capteurs.

Dans mon code, Capteur1 me permet de mesurer la longueur du carton. j’ai pensé par exemple à ce que le carton arrive en butée contre un bord de l’appareil de mesure, ce qui actionne un bouton poussoir (Bouton). en connaissant la longueur entre le Capteur1 et la butée de l’appareil de mesure (dans mon code 100cm), j’en déduit la longueur du carton ( fonction mesureLongueur);

Pour la largeur du carton c’est un peu plus complexe puisque cette largeur est calculée en fonction des mesures des Capteur2 et Capteur3, disposés l’un face à l’autre. Toujours en connaissant la distance qui les séparent (100cm) j’en déduit la largeur= 100 -mesure2-mesure3.

Ces mesures sont comme je l’ai dis déclenchées lorsque le carton vient appuyer le bouton poussoir. Dans ce cas on lance les fonctions mesureLongueur et mesureLargeur, pendant un cours délai, car il faut imaginer que cet appareil soit à l’extremité d’un convoyeur de carton, et donc qu’il peut rester quelques temps le temps qu’un opérateur vienne le ranger.

Voilà pour le résumé. J’ai réussi à faire fonctionner ce code pour obtenir des mesures avec deux capteurs.
Lorsque j’ai voulu ajouter le Capteur3 et effectuer les calculs dans la fonction mesureLargeur, sur ma console n’apparait seulement la mesure pour la longueur du carton mais pas celle pour la largeur.

Ma question: est-ce qu’il est possible dans ma fonction mesureLargeur de pouvoir récupérer les données de 2 capteurs pour effectuer des calculs, et de répéter les commandes pour les 2 capteurs comme je l’ai fait ?

Je vous remercie pour votre aide,

Raphaël

const int Bouton = 2;
int pinCapteur1 = 7;
int pinCapteur2 = 4;
int pinCapteur3 = 8;
int vSon=59; //valeur de temps en µs d'un aller retour du son sur 1cm

void setup() 
{
  
  pinMode(2, INPUT);
  pinMode(7, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(8, OUTPUT); 
  Serial.begin(9600);
}

void loop()
{
  	int b = 1;
  	int a = digitalRead(2);
  
  if (a == b) 
  {
    int longueur=mesureLongueur(); //on récupère la valeur de la longueur du carton
  	Serial.println(longueur);// on affiche la longueur du carton en cm
    
    int largeur=mesureLargeur(); //on récupère la valeur de la largeur du carton 
  	Serial.println(largeur);// on affiche la largeur du carton en cm
    
    delay(100);
    while (digitalRead(Bouton)==HIGH);
	delay(500);
   
  } 
  else 
  {
   
  }
  	
   //Delay a little bit to improve simulation performance
}


//fonction de mesure de la longueur avec capteur 1 
int mesureLongueur() {
  unsigned long mesure = 0; // variable de mesure
  unsigned long cumul = 0; //variable pour la moyenne
  for (int t = 0; t < 10; t++) { // boucle pour effectuer 10 mesures
    pinMode (pinCapteur1, OUTPUT); //on prépare le pin pour envoyer le signal
    digitalWrite(pinCapteur1, LOW); //on commence à l'état bas
    delayMicroseconds(2); //on attend que le signal soit clair
    digitalWrite(pinCapteur1, HIGH);//mise à l'état haut
    delayMicroseconds(10); //pendant 10 µs
    digitalWrite(pinCapteur1, LOW); //mise à l'état bas
    pinMode(pinCapteur1, INPUT); //on prépare le pin pour recevoir un état
    mesure = pulseIn(pinCapteur1, HIGH); // fonction pulseIn qui attend un état haut et renvoie le temps d'attente
    cumul+=mesure; //on cumule les mesures
    delay(50); //attente obligatoire entre deux mesures
  }
  mesure=cumul/10; //on calcule la moyenne des mesures
  mesure=100 - mesure/vSon;//on transforme en cm
  return mesure; //on renvoie la mesure au programme principal
}


//fonction de mesure de distance pour la largeur
int mesureLargeur() {
  unsigned long mesure2 = 0; // variable de mesure capteur 2
  unsigned long mesure3 = 0; // variable mesure capteur 3
  unsigned long largeur = 0; // variable de la largeur 
  unsigned long somme2 = 0; //variable pour la moyenne
  unsigned long somme3 = 0; // variable calculer la moyenne
  for (int t = 0; t < 10; t++) { // boucle pour effectuer 10 mesures
    pinMode (pinCapteur2, OUTPUT);
    pinMode (pinCapteur3, OUTPUT);
	digitalWrite(pinCapteur2, LOW);  //on prépare le pin pour envoyer le signal
    digitalWrite(pinCapteur3, LOW); //on commence à l'état bas
    delayMicroseconds(2); //on attend que le signal soit clair
    digitalWrite(pinCapteur2, HIGH);//mise à l'état haut
    delayMicroseconds(10);
	digitalWrite(pinCapteur3, HIGH);
    delayMicroseconds(10); //pendant 10 µs
    digitalWrite(pinCapteur2, LOW); //mise à l'état bas
	digitalWrite(pinCapteur3, LOW);
    pinMode(pinCapteur2, INPUT); //on prépare le pin pour recevoir un état
	pinMode(pinCapteur3, INPUT);
    mesure2 = pulseIn(pinCapteur2, HIGH); // fonction pulseIn qui attend un état haut et renvoie le temps d'attente
    mesure3 = pulseIn(pinCapteur3, HIGH);
	somme2 += mesure2; //on somme les mesures du capteur 2
    delay(20);
    somme3 += mesure3; //on somme les mesures du capteur 3
    delay(20); //attente obligatoire entre deux mesures
  }
  mesure2=somme2/10; //on calcule la moyenne des mesures du capteur2
  mesure3=somme3/10; //on calcule la moyenne des mesures du capteur3
  largeur=100 - mesure2/vSon - mesure3/vSon;//on transforme en cm
  return largeur; //on renvoie la largeur au programme principal
}

La bibliothèque NewPing permet de gérer plusieurs capteurs ultrasons (lien Github), elle dispose d'un exemple avec 15 capteurs.