LIDAR + ESP8266 = capteur de grande distance?

Bonjour,
J’ai besoin de mesurer une distance de 8m (pour capter les intrus garés devant mon garage qui m’empêchent de rentrer chez moi).
J’ai alors compris à mes dépens que le SR04 est limité à 4m.

Le meilleur candidat semble un LIDAR : le TF Mini de Benewake. Par contre je ne parviens pas à l’utiliser sur mon Wemos D1 Mini (ESP8266), il ne semble pas compatible avec les tutos utilisés pour le SR04 :
pour flasher le module
pour paramétrer le SR04

D’après l’excellent Scharette du site www.robotshop.com/, ce serait parce que le TFmini fonctionne en UART contrairement au SR04.

Et là, c’est le drame :disappointed_relieved: je suis au bout de mes courtes limites.

Alors quelques questions aux bonnes âmes passant par là :

  • le TF mini peut il être utilisé avec Jeedom? Avec Espeasy? si oui comment
  • existe t il d’autres capteurs de grande distance? en Zwawe? (pour une durée de vie des piles plus grande qu’en wifi) je n’ai l’impression qu’il n’y a que des détecteurs de mouvement, pas de distance…

Un grand merci pour votre attention

1 « J'aime »

De ce que je viens de lire sur le TF Mini il dialogue en série sur 2 fils tx,rx ce qui est assez classique ton ESP lui aussi utilise cette méthode, donc compatible. Le dialogue (protocol) est aussi donné.
Il ne te reste plus qu’a mettre les mains dans le cambouis pour d’un coté faire des requettes au TF Mini de l’autre renseigner renseigner ton Jeedom avec les valeures détectées.

Mon conseil : Apprend a coder tu gagnera du temps et deviendra maitre de ton micro-controleur plutôt que de perdre du temps avec des boites a outils comme espeasy. Découvre micro-python un langage très adapter aux ESP .

Désolé de ne t’avoir fourni une solution clef en main.

Merci pour ta réponse, c’est la 2e fois qu’on me conseille de programme il semble que je ça s’impose, tu aurais des conseils pour démarrer, ou des exemple idéalement, que tu utiliserais toi même ? Merci

Un VL53L0X, ou un GY-US42V2 sont sûrement des options à tenter. Je les avais utilisés avec ESP Easy, mais probablement en ajoutant des plugins depuis le playground (il faut recompiler et tout).

J’avais fait un retour d’expérience ici.

Pour le TFMini, Gotronic fournit un tutoriel pour Arduino. Normalement, c’est possible d’adapter en plugin ESP Easy. Je l’ai déjà fait, cela dépend vraiment des compétences qu’on a.

Les modules que tu cites ont une portée de 2 et 7m je ne pourrai malheureusement pas m’en servir.

Le lien que tu donnes pour le Tuto renvoie vers la page du capteur, peux tu renvoyer le lien vers le Tuto stp ça m’intéresse je vais potasser, mes compétences sont pas suffisantes à ce jour :grin:

Dans l’onglet « Ficher technique » il y a un lien « Tutoriel Arduino »

Sinon y’a aussi toute la gamme Maxbotix comme le EZ4 par exemple (765 cm), ou ceux étanches qui ont une portée jusqu’à 10m pour certains (mais pas le même prix là). Y’a les fiches techniques complètes avec même des exemples de code (même si je crois qu’il existe un plugin sur le playground esp easy).

Effectivement pour le VL53L0X il n’a pas la portée suffisante. De toutes façons, c’est du laser et je pense qu’il vaut mieux éviter, trop de risque que ça ne fonctionne pas à cause d’une mauvaise réflexion. A vérifier peut-être aussi pour le TF mini. L’avantage de l’ultrason, c’est que ça forme un cône de détection.

Un tutoriel intéressant aussi ici.

Par contre, tu parles de piles et à mon avis ça risque de ne pas être évident s’il faut le faire sur batterie. Cela dépend quel est le but : détection immédiate ? ou vérification tout les heures ?

