Bonjour,

J'ai reçu récemment un anémomètre et une girouette. Ces capteurs envoient les données sur 41 bits. Certaines sections renseignent la vitesse du vent, la direction... Il suffit de laisser une pin en LOW et les capteurs envoient les informations toutes les 2 secondes. Ma question est simple mais j'ai cherché en vain sur internet. Comment puis-je faire pour lire ces bits à la suite ? Existe-t-il une fonction pour les mettre dans un tableau ?

Je vous remercie de votre aide et m'excuse d'avance si le sujet avait déjà été abordé.

Commences donc par nous dire le nom de ton capteur afin que l'on puisse t'aiguiller précisément.

Tu peux aussi lui cet article qui traite les opérateurs bit à bits : http://fr.openclassrooms.com/informatique/cours/les-operateurs-bits-a-bits-employes-sur-des-nombres-entiers

+1

Il faut lire la documentation constructeur / datasheet pour connaitre le protocole de transmission de données

Merci de vos réponses.

Alors je cherche à relier une station La crosse Tx 20 à ma carte arduino. J'ai compris comment on pouvait extraire chaque bit mais les codes que j'ai trouvé sur internet ne fonctionnent pas dans mon cas.

int dataPin = 8;
int DTR = 3;
int bitlenght = -1;
char data[41];
  
  
void setup() {
  Serial.begin(9600);
  //pinMode(dataPin,OUTPUT);
  pinMode(DTR,OUTPUT);
  digitalWrite(DTR,HIGH); 
  //digitalWrite(dataPin,LOW);
  pinMode(dataPin, INPUT);
  Serial.print("\n\nInitializing...\n");
  Serial.print("startpin:");
  Serial.println(digitalRead(dataPin));
}

void loop() {
  collectdata3();
  delay(1000);   
}


int collectdata3(void){
   if (bitlenght <0){
      bitlenght = 1220;//getbitlenght2();

   }
  
  pinMode(dataPin, INPUT);
  digitalWrite(DTR,HIGH);
  delay(500);

  digitalWrite(DTR, LOW );
  delayMicroseconds(60000);


  while(digitalRead(dataPin) == LOW){
  }  
  //wait slave start signal
  while(digitalRead(dataPin) == HIGH){
  }
  while(digitalRead(dataPin) == LOW){
  }
  


  

  for (int i=0 ; i<42 ; i++){

    data[i] = (digitalRead(dataPin) == LOW)? 41 : 42 ;
    delayMicroseconds(bitlenght);
  }

  showdatasimple();
  return 0;
}


void showdatasimple(){
  Serial.println("");

//HEAD
  for (int i =0 ; i< 5 ; i++){
    Serial.print( ((data[i] == 41)? 0 : 1) );
  }
  
  Serial.print(" ");
  
//WINDDIR
  for (int i =5 ; i< 9 ; i++){
    Serial.print( ((data[i] == 41)? 0 : 1) );
  }
  

  
  Serial.print(" ");
  
//WIND SPEED
  for (int i =9 ; i< 18 ; i++){
    Serial.print( ((data[i] == 41)? 0 : 1) );
  }
  
  Serial.print(" ");
  
//WIND SPEED+3
  for (int i =18 ; i< 21 ; i++){
    Serial.print( ((data[i] == 41)? 0 : 1) );
  }  
  
  Serial.print(" ");
  
  //CC
  for (int i =21 ; i< 25 ; i++){
    Serial.print( ((data[i] == 41)? 0 : 1) );
  }
  
  Serial.print(" ");
  
  //WIND DIR  NEGATEIVE
  for (int i =25 ; i< 29 ; i++){
    Serial.print( ((data[i] == 41)? 0 : 1) );
  }
  
    Serial.print(" ");
  
  //WIND SPEED NEGATIVE
  for (int i =29 ; i< 38 ; i++){
    Serial.print( ((data[i] == 41)? 0 : 1) );
  }
   
   Serial.print(" ");
    
    //WIND SPEED NEGATIVE+3
  for (int i =38 ; i< 41 ; i++){
    Serial.print( ((data[i] == 41)? 0 : 1) );
  }
}

