Archives de catégorie : Applications

Mit inventor avec Arduino

.

Sommaire :

 

 

 

.

separateur-redohm-001

Communication en bluetooth d’une tablette vers Arduino
avec Mit Inventor

Mise à jour le 08/10/2022.

Dans ce tuto ,nous allons travailler sur la communication entre une tablette sous Android et une carte Arduino équipée d’une carte bluetooth de type HC06

Nous allons donc étudier la partie interface sous Mit App Inventor pour la tablette et le traitement des informations avec l’ide Arduino

.

télécharger les fichiers . Retour au sommaire

.

separateur-redohm-001

Mit Inventor création d’un controlPad

.

Mise à jour 11/10/2022. 

Cette vidéo est un tutoriel pratique détaillant la création d’une interface de contrôle pour piloter un robot mobile via une carte Arduino, utilisable sur tablette ou smartphone. Elle débute par une présentation générale du projet , suivie d’une session sur la réalisation de l’interface utilisateur avec le Designer dans MIT App Inventor . La majeure partie de la vidéo se concentre sur la programmation des blocs dans MIT App Inventor, illustrant comment les différents éléments de l’interface peuvent être programmés pour contrôler le robot. Le tutoriel se conclut avec un essai pratique du système et une conclusion , offrant une démonstration concrète de l’application en action et résumant les points clés appris.

 

télécharger les fichiers   Retour au sommaire

.

separateur-redohm-001

2023-01-08- Mit inventor contrôler votre Smartphone avec le capteur de luminosité

Dans ce tutoriel, nous allons étudier sur Mit Inventor comment contrôler votre smartphone avec le capteur de luminosité ou bien retranscrire ces informations vers votre carte Arduino ou tout autre carte microcontrôleur. Avec ce type de capteur, nous pouvons créer un luxmètre ou d’autres applications qui réagissent avec la lumière. On peut bien évidemment s’en servir aussi comme capteur de proximité

.

télécharger les fichiers   Retour au sommaire

.

separateur-redohm-001

2022-11-05- Mit inventor creation d’un joystick analogique pour
 Arduino – 1/5

Dans ce tutoriel nous allons étudier sur Mit Inventor comment créer un joystick analogique sur votre tablette ou sur un smartphone afin de pouvoir piloter en Bluetooth une unité mobile avec la carte microcontrôleur Arduino. Vous aurez donc un ensemble de 5 tutoriels traitant de ce type de pilotage.

.

télécharger les fichiers  Retour au sommaire

.

separateur-redohm-001

2023-01-19- Mit inventor un joystick analogique pour Arduino decryptage de la chaine de positionnnement 2/5

 

Dans ce tutoriel, nous allons étudier comment décrypter une chaîne de caractères de type String envoyé par Bluetooth depuis votre smartphone ou votre tablette vers arduino. Cette chaîne sera donc décryptée par arduino pour extraire les valeurs x et y de déplacement du joystick virtuel de votre application nous permettant de piloter un robot mobile , une plateforme ou tout autre objet qui peut être piloté . Cette vidéo nous permet de mettre en lumière les fonctions ou les méthodes à utiliser comme indexOf , concat ,substring.

.

Retour au sommaire

.

separateur-redohm-001

2022-09-16- Mit inventor le changement de page

Vous trouverez dans cette vidéo les informations nécessaires pour la création de plusieurs pages sur Mit Inventor et surtout la possibilité de naviguer entre elle.

Mit App Inventor est un soft pour la création d’applications pour toutes les plateformes basées sur Microsoft , qui évite le langage complexe de codage en bloc de construction visuelle par glisser-déposer.

.

Retour au sommaire

 

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 :

 

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

 

Arduino : Coder la fonction d’un télerupteur

.

Mise à jour le 09/10/2020 : Ce tutoriel vous explique comment coder un télerupteur sur Arduino. 2 types de fonctionnement vous sont proposés.

Sommaire : 

.

Principe de fonctionnement de la fonction

.

