Pb avec Sharp IR 11 - 2YA710 F

Bonjour à vous tous

Merci de m'accueillir parmi vous.
Nous mettons au point un système de chronométrage avec un ami.
Lui utilise un Lidar , moi j'aimerais faire fonction mo sharp IR

je n'y arrive pas sur le code! (je débute)

Je vous joint le code source de mon ami et ma reference sharp ir

si quelqu'un peux m'aider ( distance entre 100cm et 300cm)
merci de votre aide

Bonne soirée

voici la source :


// #include <SPI.h>
#include "printf.h"
#include "RF24.h"
#include "SoftwareSerial.h" // soft serial port header file

#define PIN_CE 9
#define PIN_CS 10
#define Buzz  8
//#define Photores  3
// Définition des fréquences des notes de musiques de la 4ème octave
#define OCTAVE_4_DO 523
#define OCTAVE_4_RE 587
#define OCTAVE_4_MI 659
#define OCTAVE_4_FA 698
#define OCTAVE_4_SOL 784
#define OCTAVE_4_LA 880
#define OCTAVE_4_SI 988
// Définition de la durée d'un temps en millisecondes 
#define DUREE_TEMPS 200
#define PAUSE_FIN_NOTE 90

SoftwareSerial Serial_tfmini(2,3); // define the soft serial port as Serial_tfmini, pin2 as RX, and pin3 as TX
int dist;// LiDAR actually measured distance value
int strength;// LiDAR signal strength
//int tempe;// LiDAR signal strength
int check;// check numerical value storage
int i;
int uart[9];// store data measured by LiDAR
const int HEADER=0x59;// data package frame header
int DIST_REF = 300;

RF24 radio(PIN_CE, PIN_CS);
const uint64_t pipeB = 0xF0F0F0F0D2LL;
const uint64_t pipeC = 0xF0F0F0F0E1LL;
const uint64_t pipeA = 0x7878787878LL;
const char CTX_Z[2] = "z";
const char CTX_R[2] = "R";
const char CTX_C[2] = "C";
const char CTX_B[2] = "B";

const char EMETTEUR[2] = "1";

struct Message
{
  char transcontext[2];
  char emeteur[2];
  char receveur[2];
  unsigned long temp;
};
Message message;
bool dep_chrono_OK=false;
unsigned long chrono_sauve=0;


void setup() {
  Serial.begin(115200);
  Serial_tfmini.begin(115200);//set the Baud rate of LiDAR and Arduino serial port
  
  Serial.println(F("RF24 - A1"));
  radio.begin();
  radio.setChannel(100);
  radio.enableAckPayload();
  radio.enableDynamicPayloads();
  //radio.setPALevel(RF24_PA_LOW);
  radio.setPALevel(RF24_PA_MIN);
  //radio.setPALevel(RF24_PA_HIGH);
  radio.openWritingPipe(pipeB);
  radio.openReadingPipe(1,pipeA);
  radio.startListening();
  radio.txDelay = 150;
  radio.setDataRate(RF24_250KBPS);

  pinMode(Buzz, OUTPUT);
  digitalWrite(Buzz,1);
  tone(Buzz,440,50);
  noTone(Buzz);

}

