gotronic Archives

Arduino avec la Camera Sen0305 , la reconnaissance faciale

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!");
    }   
     
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

// *********************************************

// 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

L3-37 version RC , Fiche de montage

Mise à jour le 11/12/2020 : Dans cet article vous retrouverez les fichiers à télécharger pour construire la tête et le buste du robot L3 -37 pour la version RC, mais aussi l’ensemble des fiches de montage pour y parvenir.

Continuer la lecture →

Création d’un indexeur pour la plateforme lidar

Mise à jour le 22/12/2019 : Dans cet article ,nous allons étudier comment installer, câbler, programmer un capteur de position pour cela , nous allons détourner le fonctionnement du module compteur de vitesse ECC 03

Continuer la lecture →

Capteur de Distance Laser LIDAR-Lite 3

Mise à jour le 01/12/2019 : Article traitant du module laser LIDAR-Lite V3 de Garmin permettant de mesurer des distances de 0 à 40 m. Ce module communique avec un microcontrôleur type Arduino via une liaison PWM ou I2C..

Continuer la lecture →

Joy-it : KY-053 Convertisseur analogique digital

Mise à jour le 29/01/2020 : Rubrique traitant du module à 4 canaux permet de mesurer des tensions analogiques avec une précision de 16 bits. Il est basé sur un ADS1115 et communique avec un microcontrôleur via le bus I2C.

Continuer la lecture →

Servomoteur à rotation continue

–

Mise à jour le 21/11/2019 : Dans cet article, vous trouverez toutes les informations nécessaires pour l’utilisation des servomoteurs à rotation continue. De nombreux programmes , en particulier pour les cartes Arduino , seront développés pour l’utilisation de ses servo, vous trouverez aussi les schémas électriques et les documentations techniques nécessaires pour réaliser éventuellement vos projets.

Continuer la lecture →

Robot Golbotth8

–.

Mise à jour le 25/02/2021 : Ce petit robot est destiné à vous initier à la programmation, nous l’appellerons Golbotth8. La construction de cet engin passe déjà par l’impression 3D, vous trouverez l’ensemble des fichiers STL sur notre site ainsi que la matière que nous avons utilisée et les différents conseils techniques. Vous aurez la possibilité de suivre des tutoriels sur Arduino avec ce module. Nous avons surtout essayé de minimiser le coût de l’ensemble.

Continuer la lecture →

Robot Nestor : Tutoriel de montage du visage de Nestor

–

Mise à jour le 04/08/2018 : Le but de ce tutoriel est de clarifier le montage des différents éléments dans le visage du robot Nestor. Vous retrouvez sur cette page ou sur la vidéo les références des matériels ainsi que les liens éventuels pour vous les procurer.

Continuer la lecture →

Robot Nestor : je veux tout savoir

–

Mise à jour le 07/09/2020 : L’équipe RedOhm vous présente le robot Nestor. Ce nouveau compagnon est prévu surtout pour être un robot de compagnie.

Continuer la lecture →

Grove : Diviseur de tension Grove 104020000

–

Mise à jour le 09/09/2018 : Rubrique traitant du module diviseur de tension Grove qui permet de diviser une tension d’entrée par 3 ou par 10 et permet de mesurer une tension analogique de 0,3 à 12,9 Vcc ou de 1 à 43 Vcc.

Continuer la lecture →