2 types de fonctionnement vous sont proposés.

  • le premier étant le modèle standard : Lorsque l’on appuie sur le bouton poussoir, une impulsion met le télérupteur au travail, il ferme le circuit jusqu’à ce qu’une nouvelle impulsion l’ouvre et ainsi de suite. Les informations électriques qui font changer l’état du télérupteur sont du type front montant.
    Il vous est donc proposé dans le programme fourni dans cet article ,un ensemble de codes composés de six lignes qui vous permet de créer cette fonction.

.

Telerupteur changement d'état sur le front montant

Telerupteur changement d’état sur le front montant

.

  • Deuxième montage. Lorsqu’on appuie sur le bouton poussoir, une impulsion met le télérupteur au travail met sur le front descendant. Il faut donc relâcher le bouton pour que le télérupteur soit actif. Lorsque nous avons une nouvelle impulsion toujours sur le front descendant le système se remet à l’état de repos et ainsi de suite.
    Il vous faudra donc mettre une ligne en commentaire pour générer cette fonction dans le code fourni . 
telerupteur changement d'état sur le front descendant

telerupteur changement d’état sur le front descendant

.

Retour au sommaire

.

Programme support pour le tutoriel 

.

//
//
//************************************************
//
//RedOhm
//le 20/09/2020
//H-Mazelin
//
//Creation d'un telerupteur  
//
//
//IDE Arduino 1.8.10 
//************************************************

// déclaration de l'entrée du bouton branché sur la broche 6
// de votre carte Arduino 
int bouton6 = 6;
 
// variable du type int pour stocker les valeurs de passage du bouton6
int bouton6v;

// creation d'une memoire_2 et forçage a 0 de la variable 
// etat du telerupteur 
int memoire_2=0;

// etat precedent du bouton et forçage a 0 de la variable 
int etat_bouton6v=0 ;




// --------------------------------------------------------------------
// 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() {
//ouvre le port série et fixe le debit de communication à 9600 bauds
   Serial.begin(9600);
// on attent que le port de communication soit pret
   while(!Serial); 

// Configure la broche spécifiée pour qu'elle se comporte soit en entrée, 
// soit en sortie.Dans notre cas en entrée pour le bouton6
  pinMode(bouton6,INPUT);

}

void loop() {
  


bouton6v = digitalRead(bouton6);

// Creation un telerupteur 
// Compare la variable à gauche avec la valeur ou la variable
// à droite . Renvoie l'information vraie lorsque les deux
// variables ne sont pas égales. 
   if (bouton6v!=etat_bouton6v)
    {
       if (!bouton6v)
      {
        //Inversion de la valeur de la variable memoire 
        memoire_2=!memoire_2;
      } 

       //si vous placez la ligne de code en commentaire 
       //alors le telerupteur fonctionnera sur les fronts
       //descendant des boutons poussoirs 
       //
       //Inversion de la valeur de la variable memoire 
       memoire_2=!memoire_2;
     
    }
// operation consitant a memoriser l'anciennne valeur de la 
// variable     
etat_bouton6v=bouton6v;



//======= Creation des offset pour le chronogramme ======== 
//
// affichage de la position du bouton 2
//
// ci joint le lien pour le tuto traitant de la fonction
// chronogramme
// https://www.youtube.com/watch?v=MBTEkbA6soI
//
bouton6v=bouton6v+2;



  Serial.print(bouton6v);
   Serial.print(",");
    Serial.print(memoire_2);
     Serial.println();


}

.

.

Retour au sommaire

.

Informations utiles pour la compréhension du code

.

! = Opérateurs de comparaison

Compare la variable à gauche avec la valeur ou la variable à droite de l’opérateur. Renvoie true lorsque les deux opérandes ne sont pas égaux. Veuillez noter que vous pouvez comparer des variables de différents types de données, mais que cela pourrait générer des résultats imprévisibles, il est donc recommandé de comparer des variables du même type de données incluant le type signé / non signé.

Syntaxe = x != y;

Paramètres : 
x: variable. Autorisé types de données: int, float, double, byte, short, long.
y: variable ou constante. Autorisé types de données: int, float, double, byte, short, long.

! 

Ce symbole peut être utilisé pour inverser la valeur booléenne

Syntaxe = x = !y;

.

Retour au sommaire

.

Pour tout problème 

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes  sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .

Facebook  Twitter  Youtube 

.

Retour au sommaire