void loop() {
  unsigned long temps=0;
  int ret;
  String msg;
  int compt;
  bool etat_laser=false;
  msg="";

/*   if (digitalRead(Photores)){
    tone(Buzz,440,10);
  }else{
    noTone(Buzz);
  }*/

  if (Serial_tfmini.available()){   //check whether the serial port has data input
    if(Serial_tfmini.read()==HEADER){  // determine data package frame header 0x59
      uart[0]=HEADER;
      if(Serial_tfmini.read()==HEADER){  //determine data package frame header 0x59
        uart[1]=HEADER;
        for(i=2;i<9;i++){  // store data to array
          uart[i]=Serial_tfmini.read();
        }
        check=uart[0]+uart[1]+uart[2]+uart[3]+uart[4]+uart[5]+uart[6]+uart[7];
        if(uart[8]==(check&0xff)){  // check the received data as per protocols
          dist=uart[2]+uart[3]*256;// calculate distance value
          strength=(uart[4]+uart[5]*256)/200;// calculate signal strength value
          if (dist<DIST_REF){
              tone(Buzz,440,10);
             if (dep_chrono_OK){
              dep_chrono_OK=false;
              memcpy(message.transcontext, CTX_C, 1);
              memcpy(message.emeteur, EMETTEUR, 1);
              memcpy(message.receveur,"M",1);
              message.temp=millis();
              chrono_sauve=message.temp;
              radio.stopListening();
              delay(20);
              ret = radio.write(&message, sizeof(message));
              if (ret){
                Serial.println(F("Depart Chrono - A1 vers Master : Envoi ok"));
              }else{
                Serial.print(F("Depart Chrono -  A1 vers Master : Envoi KO----- reçu code : "));
                Serial.println(ret);
              }
              radio.startListening();     
            }
          }
          /*
          Serial.print(dist);// output LiDAR tests distance value 
          Serial.print(" ");
          Serial.print(strength);// output signal strength veSS
          Serial.print(" ");
          Serial.print(tempe);// output signal strength veSS
          Serial.println();*/
        }
      }
    }
 }

/*  etat_laser=digitalRead(Photores);
  if (etat_laser) {
    tone(Buzz,440,10);
    if (dep_chrono_OK){
      dep_chrono_OK=false;
      memcpy(message.transcontext, CTX_C, 1);
      memcpy(message.emeteur, EMETTEUR, 1);
      memcpy(message.receveur,"M",1);
      message.temp=millis();
      chrono_sauve=message.temp;
      radio.stopListening();
      delay(20);
      ret = radio.write(&message, sizeof(message));
      if (ret){
        Serial.println(F("Depart Chrono - A1 vers Master : Envoi ok"));
      }else{
        Serial.print(F("Depart Chrono -  A1 vers Master : Envoi KO----- reçu code : "));
        Serial.println(ret);
      }
      radio.startListening();     
    }
  }
  */  
  
  if (radio.available()) {
    radio.read(&message, sizeof(message));
    Serial.print(F("RF24 -  Ard1  : "));
    Serial.print("message.transcontext : ");Serial.println(message.transcontext);
    Serial.print("message.emeteur : ");Serial.println(message.emeteur);
    Serial.print("message.receveur : ");Serial.println(message.receveur);
    Serial.print("message.temp : ");Serial.println(message.temp);
          
    if ((message.transcontext[0] == CTX_Z[0]) and (message.receveur[0] == EMETTEUR[0])) {
      memcpy(message.transcontext, CTX_Z, 1);
      memcpy(message.emeteur, EMETTEUR, 1);
      memcpy(message.receveur,"M",1);
      message.temp=millis();
      chrono_sauve=0;
      radio.stopListening();
      delay(20);
      ret = radio.write(&message, sizeof(message));
      if (ret){
        Serial.println(F("RF24 - A1 vers Master : Envoi ok"));
        dep_chrono_OK=true;
      }else{
        Serial.print(F("RF24 -  A1 vers Master : Envoi KO----- reçu code : "));
        Serial.println(ret);
      }
      radio.startListening();
    }
    if ((message.transcontext[0] == CTX_B[0]) and (message.receveur[0] == EMETTEUR[0])) {
      compt=0;
      JouerNote(OCTAVE_4_DO, 1);
      JouerNote(OCTAVE_4_DO, 1);
      JouerNote(OCTAVE_4_DO, 1);
      JouerNote(OCTAVE_4_RE, 1);
      JouerNote(OCTAVE_4_MI, 2);
      JouerNote(OCTAVE_4_RE, 2);
      JouerNote(OCTAVE_4_DO, 1);
      JouerNote(OCTAVE_4_MI, 1);
      JouerNote(OCTAVE_4_RE, 1);
      JouerNote(OCTAVE_4_RE, 1);
      JouerNote(OCTAVE_4_DO, 4);
     /* while (compt<20){
        tone(Buzz,1000,100);
        delay(10);
        tone(Buzz,500,100);
        delay(10);
        tone(Buzz,250,100);
        
       
        compt+=1;
      } */
    }

    if ((message.transcontext[0] == CTX_R[0]) and (message.receveur[0] == EMETTEUR[0])) {
      memcpy(message.transcontext, CTX_R, 1);
      memcpy(message.emeteur, EMETTEUR, 1);
      memcpy(message.receveur,"M",1);
      message.temp=chrono_sauve;
      radio.stopListening();
      delay(20);
      ret = radio.write(&message, sizeof(message));
      if (ret){
        Serial.println(F("Renvoie du dernier chrono - A1 vers Master : Envoi ok"));
        dep_chrono_OK=true;
      }else{
        Serial.print(F("Renvoie du dernier chrono -  A1 vers Master : Envoi KO----- reçu code : "));
        Serial.println(ret);
      }
      radio.startListening();
    }

    
    
  }
}

