TIPE: capteur tinyLidar code avec I2C

Bonjour à tous, je suis en classe préparatoire et mes concours arrivent bientôt.

Lors de mes oraux j’ai un projet un présenter et le mien inclue l’utilisation d’Arduino pour coder mon capteur. J’ai déjà codé un petit peu sur Arduino (pas grand chose mais un capteur ultra son basique par exemple).
Le souci que j’ai c’est que le code qui m’a été fourni avec le capteur fais des milliers de lignes et tout ne me sers pas. >j’ai donc regardé la doc du capteur et j’ai pu sélectionné la partie qui m’intéressait afin d’obtenir des distance. Mais vu que je ne sais pas du tout comment fonctionne I2C et qu’il ne me reste que peu de temps j’aimerai avoir de l’aide afin de comprendre le programme pour pouvoir l’expliquer sereinement aux jury de l’oral.
Si quelqu’un se sentirait de me l’expliquer je lui en serait gré ^^

ci joint le programme:

#include <I2C.h>

void setup() {
   Serial.begin(115200);     //setup the serial port 
   I2c.begin();
   

}

void loop() {
   uint16_t i;
    while(1) 
    {
       I2c.write(0x10,0x44);  //take single measurement 
       I2c.read(0x10,2);     // request 2 bytes from tinyLiDAR
       i = I2c.receive();        // receive MSB byte
       i = i<<8 | I2c.receive(); // receive LSB byte and put them together
       Serial.println(i);        // print distance in mm
       delay(100);               // delay as required (30ms or higher in default single step mode) 
    
    
    
    }
    }

Pour comprendre l'I2C il y a la spécification de l'I2C
Pour le fonctionnement du programme, il y a un commentaire par ligne. Ça devrait pas être trop compliqué de comprendre son fonctionnement.

Qu’est-ce que vous ne comprenez pas ?

Mais vu que je ne sais pas du tout comment fonctionne I2C et qu'il ne me reste que peu de temps

les cours et tutoriels sur l'I2C ne manquent pas......

si le temps manque je propose d'attaquer sans tarder l'étude des fonctions contenues dans le fichier I2C.h appelé en début de programe

Faire cette étude en relation avec ce cours ....ou un autre
.Objectif : valider les fonctions de I2C.h , du moins celles utilisées dans le programme.

seconde étape : avec la doc du composant Lidar valider l'usage des fonctions I2C fait dans le programme.

Merci pour vos réponses, je suis allé voir plusieurs sites déjà et des cours openclassrooms, mais l’univers I2C a l’air très vaste et j’ai compris quelques treucs mais grossiers, avec le maitre et l’esclave etc… en fait j’aimerai juste savoir les différentes étapes du programme et comment ca renvoie une distance.Concrètement je ne vois pas comment lier des formules avec ca.
Ce que j’ai compris c’est que la premiere commande prend une mesure simple en envoyant un signal sur une certaine adresse? (je sais pas trop)

Que font les bytes de poids forts et faibles et en quoi sont ils importants?

que fait cette commande:
i = i<<8 | I2c.receive()

J-M-L:
Qu’est-ce que vous ne comprenez pas ?

Je vais essayer d'être un peu plus clair en fait ^^
En traduisant l'anglais j'ai une idée de ce que ça fait vaguement.
Mais en quoi en "mettant" ensemble le byte de poids fort et le byte de poids faibles on a accès a une distance?

al1fch:
les cours et tutoriels sur l'I2C ne manquent pas......

si le temps manque je propose d'attaquer sans tarder l'étude des fonctions contenues dans le fichier I2C.h appelé en début de programe

Faire cette étude en relation avec ce cours ....ou un autre
.Objectif : valider les fonctions de I2C.h , du moins celles utilisées dans le programme.

seconde étape : avec la doc du composant Lidar valider l'usage des fonctions I2C fait dans le programme.