J'ai plusieurs questions.
J'ai vu un site sympa qui explique les différentes sections : http://www.john.geek.nz/2011/07/la-crosse-tx20-anemometer-communication-protocol/ 

Il y a un bit de tête (11011) que je n'arrive pas à obtenir dans le port série. 
 

while(digitalRead(dataPin) == LOW){
  }  
  //wait slave start signal
  while(digitalRead(dataPin) == HIGH){
  }
  while(digitalRead(dataPin) == LOW){
  }

Selon moi, cette partie de code permet de détecter le bit de tête donc je comprends pas comment certains (sur les forums) peuvent retrouver ce bit dans la boucle "for" et donc l'écrire avec le "showasimple()" parce qu'il est déja passé quand la boucle for démarre.

Si je n'arrive pas à avoir ce bit, je pense que c'est normal que tout soit faux, tout doit être décalé.

J'espère que c'est assez claire, je vous remercie de votre aide.

while(digitalRead(dataPin) == LOW){} 
while(digitalRead(dataPin) == HIGH){}
while(digitalRead(dataPin) == LOW){}

Le premier while permet de bloquer le programme temps que la pin est à LOW

Le second temps que la pin est à HIGH

Et le dernier temps que la pin est à LOW

Au final, pour passer ces 3 lignes de code, il faut que le signal passe à HIGH, puis à LOW puis à nouveau à HIGH.

Je ne vois pas du tout en quoi ça correspond au protocole ...

Il manque aussi la synchronisation donc je doute que ça puisse marcher

Je verrais donc un code comme ça :

int dataPin = 8;
int dtrPin = 3;

char data[41];



void setup() {
	Serial.begin(9600);
	Serial.println("INIT");
	pinMode(dataPin, INPUT);
	pinMode(dtrPin, OUTPUT);
	digitalWrite(dtrPin, LOW);
}

void loop() {
	
	// Normalement, le module envoie les données pendant 49.2ms toutes les 2 secondes
	
	// A partir de là, il faut se syncroniser avec le récepteur
	// Pour ce faire, on va procéder en 2 étapes :
	// 1: on attend que le signal soit à HIGH pendant au moins 100ms (de façon à être sure que le module n'envoie rien)
	// 2: on attend que le signal passe à LOW (ce qui correspond au premier bit de l'envoie d'un message)
	
	Serial.println("SYNC");
	
	// Etape 1
	unsigned long currentTime = millis();
	unsigned long startTime = currentTime;
	while ( ( currentTime - startTime ) < 100 ) {
		currentTime = millis();
		if ( digitalRead(dataPin) == LOW ) {
			startTime = currentTime;
		}
	}
	
	Serial.println("WAIT");
	
	// Etape 2 :
	while ( digitalRead(dataPin) == HIGH ) { }
	
	// A partir de là, le module est en train d'envoyer donc il faut échantilloner tout ça !
	// Pour ce faire, on va procéder en 2 étapes :
	// 1: on attend 0.6ms (de façon à faire les échantillons en milieux de bits et non au début
	// 2: on échantillonne 41 valeurs avec des pauses de 1.2ms
	
	// Etape 1
	delayMicroseconds(600);
	
	// Etape 2
	for ( int i = 0 ; i < 42 ; i++ ){
		data[i] = ( digitalRead(dataPin) == LOW ) ? '1' : '0';
		delayMicroseconds(1200);
	}
	
	Serial.println("DONE");
	
	// A partir de là, le module a tout envoyé, il ne reste plus à traiter
	
	// HEAD
	for ( int i = 0 ; i < 5 ; i++ ){
		Serial.print(data[i]);
	}
	Serial.print(" ");

	// WINDDIR
	for ( int i = 5 ; i < 9 ; i++ ){
		Serial.print(data[i]);
	}
	Serial.print(" ");

	// WIND SPEED
	for ( int i = 9 ; i < 18 ; i++ ){
		Serial.print(data[i]);
	}
	Serial.print(" ");

	// WIND SPEED+3
	for ( int i = 19 ; i < 21 ; i++ ){
		Serial.print(data[i]);
	}
	Serial.print(" ");

	// CC
	for ( int i = 21 ; i < 25 ; i++ ){
		Serial.print(data[i]);
	}
	Serial.print(" ");

	// WIND DIR NEGATEIVE
	for ( int i = 25 ; i < 29 ; i++ ){
		Serial.print(data[i]);
	}
	Serial.print(" ");

	// WIND SPEED NEGATIVE
	for ( int i = 29 ; i < 38 ; i++ ){
		Serial.print(data[i]);
	}
	Serial.print(" ");

	// WIND SPEED NEGATIVE+3
	for ( int i = 38 ; i < 41 ; i++ ){
		Serial.print(data[i]);
	}
	Serial.println(" ");
	
}