C’est pour de la vérification toutes les minutes. Idéalement détection toutes les minutes en période de retour de boulot, toutes les heures sinon.
J’ai essayé de mettre le SR04 plus près (moins de 4m), sur batterie 21000 mAh avec panneau solaire, mais la conso reste supérieure à la charge. Pour une méthode <4m il me faudrait un capteur zwave plutôt que wifi, ça consomme beaucoup moins.
Pour une méthode 8m je peux être sur secteur, mais se pose le pb de l’envoi des données à Jeedom.
Je vais fouiller ces tutos pour domestiquer tout ça, merci pour tes liens.

Pour les ultra sons de chez maxbotix, ça fait cher quand même :grin:

hello @Seb54, as-tu avancé sur ce projet ? Merci !

Yes @alexcrp absolument!
Avec un magnifique sketch arduino, qui pilote le lidar sur une carte ESP Easy, et que j’ai bidouillé pour pouvoir l’activer ou désactiver selon mon éloignement via la positon GPS de mon iPhone.
Je t’envoie tout ça si ça t’intéresse.

2 « J'aime »

@Seb54 Excellent ! Bravo :slight_smile:

Si tu en as le temps, essaye de detailler dans une reponse au post, je pense que nous serons plusieurs intéressé(e)s… Merci par avance !

Ah oui cela m’intéresse aussi :stuck_out_tongue_winking_eye:
Je n’ai toujours pas reçu mes batteries et donc je vais me mettre sur le projet sur l’hiver si tout va bien

Bonjour, alors voici le code. C’est la version complète avec buzzer. J’ai essayé de détailler au maximum les étapes. L’idée est que le LIDAR est soit actif, soit en veille, soit en reset forcé, selon la valeur de la variable jeedom « statut » créée et utilisée dans un vitruel :
Capture

Désolé pour l’aspect vrac, c’est le résultat de fusion de plusieurs sketches et tests :

/*
 * HTTP communication between ESP8266 and Jeedom Smart Home Server
 * Communication HTTP (TCP/IP) entre ESP8266 et le serveur domotique Jeedom
 * Copyright (C) 2017 https://www.projetsdiy.fr - http://www.diyprojects.io
 *   
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Code adapté pour TFmini
 * Fonctions ajoutées à sketch de base :
 *  retour URL
 *  blink
 *  requestfromurl (pour lecture variable esp_statut (on/off/reset)
 *   
 */
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <ESP8266WebServer.h>   //ne semble pas être utile pour sendtojeedom. Besoin pou réponse URL (192.168.86.19/test --> je suis là)
//#include <WiFiClientSecure.h>   //ne semble pas être utile (origine sketch sendtojeedom)
#include <ESP8266mDNS.h> //fonctionne sans cette librairie (origine sketch test retour URL)

//---incorpo code BasicReading (Test TFmini)---
#include <Arduino.h>
#include <SoftwareSerial.h>
#include "TFMini.h"
//\\

const char* ssid     = "##########";
const char* password = "#############";
const char* host     = "192.168.86.236";
const int   port     = 80;
const char* apiKey   = "##############";
const char* apiKeyJeedom = "############";
const char* idDist    = "9272";   //numéro ID de l'info virtuelle
const char* idStren   = "9273";   //numéro ID de l'info virtuelle
const char* idNbReset = "9279";   //numéro ID de l'info virtuelle
const long interval = 10;         // interval at which to measure (milliseconds) (au delà, une latence est observée entre mesure et affichage serial.print)
const int watchdog = 10000; // Fréquence d'envoi des données à Jeedom
const long interval_check_variable = 300000;  //fréquence de lecture de la variable esp_statut
unsigned long previousMillisLIDAR = millis();       // d'origine : millis()
unsigned long previousMillisSendJEEDOM = millis();  //envoi des valeurs au virtuel
unsigned long previousMillisReadJEEDOM = millis();  //lecture de la variable esp_statut (on/off/reset)