void JouerNote(unsigned int Note_P, unsigned int NombreTemps_P)
{
    // Lance l'émission de la note
    tone(8, Note_P, NombreTemps_P * DUREE_TEMPS);
    // Attend que la note soit terminée de jouée
    delay(NombreTemps_P * DUREE_TEMPS);
    delay(PAUSE_FIN_NOTE);
}

La modification Sharp :slight_smile:

#include <SPI.h>
#include "printf.h"
#include "RF24.h"
#include "SoftwareSerial.h" // soft serial port header file
#include <SharpIR.h>

#define ir A0
#define model 20150
// ir: the pin where your sensor is attached
// model: an int that determines your sensor:  1080 for GP2Y0A21Y
//                                            20150 for GP2Y0A02Y
//  

SharpIR SharpIR(GP2Y0A710K0F);

#define PIN_CE 9
#define PIN_CS 10
#define Buzz  8
//#define Photores  3
// Définition des fréquences des notes de musiques de la 4ème octave
#define OCTAVE_4_DO 523
#define OCTAVE_4_RE 587
#define OCTAVE_4_MI 659
#define OCTAVE_4_FA 698
#define OCTAVE_4_SOL 784
#define OCTAVE_4_LA 880
#define OCTAVE_4_SI 988
// Définition de la durée d'un temps en millisecondes 
#define DUREE_TEMPS 200
#define PAUSE_FIN_NOTE 90

SoftwareSerial Serial_tfmini(2,3); // define the soft serial port as Serial_tfmini, pin2 as RX, and pin3 as TX
int dist;// LiDAR actually measured distance value
int strength;// LiDAR signal strength
//int tempe;// LiDAR signal strength
int check;// check numerical value storage
int i;
int uart[9];// store data measured by LiDAR
const int HEADER=0x59;// data package frame header
int DIST_REF = 300;

RF24 radio(PIN_CE, PIN_CS);
const uint64_t pipeB = 0xF0F0F0F0D2LL;
const uint64_t pipeC = 0xF0F0F0F0E1LL;
const uint64_t pipeA = 0x7878787878LL;
const char CTX_Z[2] = "z";
const char CTX_R[2] = "R";
const char CTX_C[2] = "C";
const char CTX_B[2] = "B";

const char EMETTEUR[2] = "1";

struct Message
{
  char transcontext[2];
  char emeteur[2];
  char receveur[2];
  unsigned long temp;
};
Message message;
bool dep_chrono_OK=false;
unsigned long chrono_sauve=0;