-
Edité par lorrio 25 juillet 2014 à 23:19:46

Merci beaucoup pour ce code très complet.

Il reste cependant des problèmes.
Dans le port série, seul ce message s'affiche : 

INIT
SYNC

Il tourne indéfiniment dans la boucle :

if ( digitalRead(dataPin) == LOW ) {
            startTime = currentTime;
        }

Je pense qu'on ne peut pas laisser la dtrPin en LOW tout le temps. Sur la plupart des codes que j'ai vu, il était nécessaire de changer l'état de dtrPin pour relancer une acquisition. Cela expliquerait pourquoi dataPin reste sur LOW. 

Je n'ai fais qu'appliquer ce que j'ai lu :

The TX20 will transmit data every two seconds when DTR (Pin 3, Green) is pulled low.

Mais on peut aussi imaginer laisser DTR high et le passer à LOW lorsque l'on veut mesurer.

Dans ce cas, le code devient :

int dataPin = 8;
int dtrPin = 3;

char data[41];



void printData();



void setup() {
    Serial.begin(9600);
    Serial.println("INIT");
    pinMode(dataPin, INPUT);
    pinMode(dtrPin, OUTPUT);
    digitalWrite(dtrPin, HIGH);
}



void loop() {
    
	// Une première étape consiste à se syncroniser avec le récepteur
	// Pour ce faire, on va d'abord s'assurer que le décodeur n'envoie rien
	// 1: On s'assure que DTR est à HIGH
	// 2: On attend que DATA soit à HIGH pendant au moins 100ms
	
	Serial.println("SYNC");
	
	digitalWrite(dtrPin, HIGH);
	
	unsigned long currentTime = millis();
    unsigned long startTime = currentTime;
    while ( ( currentTime - startTime ) < 100 ) {
        currentTime = millis();
        if ( digitalRead(dataPin) == LOW ) {
            startTime = currentTime;
        }
    }
	
	// Une seconde étape consiste à informer le décodeur que l'on souhaite réccupérer les données
	// 1: On passe DTR à LOW
	// 2: On attend que le signal DATA passe à LOW (ce qui correspond au premier bit de l'envoie d'un message)
	
	Serial.println("START");
	
	digitalWrite(dtrPin, LOW);
	
	while ( digitalRead(dataPin) == HIGH ) { }
	
	// La dernière étape consiste à échantillonner 41 bits à toutes les 1.2ms
    // 1: On attend 0.6ms (de façon à faire les échantillons en milieux de bits et non au début)
    // 2: On échantillonne les 41 valeurs avec des pauses de 1.2ms

    delayMicroseconds(600);
     
    for ( int i = 0 ; i < 42 ; i++ ){
        data[i] = ( digitalRead(dataPin) == LOW ) ? '1' : '0';
        delayMicroseconds(1200);
    }
	
	// Et voila, c'est terminé, il ne reste plus qu'à faire les dernières petites opérations
	// 1: Remettre DTR à HIGH
	// 2: Afficher les données
	// 3: Attendre 2 secondes avant de recommencer
	
	Serial.println("END");
	
	digitalWrite(dtrPin, HIGH);
	
	printData();
	
	delay(2000);
	
}
	


