Arduino Forum

International => Français => Topic started by: Bubule on Dec 31, 2011, 04:42 pm

Title: Transferts de données entre arduino par la liaison série
Post by: Bubule on Dec 31, 2011, 04:42 pm
Bonjour

Il me semble avoir presque tout lu (dans le forum Français), sur ce qui se rapporte aux communications séries. Et du coup, cela me paraît bien compliqué pour le noob que je suis. Maintenant, je ne sais plus trop quelle serait la procédure à employer.

Je dois faire s'échanger des variables (int, float et long) d'une carte à l'autre (entre Duemilanove et Mega 2560).

La configuration matérielle :
Duemilanove (Pin 0(Rx) et 1(Tx)) raccordée en croisant les fils, au port serial1 de la Mega (Pin 18(Tx) et 19(Rx)).
La Mega est raccordée au Pc par le port série standard (0/1) pour contrôler la réception des valeurs sur le terminal.

La première étape que j'ai réussi à faire, c'est enregistrer les variables à transférer dans un tableau (3 variables pour commencer). Les envoyer sur le port série de la Duemilanove (pin 0 et 1), et ainsi les lire sur le terminal.

Sur la Mega, je n'arrive pas à les enregistrer. Ce qui m'apparait maintenant comme normal, au regard de ce que j'ai pu lire. Ce n'est pas aussi simple que je le pensais.

Dois-je transformer mes variables afin qu'elles aient toutes le même format dans le tableau (long, float, … ?)
Dois-je formater les variables avant l'envoi ? Comment ? (dois-je les modifier en char ? > Que faire des long ?)


Le nombre de données du tableau de l'émetteur (et donc recevoir sur l'autre) est fixe et connu.
Le format à l'arrivée serait donc à reformater pour retrouver le même type qu'avant l'envoi de la carte émettrice (connu également).

Je me pose beaucoup plus de questions après avoir potassé pendant plusieurs jours qu'avant !
Si vous avez des exemples fonctionnels, je suis preneur…



Franck

BONNES FETES DE FIN D'ANNEE !!!!!!!
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Dec 31, 2011, 06:26 pm
Bonjour,

Pour envoyer / recevoir des variables il faut d'abord les transformé en une suite d'octets.

Exemple, un char ou un byte = un octet,
Envoi :
Code: [Select]
Serial.write(variableDeTypeChar);
Réception :
Code: [Select]
char variable = Serial.read();

Exemple, un int = 2 octets,
Envoi :
Code: [Select]
Serial.write(variableDeTypeInt & 0xFF); // Envoi l'octet de poids faible
Serial.write((variableDeTypeInt >> 8) & 0xFF); // puis l'octet de poids fort

Réception :
Code: [Select]
int variableRecu = Serial.read() + (Serial.read() << 8);

Exemple, un long = 4 octets,
Envoi :
Code: [Select]
Serial.write(variableDeTypeLong & 0xFF); // Envoi l'octet de poids faible
Serial.write((variableDeTypeLong >> 8) & 0xFF);
Serial.write((variableDeTypeLong >> 16) & 0xFF);
Serial.write((variableDeTypeLong >> 24) & 0xFF); // puis l'octet de poids fort

Réception :
Code: [Select]
long variableRecu = Serial.read() + (Serial.read() << 8) + (Serial.read() << 16) + (Serial.read() << 24);

Edit: Le plus simple est de faire des fonctions exemple pour le int :
Code: [Select]

void sendInt(int valeur) {
  Serial.write(valeur & 0xFF);
  Serial.write((valeur >> 8) & 0xFF);
}

int recevInt() {
  while(Serial.available() < 2);
  return Serial.read() + (Serial.read() << 8);
}
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 01, 2012, 01:02 pm
Bonjour et MEILLEURS VŒUX A TOUS !!

Merci pour ton aide Skywood.

Ok, çà confirme, ce n'est pas aussi simple de transférer des donnés. Je ne pense pas que les bulles de la nuit en soit la seule explication …

Il faut donc bien que toutes les données soient selon le même format.
Pour info, j'ai une quinzaine de variables à transférer. La plupart sont des "int", et les "long" devraient pouvoir être passées en "int". Mais j'ai deux "double" qui gèrent le PID (librairie ici : http://arduino.cc/playground/Code/PIDLibraryConstructor ). Et là, je ne pense pas pouvoir les changer.
A moins qu'il soit possible d'écrire ceci :
Code: [Select]
int valeur_Réduite = double Valeur
Il est également possible que d'autres variables viennent compléter la liste avec le temps.

Donc pour simplifier le traitement pré-envoi,  ce qui me semble le plus logique en fonction de ce que tu proposes, serait de toutes les convertir en "double" afin de n'avoir qu'un seul type de traitement. En créant des fonctions.
Mais comment les appelles tu ? Encore un apprentissage pour moi.

Franck



Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 01, 2012, 02:16 pm

Ok, çà confirme, ce n'est pas aussi simple de transférer des donnés. Je ne pense pas que les bulles de la nuit en soit la seule explication …

C'est pas simple mais ce n'est pas énormément compliqué non plus ;)