String statut = ""; //variable globale
String urlread;     //variable globale
String nbReset;     //attention, si déclarée comme int, posera pb compatibilité avec fonction http.getString
int nbResetInt;     //variable globale

int buzzerPin=14; //Buzzer control port, default D5=GPIO14

String baseurl; //en global car aussi utilisée en fonction (en + du loop)
String url;     //en global car aussi utilisée en fonction (en + du loop)
  
ESP8266WebServer server ( 80 );  //ne semble pas être utile pour sendtojeedom. Semble nécessaire pour retour URL
HTTPClient http;

//---incorpo code BasicReading (Test TFmini)---
// Setup software serial port
SoftwareSerial mySerial(5, 4);      // connection to TFMini (=D1, D2)
TFMini         tfmini;              // tfmini access
//\\

void setup() {
  Serial.begin(115200);
  delay(10);
  
  Serial.setDebugOutput(true);  
  Serial.println("Connecting Wifi...");

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP()); 

  // on definit ce qui doit etre fait lorsque la route /test est appelee
  server.on("/test", [](){
    server.send(200, "text/plain", "tout va bien!");
  });
  // on definit ce qui doit etre fait lorsque la route /buzzer est appelee
  server.on("/buzzer", [](){
      for(int i=0; i<8; i++){
        Serial.println("loop buzzer");
        analogWrite(buzzerPin, 512);
        digitalWrite(LED_BUILTIN, HIGH);     
        delay(1000);
        analogWrite(buzzerPin, 0);
        pinMode(buzzerPin, OUTPUT);
        digitalWrite(buzzerPin, LOW);
        digitalWrite(LED_BUILTIN, LOW);
        delay(1000);
      }
  });
  // on commence a ecouter les requetes venant de l'exterieur
  server.begin();    //ne semble pas être utile pour sendtojeedom. Besoin pour réponse URL 
  
  //---incorpo code BasicReading (Test TFmini)---
  // Step 1: Initialize hardware serial port (serial debug port)
  // wait for serial port to connect. Needed for native USB port only
  while (!Serial);
  // Step 2: Initialize the data rate for the SoftwareSerial port
  mySerial.begin(TFMINI_BAUDRATE);  // default boudrate is 115200
  delay(10);
  // Step 3: Initialize the TF Mini sensor
  tfmini.begin(&mySerial);
  Serial.println ("Initializing Serial and mySerial finished");
  //\\


  //lecture de la valeur de la variable esp_nb_reset :
  String baseurlread = "/core/api/jeeApi.php?apikey="; 
  baseurlread += apiKeyJeedom;
  baseurlread += "&type=variable&name="; 
  urlread = baseurlread + "esp_nb_reset";

  //Serial.print("URL nb reset : ");
  //Serial.println(urlread);
  
  requestFromJeedom(urlread);
  Serial.print("nb reset setup : ");
  Serial.println(nbReset);
  //delay(500);

  //lecture de la valeur de la variable esp_statut :
  urlread = baseurlread + "esp_statut";

  //Serial.print("URL statut : ");
  //Serial.println(urlread);
  
  requestFromJeedom(urlread);
  Serial.print("statut setup : ");
  Serial.println(statut);
  //delay(500);
  
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
}

