Machine de tri des couleurs

Outils et machines nécessaires

À propos de ce projet

INTRO.

L'histoire amusante est que ce projet n'a jamais été censé être.

Il y a environ 3,5 ans, j'ai commencé à concevoir une machine de tri des couleurs beaucoup plus géniale et, comme beaucoup de mes projets, elle a fini par collecter à moitié 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 que je devais déterminer était de savoir comment collecter des Skittles dans un réservoir et vérifier leur couleur de manière assez fiable tout en gardant le système aussi compact que possible (ce que je n'ai pas réussi à obtenir la première fois). J'ai réussi à me convaincre de concevoir une machine de tri des couleurs plus simple juste pour obtenir la bonne conception du système de collecte. J'ai bêtement pensé que ce serait un travail de 2 week-ends, sympa, facile et rapide... Oh mon Dieu !!! avais-je tort...

J'ai pris 2 conceptions complètement différentes et de nombreux prototypes modifiés pour obtenir quelque chose qui fonctionnait de manière acceptable (je rencontre toujours des problèmes de prise en charge de temps en temps).

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

COMMENT ÇA MARCHE.

La machine peut être divisée en 2 étapes principales.

Au sommet, vous pouvez trouver le réservoir pour les Skittles non triés. Au fond de ce réservoir se trouve le mécanisme d'alimentation chargé de collecter les quilles et de les positionner 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 quilles 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 trouvée, le deuxième étage de la machine entre en action. Le support de tubes à essai aligne le tube droit devant le mécanisme d'alimentation pour la quille à déposer.

Le cycle peut alors être répété jusqu'à ce que le réservoir soit vide.

VOUS VOULEZ FAIRE LE VOTRE ???

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

ASSEMBLAGE.

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

A noter que la coque avant se décline en 2 versions. Pas vraiment de différence, ils ont juste l'air différents.

Le reste des pièces nécessaires.

Voici une vidéo du processus d'assemblage. J'ai même essayé d'être un artiste en faisant une intro avec des photos d'imprimante 3D slowmo !!!

CONFIGURATION INITIALE.

La première chose que fait la machine lorsque vous mettez sous tension est de déplacer les deux servos dans leur position initiale. Lorsque vous démarrez la machine pour la première fois, vous devez vous assurer que l'engrenage/l'arbre collectant les quilles est en position haute et que le support de tube est aligné avec le mécanisme d'alimentation.

DÉPANNAGE.

Si vous décidez de fabriquer vous-même cette machine de tri, vous pourriez rencontrer quelques problèmes courants. voici comment vous pouvez les résoudre.

LED clignotante en 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 des problèmes avec votre capteur RBG introuvable. Il y a soit un problème avec votre 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 porte-tubes se déplacera 5 fois, une fois pour chaque couleur. Vous remarquerez peut-être que les tubes ne s'alignent pas trop bien avec le mécanisme d'alimentation. Cela peut être dû au fait que les servos ne sont pas super précis ou à certaines variations dans les dimensions de l'impression.

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

Cause 2

En raison des tolérances d'impression, vous pouvez également obtenir un certain jeu dans les engrenages du porte-tubes. Selon la façon dont les tubes tournent, leur inertie peut les faire dépasser leur position d'arrêt. Cela peut également être corrigé via un logiciel en modifiant la variable anti-jeu avant et arrière. Ces valeurs seront ajoutées ou supprimées des valeurs d'angle de couleur selon la façon dont le support tourne pour compenser ce jeu.

Mélange de couleurs :

Si vous rencontrez des mélanges de couleurs, vous devrez modifier les tableaux color_limit_values. Chaque valeur de ces tableaux représente les valeurs minimales et maximales pour le rouge, le vert et le bleu. Pour avoir une meilleure idée de ce que doivent être les valeurs, chargez la machine avec une seule couleur, branchez la machine sur 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 pense qu'elle est. Cela devrait vous donner une meilleure idée du type de valeurs à associer à chaque couleur.

QUELQUES FONCTIONNALITÉS COOL.