Il faut donc bien que toutes les données soient selon le même format.
Pour info, j'ai une quinzaine de variables à transférer. La plupart sont des "int", et les "long" devraient pouvoir être passées en "int". Mais j'ai deux "double" qui gèrent le PID (librairie ici : http://arduino.cc/playground/Code/PIDLibraryConstructor ). Et là, je ne pense pas pouvoir les changer.
A moins qu'il soit possible d'écrire ceci :
Code: [Select]
int valeur_Réduite = double Valeur
Il est également possible que d'autres variables viennent compléter la liste avec le temps.

Un double est sur 4 octets comme pour un long, regarde sur la référence arduino tu as tout les types de données basique.
http://arduino.cc/en/Reference/HomePage


Donc pour simplifier le traitement pré-envoi,  ce qui me semble le plus logique en fonction de ce que tu proposes, serait de toutes les convertir en "double" afin de n'avoir qu'un seul type de traitement. En créant des fonctions.
Mais comment les appelles tu ? Encore un apprentissage pour moi.

imaginons une fonctions :
Code: [Select]
void faireQuelqueChose(char variable) {
// ...
}


tu l'appellerai ainsi :
Code: [Select]
char c = '.'; // variable quelconque pour l'exemple
// ...
faireQuelqueChose(c); // appel de la fonction


Je te conseil de faire un tour sur ce tutoriel :
http://www.siteduzero.com/tutoriel-3-13982-les-fonctions.html
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 01, 2012, 03:58 pm
Merci  ;)

Je m'en vais lire tout çà et je reviens.
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 01, 2012, 08:40 pm
Hello

Pas mal le tuto ! Les fonction vont bien se tenir avec moi maintenant !  :D

J'ai tenté la mise en application, mais çà ne commence pas bien...
Voici le code :
Code: [Select]

//Tableau de variable
long tableauDonnees[4]; //Déclare un tableau à x lignes

void setup() {  // DEBUT DE SETUP 
 
  // Initialise la liaison série
  Serial.begin(19200);                // Initialise la liaison série Hard
   delay(50);

Void loop() {

if (topToutesLesSecondes == 1) {   // bit F.Montant toutes les secondes
    int i;
for (i = 0; i < 4; i = i + 1) {
envoiLong(tableauDonnees[i]);
delay(2);
       }
     } // Fin de if

// Renseignement Tableau
tableauDonnees[0] = 'D';
tableauDonnees[1] = pos_servo_1;
tableauDonnees[2] = 357;
tableauDonnees[3] = '357';


} // Fin de loop


void envoiLong (long valeur) {
 
  Serial.println(valeur & 0xFF);// Envoi l'octet de poids faible
  Serial.println((valeur >> 8) & 0xFF);
  Serial.println((valeur >> 16) & 0xFF);
  Serial.println((valeur >> 24) & 0xFF); // puis l'octet de poids fort
 
}


Je lit bien sur le terminal 4 fois 4 lignes qui correspondent aux 4 envois de 4 octets.
Mais ne sont renseignés que les 2 premiers octets de chaque donnée. Les 2 suivants restent à 0. Je lis :

68  (D en Hexa)
0
0
0
40   (correspond bien à l'angle du servo en °)
0
0
0
101 (??)
1     (??)
0
0
55    (7 en Hexa)
53    (5 en Hexa)
0     ( on devrait trouver 51 (3 en Hexa))
0


C'est où que j'ai déconné ?  :.
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 01, 2012, 09:22 pm
Quote
C'est où que j'ai déconné ?

humm comment dire ...

-> Il manque un } pour setup() dans ton code,
-> topToutesLesSecondes n'est pas déclaré, de même pour pos_servo_1,
-> tableauDonnees[3] = '357'; n'est pas une écriture autorisé, '357' ça n'existe pas (simple quote -> pour 1 caractère) et "357" (double quote -> une chaine de caractères) n'est pas autorisé dans ce cas (pas de conversion possible de char[] vers long).

Je sais pas pourquoi tu veut absolument tous mettre dans un tableau de long !
Fait une fonction par type et envoi les variables "normalement", sans quelle soit dans un tableau, se serait plus intelligent que de vouloir à tout prix stocker des variables de type différent dans un tableau d'un type fixe...

Tu devrait faire un tour ici :
http://www.siteduzero.com/tutoriel-3-14189-apprenez-a-programmer-en-c.html?all=1#chap_14023

et peut être faire un tour du coté des structures :
http://www.siteduzero.com/tutoriel-3-14189-apprenez-a-programmer-en-c.html?all=1#chap_14043

Cette librairie te sera d'une grande aide si tu te tourne vers la solution des structures :
http://www.billporter.info/easytransfer-arduino-library/




Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 02, 2012, 07:43 am
Bonjour

Oui, en fait j'ai voulu ne recopier que les parties importantes de mon programme (celles relatives au transfert). En oubliant de recopier '}' et de montrer les déclarations de variables (Celles-ci sont déclarées en global en début de sketch.

Pour le type de variables du tableau de l'exemple, j'ai mis différents types de variables, car je souhaitais comprendre comment s'envoyait des données, et à quoi elles ressemblaient à l'arrivée.
C'est là que j'ai remarqué que seuls les 2 premiers octets passaient. Je ne comprends pas pourquoi la valeur 123 (donne 101 et 1). J'ai donc tenté d'envoyer ensuite d'autres formats (comme char 123). Mais au final, je pense n'envoyer que des doubles.

Il me semblait plus judicieux d'envoyer les données par paquets. Et donc renseigner les champs du tableau en fin de programme en fonction de l'évolution des variables à transférer. Puis d'envoyer tout le tableau. Ce qui m'impose de toutes les avoir au même format (double).
Je m'en vais lire tes liens afin d'être un peu plus calé, et très certainement revoir mes copies en fonction. Mais les vacances sont finies, et cela va me prendre un peu plus de temps.
Je reviens ensuite !

Bon courage également à ceux qui reprennent le taf…

Franck
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 02, 2012, 03:00 pm

Oui, en fait j'ai voulu ne recopier que les parties importantes de mon programme (celles relatives au transfert). En oubliant de recopier '}' et de montrer les déclarations de variables (Celles-ci sont déclarées en global en début de sketch.