void setup() {
  Serial.begin(115200);
  Serial_tfmini.begin(115200);//set the Baud rate of LiDAR and Arduino serial port
  
  Serial.println(F("RF24 - A1"));
  radio.begin();
  radio.setChannel(100);
  radio.enableAckPayload();
  radio.enableDynamicPayloads();
  //radio.setPALevel(RF24_PA_LOW);
  radio.setPALevel(RF24_PA_MIN);
  //radio.setPALevel(RF24_PA_HIGH);
  radio.openWritingPipe(pipeB);
  radio.openReadingPipe(1,pipeA);
  radio.startListening();
  radio.txDelay = 150;
  radio.setDataRate(RF24_250KBPS);

  pinMode(Buzz, OUTPUT);
  digitalWrite(Buzz,1);
  tone(Buzz,440,50);
  noTone(Buzz);

}

void loop() {
  unsigned long temps=0;
  int ret;
  String msg;
  int compt;
  bool etat_laser=false;
  msg="";

/*   if (digitalRead(Photores)){
    tone(Buzz,440,10);
  }else{
    noTone(Buzz);
  }*/

  if (Serial_tfmini.available()){   //check whether the serial port has data input
    if(Serial_tfmini.read()==HEADER){  // determine data package frame header 0x59
      uart[0]=HEADER;
      if(Serial_tfmini.read()==HEADER){  //determine data package frame header 0x59
        uart[1]=HEADER;
        for(i=2;i<9;i++){  // store data to array
          uart[i]=Serial_tfmini.read();
        }
        check=uart[0]+uart[1]+uart[2]+uart[3]+uart[4]+uart[5]+uart[6]+uart[7];
        if(uart[8]==(check&0xff)){  // check the received data as per protocols
          dist=uart[2]+uart[3]*256;// calculate distance value
          strength=(uart[4]+uart[5]*256)/200;// calculate signal strength value
          if (dist<DIST_REF){
              tone(Buzz,440,10);
             if (dep_chrono_OK){
              dep_chrono_OK=false;
              memcpy(message.transcontext, CTX_C, 1);
              memcpy(message.emeteur, EMETTEUR, 1);
              memcpy(message.receveur,"M",1);
              message.temp=millis();
              chrono_sauve=message.temp;
              radio.stopListening();
              delay(20);
              ret = radio.write(&message, sizeof(message));
              if (ret){
                Serial.println(F("Depart Chrono - A1 vers Master : Envoi ok"));
              }else{
                Serial.print(F("Depart Chrono -  A1 vers Master : Envoi KO----- reçu code : "));
                Serial.println(ret);
              }
              radio.startListening();     
            }
          }
          /*
          Serial.print(dist);// output LiDAR tests distance value 
          Serial.print(" ");
          Serial.print(strength);// output signal strength veSS
          Serial.print(" ");
          Serial.print(tempe);// output signal strength veSS
          Serial.println();*/
        }
      }
    }
 }

/*  etat_laser=digitalRead(Photores);
  if (etat_laser) {
    tone(Buzz,440,10);
    if (dep_chrono_OK){
      dep_chrono_OK=false;
      memcpy(message.transcontext, CTX_C, 1);
      memcpy(message.emeteur, EMETTEUR, 1);
      memcpy(message.receveur,"M",1);
      message.temp=millis();
      chrono_sauve=message.temp;
      radio.stopListening();
      delay(20);
      ret = radio.write(&message, sizeof(message));
      if (ret){
        Serial.println(F("Depart Chrono - A1 vers Master : Envoi ok"));
      }else{
        Serial.print(F("Depart Chrono -  A1 vers Master : Envoi KO----- reçu code : "));
        Serial.println(ret);
      }
      radio.startListening();     
    }
  }
  */  
  
  if (radio.available()) {
    radio.read(&message, sizeof(message));
    Serial.print(F("RF24 -  Ard1  : "));
    Serial.print("message.transcontext : ");Serial.println(message.transcontext);
    Serial.print("message.emeteur : ");Serial.println(message.emeteur);
    Serial.print("message.receveur : ");Serial.println(message.receveur);
    Serial.print("message.temp : ");Serial.println(message.temp);
          
    if ((message.transcontext[0] == CTX_Z[0]) and (message.receveur[0] == EMETTEUR[0])) {
      memcpy(message.transcontext, CTX_Z, 1);
      memcpy(message.emeteur, EMETTEUR, 1);
      memcpy(message.receveur,"M",1);
      message.temp=millis();
      chrono_sauve=0;
      radio.stopListening();
      delay(20);
      ret = radio.write(&message, sizeof(message));
      if (ret){
        Serial.println(F("RF24 - A1 vers Master : Envoi ok"));
        dep_chrono_OK=true;
      }else{
        Serial.print(F("RF24 -  A1 vers Master : Envoi KO----- reçu code : "));
        Serial.println(ret);
      }
      radio.startListening();
    }
    if ((message.transcontext[0] == CTX_B[0]) and (message.receveur[0] == EMETTEUR[0])) {
      compt=0;
      JouerNote(OCTAVE_4_DO, 1);
      JouerNote(OCTAVE_4_DO, 1);
      JouerNote(OCTAVE_4_DO, 1);
      JouerNote(OCTAVE_4_RE, 1);
      JouerNote(OCTAVE_4_MI, 2);
      JouerNote(OCTAVE_4_RE, 2);
      JouerNote(OCTAVE_4_DO, 1);
      JouerNote(OCTAVE_4_MI, 1);
      JouerNote(OCTAVE_4_RE, 1);
      JouerNote(OCTAVE_4_RE, 1);
      JouerNote(OCTAVE_4_DO, 4);
     /* while (compt<20){
        tone(Buzz,1000,100);
        delay(10);
        tone(Buzz,500,100);
        delay(10);
        tone(Buzz,250,100);
        
       
        compt+=1;
      } */
    }

    if ((message.transcontext[0] == CTX_R[0]) and (message.receveur[0] == EMETTEUR[0])) {
      memcpy(message.transcontext, CTX_R, 1);
      memcpy(message.emeteur, EMETTEUR, 1);
      memcpy(message.receveur,"M",1);
      message.temp=chrono_sauve;
      radio.stopListening();
      delay(20);
      ret = radio.write(&message, sizeof(message));
      if (ret){
        Serial.println(F("Renvoie du dernier chrono - A1 vers Master : Envoi ok"));
        dep_chrono_OK=true;
      }else{
        Serial.print(F("Renvoie du dernier chrono -  A1 vers Master : Envoi KO----- reçu code : "));
        Serial.println(ret);
      }
      radio.startListening();
    }

    
    
  }
}

