Projets Matlab & Microcontrôleur #8: Machine de tri Automatique par couleurs

Découvrez notre nouvelle Chaîne YouTube "Ingénierie & Bourse"
Obtenir le fichier PDF

Machine de tri automatique avec arduino Schéma de principe

Objectifs

  • Savoir contrôler un servomoteur avec Matlab
  • Savoir établir la liaison série entre Matlab & Arduino
  • Savoir comment détecter une couleur dans une image
  • Savoir utiliser un seuil optimal d’une image
  • Savoir utiliser quelques fonctions de morphologie mathématique
  • Et autres astuces.

Vidéo démonstration

Fonctionnement

Le projet dans sa globalité permet de trier des objets en fonction de leurs couleurs. Par exemple le tri des balles, pièces, etc. C’est un système détection et poursuite d’objets basés sur la détection des couleurs. Il est constitué par les éléments suivants :

Caméra : comme tout système de vision, une caméra est un capteur d’image. Elle fournit l’image de la scène. On utilisera la caméra de l’ordinateur.

Matlab : Son rôle est la récupération des images de la caméra, traitement et analyse d’images. Il coconnait et traque l’une ou plusieurs des trois composantes d’une image (Red (R), Green (G) et Bleu (B)). Le programme filtre l’ensemble de l’information dans l’image et préserve uniquement les couleurs cibles. Par exemple si on montre une balle rouge avec sa main, alors la zone de la balle sera détectée (la main et le reste de la scène sera filtrés et remplacés par une zone noire (pixels nuls)). Si on montre deux balles rouge et bleu, le programme indique la présence des deux couleurs, ou trois balles, etc.

La lecture de la caméra se fait en boucle ainsi que l’ensemble des traitements. Lorsqu’une couleur est détectée, l’information est envoyée à la carte Arduino via la liaison série. La valeur envoyée indique le nombre des composantes détectées. En effet, avec trois composantes on peut avoir 8 combinaisons possibles : 000-111 ou de 0 à 7.

Carte Aduino : Elle récupère la donnée  envoyée par le logiciel Matlab comprise entre 0 et 7 et la transforme en commande.

Les LEDs : les trois LED rouge, vert et bleu s’activent lorsqu’une une ou plusieurs composante couleur est détectée. En effet, on duplique les valeurs acquises (0-7) sur les LED. Exemples :

  • Valeur =(0) 000 : Trois LEDs éteintes
  • Valeur =(1)001 : LED rouge allumée, détection de la composante rouge uniquement
  • Valeur =(2)010 : LED bleu allumée, détection de la composante bleu uniquement
  • …
  • Valeur =(7)111 : Trois LEDs Allumé (détection de trois balles)

Servomoteur : le servomoteur est un simulateur d’un système de tri des pièces. On imagine l’arrivée des pièces dans un tapis roulant, un système d’aguillage à base du servomoteur se trouve à l’extrémité du tapis. Il dirige les pièces dans trois boîtes : la première pour les pièces rouges, la deuxième pour les rouges et la dernière pour les bleus. En effet, dans ce cas on ne peut détecter que l’une des trois couleurs (001 (1) ou 010 (2) ou 100(4)). Les autres combinaisons sont ignorées par le programme (voir la suite pour plus des détails).

Commande servomoteur SG90

Projets indispensables pour la compréhension de le suite

  1. ARDUINO CLAP CLAP

  2. RECONNAISSANCE DES COULEURS AVEC MATLAB ET ARDUINO 1/2

  3. RECONNAISSANCE DES COULEURS AVEC MATLAB ET ARDUINO 2/2

Programme Matlab

Ouverture du port série (Open.m)

function SerialCOM = Open()

% Paramètres de la liaison série (COM)

BauValue=115200;            % Vitesse
NumBits=8;                  % Nombre de bits

% Création d'un objet Serial Port
SerialCOM = serial('COM3','BaudRate',BauValue,'DataBits', NumBits, 'Parity', 'none');
SerialCOM.Terminator = 'LF';
set(SerialCOM, 'Timeout',2);

% Connexion du port
fopen(SerialCOM);