Je me doutai bien qu'il y avait une histoire dans ce gout là, mais le mieux c'est de tout envoyer pour avoir une vision d'ensemble du code.


Pour le type de variables du tableau de l'exemple, j'ai mis différents types de variables, car je souhaitais comprendre comment s'envoyait des données, et à quoi elles ressemblaient à l'arrivée.
C'est là que j'ai remarqué que seuls les 2 premiers octets passaient. Je ne comprends pas pourquoi la valeur 123 (donne 101 et 1). J'ai donc tenté d'envoyer ensuite d'autres formats (comme char 123). Mais au final, je pense n'envoyer que des doubles.

Tu n'envoi que des doubles car ton tableau est constituer de double ...
Pour le format en entrée et en sortie c'est simple, en entrée tu as des octets, en sortie tu a des octets, octets qui mis bout à bout donne un type.
C'est pas compliqué, tout ce qui peut être stocker dans la ram peut être transformer en une suite d'octet, que ce soit une variable, une structure, etc ...


Il me semblait plus judicieux d'envoyer les données par paquets. Et donc renseigner les champs du tableau en fin de programme en fonction de l'évolution des variables à transférer. Puis d'envoyer tout le tableau. Ce qui m'impose de toutes les avoir au même format (double).

Si tu veut faire un envoi par paquets de variables avec des types différents ce n'est pas un tableau que tu doit utiliser mais une structure, les tableaux ne sont utiles que pour stocker des valeurs d'un seul et unique type.
Title: Re: Transferts de données entre arduino par la liaison série
Post by: tochinet on Jan 03, 2012, 04:41 pm
Pour reprendre au début, il y a probablement une infinité de moyens de transférer ces données.

Si on considère que le duemilanove est déporté (ou "esclave", etc), on peut partir du postulat que c'est mieux de concentrer l'intelligence sur le MEGA qui est toujours connecté au PC. Donc,
tu peux allègrement simplifier en utilisant les librairies standard sur le duemilanove, et envoyer    Serial.println( tavariable, DEC ou autre);  (avec un serial.print ( "tonetiquette1 : ") avant )  puis laisser le MEGA "se débrouiller".   Remplacer evidemment tavariable et tonetiquette par des mots plus adaptés.

Plus fouillé, tu peux utiliser la librairie firmata (utilise des message pseudo  MIDI) ou bien le "aProtocol" qui utilise des strings de 12 caractères. Plus compliqué au début, mais plus souple pour les nombreuses additions que tu ne manqueras pas de faire par la suite...

En fait, ce n'est pas parce que tu définis un tableau de long que tout ce que tu y mets en devient un, la conversion de type suit des règles pas toujours évidentes. Ton premier exemple est un Char, le deuxième un byte ou int, le troisième un int, etc.  et ... un tableau n'est qu' un pointeur ! Donc ton int 357 est envoyé comme 1x256 + 101 , logique.  Ton '357' n'est en effet pas correct, je ne sais pas pourquoi on retrouve 2 chars (probablement une conversion typecast vers int ?). Si tu utilise des floats, ils ont la même longueur que les long (4 bytes) mais un tout autre format (mantisse exposant)

Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 03, 2012, 07:33 pm
Bonsoir à tous

Je suis en train de reprendre les bases sur le site du zéro que m'a donné skywood. Et j'ai du taf vu mon niveau  XD. Mais c'est tellement intéressant que je m'y prends au jeu, et ai repris la lecture au tout début. ;)

Je comprends qu'il me faudrait en dire plus, mais cela risque de perdre un peu le sens du topique. Cependant, je serais prêt à vous transférer tout le sketch (17K) afin que vous y jetiez un œil d'expert.  ;) Surtout que j'ai parfois quelques plantages ( http://arduino.cc/forum/index.php/topic,82815.0.html ).

Pour expliquer ma démarche et mon installation. J'ai reçu ma Duemilanove il y a un an, avec laquelle j'ai commencé à piloter 2 servomoteurs (accessoires d'un aquarium récifal de 500L). Mon niveau de programmation était presque nul (qui a dit qu'il l'était encore ?  ]:D). Et puis avec le temps, je me suis dit que je pouvais adjoindre d'autres fonctionnalités à la carte. Mesures, régulations, pilotage de pompes… Tout cela est maintenant fonctionnel.
Et ensuite qu'il serait bien de pouvoir lire et modifier des paramètres avec un afficheur tactile ( http://arduino.cc/forum/index.php/topic,78741.0.html ) Et là les problèmes commencent (ou sont mis en évidence).

La Duemilanove n'est plus suffisante (Entrées/sorties) et sera plus tard remplacée par la Mega. Mais la Duemilanove est en place et gère déjà pas mal de choses que je ne veux pas arrêter tant que je n'ai pas suffisamment avancé sur ce projet.  Les plantages de la Duemilanove m'ont fait réfléchir à la nécessité de redondance (il y a un gros risque pour la vie des occupants du bac si une sortie vient à dérailler dans une mauvaise configuration).
Donc à terme, la Mega gèrera la partie opérative (gestion du bac), et dialoguera avec la Duemilanove pour envoyer ses données, et recevra les nouvelles consignes de la Demilanove par une liaison série.
La Duemilanove effectuera une vérification du bon fonctionnement de la Mega (capteurs en double, vérification d'un top émis par la Mega toutes les 5 secondes, …). Et effectuera les liaison avec la dalle tactile (4D en mode GFX) et la Mega par des liaisons softserial, puisque la Duemilanove n'a qu'un seul port série, qui sera très certainement réservé pour le PC

Mais il me faut débuter, et c'est pour cela que pour le moment je tente l'envoi de données par les liaisons série 'hard'.
La première étape était que la Duemilanove en place, envoie ses données à la Mega. Et que je puisse retrouver ces valeurs dans la Mega grâce au PC.
Comme déjà là je ne m'en sortais pas, j'ai tenté d'envoyer une série de variables d'un tableau de la Mega au terminal du PC. Et me voilà.
Mais je ne désespère pas. Je réussirais avec votre aide, et j'en sortirais encore plus riche de connaissances.

Dès que j'ai un moment, je tente l'envoi de plusieurs variables 'long' de la Mega vers le terminal. C'est pas encore gagné.

Voilà, j'ai été un peu long (pas char) mais si cela vous inspire d'autres pistes, je suis preneur.

Franck
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 03, 2012, 10:32 pm

Je suis en train de reprendre les bases sur le site du zéro que m'a donné skywood. Et j'ai du taf vu mon niveau  XD. Mais c'est tellement intéressant que je m'y prends au jeu, et ai repris la lecture au tout début. ;)

Tu peut passer outre les parties "pc" (SDL, etc ...), quoi qu'il en soit c'est une bonne philosophie de vouloir progresser (et mieux si c'est en s'amusant :P) ;)