Je te remercie je vais aller voir ça (répétition est mère de pédagogie peut être que j'arriverait a comprendre tout ca a force de revoir sans cesse le cours^^)

Si la distance était codée sur un seul octet tu serais limité a 255 mm.
Avec deux octets tu es limité à 65535 mm.

  i = I2c.receive();        // receive MSB byte
  i = i<<8 | I2c.receive(); // receive LSB byte and put them together

La première ligne permet de recevoir l’octet de poids fort : 8 bits.
La deuxième ligne permet de recevoir l’octet de poids faible : 8 bits aussi, et la combine avec l’octet de poids fort pour former un mot de 16 bits (uint16_t).

Si octet 1 = 00000001 et octet 2 = 10101010

Après la première ligne i vaut 0000000000000001
Après l’opération i << 8 qui est un décalage à gauche de 8 bits, i vaut 0000000100000000
Après l’opération i | I2c.receive(), cela donne 0000000110101010 donc 426 mm.

@+

Merci hbachetti, je comprends de mieux en mieux!

I2c.write(0x10,0x44);  //take single measurement

en fait cette commande permet de prendre une mesure.. mais comment?
De ce que j'ai compris la commande 0x44 envoie une commande de lecture de distance et le capteur "reçoit"alors une réponse sous forme d'une suite d'octet avec l'octet de poids fort (MSB) en premier.

Mais pourquoi en mettant juste les LSB et MSB
ensemble on obtient la distance ?

Regardez dans la spec de votre capteur (p8 et p12) ce qui est retourné pour la commande “0x44” (en fait le caractère ‘D’ comme distance) et sous quel format

D.png

AMHA tu ne prend pas le sujet par le bon bout : comment procède le Lidar est la première question a se poser.
Comment délivre-t-il une mesure ?

Il me semble que ce genre de produit à une notice technique (ou datasheet) et que les premières informations sont à rechercher dedans avant de fouiller le code d'application.

Je serais fort surpris que les procédures pour lancer une mesure et la récupérer ensuite ne soient pas décrites.

GRRRRRR, grillé par J-M-L

68tjs:
GRRRRRR, grillé par J-M-L

désolé :slight_smile:

C'est de ma faute si je ne passais pas autant de temps à rectifier les fotes d'ortografes je serais arrivé avant :grin:

J-M-L:
Regardez dans la spec de votre capteur (p8 et p12) ce qui est retourné pour la commande "0x44" (en fait le caractère 'D' comme distance) et sous quel format

Je l'avais justement cette doc mais je ne comprenais pas comment cela fonctionnait. Est ce que l'octet de poids fort sert juste a lire la donnée? j'ai vu que grossierement c'était soit read soit write

68tjs:
AMHA tu ne prend pas le sujet par le bon bout : comment procède le Lidar est la première question a se poser.
Comment délivre-t-il une mesure ?

Il me semble que ce genre de produit à une notice technique (ou datasheet) et que les premières informations sont à rechercher dedans avant de fouiller le code d'application.

Je serais fort surpris que les procédures pour lancer une mesure et la récupérer ensuite ne soient pas décrites.

Je vais fouiller pour trouver une bonne "datasheet" alors, elle n'était pas fourni, il y'a le doc technique mais ça ne m'aide pas vrmt pour l'i2c, je vais voir vers la : https://www.digikey.com/en/datasheets/stmicroelectronics/stmicroelectronics-endm00279086

A mon sens le capteur émet un rayon lumineux qui est réfléchi et capté par le "sensor" et le capteur en deduit la distance. Mais c'est le comment il en deduit la distance qui m'interpelle ^^'

ps: le programme fonctionne très bien, j'arrive a obtenir les distances mesurées mais j'ai créé le sujet pour comprendre un peu le pourquoi du comment ^^

un entier (votre distance) est codé sur 2 octets et votre tinyLidar envoie ces octets l'un après l'autre dans le protocole I2C

comme vous les recevez un après l'autre, il faut les rassembler pour fabriquer la bonne mesure

Okay pour ça!

En gros le MSB correspond a la première partie de la distance et le LSB a la 2 ème. regroupé ensemble on obtient la distance totale. Que contiennent alors les octets entre ces deux-ci?

le calcul de la distance se fait automatiquement sans que l'on ne controle rien de ça?

Le programme ne serait finalement qu'une demande de mesure et une récolte des infos que l'on souhaite?
merci d'avance :slight_smile:

un entier tel que retourné est sur 2 octets. quand on parle de ces deux octets on va dire qu’il y a le MOST SIGNIFICANT BYTE, c’est à dire l’octet de poids fort, celui qui contient la partie haute des valeurs et le le LEAST SIGNIFICANT BYTE, c’est à dire l’octet de poids faible (les unités, la partie sous 255)

pour fabriquer l’entier complet quand on a les deux bouts on fait 256 * MSB + LSB. et comme multiplier par 256 c’est 28, ça revient à décaler 8 fois le MSB vers la droite, d’où l’usage de l’opérateur <<

Par exemple la valeur 750(decimal) s’écrit en hexadécimal 0x02EE(hex)

0x02(hex) c’est l’octet de poids fort et 0xEE(hex) celui de poids faible.

0x02(hex) en base 10 c’est 2(decimal)
0xEE(hex) en base 10 c’est 238(decimal)

si vous faites 2 x 256 + 238 vous retrouvez bien les 750

constantinrontard:
le calcul de la distance se fait automatiquement sans que l’on ne controle rien de ça?

OUI :slight_smile: (enfin vous contrôlez quand vous demandez la lecture en envoyant la commande ‘D’ sur I2C)

Je vous remercie, vous m'avez bien aidé!
une dernière petite question:
le delay (100)
cela signifie bien qu'avant de redemander une mesure une laisse une période de 100ms?
ce que je comprends c'est que la en gros le capteur est en mode continu, et laisse 100 ms entre chaque mesure, est ce bien ca?

Apparemment ce n’est pas ca… Comment pourrait-on modifier le temps entre 2 mesures de distances?

Re!

J’aimerai pouvoir controler le temps entre 2 impulsions, savez vous comment je pourrais faire?

Il me semblait que c’était avec le delay(100) dans le programme, mais les distances qui me sont affichées sont séparées d’un temps très grand, j’aimerai pouvoir programmer simplement le capteur en mode continu en gros

Qu’avez vous lu et essayé en une semaine?