Go Down

Topic: Communication serie entre 2 cartes ! (Read 2 times) previous topic - next topic

barbudor

Que c'e'st compliqué et prise de tête ;)

Utilise un tableau ou une structure.

Avec une structure, tu peux mélanger plusieurs types :
Code: [Select]
struct MaStructure
{
  int entier1;
  int entier2;
  float un_flottant;
  char chaine[10];
} trame;


et tu envoi avec :
Code: [Select]
Serial.write( (uint8_t*)&trame, sizeof(trame) );
et tu reçoit avec
Code: [Select]
Serial.readBytes( (char*)&trame, sizeof(trame) );

C'est pas plus lisible ?

Mais de toute façon tu es partit pour une transmission non fiable : pas de synchro, pas de vérification.
Au moindre défaut sur la liaison série, tu t'envoie en l'air.

Jette un coup d'oeil sur mon tutu sur les protocoles de communication.
Barbuduino: Arduino sur Breadboard & VinciDuino: Clone Leonardo // WR703: Mini-routeur hacké // LauchPad MSP430 et Stellaris // Panda II Arduino-like .NetMF sous VisualC#
RTFC: Read That F.....g Code / RTFD: Read That F.....g Doc / RTFDS: Read That F.....g DataSheet / RTFS: Read That F.....g Schematic / Wot da ya wanna D.I.Y. today ?

vince3838

Salut barbudor, j'ai regardé ton tuto,

alors j'ai bien compris la partie gestion du temps mais j'ai du mal sur les transmissions !!
et oui je suis peut être parti sur une liaison pas top car je découvre juste le série...

Je veux bien faire une liaison tip top mais il faut m'expliquer de A à Z..

merci à toi et à ceux qui veulent bien m'éclairer.

par exemple
Quote
Serial.write( (uint8_t*)&trame, sizeof(trame) );

c'est du chinois pour moi..

barbudor

La fonction write() à plusieurs formes.

write( char c ) pour envoyer un char
write( uint8_t *ptr , int nbbytes ) pour envoyer un ensemble d'octets dont ptr est le pointeur et nbbytes le nombre d'octets

Donc [font=Courier]&trame[/font] est le pointeur sur la structure trame. Mais le pointeur sur trame est du type [font=Courier]struct MaStructure *[/font]
Donc je fais un "cast" (changement de type forcé) de pointeur sur MaStructure en pointeur sur uint8_t sui tes le type attendu par l'autre forme de write afin d'envoyer tous les octets d'un coup. (Enfin, les uns derrière les autres).

Barbuduino: Arduino sur Breadboard & VinciDuino: Clone Leonardo // WR703: Mini-routeur hacké // LauchPad MSP430 et Stellaris // Panda II Arduino-like .NetMF sous VisualC#
RTFC: Read That F.....g Code / RTFD: Read That F.....g Doc / RTFDS: Read That F.....g DataSheet / RTFS: Read That F.....g Schematic / Wot da ya wanna D.I.Y. today ?

skywodd

Bonjour,

La méthode du "découpage" du type en une suite d'octets à la main est lourde, mais permet de faire communiquer deux systémes pouvant avoir une architecture différente (µc 8 bits qui envoi, avec µc 32 bit qui reçois) car tu découpe et recolle les morceaux toi même.

La méthode du cast de pointeur sur structure vers un pointeur de tableau de byte est beaucoup plus simple mais attention, le compilateur aime bien les nombre pairs, une structure telle que celle ci :
struc {
  uint32_t aa; // 2 octets
  uint32_t aa;
  uint8_t aa; // 1 octets
} Test_t;

Ne fera pas 2 + 2 + 1 = 5 octets mais 6 octets ! (c'est ce que l'on appelle le padding).

Il y aura donc des données caché en plus a envoyer, et la taille, disposition, alignement de la structure dépendra directement du compilateur et de l'architecture utilisé.

Il existe une librairie qui permette de communiquer entre deux carte arduino de manière simple :
http://www.billporter.info/easytransfer-arduino-library/

La seul vrai solution reste de concevoir son propre protocole, avec (c'est mieux) une checksum pour valider la bonne réception des données.
Des news, des tuto et plein de bonne chose sur http://skyduino.wordpress.com !

barbudor


La seul vrai solution reste de concevoir son propre protocole, avec (c'est mieux) une checksum pour valider la bonne réception des données.


Et une synchro pour se recaler en cas de perte.
Barbuduino: Arduino sur Breadboard & VinciDuino: Clone Leonardo // WR703: Mini-routeur hacké // LauchPad MSP430 et Stellaris // Panda II Arduino-like .NetMF sous VisualC#
RTFC: Read That F.....g Code / RTFD: Read That F.....g Doc / RTFDS: Read That F.....g DataSheet / RTFS: Read That F.....g Schematic / Wot da ya wanna D.I.Y. today ?

Go Up