void loop() {

  unsigned long currentMillis = millis();

  server.handleClient();     //ne semble pas être utile pour sendtojeedom. Besoin pour retour URL :
                             //a chaque iteration, on appelle handleClient pour que les requetes soient traitees

  if ( statut == "reset") {

    Serial.println("Resetting ESP");

    nbResetInt++; 
   
    baseurl = "/core/api/jeeApi.php?apikey="; //obligé de refaire la variable même si déclarée en racine loop
    baseurl += apiKeyJeedom;
    baseurl += "&type=variable&name="; 
    url = baseurl + "esp_nb_reset";
    url += url + "&value="; url += nbResetInt;
    sendToJeedom(url);    
    Serial.print("reset nb : ");     Serial.println(nbResetInt);
    delay(120000); //120000   //PM variable passe de reset à on au bout de 5mn dans jeedom
    ESP.restart(); //ESP.reset();
   
    } else {
      if ( statut == "off") {
      Serial.println("ESP désactivé, contrôle d'activation dans 2mn");  
      digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
      delay(500); //d'origine : 1000
      digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
      delay(120000); //300000 = 5 minutes
      requestFromJeedom(urlread);     
      
      } else {  
        if ( currentMillis - previousMillisLIDAR >= interval ) {     //remplacement > par >=
        previousMillisLIDAR = currentMillis;
        //---incorpo code BasicReading (Test TFmini)---
        // Take one TF Mini distance measurement
        uint16_t dist = tfmini.getDistance();
        uint16_t strength = tfmini.getRecentSignalStrength();
        // Display the measurement
        Serial.print(dist);
        Serial.print(" cm   Signal: ");
        Serial.println(strength);
        //\\
        } else {
          if ( currentMillis - previousMillisSendJEEDOM >= watchdog ) {     //remplacement > par >=
            previousMillisSendJEEDOM = currentMillis;
            if(WiFi.status() != WL_CONNECTED) {
              Serial.println("WiFi not connected !");
            } else {
                Serial.print("Distance envoyée à Jeedom : ");
                Serial.println(dist);
          
                baseurl = "/core/api/jeeApi.php?apikey="; 
                baseurl += apiKey;
                baseurl += "&type=virtual&id="; 
                url = baseurl + idDist;
                url += url + "&value="; url += dist;   //String(t); 
                sendToJeedom(url);
                digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
                delay(500); //d'origine : 1000
                                
                url = baseurl + idStren;
                url += url + "&value="; url += strength;    //String(h);
                sendToJeedom(url);
                Serial.println("données envoyées");
                digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
                delay(500); //d'origine : 1000

                if ( currentMillis - previousMillisReadJEEDOM >= interval_check_variable ) { //rafraîchit statut tous les interval check
                  previousMillisReadJEEDOM = currentMillis;
                  Serial.println("rafraîchissement de la valeur de la variable");
                  delay(500);
                  requestFromJeedom(urlread);
                  }
            }
          }
       }
    }
  }
}

boolean sendToJeedom(String url) {
  //Serial.print("connecting to ");
  //Serial.println(host);
  //Serial.print("Requesting URL: ");
  //Serial.println(url);
  http.begin(host,port,url);
  int httpCode = http.GET();
  //Serial.println("données envoyées");
  http.end();
}

String requestFromJeedom(String urlread) {
  http.addHeader("Content-Type", "text/html");    // sans cette ligne, httpcode = 302 au bout de qqes requetes
  int httpCode = http.GET();  //ligne OBLIGATOIRE!!!
  Serial.print("httpcode : ");
  Serial.println(httpCode); 

  if ( httpCode == 302 ) {  //|| httpCode ==200 ) {
    Serial.println("httpcode = 302, ESP redémarre");    
    delay(1000);  //1000
    
    nbResetInt++; 
    baseurl = "/core/api/jeeApi.php?apikey="; //obligé de refaire la variable même si déclarée en racine loop
    baseurl += apiKeyJeedom;
    baseurl += "&type=variable&name="; 
    url = baseurl + "esp_nb_reset";
    url += url + "&value="; url += nbResetInt;
    http.end();    
    sendToJeedom(url);    
    
    delay(100);
    ESP.restart(); 
  } 

  http.begin(host,port,urlread);
  //int httpCode = http.GET();
  //Serial.println("données envoyées");

  if ( urlread.indexOf("reset") > 0 ) {
    nbReset = http.getString();
    Serial.print("URL nb reset : ");
    Serial.println(urlread);    
    Serial.print("nb reset : ");
    Serial.println(nbReset);  
    delay(100);  
    nbResetInt = nbReset.toInt();
    if ( nbReset == "" ) {   //couvre aussi la cas où httpCode = -1
      Serial.println("variable non lue, requête relancée dans 2s");
      delay(1000); 
      requestFromJeedom(urlread);
      }
    }
    
  if ( urlread.indexOf("statut") > 0 ) {
    http.addHeader("Content-Type", "text/html");    // sans cette ligne, httpcode = 302 au bout de qqes requetes
    int httpCode = http.GET();
    statut = http.getString();
    Serial.print("URL statut : ");
    Serial.println(urlread);
    Serial.print("statut : ");
    Serial.println(statut);     
    delay(100);
    if ( statut == "" ) {   //couvre aussi la cas où httpCode = -1
      Serial.println("variable non lue, requête relancée dans 2s");
      delay(1000); 
      requestFromJeedom(urlread);
      }  
  }

  //Serial.print("statut request : ");
  //delay(500); 
  //Serial.println(statut);
  http.end();
}

