Machine de tri par couleur avancée avec Arduino et capteur RGB

Composants et fournitures

Arduino Nano R3	×	1
Capteur RGB TCS34725	×	1
Convertisseur abaisseur LM2596	×	1
Servomoteurs MG-90S	×	2
Roulement à billes MR105ZZ (5 × 10 × 4 mm)	×	3
Roulement à billes 608RS ou 608ZZ (8 × 22 × 7 mm)	×	1
Roulement à billes 6003RS (17 × 35 × 10 mm)	×	1
Vis à tête fraisée M3 × 15 mm	×	1
Vis auto-taraudeuses M2 × 10 mm	×	20
LED RVB (anode commune +)	×	1
Résistances 220 Ω	×	3
Fils	×	1
Prise jack 2,1 × 5,5 mm	×	1
Gaine thermorétractable	×	1
Connecteurs Dupont	×	1
Alimentation 9 V ou 12 V (1 A minimum)	×	1
5 tubes à essai 22 mm (OD) × 100 mm (Danmu Art)	×	1
Skittles !!!!!!!!	×	1

Outils et machines nécessaires

• Imprimante 3D
• Tournevis
• Dénudeur de fils
• Pinces
• Fer à souder
• Multimètre
• Outil à sertir

À propos de ce projet

Introduction

L'histoire amusante, c'est que ce projet n'était pas prévu au départ. Il y a environ 3,5 ans, j'ai commencé à concevoir une machine de tri par couleur bien plus sophistiquée et, comme beaucoup de mes projets, elle est restée à moitié finie, prenant la poussière sur le rebord de la fenêtre (je suis sûr que personne d'autre ne peut s'identifier à cela, haha).

Pour faire court, il y a quelques mois, j'ai décidé de reprendre ce vieux projet. La première chose à résoudre était comment collecter les Skittles depuis un réservoir et vérifier leur couleur de manière fiable, tout en gardant le système aussi compact que possible (ce que j'avais échoué à réaliser la première fois). Je me suis convaincu de concevoir une machine de tri plus simple juste pour valider le système de collecte. Je pensais naïvement que ce serait un travail de deux week-ends, simple, facile et rapide... Oh que j'avais tort !

Il m'a fallu deux conceptions complètement différentes et de nombreux prototypes ajustés pour obtenir quelque chose qui fonctionne de manière acceptable (je rencontre encore parfois des problèmes de prise).

Même si ce n'est pas parfait, je suis assez satisfait du résultat.

Comment ça fonctionne

La machine se divise en deux étapes principales.

Au sommet se trouve le réservoir pour les Skittles non triés. Au fond de ce réservoir se trouve le mécanisme d'alimentation responsable de la collecte des Skittles et de leur positionnement devant le capteur de couleur où leur couleur sera vérifiée.

Le mécanisme d'alimentation comprend un bras qui secoue le contenu du réservoir pour s'assurer que les Skittles s'écoulent bien à travers l'orifice du mécanisme d'alimentation sans se coincer à l'intérieur du réservoir (malheureusement, cela arrive encore parfois).

Une fois la couleur du Skittle identifiée, la deuxième étape de la machine entre en action. Le support des tubes à essai aligne le bon tube devant le mécanisme d'alimentation pour que le Skittle y tombe.

Le cycle peut alors se répéter jusqu'à ce que le réservoir soit vide.

Vous voulez fabriquer la vôtre ?

..................https://www.littlefrenchkev.com/colour-sorting-machine.......................

Assemblage

Une fois que vous avez téléchargé et imprimé les pièces, vous devriez obtenir quelque chose comme ceci :

Notez que le boîtier avant existe en deux versions. Pas de différence réelle, elles ont juste un aspect différent.

Le reste des pièces nécessaires.

Voici une vidéo du processus d'assemblage. J'ai même essayé d'être artistique en faisant une intro avec des plans en slow-motion de l'imprimante 3D !!!

Configuration initiale

La première chose que fait la machine quand vous l'allumez est de déplacer les deux servomoteurs vers leur position initiale. Lors du premier démarrage, vous devez vous assurer que l'engrenage/arbre collectant les Skittles est en position haute et que le support de tubes est aligné avec le mécanisme d'alimentation.

Dépannage

Si vous décidez de construire cette machine de tri, vous pourriez rencontrer quelques problèmes courants. Voici comment les résoudre.