Je comprends qu'il me faudrait en dire plus, mais cela risque de perdre un peu le sens du topique. Cependant, je serais prêt à vous transférer tout le sketch (17K) afin que vous y jetiez un œil d'expert.  ;) Surtout que j'ai parfois quelques plantages ( http://arduino.cc/forum/index.php/topic,82815.0.html ).

Tu peut toujours le joindre en pièce jointe on y jettera un oeil, si ça ce trouve tes bug sont de simple erreurs toute bête (plus c'est bête plus c'est difficile de les détecter :smiley-yell:, 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 ;))


La Duemilanove n'est plus suffisante (Entrées/sorties) et sera plus tard remplacée par la Mega. Mais la Duemilanove est en place et gère déjà pas mal de choses que je ne veux pas arrêter tant que je n'ai pas suffisamment avancé sur ce projet.  Les plantages de la Duemilanove m'ont fait réfléchir à la nécessité de redondance (il y a un gros risque pour la vie des occupants du bac si une sortie vient à dérailler dans une mauvaise configuration).
Donc à terme, la Mega gèrera la partie opérative (gestion du bac), et dialoguera avec la Duemilanove pour envoyer ses données, et recevra les nouvelles consignes de la Demilanove par une liaison série.

Si c'est purement un probléme de nombre d'entrées sortie regarde du coté du PCF8575 ou PCF8574, si ça ce trouve tu doit pouvoir garder ton systéme actuelle moyenne des modifications minim de ton code.


La Duemilanove effectuera une vérification du bon fonctionnement de la Mega (capteurs en double, vérification d'un top émis par la Mega toutes les 5 secondes, …). Et effectuera les liaison avec la dalle tactile (4D en mode GFX) et la Mega par des liaisons softserial, puisque la Duemilanove n'a qu'un seul port série, qui sera très certainement réservé pour le PC

Si tu veut tu peut faire un systéme de "failover", en gros si la mega plante prévoit un systéme de "soft reset" pour tenter de résoudre le probléme au plus vite.
C'est valable dans les deux sens, si la mega ne répond pas à ton "ping" par un "pong" toute les 5sec alors déclenche le "soft reset" de même si la duemilanove ne génère pas de "ping" aprés 10sec par exemple déclenche un "soft reset" coté duemilanove.
Bon évidement fait déja ton code de base, et vérifie chaque fonction pour s'assurer de son bon fonctionnement. Une fois que tout sera ok tu pourrait faire ton systéme de failover.
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 09, 2012, 11:09 am
Me revoilà après quelques lectures. Je n'ai pas encore tout ingurgité. J'espère que vous me pardonnerez  :smiley-red:.
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), :
Code: [Select]
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 :
 
Code: [Select]

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
Code: [Select]

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 :
Code: [Select]

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.
Code: [Select]
envoiInt(67534);

Partie émettrice je modifie la fonction en y rajoutant le traitement des 2 octets supplémentaires :
Code: [Select]

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):
Code: [Select]

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
Code: [Select]
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
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 09, 2012, 04:31 pm

Code: [Select]

long recevLong() {   
    while (Serial1.available() < 4 ); 
     long recu = (Serial1.read()  + (Serial1.read() << 8 ) + (Serial1.read() << 16) + (Serial1.read() << 24));
       return (recu);
  }

Et cette fois la variable prend la valeur 1998, ce qui correspond aux deux octets 206,7. Les 2 octets suivants ne passent pas.

essaye :
Code: [Select]

long recevLong() {   
  while (Serial1.available() < 4 ); 
    long recu = (Serial1.read()  | (Serial1.read() << 8 ) | ((unsigned long)Serial1.read() << 16) | ((unsigned long)Serial1.read() << 24));
    return (recu);
}

Je peut pas tester mon morceau de code tout de suite donc à prendre avec des pincettes ;)
(eeepc, wifi, cours en amphi, tout ça :smiley-mr-green:)
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 10, 2012, 08:35 am
Bonjour

Bon, j'ai testé rapidement hier soir. Ça a l'air de fonctionner  XD  :D. La déclaration (unsigned long) semble être la parade. Le '|' semble également pouvoir être remplacé par le '+'. Je testerais avec plus de valeurs lorsque j'aurais un peu plus de disponibilité également.

C'est quand même cool d'avoir des dieux de la programmation…  :smiley-mr-green:  ;)(Je n'aurais jamais trouvé  :smiley-eek-blue:).

Merci !

Les étapes suivantes :
-   Transfert de plusieurs valeurs par le biais de tableaux.
-   Passage du port Uart 0/1 aux ports 'softserial'
-   Déclenchement de l'envoi sur quel critère ? (variation d'une variable du tableau, top horloge, réponse à une interruption, …)
-   Envoi de toutes les données du tableau, ou juste celle modifiée ?
-   Augmentation de la vitesse de transfert.