(enfin je pense qu'ils le sont de toute façon !)

La LED RVB :

Il y a une LED RVB montée sur la base de la machine. Pendant le processus de tri, il change de couleur pour correspondre à la couleur de la quille qui est larguée. Il parcourt toutes les couleurs de Skittle en continu une fois le réservoir vide.

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

Compensation anti-jeu :

Le porte-tubes est filé à l'aide de deux engrenages droits. En raison de la tolérance d'impression, il est très difficile d'éliminer complètement tout jeu dans les engrenages. Cela signifie que le porte-tube 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 en fonction de la direction dans laquelle le support tourne.

Retard avec extra :

Le code comprend une fonction "set_led(ms, color)". Il agit exactement comme la fonction "delay(ms)" mais permet à la LED de passer en douceur à sa nouvelle couleur pendant que le retard se produit. C'est un régal de changer les couleurs de la LED pendant que le porte tube tourne jusqu'à sa position !

REMARQUES SUPPLÉMENTAIRES.

Remarque 1 :j'ai imprimé ma machine en noir, cela aura un impact sur les valeurs de couleur que le capteur lira, en particulier lorsqu'aucune quilles n'est collectée par le mécanisme d'alimentation.

Remarque 2 :Après avoir effectué plusieurs fois le processus de tri, les couleurs des Skittles semblent devenir plus difficiles à lire de manière fiable. Je suppose que cela est dû au fait qu'ils perdent leur éclat après avoir frotté l'intérieur du réservoir à plusieurs reprises ou qu'ils deviennent un peu plus collants lorsqu'ils sont manipulés à la main (ça a l'air dégoûtant !). Lors de l'étalonnage des valeurs de couleur, essayez d'utiliser des quilles « fraîches ».

Remarque 3 :Veuillez vous assurer de prendre toutes les précautions nécessaires lors de la manipulation des aliments. Cela inclut de s'assurer que vous utilisez un filament d'impression sans danger pour les aliments.

Note 4 :J'essaie de publier quelques travaux en cours et quel projet je suis en train de préparer sur Instagram. Si c'est votre truc, vous pouvez jeter un oeil ici :https://www.instagram.com/little_french_kev/

Code

• LFK_sorting_machine

LFK_sorting_machineC/C++

#include #include "Adafruit_TCS34725.h"#include/* Basé sur un exemple de code pour la bibliothèque de dérivation Adafruit TCS34725 */// =======================Variables liées au capteur RVB=========================Adafruit_TCS34725 tcs =Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_24MS, TCS34725_GAIN_1X); // configuration RGB sensorint color =0;//0-black, 1-ylow, 2-green, 3-orange, 4-red, 5-purpleint previous_colour =color;int black_count =0; // nombre de colorint vide/inconnu start_measurment_angle =88; // position du servo pour aligner la quille devant sensorint measurment_sweep =2; //nombre de mesure prise . utilisé pour moyenner errorint measurment_angle_increment =4; //incrément d'angle entre les mesures//valeurs limites[] ={min_red_values, max_red_values, min_green_values, max_green_values, min_blue_values, max_blue_values}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 =========================octet R_pin =5; octet G_pin =6;octet 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 vert[] ={255, 0, 255};const int jaune[] ={0, 170, 255};const int violet[] ={0, 255, 40};//=======================Variables liées aux servos d'alimentation =========================int release_delay =220;const int colour_angles[] ={10, 46, 82, 118, 154};//{10, 46, 82, 118, 154};//int holder_offset =0; // ajustement du décalage pour le porte-tubes . à conserver entre 0 et 36const int back_anti_backlash =2;const int forward_anti_backlash =2;Servo feeder_servo; //déclarer le servomoteur d'alimentation Holder_servo; //déclarer le servo porte-tubes//===================================SETUP =========================================configuration void (void) { Serial.begin (9600); pinMode(R_pin, SORTIE); //définir la broche LED pinMode(G_pin, OUTPUT); pinMode(B_pin, SORTIE); analogWrite(R_pin, 255); // éteint la LED analogWrite (G_pin, 255); analogWrite(B_pin, 255); feeder_servo.attach(3) ; //fixer le servo d'alimentation à la broche 3 holder_servo.attach(2) ; // attachez le servo du support à la broche 2 feeder_servo.write(0); holder_servo.write(couleur_angles[0]); int blanc[] ={0, 0, 0} ; //valeurs blanches locales variable int black[] ={255, 255, 255}; //valeurs noires locales variable set_led(1000, blanc); // allume la LED (blanche) if (tcs.begin()) { // vérifie si le capteur a été trouvé Serial.println("Found sensor"); start_sequence(); } else { Serial.println("Aucun TCS34725 trouvé... vérifiez vos connexions"); while (1) //clignotement rouge rapide si capteur introuvable { set_led (300, rouge); set_led (300, noir); } }}//===================================BOUCLE ==========================================void loop(void) { if (black_count <10) { feeder_servo.write(0 ); // place la position du servo en haut pour le délai de récupération de la quille (450); // retard pour laisser le temps au servo d'alimentation de se mettre en position previous_colour =color; obtenir_couleur(); // lit la couleur de la quille if (couleur ==0) { black_count ++; //si aucune couleur n'est trouvée, incrémenter le black count shake();//donne un peu plus de shake au réservoir même s'il n'y a pas de quille } else if (couleur ==6) { black_count ++; //si la couleur est inconnue, incrémenter le nombre de noirs - pas de relâchement de la quille } else { //si la couleur est trouvée move_holder(); // déplacer le porte-tube release_skittle(); // relâche la quille black_count =0; } } else { end_loop(1000); }}//===================================OBTENIR LA COULEUR ==========================================void get_colour() { uint16_t r, g, b, c;//, colorTemp , lux; uint16_t total_r =0 ; uint16_t total_g =0 ; uint16_t total_b =0 ; feeder_servo.write(start_measurment_angle); //déplacer pour démarrer la mesure de l'angle delay(200); Serial.println("----------------"); for (int i =0; i <=mesure_sweep; i++) //boucle pour chaque mesure { tcs.getRawData(&r, &g, &b, &c); // obtenir les données de couleur feeder_servo.write(start_measurment_angle + i * measurment_angle_increment); //incrémenter l'angle d'asservissement pour la prochaine mesure total_r +=r; //ajoute la valeur rouge au total de la valeur rouge total_g +=g; //ajoute la valeur verte à la valeur verte totale total_b +=b; //ajout de la valeur bleue à la valeur totale du bleu delay(15); } total_r /=mesure_sweep; //valeurs moyennes sur toutes les mesures total_g /=measurment_sweep ; total_b /=mesure_sweep ; Serial.print(total_r); Serial.print(" "); Serial.print(total_g); Serial.print(" "); Serial.print(total_b); Serial.print(" "); Serial.println(" "); // comparer les valeurs pour déterminer la couleur . if ((total_r =yellow_limit_values[0]) &&//vérifier le jaune (total_r =yellow_limit_values[2]) &&(total_g  =yellow_limit_values[4]) &&(total_b =green_limit_values[0]) &&//vérifier le vert (total_r =green_limit_values[2]) &&(total_g  =green_limit_values[4]) &&(total_b =orange_limit_values[0]) &&//vérifier orange (total_r =orange_limit_values[2]) &&(total_g  =orange_limit_values[4]) &&(total_b =red_limit_values[0]) &&//vérifier le rouge (total_r =red_limit_values[2]) &&(total_g  =red_limit_values[4]) &&(total_b =purple_limit_values[0]) &&//vérifier le violet (total_r =purple_limit_values[2]) &&(total_g  =purple_limit_values[4]) &&(total_b  couleur) { //force le servo du support à revenir plus loin que la position normale pour compenser le jeu d'engrenage int anti_backlash_angle =new_holder_position - back_anti_backlash; holder_servo.write(anti_backlash_angle); //delay(holder_delay); } else { int anti_backlash_angle =new_holder_position + forward_anti_backlash; //holder_servo.write(anti_backlash_angle); holder_servo.write(new_holder_position); // déplace le titulaire en position //delay(holder_delay); } if (couleur ==1) { set_led(holder_delay , jaune); } else if (couleur ==2) { set_led(holder_delay , vert); } else if (couleur ==3) { set_led(holder_delay , orange); } else if (couleur ==4) { set_led(holder_delay , rouge); } else if (couleur ==5) { set_led(holder_delay , violet); } else {}}//=============================LIBÉRER LE QUILLE ===========================void release_skittle() { feeder_servo.write(180); // régler la position du servo vers le bas pour le délai de relâchement de la quille (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); // place la position du servo en bas pour le délai de relâchement de la quille (release_delay); feeder_servo.write(120); // place la position du servo en bas pour le délai de relâchement de la quille (80); for (int i =0; i <=shake_amount; i++) //boucle pour chaque mesure { feeder_servo.write(shake_min_value); // place la position du servo en bas pour le délai de relâchement de la quille (shake_delay); feeder_servo.write(shake_max_value); // place la position du servo en bas pour le délai de relâchement de la quille (shake_delay); }}//============================SÉQUENCE DE DÉMARRAGE ============================void start_sequence() { color =1; move_holder(); set_led (300, jaune); retard (400); couleur =2 ; move_holder(); set_led (300, vert); retard (400); couleur =3 ; move_holder(); set_led (300, orange); retard (400); couleur =4 ; move_holder(); set_led (300, rouge); retard (400); couleur =5 ; move_holder(); set_led (300, violet); retard (400); couleur_précédente =couleur ; couleur =3 ; move_holder(); end_loop(200);}//================================FIN DE BOUCLE ==================================void end_loop(int duration) { set_led(duration , orange); set_led(durée , rouge); set_led(durée , vert); set_led(durée , jaune); set_led(durée, violet);}//============================SET RVB LED COULEUR =======================// Cela agit comme un délai () mais permet à la LED de changer de couleur en attendant .void set_led(int duration, int color[3]) { int start_time =millièmes (); // start_time value int current_time =start_time; // valeur de l'heure actuelle int current_duration =0; // durée totale while (current_duration  

Schémas