LED clignotante rouge - pas de séquence de démarrage :

Après s'être déplacée vers sa position initiale, la machine devrait passer par sa séquence de démarrage. Si ce n'est pas le cas et que la LED clignote en rouge, cela signifie que vous avez un problème avec votre capteur RGB non détecté. Soit un problème de câblage, soit le capteur est défectueux.

Les tubes ne s'alignent pas correctement :

Cause 1

Pendant la séquence de démarrage, le support de tubes se déplace 5 fois, une fois pour chaque couleur. Vous pourriez remarquer que les tubes ne s'alignent pas bien avec le mécanisme d'alimentation. Cela peut être dû à l'imprécision des servos ou à des variations dans les dimensions d'impression.

Cela peut être corrigé par logiciel en modifiant le tableau de variables colour_angle. Chaque valeur dans ce tableau représente la position du servo pour chaque couleur ; en modifiant ces valeurs, vous pouvez affiner l'endroit où le tube s'arrête pour chaque couleur.

Cause 2

En raison des tolérances d'impression, vous pourriez aussi avoir du jeu dans les engrenages du support de tubes. Selon le sens de rotation, l'inertie peut faire dépasser la position d'arrêt. Cela peut aussi être corrigé par logiciel en modifiant les variables forward et backward anti_backlash. Ces valeurs seront ajoutées ou retranchées des valeurs d'angle de couleur selon le sens de rotation du support pour compenser ce jeu.

Mélange des couleurs :

Si vous rencontrez du mélange des couleurs, vous devrez modifier les tableaux colour_limit_values. Chaque valeur dans ces tableaux représente les valeurs minimales et maximales pour le Rouge, le Vert et le Bleu. Pour avoir une meilleure idée des valeurs à utiliser, chargez la machine avec une seule couleur, branchez-la à votre ordinateur et ouvrez le moniteur série. À chaque fois qu'un Skittle est vérifié, vous devriez obtenir ses valeurs RVB lues et la couleur que le programme identifie. Cela devrait vous donner une meilleure idée des valeurs à associer à chaque couleur.

Quelques fonctionnalités sympas

(en tout cas, je le pense !)

La LED RVB :

Il y a une LED RVB fixée à la base de la machine. Pendant le tri, elle change de couleur pour correspondre à la couleur du Skittle en cours de dépôt. Elle parcourt toutes les couleurs des Skittles en continu une fois le réservoir vide.

Elle clignotera aussi en rouge au démarrage si un problème est détecté avec le capteur.

Compensation anti-rebond :

Le support de tubes est entraîné par un couple d'engrenages droits. En raison des tolérances d'impression, il est très difficile d'éliminer complètement tout jeu dans les engrenages. Cela signifie que le support a tendance à dépasser sa position idéale. Le code permet de compenser cela en arrêtant le support plus tôt d'un certain montant selon la direction de rotation.

Délai avec bonus :

Le code inclut une fonction set_led(ms, color). Elle agit exactement comme la fonction delay(ms) mais permet à la LED de passer en douceur à sa nouvelle couleur pendant le délai. Cela fonctionne à merveille pour changer les couleurs de la LED pendant que le support de tubes tourne vers sa position !

Notes supplémentaires

Note 1 : J'ai imprimé ma machine en noir, ce qui aura un impact sur les valeurs de couleur que le capteur lira, surtout lorsqu'aucun Skittle n'est collecté par le mécanisme d'alimentation.

Note 2 : Après plusieurs cycles de tri, les couleurs des Skittles semblent devenir plus difficiles à lire de manière fiable. Je suppose que c'est dû à la perte de leur brillance après avoir frotté à l'intérieur du réservoir trop de fois ou qu'ils deviennent un peu collants lorsqu'ils sont manipulés à la main (ça fait dégoûtant !). Lors du calibrage des valeurs de couleur, essayez d'utiliser des Skittles « frais ».

Note 3 : Assurez-vous de prendre toutes les précautions nécessaires lors de la manipulation d'aliments. Cela inclut l'utilisation de filament d'impression alimentaire.

Note 4 : J'essaie de poster du travail en cours et mes projets sur Instagram. Si ça vous intéresse, jetez un œil ici : @little_french_kev

Code

LFK_sorting_machine (C/C++)

