Me revoilà après quelques lectures. Je n’ai pas encore tout ingurgité. J’espère que vous me pardonnerez 
.
Cela prend du temps…
Mais j’ai tout de même essayé de progresser avec sur les bases données par Skywood un peu plus haut.
Cela fonctionne avec des variables int, mais pas avec des long.
Pour commencer, j’ai mis ce code dans la carte émettrice (Duemilanove), :
void loop() {
if (topToutesLesSecondes ==1) { // (Je vous fais abstraction de la déclaration et de la création du top seconde.
//Il passe à ‘1’ toutes les secondes pendant un cycle loop).
envoiInt(1534); // envoi de la valeur 1534 (que j’imagine être un entier décimal) dans la fonction « envoiInt » ci-dessous.
}
} // Toutes les secondes, la valeur 1534 est ainsi envoyée une fois à la fonction envoiInt
void envoiInt (int valeur) {
Serial.write(valeur & 0xFF); // Envoi l'octet de poids faible
Serial.write((valeur >> 8) & 0xFF); // puis l'octet de poids fort
}
Sur le terminal raccordé à la carte émettrice on peux lire, toutes les secondes :
254
5
La valeur 1534 correspond en binaire à 000000101 11111110
Soit 11111110 pour le premier octet (= 254) et 00000101 pour le second octet (= 5)
Cela me semble donc correct
Dans la carte réceptrice (Mega) j’ai mis le code :
void setup()
{
Serial.begin(19200);
Serial1.begin(19200);
digitalWrite(18, HIGH); // Pull-up, nécessaire pour avoir une liaison série fiable
digitalWrite(19, HIGH); // Sans cela, je perdais des données
}
void loop() {
if (Serial1.available()) {
int ValEntree = Serial1.read();
Serial.print(ValEntree);
}
delay(50);
}
Je retrouve sur le terminal relié à la carte réceptrice, toutes les secondes, la réception de 2545 (254, puis 5).
Cela prouve que je reçois bien et correctement les données envoyées sur le port sérial1 de la Méga.
1er octet : 254 (3 char (2, 5 et 4), second octet : 5 (1 seul char).
Je rajoute entre le setup et le loop la fonction
int recevInt() {
while (Serial1.available() <2 );
int donnee = (Serial1.read() + (Serial1.read() << 8 ));
return(donnee);
}
Je remplace ce qu’il y a dans le loop par :
int variable = recevInt();
if (topToutesLesSecondes ==1) { // je vous fais abstraction du traitement du top Toutes les secondes
Serial.print("Variable : ");
Serial.println(variable);
}
Cela fonctionne, je reçois bien sur le terminal la valeur 1534. J’ai déjà fais un pas.
Je modifie maintenant l’ensemble pour passer aux long. Et là çà se corse dès que j‘envoi des valeurs qui dépassent les 32768 (plus de 2 octets) :
Par exemple, je modifie la variable à envoyer par une valeur supérieure à 65535 :
Dans le loop, je mets la valeur 67534, qui sera émis toujours une fois toutes les secondes.
envoiInt(67534);
Partie émettrice je modifie la fonction en y rajoutant le traitement des 2 octets supplémentaires :
void envoiInt (long valeur) {
Serial.write(valeur & 0xFF); // Envoi l'octet de poids faible
Serial.write((valeur >> 8) & 0xFF);
Serial.write((valeur >> 16) & 0xFF);
Serial.write((valeur >> 24) & 0xFF); // puis l'octet de poids fort
} // FIN de la fonction
Je retrouve bien sur le port série de l’émettrice les valeurs 206, 7, 1, 0 qui correspondent bien aux 4 octets qui représentent la valeur 67534.
Dans la carte réceptrice je modifie également la fonction ainsi (je pense que c’est là que se trouve le problème):
long recevLong() {
while (Serial1.available() < 4 );
long recu = (Serial1.read() + (Serial1.read() << 8 ) + (Serial1.read() << 16) + (Serial1.read() << 24));
return (recu);
}
Et dans le loop
long variable = recevLong();
Et cette fois la variable prend la valeur 1998, ce qui correspond aux deux octets 206,7. Les 2 octets suivants ne passent pas.
Une idée. Je cherche depuis quelques jours…
Franck
, qui n'as jamais copier/coller d'un morceau de code avant de se rendre compte d'une petite erreur sans modifié le morceau copié hein ;))
)
).