Archives par étiquette : robotique

.

Mise à jour le 11/11/2021 : Dans cet article vous trouverez les caractéristiques principales du module AI HuskyLens Gravity SEN0305 avec utilisation de la reconnaissance faciale .

Sommaire :

• Présentation du module AI HuskyLens Gravity SEN0305
• Tuto sur la  reconnaissance facial
• Schéma de principe pour le cablage entre la carte Arduino Uno et la carte SEN0305
• Programme de  reconnaissance faciale,  de suivis de visage et du mode patrouille
• Retour au menu de la caméra.

 

Retour au sommaire

.

.

Présentation du module AI HuskyLens Gravity SEN0305

.

Le HuskyLens Gravity est un capteur visuel intelligent, économique, simple d’utilisation basé sur une caméra OV2640 associée à un afficheur 2″ IPS et à un processeur Kendryte K210.

Grâce au port UART / I2C, HuskyLens peut se connecter à Arduino et micro:bit pour vous aider à réaliser des projets très créatifs sans jouer avec des algorithmes complexes.

Spécification :

• Processeur : Kendryte K210
• Capteur d’images  : Objectif Husky SEN0305 : OV2640 (appareil photo 2,0 mégapixels).
• Tension d’alimentation : 3,3 ~ 5,0 V
• Consommation :  320 mA à 3,3 V , 230 mA à 5,0 V (mode de reconnaissance faciale ; luminosité du rétroéclairage à 80 % ; lumière d’ appoint éteinte).
• Port de communication : UART ; I2C
• Affichage : écran IPS de 2,0 pouces avec une résolution de 320*240
• Algorithmes intégrés : reconnaissance faciale, suivi d’objets, reconnaissance d’objets, suivi de lignes, reconnaissance de couleurs, reconnaissance de balises, classification d’objets
• Dimensions : 52 mm x 44,5 mm (2,05 * 1,75 pouces)

 

 

Retour au sommaire

.

Tuto sur la  reconnaissance facial

.

.

Retour au sommaire

.

Schéma de principe pour le cablage entre la carte Arduino Uno et la carte SEN0305

.

.

Matériel :

• Régulateur 7805 en boitier TO2020
  • https://www.gotronic.fr/art-l7805cv-1578.htm
• Module AI HuskyLens Gravity SEN0305
  • https://www.gotronic.fr/art-module-ai-huskylens-gravity-sen0305-31965.htm 
  • https://fr.rs-online.com/
    • code article  : 204-9898
• Arduino UNO
  • https://www.gotronic.fr/ 
    • code article : 25950

Retour au sommaire

.

Programme de  reconnaissance faciale,  de suivis de visage et du mode patrouille

.

//
//
// *********************************************
//
// reconnaissance faciale
//  suivis de visage reconnu
//   mode patrouille 
//
// Arduino avec la Camera Sen0305
//
// 
// Code Modifié : Mazelin H
// RedOhm 
// Le 01/09/2021
// *********************************************



//  À utiliser pour déterminer s'il s'agit d'une flèche ou d'un bloc
//  -> COMMAND_RETURN_BLOCK : C'est un bloc
//  -> COMMAND_RETURN_ARROW : C'est une flèche
//
// Pour un bloc :
// xCenter : X Centre du bloc
// yCenter : Centre Y du bloc
// width : Largeur du bloc
// height : Hauteur du bloc

#include <Servo.h>
#include "HUSKYLENS.h"

HUSKYLENS huskylens;

void printResult(HUSKYLENSResult result);

// Variable de passage 
int passage_setup = 0 ;

// Crée un objet de type "Servo_X", nommé -> Servo_X
Servo servo_x;
Servo servo_y;

int position_x = 90 ;
int position_y = 90 ;

// variable pour le calcul de l'erreur de positionnement en x 
int erreur_x;
 // Variable pour La grandeur réglante en x. La valeur réglante est la grandeur de  
 // commande qui a été choisie pour contrôler la grandeur réglée
 int valeur_reglante_x;
// variable pour le calcul de l'erreur de positionnement en y 
int erreur_y; 
 // Variable pour La grandeur réglante en y. La valeur réglante est la grandeur de  
 // commande qui a été choisie pour contrôler la grandeur réglée
 int valeur_reglante_y;
// position du mode patrouille
int pos ;
 

// **********************************************************************
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécutée une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// **********************************************************************
void setup() {
    // initialisation de la connexion série
    // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
    Serial.begin(115200);
    // on attent que le port de communication soit pret
    while (!Serial) {
     ; 
    }

    
    // communication i2c
    Wire.begin();
    while (!huskylens.begin(Wire))
    {
        Serial.println(F("Échec du démarrage!"));
        Serial.println(F("1.Veuillez revérifier le \"Protocol Type\" in HUSKYLENS (General Settings>>Protocol Type>>I2C)"));
        Serial.println(F("2.Veuillez revérifier la connexion."));
        delay(100);
    }
   
// associe le servomoteur x à la broche 9   
   servo_x.attach(9);
 // associe le servomoteur y à la broche 9     
    servo_y.attach(8);
    delay(15);
// Positionne mes servomteurs à 90 (phase d'initialisation) 
   servo_x.write(position_x);
   servo_y.write(position_y);
// Réalise une pause dans l'exécution du programme pour une durée 
// de 50 millisecondes
// permettant au servomoteur d'atteindre sa position  
   delay(50);
} 