end
...
SerialCOM = Open();
...

Création d’un objet vidéo

vid=videoinput('winvideo',1);
set(vid,'ReturnedColorSpace','RGB');

Obtenir un snapshot de la caméra

imm=getsnapshot(vid); % Obtenir l'image actuelle
im_rgb=imresize(imm,0.5); % Réduction de 50%

Récupérer les composantes R, G et B

...
im_gray=rgb2gray(im_rgb);
im_R=im_rgb(:,:,1);im_r=imsubtract(im_R,im_gray);
im_G=im_rgb(:,:,2);im_g=imsubtract(im_G,im_gray);
im_B=im_rgb(:,:,3);im_b=imsubtract(im_B,im_gray);
...

Composante rouge après soustraction Composante vert après soustraction

Seuillage + Ouverture

...
val_r=abs(max(double(im_r(:)))-20); seuil_r=val_r/255;  % Seuil de l'image (variable)
val_g=abs(max(double(im_g(:)))-20); seuil_g=val_g/255;
val_b=abs(max(double(im_b(:)))-20); seuil_b=val_b/255;

Seuil_min=50;     % Seuil minimal fixe ( Problème du à l'absence de la couleur cible)
im_bw=im2bw(im_r,seuil_r);im_bw1=im_bw & (im_r >Seuil_min);
se=strel('disk',10); im_out_r=imclose(im_bw1,se);

im_bw=im2bw(im_g,seuil_g);im_bw1=im_bw & (im_g >(Seuil_min/5));
im_out_g=imclose(im_bw1,se);

im_bw=im2bw(im_b,seuil_b);im_bw1=im_bw & (im_b >Seuil_min);
im_out_b=imclose(im_bw1,se);
...

Calcul de l’état des  LED (0 -7)

...
% Nombre des pixels de la couleur R, G, B
taille_r=length(find(im_out_r(:)==1));
taille_g=length(find(im_out_g(:)==1));
taille_b=length(find(im_out_b(:)==1));

% Activation de la LED par le nombre de pixels
Seuil_detec=100;
LED_r=double(taille_r>Seuil_detec);
LED_g=double(taille_g>Seuil_detec);
LED_b=double(taille_b>Seuil_detec);
LED=[LED_r LED_g LED_b];
...

 Conversion et transmission de la valeur à la carte Arduino

...
% Conversion BCD => Decimal
LED_val =LED_r*4+ LED_g*2 + LED_b % RGB

% Transfert de la valeur
fprintf(SerialCOM,'%d\n',LED_val);
...

Programme Matlab Complet

close all; clc;

%% Ouverture du port série

SerialCOM = Open(); % A commenter après la 1ère exécution

%% Création de l'objet vidéo

vid=videoinput('winvideo',1);
set(vid,'ReturnedColorSpace','RGB');

%% Détection de la composante rouge dans l'image

while 1
    
    % Obtenir l'image actuelle
    imm=getsnapshot(vid); 
    im_rgb=imresize(imm,0.5); % Réduction de 50%
    
    % Récupérer les composantes R, G et B
    im_gray=rgb2gray(im_rgb);
    im_R=im_rgb(:,:,1);im_r=imsubtract(im_R,im_gray);
    im_G=im_rgb(:,:,2);im_g=imsubtract(im_G,im_gray);
    im_B=im_rgb(:,:,3);im_b=imsubtract(im_B,im_gray);
    
    %     subplot(221); imshow(im_rgb); title('Image RGB');
    %     subplot(222); imshow(im_r); title('R Après soustraction');
    %     subplot(223); imshow(im_g); title('G Après soustraction');
    %     subplot(224); imshow(im_b); title('B Après soustraction');
    
    %% Seuillage de l'image (binérisation)
    
    val_r=abs(max(double(im_r(:)))-20); seuil_r=val_r/255;  % Seuil de l'image (variable)
    val_g=abs(max(double(im_g(:)))-20); seuil_g=val_g/255;
    val_b=abs(max(double(im_b(:)))-20); seuil_b=val_b/255;
    
    Seuil_min=50;     % Seuil minimal fixe ( Problème du à l'absence de la couleur cible)
    im_bw=im2bw(im_r,seuil_r);im_bw1=im_bw & (im_r >Seuil_min);
    se=strel('disk',10); im_out_r=imclose(im_bw1,se);
    
    im_bw=im2bw(im_g,seuil_g);im_bw1=im_bw & (im_g >(Seuil_min/5));
    im_out_g=imclose(im_bw1,se);
    
    im_bw=im2bw(im_b,seuil_b);im_bw1=im_bw & (im_b >Seuil_min);
    im_out_b=imclose(im_bw1,se);
    
    %% Activation des LEDs (0-7)
    
    % Nombre des pixels de la couleur R, G, B
    taille_r=length(find(im_out_r(:)==1));
    taille_g=length(find(im_out_g(:)==1));
    taille_b=length(find(im_out_b(:)==1));
    
    % Activation de la LED par le nombre de pixels
    Seuil_detec=100;
    LED_r=double(taille_r>Seuil_detec);
    LED_g=double(taille_g>Seuil_detec);
    LED_b=double(taille_b>Seuil_detec);
    LED=[LED_r LED_g LED_b];
    
    %% Affichage
    
    subplot(221); imshow(im_rgb);   title('RGB');
    subplot(222); imshow(im_out_r); title('R');
    subplot(223); imshow(im_out_g); title('G');
    subplot(224); imshow(im_out_b); title('B');
    
    %% Transmission à l'Arduino
    
    % Conversion BCD => Décimal
    LED_val =LED_r*4+ LED_g*2 + LED_b % RGB
    
    % Transfert de la valeur
    fprintf(SerialCOM,'%d\n',LED_val);
    
end

%% Port Delete (Previous port if exist)

Delete(SerialCOM); % A exécuter seule pour libérer le port

Programme Arduino

  • LED_r: PIN 5
  • LED_g: PIN 6
  • LED_b: PIN 7
  • ServoMoteur: PIN 11

Lecture du port série en format entier

LED_val = Serial.parseInt();

Allumage des LED en fonction de la valeur acquise

void SetLEDs(int LED_vall, int LED_r_PINN, int LED_g_PINN, int LED_b_PINN )
{
  switch (LED_vall) 
  {
    case 0:
      digitalWrite(LED_b_PINN, LOW);
      digitalWrite(LED_g_PINN, LOW);
      digitalWrite(LED_r_PINN, LOW);
      break;
    case 1:// B
      digitalWrite(LED_b_PINN, HIGH);
      digitalWrite(LED_g_PINN, LOW);
      digitalWrite(LED_r_PINN, LOW);
      break;
    case 2:
      digitalWrite(LED_b_PINN, LOW);
      digitalWrite(LED_g_PINN, HIGH);
      digitalWrite(LED_r_PINN, LOW);
      break;
    case 3:
      digitalWrite(LED_b_PINN, HIGH);
      digitalWrite(LED_g_PINN, HIGH);
      digitalWrite(LED_r_PINN, LOW);
      break;
    case 4:
      digitalWrite(LED_b_PINN, LOW);
      digitalWrite(LED_g_PINN, LOW);
      digitalWrite(LED_r_PINN, HIGH);
      break;
    case 5:
      digitalWrite(LED_b_PINN, HIGH);
      digitalWrite(LED_g_PINN, LOW);
      digitalWrite(LED_r_PINN, HIGH);
      break;
    case 6:
      digitalWrite(LED_b_PINN, LOW);
      digitalWrite(LED_g_PINN, HIGH);
      digitalWrite(LED_r_PINN, HIGH);
      break;
    case 7:
      digitalWrite(LED_b_PINN, HIGH);
      digitalWrite(LED_g_PINN, HIGH);
      digitalWrite(LED_r_PINN, HIGH);
      break;
  }
}
...
SetLEDs( LED_val, LED_r_PIN, LED_g_PIN, LED_b_PIN);
...

Contrôle du servomoteur

  • Détection de la couleur Rouge : Angle 20 degré
  • Détection de la couleur Vert : Angle 20+70=90 degré
  • Détection de la couleur Bleu : Angle 20+140=160 degré
void SetServoM(int LED_vall)
{
  switch (LED_vall) 
  {
    case 1:
      SERVO1.write(20);
      delay(100);    
      break;
    case 2:
      SERVO1.write(90); 
      delay(100);   
      break;
    case 4:
      SERVO1.write(160);
      delay(100);    
      break;  
  }
}
...
SetServoM(LED_val); 
...

Programme complet

#include <Servo.h>

/*
LED_r:    PIN 5
LED_g:    PIN 6
LED_b:    PIN 7
ServoMoteur: PIN 11
*/
Servo SERVO1;
const int LED_r_PIN=5; 
const int LED_g_PIN=6; 
const int LED_b_PIN=7; 
const int ServoM_PIN=11; 

int LED_val=0;

void setup() 
{
  // LED R, G et B 
  pinMode(LED_r_PIN, OUTPUT);   
  pinMode(LED_g_PIN, OUTPUT);   
  pinMode(LED_b_PIN, OUTPUT);    
  
  // Initialisation
  digitalWrite(LED_r_PIN, LOW);
  digitalWrite(LED_g_PIN, LOW);
  digitalWrite(LED_b_PIN, LOW);

  // Servo
  SERVO1.attach(ServoM_PIN);
  
  // UART
  Serial.begin(115200);
}

void loop() 
{ 
  LED_val = Serial.parseInt();
  SetLEDs( LED_val, LED_r_PIN, LED_g_PIN, LED_b_PIN);
  SetServoM(LED_val); 
}

void SetLEDs(int LED_vall, int LED_r_PINN, int LED_g_PINN, int LED_b_PINN )
{
  switch (LED_vall) 
  {
    case 0:
      digitalWrite(LED_b_PINN, LOW);
      digitalWrite(LED_g_PINN, LOW);
      digitalWrite(LED_r_PINN, LOW);
      break;
    case 1:// B
      digitalWrite(LED_b_PINN, HIGH);
      digitalWrite(LED_g_PINN, LOW);
      digitalWrite(LED_r_PINN, LOW);
      break;
    case 2:
      digitalWrite(LED_b_PINN, LOW);
      digitalWrite(LED_g_PINN, HIGH);
      digitalWrite(LED_r_PINN, LOW);
      break;
    case 3:
      digitalWrite(LED_b_PINN, HIGH);
      digitalWrite(LED_g_PINN, HIGH);
      digitalWrite(LED_r_PINN, LOW);
      break;
    case 4:
      digitalWrite(LED_b_PINN, LOW);
      digitalWrite(LED_g_PINN, LOW);
      digitalWrite(LED_r_PINN, HIGH);
      break;
    case 5:
      digitalWrite(LED_b_PINN, HIGH);
      digitalWrite(LED_g_PINN, LOW);
      digitalWrite(LED_r_PINN, HIGH);
      break;
    case 6:
      digitalWrite(LED_b_PINN, LOW);
      digitalWrite(LED_g_PINN, HIGH);
      digitalWrite(LED_r_PINN, HIGH);
      break;
    case 7:
      digitalWrite(LED_b_PINN, HIGH);
      digitalWrite(LED_g_PINN, HIGH);
      digitalWrite(LED_r_PINN, HIGH);
      break;
  }
}

void SetServoM(int LED_vall)
{
  switch (LED_vall) 
  {
    case 1:
      SERVO1.write(20);
      delay(100);    
      break;
    case 2:
      SERVO1.write(90); 
      delay(100);   
      break;
    case 4:
      SERVO1.write(160);
      delay(100);    
      break;  
  }
}

Téléchargement

Photos du projet

Machine de tri automatique BLEU

Machine de tri automatique ROUGE

Tout les projets Matlab & µC

Nous Soutenir 💌
Le blog contient des publicités, elles permettent de financer l'hébergement et maintenir le blog en fonctionnement. Vous pouvez utiliser adblock pour une lecture sans publicités.

You have successfully subscribed to the newsletter

There was an error while trying to send your request. Please try again.

FPGA | Arduino | Matlab | Cours will use the information you provide on this form to be in touch with you and to provide updates and marketing.