void printData() {

	// Mettre ici la portion du code pour afficher les données
	// Copier/coller du code que je t'ai déjà donné précédement

}

Je suis d'accord avec ce code excepté une ligne :

if ( digitalRead(dataPin) == LOW ) {

Si dtrPin est HIGH, dataPin sera toujours LOW non ?

J'ai essayé votre code et en changeant cette ligne mais dans les deux cas ça ne fonctionne pas.

Si je prends exactement votre code, je ne passe pas l'étape :

while ( ( currentTime - startTime ) < 100 ) {
        currentTime = millis();
        if ( digitalRead(dataPin) == LOW ) {
            startTime = currentTime;

Si je change comme je l'ai expliqué précédemment, je obtiens 41 bit de 1 dans le port série.

Je commence à me demander si les capteurs ne sont pas défaillants. J'ai essayé de mesures les tensions avec un multimètre et certaines choses m'étonnent.

- Quand dtrPin est HIGH : Si je mesure la tension au borne de VCC (sans le connecter à la board), j'obtiens 5 V. Donc j'aimerais que vous m'indiquiez si mes branchements sont faux. TxD-->pin 8; dtr-->pin 3; GND-->GND; VCC-->3.3V(j'ai déjà essayé 5V ça ne change rien). Une chose m'échappe, pourquoi j'obtiens 5V en VCC alors que c'est sensé être l'alimentation ?

Est-ce que j'ai un moyen de savoir si les capteurs fonctionnent correctement ?

Je vous remercie.

A voir le chronogramme, il me semble que par défaut, la pin DATA est à HIGH.

Du coup, c'est bien un IF LOW qu'il faut ici.

Par contre, ton capteur a l'air d'avoir des entrée/sorties en collecteur ouvert mais possède t'il des pull-up ?

Pour le savoir, il faudrait juste alimenter ton capteur : GND sur GND, VCC sur VCC (5V) et laisser les pin DTR et DATA dans le vide.

Ensuite, tu places ton voltmètre de faàon à mesurer la tension des pin DTR et DATA, que mesures tu ?

Alors j'ai fait ce que vous avez demandé :

- Tension entre DTR et GND : 3.5 V

- Tension entre TxD et GND : 0 V

Donc il n'y a pas de pull-up sur TxD, c'est peut être à cause de ça que ton code ne marche pas

Ou alors, que TxD est à l'état bas par défaut (ce qui ne m'étonne un peu).

Pour vérifier cela, je te propose de brancher ton capteur comme tu le faisait avant mais d'y mettre ce code :

int dataPin = 8;
int dtrPin = 3;

void setup() {
    Serial.begin(9600);
    Serial.println("INIT");
    pinMode(dataPin, INPUT_PULLUP);
    pinMode(dtrPin, INPUT_PULLUP);
    Serial.println("READY");
}

void loop() {
    if ( digitalRead(dataPin) == LOW ) {
		Serial.println("DATA LOW");
	} else {
		Serial.println("DATA HIGH");
	}
	if ( digitalRead(dtrPin) == LOW ) {
		Serial.println("DTR LOW");
	} else {
		Serial.println("DTR HIGH");
	}
	delay(1000);
}

Une fois que l'arduino a envoyé "READY", refais tes mesures de tension DATA et DTR tout en les laissant connectée à l'arduino et dis moi ce que t'affiche l'arduino

L'arduino me renvoie ceci :

INIT
READY
DATA LOW
DTR HIGH

- Tension entre DTR et GND : 5 V

- Tension entre TxD et GND : 1.90 V

J'ai bien l'impression que ton capteur dispose d'une sortie à collecteur ouvert.

Pour faire simple, ce genre de sortie est quelque chose de LOW COST puisqu'il n'y a besoin que d'un seul transistor.

Ce transistor sert à forcer le signal à LOW, mais il ne peut pas le forcer à HIGH.

Pour le le niveau HIGH, il faut utiliser ce qu'on appel une résistance de pull-up connectée sur VCC.

Cette résistance va amener le signal à HIGH lorsque le transistor ne le force pas à LOW.

==========

En mettant cette ligne pinMode(dataPin, INPUT_PULLUP); on demande à l'arduino de passer la pin en INPUT et d'y connecter sa pull-up interne.

Malheureusement, la pull-up de l'arduino n'est pas assez puissante pour faire remonter le signal à HIGH puisque tu mesures seulement 1.90V.

D’où ma question : aurais tu une résistance sous la main pour faire le test ?

Il s'agit de laisser le montage tel qu'il est et d'ajouter cette résistance entre VCC et TxD.

Bien sur, il ne faut pas n'importe quelle résistance mais c'est assez simple : je pense que n'importe qu'elle résistance entre 1k et 10k pourrais faire l'affaire.

-
Edité par lorrio 26 juillet 2014 à 21:13:57

Voila ce que j'en déduis de ce que tu viens de dire :

- en laissant DTR à LOW en permanence, le module envoie des données toutes les 2 secondes (pas besoin de remontre DTR à HIGH)

- par défaut (et contrairement à ce que je pensais), TxD est LOW

- les 2 pull-up (celle de l'arduino + ta résistance) TxD sont indispensable (car sinon, le signal n'est pas assez haut)

Et d'après la doc, il faut inverser le signal : un LOW correspond à un '1' ; un 'HIGH' correspond à un 0

Du coup, on peut reprendre le premier code que je t'ai envoyé en inversant les niveaux :

int dataPin = 8;
int dtrPin = 3;

char data[41];

void printData();

 
 
void setup() {
    Serial.begin(9600);
    Serial.println("INIT");
    pinMode(dataPin, INPUT_PULLUP);
    pinMode(dtrPin, OUTPUT);
    digitalWrite(dtrPin, LOW);
}



void loop() {
    
    // Normalement, le module envoie les données pendant 49.2ms toutes les 2 secondes
    
    // A partir de là, il faut se syncroniser avec le récepteur
    // Pour ce faire, on va procéder en 2 étapes :
    // 1: on attend que le signal soit à LOW pendant au moins 100ms (de façon à être sure que le module n'envoie rien)
    // 2: on attend que le signal passe à HIGH (ce qui correspond au premier bit de l'envoie d'un message)
    
    Serial.println("SYNC");
    
    unsigned long currentTime = millis();
    unsigned long startTime = currentTime;
    while ( ( currentTime - startTime ) < 100 ) {
        currentTime = millis();
        if ( digitalRead(dataPin) == HIGH ) {
            startTime = currentTime;
        }
    }
    
    Serial.println("WAIT");
    
    while ( digitalRead(dataPin) == LOW ) { }
    
    // A partir de là, le module est en train d'envoyer donc il faut échantilloner tout ça !
    // Pour ce faire, on va procéder en 2 étapes :
    // 1: on attend 0.6ms (de façon à faire les échantillons en milieux de bits et non au début)
    // 2: on échantillonne 41 valeurs avec des pauses de 1.2ms
    
    delayMicroseconds(600);
    
    for ( int i = 0 ; i < 42 ; i++ ){
        data[i] = ( digitalRead(dataPin) == LOW ) ? '1' : '0';
        delayMicroseconds(1200);
    }
    
    // A partir de là, le module a tout envoyé, il ne reste plus à traiter et recommencer
    
    Serial.println("DONE");
    
    printData();
    
    Serial.println("END");
    
}



void printData() {
    
    // HEAD
    for ( int i = 0 ; i < 5 ; i++ ){
        Serial.print(data[i]);
    }
    Serial.print(" ");
    
    // WINDDIR
    for ( int i = 5 ; i < 9 ; i++ ){
        Serial.print(data[i]);
    }
    Serial.print(" ");
    
    // WIND SPEED
    for ( int i = 9 ; i < 18 ; i++ ){
        Serial.print(data[i]);
    }
    Serial.print(" ");
    
    // WIND SPEED+3
    for ( int i = 19 ; i < 21 ; i++ ){
        Serial.print(data[i]);
    }
    Serial.print(" ");
    
    // CC
    for ( int i = 21 ; i < 25 ; i++ ){
        Serial.print(data[i]);
    }
    Serial.print(" ");
    
    // WIND DIR NEGATEIVE
    for ( int i = 25 ; i < 29 ; i++ ){
        Serial.print(data[i]);
    }
    Serial.print(" ");
    
    // WIND SPEED NEGATIVE
    for ( int i = 29 ; i < 38 ; i++ ){
        Serial.print(data[i]);
    }
    Serial.print(" ");
    
    // WIND SPEED NEGATIVE+3
    for ( int i = 38 ; i < 41 ; i++ ){
        Serial.print(data[i]);
    }
    Serial.println(" ");
    
}

diralark a écrit:

lorrio tu es très serviable

Hum, c'est possible

Mais quand un membre s'implique en indiquant les tests qu'il a fait, les sites qu'il a consulté (ce qui signifie qu'il a fait des recherches), ça donne envie d'aider non ?