// **********************************************************************
// Le programme principal s’exécute par une boucle infinie appelée Loop ()
// ********************************************************************** 
void loop() {
    

    
    // verifie la connexion
    if (!huskylens.request())
    {
      Serial.println(F("Échec de la demande de données à HUSKYLENS, revérifiez la connexion!"));
    }

    // controle si le module possède des enregistrements  
    else if(!huskylens.isLearned())
    {
      Serial.println(F("Je suis desolé il faut appuyer sur le bouton d'apprentissage "));
    }
    
    // on verifie si le systeme ne detecte rien dans son champs de vision 
    else if(!huskylens.available())
    {
      Serial.println(F("Aucun bloc ou flèche n'apparaît à l'écran! Oryon ne detecte rien "));
      
      // mise en service du mode patrouille 
      // pour la recherche d'un visage 
      // x < y (position_x est inferieur à y)
      if (( position_x < 170)&&( pos == 0))  
      {
      position_x = position_x +1;      
      servo_x.write(position_x);
      
      }  
      else if (( position_x < 171)&&(position_x > 10))
      {
      pos = 1 ;
      position_x = position_x -1;      
      servo_x.write(position_x);   
      }
      else if (position_x <= 10)
      {
      pos=0;  
      }
      delay(20);
      Serial.println (position_x);
    }
    
    else
    {
        Serial.println(F("###########"));
        while (huskylens.available())
        {
            HUSKYLENSResult result = huskylens.read();
            printResult(result);

            
           
        }    
    }
}


//
void printResult(HUSKYLENSResult result){
    if (result.command == COMMAND_RETURN_BLOCK){
          Serial.println(String()+F("Block:xCenter=")+result.xCenter+F(",yCenter=")+result.yCenter+F(",width=")+result.width+F(",height=")+result.height+F(",ID=")+result.ID);
           
           
            // Deplacement de la camera sur horizontal cote droit 
            // 
            // x > y (result.xCenter est supérieur à y)
            if (result.xCenter > 165)
            {
              
              // calcul de l'erreur de positionnement 
              erreur_x = result.xCenter - 165 ; 
              // valeur_reglante
              valeur_reglante_x= map(erreur_x,1,50,1,5);
              position_x =position_x+valeur_reglante_x ;
              servo_x.write(position_x);  
            }

            // Deplacement de la camera sur horizontal cote gauche 
            // 
            else if ( result.xCenter < 155)
            {  
              // calcul de l'erreur de positionnement 
              erreur_x = 155 - result.xCenter ;
              // valeur_reglante
              // map -> Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette
              // map (valeur, limite_basse_source, limite_haute_source, limite_basse_destination, limite_haute_destination)
              valeur_reglante_x= map(erreur_x,1,50,1,5);
              position_x = position_x - valeur_reglante_x ;
              
              servo_x.write(position_x);  
            }

            
            else if ((result.xCenter > 165)&&( result.xCenter < 155))
            {

            servo_x.write(position_x); 
            
            }
            // si la camera est trop haut
            if (result.yCenter < 115) 
            {
              // calcul de l'erreur de positionnement 
              erreur_y = 115-result.yCenter  ; 
              // valeur_reglante
              valeur_reglante_y= map(erreur_y,1,50,1,5); 
              position_y = position_y + valeur_reglante_y ;
              servo_y.write(position_y);       
            }

            // si la camera est trop basse 
            else if ( result.yCenter > 125)
            {  
              // calcul de l'erreur de positionnement pour la camera trop basse 
              erreur_y = result.yCenter -125  ; 
              // valeur_reglante
              valeur_reglante_y= map(erreur_y,1,50,1,5); 
              position_y = position_y -valeur_reglante_y ;
              servo_y.write(position_y);  
            }

           // Temporisation de stabilité 
           delay (100);
             
           
           // affectation du resultat a un prenom ( a une personne )
           if (result.ID == 1 )
           {
            Serial.println ("Bonjour Louis");
           }
           else if (result.ID == 2 ) 
           {
            Serial.println ("Bonjour Timeo");
           } 
           else if (result.ID == 3 ) 
           {
            Serial.println ("Bonjour au grand maitre ");
           } 
           else if (result.ID == 4 ) 
           {
            Serial.println ("Salut Johann ");
           }
           else if (result.ID == 5 ) 
           {
            Serial.println ("Bonjour Marie");
      
      
           }

    }      
    
    else if (result.command == COMMAND_RETURN_ARROW){
        Serial.println(String()+F("Arrow:xOrigin=")+result.xOrigin+F(",yOrigin=")+result.yOrigin+F(",xTarget=")+result.xTarget+F(",yTarget=")+result.yTarget+F(",ID=")+result.ID);
        
    }
    else{
        Serial.println("Objet inconnu!");
    }   
     
}

.

Retour au sommaire