void JouerNote(unsigned int Note_P, unsigned int NombreTemps_P)
{
    // Lance l'émission de la note
    tone(8, Note_P, NombreTemps_P * DUREE_TEMPS);
    // Attend que la note soit terminée de jouée
    delay(NombreTemps_P * DUREE_TEMPS);
    delay(PAUSE_FIN_NOTE);
}

ça veut dire quoi ?

hello
as tu essayé l'exemple donné avec la librairie?

Il n'y a pas de modification, tu as laissé le code de communication du Lidar et tu n'exploites pas le signal du capteur Sharp.

Bonjour

Juste une faute de frappe " lire faire fonctionner mon Capteur Sharp IR"
Merci

bonjour
merci de ton retour

Oui mais je ne sais pas quelles valeurs introduire

merci de ton retour

effectivement je n'avais pas fait attention
mais je ne sais pas quelles valeurs inscrire pour le capteur sharp
j'ai besoin d'une plage entre 100 cm et 300cm

la précision n'est pas importante, c'est juste pour démarrer le chrono
j'ai le même montage pour la ligne d'arrivée.

merci encore pour ton support

Bonjour,

La première chose à faire est d'essayer l'exemple de la librairie SharpIR

cm ou mm ?

  1. Distance measuring range : 10 to 80 cm

OUPS, autant pour moi :

Distance measuring range : 100 to 550 cm

bonjour merci pour les fiches
j'utilise le 2 eme modèle