A bientôt
Franck
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 10, 2012, 12:31 pm

Bon, j'ai testé rapidement hier soir. Ça a l'air de fonctionner  XD  :D. La déclaration (unsigned long) semble être la parade. Le '|' semble également pouvoir être remplacé par le '+'. Je testerais avec plus de valeurs lorsque j'aurais un peu plus de disponibilité également.

Le + et le | (ou bits à bits) ont le même effet dans le cas d'un calcul "bitwise", mais dans le doute comme je pouvais tester pas mon code j'ai utilisé le | qui marche dans tout les cas.


C'est quand même cool d'avoir des dieux de la programmation…  :smiley-mr-green:  ;)(Je n'aurais jamais trouvé  :smiley-eek-blue:).

"Dieux de la programmation" :smiley-mr-green:


Les étapes suivantes :
-   Transfert de plusieurs valeurs par le biais de tableaux.
-   Passage du port Uart 0/1 aux ports 'softserial'
-   Déclenchement de l'envoi sur quel critère ? (variation d'une variable du tableau, top horloge, réponse à une interruption, …)
-   Envoi de toutes les données du tableau, ou juste celle modifiée ?
-   Augmentation de la vitesse de transfert.

- boucle for, tableaux
- lib NewSoftSerial
- (for/if, lib MsTimer, attachInterrupt())
- transfert complet -> simple et rapide, transfert partiel -> envoi d'une adresse, longueur du paquet, ... -> compliqué, mais pratique lors de l'envoi de grosse quantité de données.
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 10, 2012, 01:38 pm

- lib NewSoftSerial


Il me semble avoir lu que la version V1.0 intègre maintenant les fonctionnalités de la NewSoftSerial sous la dénomination de la Softserial.
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 10, 2012, 05:04 pm

Il me semble avoir lu que la version V1.0 intègre maintenant les fonctionnalités de la NewSoftSerial sous la dénomination de la Softserial.

Ouaip en faite ils ont juste renommé NewSoftSerial en SoftSerial ^^
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 13, 2012, 11:03 pm
Me revoici  :)

Ca avance !
Mais il y a au moins un hic :

Je n'arrive pas à chopper la première valeur (tableauDonnée[0]).
Sinon, toutes les valeurs (tableauDonnée[1 à 4]) sont quant à elles correctes.


A l'émission j'ai mis dans le loop :
Code: [Select]

// Renseignement Tableau
 tableauDonnees[0] = 999999999;    // valeur arbitraire signalant le début de la transmission
 tableauDonnees[1] = pos_servo_1;  // Variable oscillant entre 10 et 130
 tableauDonnees[2] = millis();        
 tableauDonnees[3] = pH*100;       // Variable (double) multipliée par 100 pour chopper 2 décimales
 tableauDonnees[4] = 111111111;    // valeur arbitraire signalant la fin de la transmission

// Toutes les secondes :
int e;
   for (e = 0; e < 5 ; e = e + 1) {
     envoiInt(tableauDonnees[e]);
     }

 Fin de loop


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



Dans la carte réceptrice :
Code: [Select]

 
// Déclaration des variables et constantes horloge
 unsigned long refTemps;      // Mémoire de l'horloge millis pour horloge
 int topsec = 0;              // Impulsion topsec toutes les secondes
 int topmin = 0;              // Impulsion topmin toutes les minutes

// Permet de remettre l'horloge à l'heure sur init
 int heure = 14;              // Heures de l'horloge >>>> Permet de remettre l'horloge à l'heure sur init
 int minute = 35;             // Minutes de l'horloge >>> Permet de remettre l'horloge à l'heure sur init
 int seconde = 0;             // Secondes de l'horloge

 //Tableau de variable
 long tableauDonnees[5] = {0};         //Déclare un tableau à 5 lignes
 
   // Valeurs du tableau de variable qui doivent être reçues de la carte emettrice
 long var0;          // Doit recevoir la valeur 999999999 (valeur fixe)
 long milli;         // Doit recevoir la valeur millis() de la carte emettrice (variable)
 long posServo1;     // Doit recevoir la position du servo 1 (10 à 130) (variable)
 double pH = 0.00;   // Doit recevoir la mesure de pH (variable)
 long var4;          // Doit recevoir la valeur 111111111 (valeur fixe)
   
 
void setup() {
 Serial.begin(19200);
 Serial1.begin(19200);
 
// Pull-up de la liaison série
 digitalWrite(18, HIGH);  
 digitalWrite(19, HIGH);
 
} //FIN de SETUP


 long recevLong() {    
   while (Serial1.available() < 4 );  
     long recu = ((unsigned long)Serial1.read() | ((unsigned long)Serial1.read() << 8 ) | ((unsigned long)Serial1.read() << 16) | ((unsigned long)Serial1.read() << 24));
    return (recu);
   }