A votre dispo pour tout précision.

3 « J'aime »

commandes du virtuel :

1 « J'aime »

Hello @Seb54 Merci de partager ta solution! Vu le nombre de tes messages sur le forum, tu as du beaucoup travailler pour y parvenir :slight_smile:

J’utilise espEASY et par ailleurs j’ai un peu joué avec un arduino mais je n’ai jamais utilisé un code dans espEASY.
Comment doit-on s’y prendre pour intégrer ce code dans espEASY ? J’ai vu que tu évoques différentes solutions avec des membres dans d’autres posts, mais je ne sais pas celle que tu as retenu finalement.
Pourrais tu au moins décrire les grandes étapes ? ce serait vraiment très utile :slight_smile:
Merci d’avance :slight_smile: :slight_smile: :slight_smile:

Hello, de mémoire c’était une étape facile, il suffisait de verser le code depuis le pc sur lequel tournait arduino IDE (pour écrire le code) vers le ESP, branché au PC en USB.
Exemple

J’ai testé mBlock sur ton lien ci dessus mais ca plante au niveau de l’authentification.
Du coup j’ai installé platformIO, en me basant sur ce tuto, je suppose que ca fera l’affaire :
https://projetsdiy.fr/esp-easy-transformer-code-arduino-plugin-esp-easy-mega-platformio/

Dans ton code tu fais référence à TFMINI.h
#include "TFMini.h"

Peux tu m’indiquer ou trouver ce fichier ?
Merci

J’avais dû le trouver dans un des tuto dont je me suis inspiré.
Je l’ai retrouvé sur github

Si c’est pas le bon je remets les miens en ligne

J’ai des erreurs de compilations, pourrais tu m’envoyer ton fichier (j’en ai trouvé 3 différents sur internet donc ce n’est peut être pas le bon).

Par contre j’ai l’impression qu’il ne suffit pas de verser le code dans l’ESP.
Dis moi si je me trompe mais j’ai l’impression qu’il faut d’abord compiler ton fichier de code et pour cela il faut tout l’environnement de ESPeasy.
Il faut donc installer l’environnement de dev, ce tuto me semble bien l’expliquer.
https://espeasy.readthedocs.io/en/latest/Participate/PlatformIO.html

Ensuite il faut télécharger le source de ESP easy, le compiler comme indiqué ici :
https://espeasy.readthedocs.io/en/latest/Participate/PlatformIO.html

Ensuite j’ai installé ton code sous le nom _P345_TFMini.ino
J’ai copié le fichier TFMini.h dans include
Puis j’ai essayé de compiler de nouveau pour obtenir la version compilée de ton code sous forme de plugin à téléverser dans l’ESP.

Est ce bien la bonne démarche ?
Merci

Dsl je suis en formation je pourrai pas regarder mon pc.
De mémoire j’ai installé arduino IDE sur le pc, j’ai copié les fichiers (dont le TFMini.h) en racine du projet sur le pc, ensuite j’ai codé et compilé le tout sur le ESP