#include <Wire.h> 
#include "Adafruit_TCS34725.h" 
#include <Servo.h> 

/* Basé sur l'exemple de code pour la bibliothèque Adafruit TCS34725 */

//======================= Variables liées au capteur RGB =========================
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_24MS, TCS34725_GAIN_1X);
int colour = 0; // 0-noir, 1-jaune, 2-vert, 3-orange, 4-rouge, 5-violet
int previous_colour = colour;
int black_count = 0;
int start_measurment_angle = 88;
int measurment_sweep = 2;
int measurment_angle_increment = 4;

uint16_t black_limit_values[] = {0, 200, 0, 200, 0, 200};
uint16_t yellow_limit_values[] = {850, 2200, 800, 2200, 400, 1100};
uint16_t green_limit_values[] = {400, 800, 700, 1400, 300, 700};
uint16_t orange_limit_values[] = {650, 1800, 300, 850, 210, 600};
uint16_t red_limit_values[] = {400, 950, 150, 450, 150, 400};
uint16_t purple_limit_values[] = {150, 400, 150, 450, 150, 500};

//======================= Variables liées à la LED RVB =========================
byte R_pin = 5; byte G_pin = 6; byte B_pin = 11;
int current_red_value = 255; int current_green_value = 255; int current_blue_value = 255;
const int orange[] = {0, 230, 255};
const int red[] = {0, 255, 255};
const int green[] = {255, 0, 255};
const int yellow[] = {0, 170, 255};
const int purple[] = {0, 255, 40};

//======================= Variables liées aux servos d'alimentation =========================
int release_delay = 220;
const int colour_angles[] = {10, 46, 82, 118, 154};
const int backward_anti_backlash = 2;
const int forward_anti_backlash = 2;
Servo feeder_servo;
Servo holder_servo;

//=================================== SETUP =========================================
void setup(void) {
  Serial.begin(9600);
  pinMode(R_pin, OUTPUT); pinMode(G_pin, OUTPUT); pinMode(B_pin, OUTPUT);
  analogWrite(R_pin, 255); analogWrite(G_pin, 255); analogWrite(B_pin, 255);
  feeder_servo.attach(3); holder_servo.attach(2);
  feeder_servo.write(0); holder_servo.write(colour_angles[0]);
  
  int white[] = {0, 0, 0}; int black[] = {255, 255, 255};
  set_led(1000, white);
  
  if (tcs.begin()) {
    Serial.println("Found sensor"); starting_sequence();
  } else {
    Serial.println("No TCS34725 found ... check your connections");
    while (1) { set_led(300, red); set_led(300, black); }
  }
}

//=================================== LOOP =========================================
void loop(void) {
  if (black_count < 10) {
    feeder_servo.write(0); delay(450);
    previous_colour = colour; get_colour();
    if (colour == 0) { black_count++; shake(); }
    else if (colour == 6) { black_count++; }
    else { move_holder(); release_skittle(); black_count = 0; }
  } else { end_loop(1000); }
}