void loop() {              
 
   if (recevLong()) {  
      int r;      
      for (r = 0; r < 4; r = r + 1){       // Passer à  'r < 5' ne permet pas de renseigner le champ [0]. Et les valeurs suivantes sont erronées.
        tableauDonnees[r + 1] = recevLong(); // Et du coup, afin de pouvoir renseigner les bonnes cases du tableau, je dois passer à r + 1
         }
     }
   
    var0 =      tableauDonnees[0] ;
    posServo1 = tableauDonnees[1] ;
    milli  =    tableauDonnees[2] ;
    pH =        tableauDonnees[3] / 100.00;
    var4 =      tableauDonnees[4];
   
         // LIAISON SERIE POUR TESTS
    if (topsec) {  
       Serial.println(var0);
       Serial.println(posServo1);
       Serial.println(milli);
       Serial.println(pH);
       Serial.println(var4);
       Serial.println("fin");
       Serial.println();    
   }
     
 
  topsec = 0;
  topmin = 0;

     // HORLOGE
     if (millis() >= refTemps){
        refTemps += 1000;
        seconde++;           // Incrémentation des secondes
        topsec = 1;          // Monte le bit topsec toutes les secondes
       if (seconde >= 60) {  // à chaque 60 secondes
           minute++ ;        // Incrémentation des minutes
           seconde = 0;
           topmin = 1;       // Monte le bit topmin toutes les minutes
         if (minute >= 60) {
             heure++ ;       // Incrémentation des heures
             minute = 0 ;
           if (heure >=24) {
                 heure = 0 ; // réinitialise l'horloge toutes les 24h
              }
             }
            }
           }
               
/*    
    // POUR TEST réception Port Serial1 et transfert sur port Uart          
   if (Serial1.available()) {
      long ValEntree = Serial1.read();
      Serial.print(ValEntree);
     }

*/
     
} // FIN de LOOP


Puis-je mieux faire ?
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 14, 2012, 01:34 pm
Tu as fait une erreur dans la partie réception :
Code: [Select]
if (recevLong()) { 
  int r;       
  for (r = 0; r < 4; r = r + 1){       // Passer à  'r < 5' ne permet pas de renseigner le champ [0]. Et les valeurs suivantes sont erronées.
    tableauDonnees[r + 1] = recevLong(); // Et du coup, afin de pouvoir renseigner les bonnes cases du tableau, je dois passer à r + 1
  }
}

Le if(recevLong()) te "mange" le 1er long reçu donc par la suite tout ta réception est faussé ;)

Code: [Select]
if (tableauDonnees[0] = recevLong()) {     
  for (int r = 1; r < 5; r++){
    tableauDonnees[r] = recevLong();
  }
}
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 14, 2012, 01:58 pm
:smiley-eek: :smiley-eek: :smiley-eek:

Bonjour