Je vous remercie pour le temps que vous m'accordez ! J'ai encore quelques questions

Alors je suis d'accord avec le code que vous me donnez mais ça ne marche toujours pas, j'ai quelques observations à vous faire part. J'ai essayé ce code la pour regarder :

int dataPin = 8;
int dtrPin = 3;
 
char data[41];
 
 
 
void printData();
 
 
 
void setup() {
    Serial.begin(9600);
    Serial.println("INIT");
    pinMode(dataPin, INPUT_PULLUP);
    pinMode(dtrPin, OUTPUT);
    digitalWrite(dtrPin, HIGH);
}
 
 
 
void loop() {
          
    digitalWrite(dtrPin, LOW);
    Serial.println("LOW");
    delay(5000);
    
     
    digitalWrite(dtrPin, HIGH);
    Serial.println("HIGH");
    delay(5000);
}

Je mesure la tension aux bornes de TxD en faisant varier DTR.

- Sans mettre de résistance en plus :
Je mesure une tension de 2.22V quand DTR est LOW et 1.19V quand DTR est HIGH.

- EN mettant une résistance de 5k entre VCC et TxD
Je mesure une tension de 80mV quand DTR est LOW et 1.49 quand DTR est HIGH.

C'est vraiment étrange que ce soit complètement inversé, là je comprends pas du tout ...