je ne sais pas comment programmer la plage 2.2 V vs 1.5V

C'est çà que je ne comprends pas en code Arduino (électroniquement çà colle) mais en langage je rame :frowning:

oui merci pour ton retour
c'est ici que je sais pas comment coder :frowning:

*SHARP GP2Y0A710K0F IR distance sensor with Arduino and SharpIR library example code. More info: https://www.makerguides.com */

*// Include the library:
#include <SharpIR.h>

// Define model and input pin:
#define IRPin A0
#define model 100500
#define Buzz 8

Create variable to store the distance:
int distance_cm

 Create a new instance of the SharpIR class:
SharpIR mySensor = SharpIR(IRPin, model);
SharpIR mySensor = SharpIR(1, model);

void setup() {
Serial.begin(9600);

}
int sensorValue;
int distance;
void loop() {
  
 sensorValue = analogRead(0);   
 if(sensorValue>=280&&sensorValue<=512)
 {
   Serial.print("Distance: ");
   distance=28250/(sensorValue-229.5);
  Serial.print(distance);
  Serial.println("cm");
 }
  delay(200);                  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void setup() {
Serial.begin(9600);
 
}
int sensorValue;
int distance;
void loop() {
  
 sensorValue = analogRead(0);   
 if(sensorValue>=280&&sensorValue<=512)
 {
   Serial.print("Distance: ");
   distance=28250/(sensorValue-229.5);
  Serial.print(distance);
  Serial.println("cm");
 }
  delay(200);                  
}

Tu instancies un objet mySensor mais tu ne l'utilises pas.
Regarde l'exemple : SharpIR/SharpSensorCm.ino at master · guillaume-rico/SharpIR · GitHub

si j'en crois la spec on a quasiment une droite qui relie l'inverse de la distance à la tension de sortie

si x = 1/Dcm vaut 0.002 (D = 500cm) alors la tension y vaut ~1.4V
si x = 1/Dcm vaut 0,01 (D = 100cm) alors la tension y vaut ~2.5V

donc 1/Dcm est une fonction affine du type y = ax + b (équation d'une droite non verticale) et on connait 2 points de passage avec les valeurs données ci dessus (0.002, 1.4) et (0.01, 2.5) on peut trouver a et b par simple résolution d'un système de 2 équations à 2 inconnues.
➜ On obtient a= 137.5 et b = 1.125 donc la fonction affine est
y = 137.5 * x + 1.125

En remplaçant x par 1/Dcm on a donc
y = a / Dcm + b et donc Dcm = a / (y-b)
(note: attention à la division par 0)

y est la tension lue, donc ce que l'on trouve par le analogRead() (:innocent: )

donc en première approche je dirais que

float d_cm = 137.5   / (analogRead(A0) - 1.125); // si A0 était entre 1.4 et 2.5V sinon on est indéfini

(:warning: c'est pas vrai... je vous laisse trouver l'erreur - faut pas non plus tout mâcher le travail)

mais bon, il vaut mieux regarder ce que fait la bibliothèque, ils ont dû lire la spec en entier :slight_smile:

merci beaucoup

j'ai enfin pigé
les maths çà allait, mais c'est le code
millions de mercis

j'ai rajouté pendant que vous répondiez:

:warning: c'est pas vrai... je vous laisse trouver l'erreur - faut pas non plus tout mâcher le travail

Indice: il y a un petit raccourci sur ce que représente analogRead(A0)

merci kamill :slight_smile:

Merci JML bon dimanche à vous

Pour Info,

Si vous utilisez ce type de Capteur
Utilisez bien la librairie SHARP Master, car il y quelques Bugs dans Sharp IR (Vérifiez bien le fichier .cpp)

A bientôt

Si vous avez testé deux bibliothèques et qu’une fonctionne mieux que l’autre mettez un lien clickable vers la bibliothèque qui est fonctionnelle et expliquez quel souci existe dans l’autre