//=================================== GET COLOUR =========================================
void get_colour() {
  uint16_t r, g, b, c; uint16_t total_r = 0, total_g = 0, total_b = 0;
  feeder_servo.write(start_measurment_angle); delay(200);
  Serial.println("----------------");
  for (int i = 0; i <= measurment_sweep; i++) {
    tcs.getRawData(&r, &g, &b, &c);
    feeder_servo.write(start_measurment_angle + i * measurment_angle_increment);
    total_r += r; total_g += g; total_b += b; delay(15);
  }
  total_r /= measurment_sweep; total_g /= measurment_sweep; total_b /= measurment_sweep;
  Serial.print(total_r); Serial.print(" "); Serial.print(total_g); Serial.print(" "); Serial.print(total_b); Serial.println(" ");
  
  if ((total_r < black_limit_values[1]) && (total_g < black_limit_values[3]) && (total_b < black_limit_values[5])) {
    Serial.println("black"); colour = 0;
  } else if ((total_r >= yellow_limit_values[0]) && (total_r < yellow_limit_values[1]) && 
             (total_g >= yellow_limit_values[2]) && (total_g < yellow_limit_values[3]) && 
             (total_b >= yellow_limit_values[4]) && (total_b < yellow_limit_values[5])) {
    Serial.println("yellow"); colour = 1;
  } else if ((total_r >= green_limit_values[0]) && (total_r < green_limit_values[1]) && 
             (total_g >= green_limit_values[2]) && (total_g < green_limit_values[3]) && 
             (total_b >= green_limit_values[4]) && (total_b < green_limit_values[5])) {
    Serial.println("green"); colour = 2;
  } else if ((total_r >= orange_limit_values[0]) && (total_r < orange_limit_values[1]) && 
             (total_g >= orange_limit_values[2]) && (total_g < orange_limit_values[3]) && 
             (total_b >= orange_limit_values[4]) && (total_b < orange_limit_values[5])) {
    Serial.println("orange"); colour = 3;
  } else if ((total_r >= red_limit_values[0]) && (total_r < red_limit_values[1]) && 
             (total_g >= red_limit_values[2]) && (total_g < red_limit_values[3]) && 
             (total_b >= red_limit_values[4]) && (total_b < red_limit_values[5])) {
    Serial.println("red"); colour = 4;
  } else if ((total_r >= purple_limit_values[0]) && (total_r < purple_limit_values[1]) && 
             (total_g >= purple_limit_values[2]) && (total_g < purple_limit_values[3]) && 
             (total_b >= purple_limit_values[4]) && (total_b < purple_limit_values[5])) {
    Serial.println("purple"); colour = 5;
  } else { Serial.println("unknown"); colour = 6; }
}

//============================== MOVE HOLDER =============================
void move_holder() {
  int new_holder_position = colour_angles[colour - 1];
  int holder_delay = (abs(previous_colour - colour) * 70);
  if (holder_delay < 0) holder_delay = 0;
  
  if (previous_colour > colour) {
    int anti_backlash_angle = new_holder_position - backward_anti_backlash;
    holder_servo.write(anti_backlash_angle);
  } else {
    int anti_backlash_angle = new_holder_position + forward_anti_backlash;
    holder_servo.write(new_holder_position);
  }
  
  if (colour == 1) set_led(holder_delay, yellow);
  else if (colour == 2) set_led(holder_delay, green);
  else if (colour == 3) set_led(holder_delay, orange);
  else if (colour == 4) set_led(holder_delay, red);
  else if (colour == 5) set_led(holder_delay, purple);
}

//============================= RELEASE SKITTLE ===========================
void release_skittle() { feeder_servo.write(180); delay(release_delay); }

//================================= SHAKE =================================
void shake() {
  int shake_delay = 80; int shake_amount = 5; int shake_min_value = 90; int shake_max_value = 180;
  feeder_servo.write(180); delay(release_delay);
  feeder_servo.write(120); delay(80);
  for (int i = 0; i <= shake_amount; i++) {
    feeder_servo.write(shake_min_value); delay(shake_delay);
    feeder_servo.write(shake_max_value); delay(shake_delay);
  }
}

//============================ STARTING SEQUENCE ============================
void starting_sequence() {
  colour = 1; move_holder(); set_led(300, yellow); delay(400);
  colour = 2; move_holder(); set_led(300, green); delay(400);
  colour = 3; move_holder(); set_led(300, orange); delay(400);
  colour = 4; move_holder(); set_led(300, red); delay(400);
  colour = 5; move_holder(); set_led(300, purple); delay(400);
  previous_colour = colour; colour = 3; move_holder(); end_loop(200);
}

//================================ END LOOP =================================
void end_loop(int duration) {
  set_led(duration, orange); set_led(duration, red); set_led(duration, green);
  set_led(duration, yellow); set_led(duration, purple);
}

//============================ SET RGB LED COLOUR =======================
void set_led(int duration, int color[3]) {
  int start_time = millis(); int current_time = start_time; int current_duration = 0;
  while (current_duration < duration) {
    analogWrite(R_pin, map(current_duration, 0, duration, current_red_value, color[0]));
    analogWrite(G_pin, map(current_duration, 0, duration, current_green_value, color[1]));
    analogWrite(B_pin, map(current_duration, 0, duration, current_blue_value, color[2]));
    current_time = millis(); current_duration = current_time - start_time;
  }
  current_red_value = color[0]; current_green_value = color[1]; current_blue_value = color[2];
}

Schémas

Le câblage est assez simple. Assurez-vous simplement que votre convertisseur abaisseur délivre 5 V avant de brancher quoi que ce soit !!!!!