Je pense que je me trompe avec la résistance à rajouter.. Pourtant je la branche seulement entre VCC et TxD ! 

En effet, ce n'est pas très logique ...

Mais peut-être que ton capteur n'est pas prévu pour être utilisé directement connecté à un micro-processeur.

Aurais tu un transistor NPN pour faire le montage suivant :

Pour observer ce qu'il se passe, ne branche pas TX et DTR sur l'arduino mais juste le GND et VCC.

Mesure ensuite la tension aux points P1 et P2.

Si le montage marche, tu devrais avoir 5V sur P1 et 0V sur P2.

Ensuite, rajoute un fil entre GND et P1 (c'est les petits bout de fil que j'ai essayé de dessiner de façon à ce que ça ressemble à un bouton).

Mesure ensuite la tension aux points P1 et P2.

Si le montage marche, tu devrais avoir 0V sur P1 (ce qui est logique vu le fil que tu viens de rajouter) et 5V sur P2.

-
Edité par lorrio 27 juillet 2014 à 23:04:33

delay(15000);

Je n'ai pas mis de résistance en plus.

- DTR en LOW : pendant 5-6s, TxD vaut 2.22V et ensuite elle vaut 10 mV et fais des trucs bizarres toutes les 2 secondes.

- DTR en HIGH : TxD vaut 1.19 V

