je tente de connecter deux arduinos un en maitre et l'autre en esclave
l'esclave a un capteur il mesure et envoie ensuite les donnees au maitre j ai essaye de regarder sur le net comment s effectuait la liaison j ai eu un apercu du i2c mais j ai essaye de l adapter avec un capteur rien .
Bon au départ tu avais dit deux. Les moyens seront différents, ça dépend de plein de choses. Le nombre de trucs à connecter, leur proximité, le débit voulu, connexion par fils ou par ondes, etc.
J'avais écrit ça pour quelqu'un qui avait le même genre de problème. Je n'ai jamais su si ça avait fonctionné correctement, mais il ne s'est pas plaint.
Côté maitre :
/***MASTER***/
#include <stdio.h>
#include <string.h>
#define SLAVE_1 0x01 /*les adresses esclave sur 7 bits juste pour info*/
#define SLAVE_2 0x02
#define NUM_SLAVE 2 /* le nombre d'esclave à gérer */
typedef enum{SUCCESS, DATA_LEN, ADR_NACK, DATA_NACK, OTHER, BAD_COM} COM_STS; /*voir doc*/
typedef struct _Slave
{
unsigned byte adr; /*adresse*/
COM_STS sts; /*idem doc endTransmission, j'ajoute BAD_COM= friture (message retourné!=envoyé)*/
unsigned byte message[20];/*20 juste pour tester, on améliore après si ça fonctionne*/
}
Slave;
Slave slave[NUM_SLAVE];
char* message = "Hello World!";
size_t msg_len;
void init_slave(Slave*);
unsigned byte fetch_slave(Slave*);
unsigned byte chck_msg(Slave*);
void produce_report(unsigned byte, Slave*);
void init_slave(Slave* I_slave)
{/*init des structures*/
for(int i=0; i<NUM_SLAVE; i++)
{
I_slave[i].adr = i+1;
I_slave[i].sts = 0;
for(int j=0; j<20; j++) /*ou : memset(I_slave[i].message,0,20); avec string.h*/
I_slave[i].message[j] = 0;
}
}
unsigned byte fetch_slave(Slave* I_slave)
{/*recherche/scan des esclaves*/
bool retry = false;/*on se laisse un retry si un esclave est plus lent à booter*/
unsigned byte success = 0;
for(int this=0; this<NUM_SLAVE; this++)
{
do
{
Wire.beginTransmission(I_slave[this].adr);
Wire.write(message, msg_len);
I_slave[this].sts = (COM_STS)Wire.endTransmission();
if(!I_slave[this].sts)
{/*si le message a été reçu : 0(zéro) selon la doc*/
success += chck_msg(&slave[this]); /*vérif de qualité*/
retry = false;
}
else if(!retry)
{/*si premier échec*/
retry = true; /*on va refaire une tentative*/
delay(1000); /*au pif, il reste probable que
l'autre n'ait pas fini de booter,
on lui laisse le temps*/
}
else
retry = false; /*on laisse tomber pour celui-ci*/
}while(retry);
}
return success;
}
unsigned byte chck_msg(Slave* I_slave)
{/*vérifie la cohérence du message*/
unsigned char funcSts =0;
byte received =0;
delay(50);/*pas certain, ptet laisser le temps à l'autre de
traiter le message. on peut essayer de virer
et voir si ça passe ou pas, là c'est large*/
received = Wire.requestFrom(I_slave.adr, msg_len);/*toujours 13 à titre de test seulement*/
if(received==msg_len && Wire.available())/*second test probablement inutile ?*/
{
for(int i=0; i<msg_len; i++)
I_slave.message[i]=Wire.read();
I_slave.sts = (strcmp(message,I_slave.message))? BAD_COM : I_slave.sts;
}
return (unsigned byte)!I_slave.sts;
}
void produce_report(unsigned byte num, Slave* I_slave)
{/*affiche le résultat des recherches*/
char L_msg[50];
Serial.print("sent message :");
Serial.print(message);
sprintf(L_msg, "reached %d slave%c", num, (num>1)? 's':' ');
Serial.print(L_msg);
for(int i=0; i<NUM_SLAVE; i++)
{
sprintf(L_msg,
"Slave %d : sts=%d; returned : %s",
i, (unsigned int)I_slave[i].sts, (char*)I_slave[i].message);
Serial.print(L_msg);
}
}
void setup()
{/*mstr setup*/
Wire.begin();/*master, pas d'argument*/
Serial.begin(9600);/*console PC pour débug*/
msg_len = strlen(message)+1;
init_slave(slave);
unsigned byte numAvailable = fetch_slave(slave);
produce_report(slave,numAvailable);
}
Côté esclave :
/***SLAVE****/
#include <stdio.h>
#include <string.h>
#define I2C_ADR 0x01 /*à changer dans chaque esclave*/
typedef enum{SUCCESS, DATA_LEN, ADR_NACK, DATA_NACK, OTHER, BAD_COM} COM_STS; /*voir doc*/
typedef struct _Com
{
COM_STS sts; /*idem doc endTransmission, j'ajoute BAD_COM= friture (message retourné!=envoyé)*/
unsigned byte message[20];/*20 juste pour tester, on améliore après si ça fonctionne*/
size_t msg_len;
}
Com;
Com com;
void get_msg()
{
int index=0;
while(Wire.available() && index<20)
{
com.message[index]=Wire.read();
index++;
}
com.msg_len = strlen((char*)com.message);/*on suppose qu'on a reçu
du texte correctement (!?)*/
}
void send_msg()
{
Wire.write(com.message, com.msg_len);
}
void setup()
{
Wire.begin(I2C_ADR);
Wire.onReceive(get_msg);
Wire.onRequest(send_msg);
}
Voilà. Je sais que ça compile, mais je ne l'ai jamais testé moi même, n'ayant pas 2 arduinos pour tester. Mais s'il y a des erreurs, ça ne devrait pas aller chercher bien loin. C'était juste un test, il suffit de s'en inspirer pour adapter à tes besoins.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Bonhomme !! | Jeu de plateforme : Prototype.