Arduino et l’application Android Sensoduino

Que fait cette application ?

L’application Android Sensoduino est un moyen très simple pour utiliser les capteurs de votre Android dans votre projet.

En effet, les téléphones ou les tablettes sont équipés de capteurs perfectionnés et qui seraient coûteux à acheter séparément : GPS, accéléromètre, etc …

Cette applivation permet pour les capteurs sélectionnés :
– de visualiser les valeurs courantes ;
– de les enregistrées dans un fichier ;
– de les transférer vers arduino via Bluetooth.

Pour plus d’informations, voici le site de l’auteur.

Une petite bibliothèque personnelle en aide : SensoduinoDLF

Lorsqu’Arduino reçoit des données depuis Sensoduino, chaque ligne a la structure suivante :

– numéro du capteur (comme indiqué sur le site de l’auteur
– compteur de données reçues (incrémenté aprés chaque nouvelle donnée)
– 3 valeurs numériques correspondant à chaque capteur.

Lorsqu’un capteur ne nécessite pas trois valeurs, les autres sont mises à 99.99.

Pour faciliter la lecture de cette ligne d’informations, j’ai créé une petite bibliothèque qui travaille avec mon autre bibliothèque SerialDLF.

Pour les télécharger :
https://filedn.com/lpKG7uY9hIHVel5exA5Ik80/Wordpress/Num%C3%A9rique/Arduino/SerialDLF.zip
https://filedn.com/lpKG7uY9hIHVel5exA5Ik80/Wordpress/Num%C3%A9rique/Arduino/SensoduinoDLF.zip

Un exemple : commande d’un robot

Dans ce projet, je me suis servi de l’accéléromètre comme « joystick ». On penche l’appareil et le robot se déplace en conséquence.

Voici le code :


/* 
 Robot Commande par Bluetooth (Sensoduino)
 */

//------------------------------------------------------------
// Librairies
//------------------------------------------------------------

// pour le traitement du message recu sur la liaison serie
#include <SerialDLF.h>
#include <SensoduinoDLF.h>

//------------------------------------------------------------
// Constantes et variables
//------------------------------------------------------------

// Classe de SerialDLF
SerialString messageRecu;

float X,Y,Z;
boolean isClosed =false;

//Moteur A
int E1 = 5; // Vitesse (PWM)
int M1 = 4; // Direction

//Motor B
int E2 = 6; // Vitesse (PWM)
int M2 = 7; // Direction

const int MOTEUR_A=0;
const int MOTEUR_B=1;

const int AVANT=0;
const int ARRIERE=1;


//------------------------------------------------------------
// Setup
//------------------------------------------------------------

void setup()
{
  // Initialisation de la liaison serie
  Serial.begin(9600); 
  Serial.flush();
  Serial.println("Liaison serie operationnelle !");
  Serial.println("------------------------------");
  delay(1000);
  Serial.println("Descriptif du programme :");
  Serial.println("--------------------------");
  Serial.println("Ce programme permet de commander un robot.");
  Serial.println("--------------------------");
  Serial.println("Pour connaitre les commandes, taper sur h ou H.");
  Serial.println("--------------------------");


  // Autres initilisations
  
  pinMode(E1, OUTPUT);
  pinMode(M1, OUTPUT);

  pinMode(E2, OUTPUT);
  pinMode(M2, OUTPUT);


} // fin setup

//------------------------------------------------------------
// Loop
//------------------------------------------------------------

void loop()
{ 
  messageRecu.renew();  // on lit un eventuel message.
  if (messageRecu.empty()==false) // Si le message est non vide ...
  {
    //Serial.println(messageRecu.get());
    traitement();
    Serial.flush();
  }
} //fin loop


//------------------------------------------------------------
// Fonction traitement()
//------------------------------------------------------------
/*
Execute le traitement des caracteres recus par la liaison serie
 qui sont stockes dans messageRecu.
 */

void traitement()
{
  float temp;

  if ((messageRecu.equals("Descriptif")) || (messageRecu.equals("d")))
  {

    Serial.println("--------------------------");
    Serial.println("Descriptif du programme :");
    Serial.println("--------------------------");
    Serial.println("Ce programme mesure la temperature a la demande.");
    Serial.println("--------------------------");
  }
  else if  ((messageRecu.equals("Help")) || (messageRecu.equals("h")))
  {
    Serial.println("--------------------------");
    Serial.println("Liste des commandes :");
    Serial.println("--------------------------");
    Serial.println("--> Descriptif ou d : affiche le descriptif du programme.");
    Serial.println("--> Help ou h : affiche la liste des commandes.");
    Serial.println("--> Mesure ou m : demande une mesure.");
    Serial.println("--------------------------");
  }
  else if (messageRecu.isSensoduino()==true)
  {
    Sensoduino sensoParam(messageRecu.get());
    //Serial.println(sensoParam.get());
    if (sensoParam.getType() == SSD_ACCELEROMETER)
    {
      X = sensoParam.getVal0();
      Y = sensoParam.getVal1();
      Z = sensoParam.getVal2();
      if ( X > 3)
      {
        //avancer
        Serial.println("Avancer");
        activer(MOTEUR_A, AVANT, 200);
        activer(MOTEUR_B, AVANT,200);

      }
      else if (X<-3)
      {
        //reculer
        Serial.println("Reculer");
        activer(MOTEUR_A, ARRIERE, 128);
        activer(MOTEUR_B, ARRIERE, 128);
      }
      else if (Y>2)
      {
        //tourner a gauche
        Serial.println("Tourner a gauche");
        activer(MOTEUR_A, ARRIERE, 128);
        activer(MOTEUR_B, AVANT, 128);
      } 
      else if (Y <-2)
      {
        //tourner a droite
        Serial.println("Tourner a droite");
        activer(MOTEUR_A, AVANT, 128);
        activer(MOTEUR_B, ARRIERE, 128);
      }
      else
      {
        //arreter
        Serial.println("Arreter");
        activer(MOTEUR_A, AVANT, 0);
        activer(MOTEUR_B, AVANT, 0);
      }   	
    }
    /*
    if (sensoParam.getType() == SSD_PROXIMITY)
     {
     	if ( sensoParam.getVal0()==0.0)
     	{
     		isClosed=true;
     	}
     	else
     	{
     		isClosed=false;
     	}
     	
     }
     */
  }

  else
  {
    Serial.println("Erreur de saisie !");
  }

} // fin traitement


//////////////////////////////////////////
// Fonction activer
//////////////////////////////////////////

void activer(int moteur, int sens, int vitesse)
// moteur : MOTEUR_A ou MOTEUR_B
// sens : AVANT ou ARRIERE
// vitesse : entre 0 et 255
{

  switch (moteur)
  {
  case MOTEUR_A :
    if (sens==AVANT)
    {
      digitalWrite(M1, HIGH);       
      analogWrite(E1, vitesse);
    }
    else
    {
      digitalWrite(M1, LOW);       
      analogWrite(E1, vitesse);
    }
    break;

  case MOTEUR_B :
    if (sens==AVANT)
    {
      digitalWrite(M2, HIGH);       
      analogWrite(E2, vitesse);
    }
    else
    {
      digitalWrite(M2, LOW);       
      analogWrite(E2, vitesse);
    }
    break;
  }
}



//////////////////////////////////////////
// Fonction arreter_tout
//////////////////////////////////////////

void arreter_tout()
{
  analogWrite(E1, 0);
  analogWrite(E2, 0);
}


//////////////////////////////////////////
// Fonction arreter
//////////////////////////////////////////

void arreter(int moteur)
{
  switch (moteur)
  {
  case MOTEUR_A :
    analogWrite(E1, 0);

  case MOTEUR_B :
    analogWrite(E2, 0);
  }
}



Niveau supérieur : La communication Bluetooth