Je n'arrive pas à expliquer tout ça..

J'ai réalisé le montage. Tout est conforme à ce que tu m'as dit !

Voici ce qu'il se passe (ou du moins, l'explication que j'arrive à trouver) :

====================

En mettant DTR à LOW, ton capteur doit surement s'initialiser pendant 5 à 6 secondes.

Pendant ce temps initialisation, il ne force pas le niveau LOW donc la pull up interne de l'arduino arrive à remonter le signal à 2.22V.

Après l'initialisation, le capteur force l'état LOW donc tu mesures 10mV.

Et bien sur, il envoie des données toutes les 2s ce qui explique pourquoi ton voltmètre s'affole toute 2 secondes.

====================

Lorsque DTR est à HIGH, le capteur n'envoie rien et reste dans un état d'attente.

Dans ce mode, il ne force pas DTR à LOW donc la pull up interne de l'arduino arrive à remonter le signal à 1.19V.

A noter que la différence entre 2.22V et 1.19V vient peut-être du capteur : il est possible que celui-ci connecte une pull-up qui vient aider celle de l'arduino lorsque DTR est LOW (ce qui explique pourquoi tu mesures 1.03V de plus).

-
Edité par lorrio 28 juillet 2014 à 0:18:41

Je comprends mieux avec vos explications

Sinon je ne vois pas trop comment intégrer le montage précédent au circuit, il faut brancher P1 et P2 sur les deux autres pin de la carte ? 

J'ai effectué ces branchements et ... ça fonctionne !!!!!!

J'ai simplement une dernière question à laquelle je n'arrive pas à répondre :

In the example image above, the Wind direction is read as 0011, Inverted to 1100 and then it’s endianness is swapped to 0011, which is ENE, or 67.5 degrees.

From the example image above, the wind speed is read as 111010101111, Inverted to 000101010000, then endianness swapped to 000010101000, which is 168, or 16.8 metres per second.

Que signifie "Then endianness swapped to ..." ? 

Merci beaucoup pour votre aide précieuse et le temps que vous m'avez accordé

Quand tu écris un chiffre, tu écris d'abord les chiffres du plus grand au plus petit.

Par exemple, pour écrire quinze, tu commences par écrire 1 (qui est le chiffre le plus grand) puis 5 (qui est le chiffre le plus petit).

Mettre les chiffres dans cet ordre s'appel du Big Endian.

Cependant, il y a aussi une autre convention : le Little Endian qui définie que c'est les chiffre les plus faible à mettre en premier.

En Little Endian, "quatre cent vingt et un" s'écrit donc "124"

====================

Les humains (du moins, tous ceux que je connais) lisent et écrivent en Big Endian.

En revanche, en électronique numérique, les circuit ont plutot tendance à être en Little Endian.

Du coup, si tu veux lire du Little Endian, il te faut inverser ("swap" en anglais) les bits reçu.

Par exemple, si le capteur t'envoie "00011", tu dois tout inverser ce qui revient à être "11000" (en binaire) et donc le nombre 24 (en décimal).

-
Edité par lorrio 28 juillet 2014 à 15:46:53

Bonjour,

J'ai un projet similaire qui consiste à réaliser un station météo perso (temp, humidité, vent vitesse et direction, ...) via un arduino uno rev3 et je suis tombé sur votre travail qui m'interresse. Pourriez vous partager votre expérience avec ce capteur TX20 et me faire parvenir le schéma elec et le dernier programme fonctionnel avec quelques petites explications si il y a des subtilités svp ?

Merci d'avance pour l'attention que vous m'accorderez.

Bonne Journée