Je ne pensais pas que l'on pouvait écrire un truc pareil dans une condition
if(tableauDonnees[0] = recevLong()) {     
 

Et çà marche en plus !!!

Merci dieux
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 14, 2012, 02:10 pm

Je ne pensais pas que l'on pouvait écrire un truc pareil dans une condition
if(tableauDonnees[0] = recevLong()) {     
 
Et çà marche en plus !!!

C'est une assignation conditionné ;) 
Ya plein de petites astuces dans ce genre pour réduire la taille d'un programme tout en gardant un maximum de lisibilité ;)
(Pour dire vrai ya tellement d'astuces dans ce genre que ce serais impossible de toute les lister :smiley-sweat:)


Merci dieux

heu ... pas de quoi :smiley-mr-green:
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 15, 2012, 12:32 pm
Bonjour

Bon, maintenant que les transferts sont correctement envoyés, reçus, et répartis dans les bonnes variables, je suis en train de libérer les ports Uart (Serial), au profit des ports Softserial.

J'ai donc inclus la librairie SoftSerial qui correspondrait à la librairie NewSoftSerial depuis l'IDE V0.1.

La liaison fonctionne sur ma Duemilanove, mais j'ai une interaction avec la librairie « servo ».  Enfin c'est-ce que je suppose car, à chaque envoi de données sur le port (RX pin 4 / Tx pin 5), les servos raccordés sur les pin 10 et 11, sont parasités. C'est-à-dire qu'ils effectuent un saut de quelques degrés (avec retour à la position) en une fraction de seconde. Cela est suffisamment bruyant pour être gênant.

Ce parasite intervient à chaque envoi des données. Soit toutes les secondes.

Avez-vous déjà remarqué ce phénomène ?
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 15, 2012, 12:45 pm

J'ai donc inclus la librairie SoftSerial qui correspondrait à la librairie NewSoftSerial depuis l'IDE V0.1.
(...)
Ce parasite intervient à chaque envoi des données. Soit toutes les secondes.
Avez-vous déjà remarqué ce phénomène ?

SoftSerial (et par extension NewSoftSerial) utilise l'interruption d'un timer pour fonctionner, de même pour Servo, par conséquent quand SoftSerial transmet des données l'interruption de Servo est mis en pause ... essaye de mettre sei(); avant l'envoi des données, ça va relancer l'interruption de Servo le probléme c'est que ya de forte chance que ça fasse planter les timings de SoftSerial du coup ...
Title: Re: Transferts de données entre arduino par la liaison série
Post by: Bubule on Jan 15, 2012, 01:50 pm
Ça ne change rien. J'ai tenté de mettre l'instruction sei(); à différents endroits (dans le loop, juste avant l'appel de la fonction d'envoi, dans la fonction avant les 4 port45.write(....) ). J'ai toujours le même parasite.

Ça confirme un peu ce que je pensais. Bien que je pensais plus à un pb d'interruption.

Je me dis maintenant que la solution serait peut-être de travailler sur d'autres timer, mais comme j'ai modifié les prescaler des autres timer pour augmenter la fréquence des PWM afin de limiter le bruit des moteurs de pompes. C'est sans doute impossible de s'en sortir.

Je dois avouer que je suis un peu déçu par le procédé µC (très certainement parce que je ne maitrise pas tout). Une application fonctionne bien, et puis on y ajoute d'autres applications, puis encore d'autres. Au final, on se retrouve avec des interactions gênantes.

J'espère que la solution de remplacement de la Duemilanove par la mega sera la solution à tous ces problèmes. Mais l'utilisation des ports Serial 1, 2 et 3 ne posera-t-il pas le même soucis ?
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 15, 2012, 03:13 pm

Ça confirme un peu ce que je pensais. Bien que je pensais plus à un pb d'interruption.

C'est un probléme de conflit entre l'interruption du timer utilisé par la lib Servo et l'interruption du timer utilisé par la lib SoftSerial.


Je me dis maintenant que la solution serait peut-être de travailler sur d'autres timer, mais comme j'ai modifié les prescaler des autres timer pour augmenter la fréquence des PWM afin de limiter le bruit des moteurs de pompes. C'est sans doute impossible de s'en sortir.

Le probléme c'est qu'il n'est pas possible d'avoir deux taches simultanément, donc impossible d'avoir deux interruptions simultanément ...
Lorsque SoftSerial bloque le µc pour envoyer les données l'interruption de Servo passe à la trappe ...


Je dois avouer que je suis un peu déçu par le procédé µC (très certainement parce que je ne maitrise pas tout). Une application fonctionne bien, et puis on y ajoute d'autres applications, puis encore d'autres. Au final, on se retrouve avec des interactions gênantes.

Faut pas être déçu, c'est ça la programmation embarqué, ya pas de multitâche sur les micro-contrôleur faut faire avec ;)
L'utilisation de SoftSerial est vraiment obligatoire ? Tu ne peut pas rester en Serial hardware ?
Sinon tu peut laisser de coté la lib Servo est utilisé les broches PWM hardware ce qui réglerai le probléme :
http://www.societyofrobots.com/member_tutorials/node/231


J'espère que la solution de remplacement de la Duemilanove par la mega sera la solution à tous ces problèmes. Mais l'utilisation des ports Serial 1, 2 et 3 ne posera-t-il pas le même soucis ?

Serial, Serial1, Serial2, Serial3 sont des ports série hardware qui fonctionne sans avoir besoin d'interruption, pas d'incompatibilité donc.
Title: Re: Transferts de données entre arduino par la liaison série
Post by: zeric on Jan 16, 2012, 07:27 pm
Bonjour,
J'en rajoute un peu, comme ça concerne du transfert de données par la laison série:
Perso, je fais que du bricolage (débutant), j'aimerais donc bien avoir l'avis de qqun qui connait le "C" pour améliorer mon prog de transfert de String (propre  :smiley-mr-green:)

Code: [Select]
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //init lib (keypad shield)
String hein = ""; //you talking to me?

void setup(){
Serial.begin(9600); //régler SerialMonitor sur [NewLine]
lcd.begin(16, 2);
lcd.print("Test RX");
}

void decode_rx(String quoi){ //anlyse fct
while (Serial.available() > 0){ //data on RX
  char lu = Serial.read(); //read 1° byte & put in variable
if (lu == 10){ //char newline?
hein = ""; //RAZ
break; //get out of while
}
else hein += char(lu); //char not a newline, add char to String
}
}

void loop(){
decode_rx(hein); //ma, que volio? (humour)
if (hein == "Oups"){
Serial.print("mince\n");
lcd.setCursor(0,1);
lcd.print("mince alors    ");
}
if (hein == "ben_alors"){
Serial.print("ben vrai\n");
lcd.setCursor(0,1);
lcd.print("mon pov' msieur");
}
}


Si je veux que ça fonctionne avec un programme plus long (qqKO), je suis obligé de rajouter une nouvelle variable "String"
que je "reset" au moment voulu dans le prog, car, comme je la "RAZ" dès le code "\n" reçu, elle part vite au paradis des données ! :smiley-red:

Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 16, 2012, 07:53 pm
@zeric :
Code: [Select]
// Exemple d'appel :
// String str;
// decode_rx(&str);

void decode_rx(String *str){
  *str = ""; // Init String
  char c; // Declare temp char
  while(Serial.available() < 1); // Block until Serial data available
  c = Serial.read(); // First read
  while(Serial.available() > 0 && c != '\0'){ // Serial test && char test
if(c == 10)
  *str = ""; // Reset string
else
  *str = *str + c; // Append char to string
c = Serial.read(); // Next read
  }
}


Version plus propre sans String utilisant un tableau de char :
Code: [Select]
void loop() { // Exemple d'appel
  char str[10];
  if(Serial.available() > 0)
    decode_rx(str, 10);
}

void decode_rx(char str[], int max){
  memset(str, 0, max);
  int i = 0;
  while(Serial.available() > 0 && i < (max - 1)){
    if(str[i] = Serial.read())
      i++;
    else
      break;
  }
}

Title: Re: Transferts de données entre arduino par la liaison série
Post by: zeric on Jan 16, 2012, 09:37 pm
Merci beaucoup  :smiley-eek-blue: , mais je dois apprendre les pointeurs :
& reference operator
* dereference operator
et voir l'instruction "memset" avant d'assimiler tout ça ...
Je reviens quand j'ai lu les explications !
Title: Re: Transferts de données entre arduino par la liaison série
Post by: zeric on Jan 17, 2012, 06:54 pm

@zeric :
Code: [Select]
// Exemple d'appel :
// String str;
// decode_rx(&str);

void decode_rx(String *str){
  *str = ""; // Init String
  char c; // Declare temp char
  while(Serial.available() < 1); // Block until Serial data available
  c = Serial.read(); // First read
  while(Serial.available() > 0 && c != '\0'){ // Serial test && char test
if(c == 10)
  *str = ""; // Reset string
else
  *str = *str + c; // Append char to string
c = Serial.read(); // Next read
  }
}


Bonjour, pour l'instant je me suis attaqué à la 1° solution:
Pourquoi bloquer le programme tant qu'on ne reçoit pas de caractère ?   =>while(Serial.available() < 1); // Block until Serial data available
Pourquoi tester le caractère '\0' qui correspond au code NULL?
Pourquoi initialiser la valeur de str dans la fonction alors que l'on gagne 36 octets de prg en le faisant dans les définitions =>   *str = ""; // Init String 1°ligne de la fct
La fonction n'est pas linéaire, on ne fait rien d'autre tant que l'on n'est pas sorti de la 2° boucle !
Ne peut-on pas faire une addition composée sur une valeur pointée et gagner 126 octets de prg ?  =>*str = *str + c; // Append char to string  =>(*str += c;)
Euh, une dernière remarque  :smiley-roll-sweat: ça ne fonctionne pas :smiley-zipper:
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 17, 2012, 09:26 pm

Pourquoi bloquer le programme tant qu'on ne reçoit pas de caractère ?   =>while(Serial.available() < 1); // Block until Serial data available

Je fait toute mes fonctions de réception en tant que fonction bloquante, aprés c'est un choix tu peut aussi conditionner l'appel à la fonction avec un if(Serial.available() > 0) juste avant.


Pourquoi tester le caractère '\0' qui correspond au code NULL?

J'ai réfléchi comme si c'était une chaine de caractéres :smiley-roll-sweat: un test avec '\n' serais plus malin ... Nobody is perfect ...


Pourquoi initialiser la valeur de str dans la fonction alors que l'on gagne 36 octets de prg en le faisant dans les définitions =>   *str = ""; // Init String 1°ligne de la fct
(...)
Ne peut-on pas faire une addition composée sur une valeur pointée et gagner 126 octets de prg ?  =>*str = *str + c; // Append char to string  =>(*str += c;)

... Là c'est du vraiment du grappillage ... oui tu peut faire un += et faire l'initialisation avant l'appel, mais à ce moment si tu veut vraiment gratter le moindre octets de ram/flash c'est un char[] qu'il faut utiliser ...


Euh, une dernière remarque  :smiley-roll-sweat: ça ne fonctionne pas :smiley-zipper:

A pars le if(c == 10) que j'ai repris de ta fonction sans chercher à comprendre je vois pas ce qui pourrai planter ...

Code: [Select]
void decode_rx(String *str){
  char c = Serial.read();
  while(Serial.available() > 0 && c != '\n'){
    *str += c;
    c = Serial.read();
  }
}
Title: Re: Transferts de données entre arduino par la liaison série
Post by: zeric on Jan 17, 2012, 10:48 pm
Bonsoir,
Merci pour la réponse  :smiley-sweat:
Je viens de lire que le '\0' est le caractère qui même si on ne le voit pas, fini chaque chaîne de caractère implicitement:
- comme  justement je travaille sur des chaînes de caractères  :smiley-sweat:, ça me fait le '\n' en moins a envoyer ...
Pour le grapillage : 36+126=162 octets pour 2 instructions :smiley-eek: A l'échelle d'un programme, je trouve ça  :smiley-eek-blue:
Pour le char[], la 2° solution, la taille  divisée par 2, ça me plait  ;)

Quote


Euh, une dernière remarque  :smiley-roll-sweat: ça ne fonctionne pas :smiley-zipper:

A pars le if(c == 10) que j'ai repris de ta fonction sans chercher à comprendre je vois pas ce qui pourrai planter ...

Ben justement, vu que j'envoie le '\n' juste après (...le '\0' que je ne savais pas qu'on envoyais!), on rentre jamais dans cette partie de boucle...

-La 2°solution, bien la fct "memset" pour faire une init de chaine, mais la fct "decode_rx" ne marche pas comme mon prg, je peux pas faire de test de la chaine
complète dans la suite, je vais voir ça de plus près...
Title: Re: Transferts de données entre arduino par la liaison série
Post by: skywodd on Jan 17, 2012, 10:52 pm

-La 2°solution, bien la fct "memset" pour faire une init de chaine, mais la fct "decode_rx" ne marche pas comme mon prg, je peux pas faire de test de la chaine
complète dans la suite, je vais voir ça de plus près...

hu? Peut pas faire de test sur la chaine ?
-> strcmp ?
Code: [Select]
if(strcmp(chaine_recu, "blabla") == 0)
  Serial.print("balbla recu !");

Je vois pas ce qui te pose probléme, enfin j'ai pas compris ou tu avait un probléme :smiley-sweat:
Title: Re: Transferts de données entre arduino par la liaison série
Post by: zeric on Jan 17, 2012, 11:11 pm
Raah, trop rapide !
Au départ, je voulais juste savoir si il était possible d'écrire ma fonction "mieux" (plus "programmeur" => optimisé, moins de place  :smiley-sweat:)
La version 2 va dans ce sens: le problème, si je veux faire le test dans mon prg: if (hein == "ben_alors"){
"ben_alors" est la chaine de caractère que j'envoie depuis l'autre côté (ou le Serial Monitor ou un autre arduino!), decode_rx la décode :D
et comme j'en envoie plein (de chaines de caractères), je conditionne des branchements derrière "en fonction de".
M'exprime-je bien :smiley-sweat:
Title: Re: Transferts de données entre arduino par la liaison série
Post by: RANKOMAN on Mar 24, 2013, 10:44 pm
Bonjour,
peut être pourriez vous m'aider, j ai un clavier PS/2 connecté sur un arduino alimentation sur broch +5 volt et Grnd et broche 8 et 2 pour les data et l irq. Je recois bien les données mais je voudrais envoyer au clavier deux octet F3 et 00. POurriez vous m indiquer si il faut utiliser Serial.write tet comment, merci d avance