Communication de données entre deux cartes arduino - Xbee

Bien le bonsoir, j’ai 18 ans et dans le cadre d’un projet scolaire, je me dois de faire communiquer deux cartes arduino mega 2560, chacune équipée d’un shield proto xbee ainisi que le module xbee en lui même, je vous joint une première photo (Je m’excuse d’avance de cette médiocre qualité, j’en fournirait d’autre fin de semaine si besoin).

Après avoir potassé depuis quelques jours sur ces petits joujous (comme ici, merci d’ailleurs à son créateur), il y a encore de nombreux points flous concernant leur utilisation. En effet, il existe 3 modes ; Transparent, Command & Api.

Pour mon utilisation, je me contenterais du monde transparent (enfin je crois…), il n’y a aucun nœud réseau puisqu’il n’y a que 2 cartes ce qui veut donc dire, si j’ai bien compris, qu’il y aura un “Router” & un “Coordinator”. Je crois qu’il faut aussi les mettre sur le même ID réseau…

Pour configurer tout cela, j’ai télécharger le soft X-Ctu et j’ai au préalable chargé le programme :

void setup() {}
void loop() {}

permettant au soft de reconnaître le module indépendamment de la carte arduino.

Cependant quand je fais le " Com test/Query Modem ", le module est bien reconnu mais son “modem type” est inconnu tout comme “Modem Firmware version” et sans cela je ne peux pas configurer ces derniers dans l’onglet “Modem Configuration” de X-Ctu :

(Je tiens à préciser que ce n’est pas mon screen, je ne peux vous fournir un screen avant la fin de semaine tout simplement car je ne dispose pas du matériel, il appartient à l’école).

Afin d’effectuer des premiers tests, je souhaite pouvoir allumer et éteindre une led branché sur une carte arduino par un bouton poussoir branché sur l’autre carte Arduino. Pour cela je souhaite faire intervenir des variables pour obtenir un programme du genre : si variable bouton = 0 (relaché) sur la première carte alors variable led = 1 (allumé) sur l’autre carte arduino. Cependant je suis complètement perdu quand aux instructions de communication entre les deux xbee.

J’ai besoin d’aide, Merci d’avance à vous !
Bonne soirée

Alors à mon avis, vu ton besoin, tu peux simplement utiliser les XBee en communication serie standard. En gros, ne t'occupes pas de les configurer.
La lecture/écriture sur un simple port série (ou SoftwareSerial) répondra largement à ton besoin.

Maintenant à toi de jouer. En faisant une petite recherche sur le forum, tu trouveras une bonne dizaine d'exemple de communication série entre 2 arduinos via des modules XBee.

Quand tu auras déjà des ébauches de sketch, n’hésites pas à revenir poser des questions si tu coinces et que tu ne trouves pas la réponse sur le forum :slight_smile:

Merci de ta réponse. Alors le projet avance doucement mais surement j’ai défini une variable qui sera celle envoyée à l’autre carte arduino. Pour le moment j’ai donc un boutton poussoir sur la broche 2 et une led simulant l’état de la ruche (volée ou non). Petite précision sur mon projet, j’ai pour but de sécurisé une ruche pour un apiculteur de la région, j’ai donc une multitude d’autre tâche à gérer pour ce projet, mais avant toutes choses je dois donc régler cette histoire de transmission Zigbee avec les Xbee.

voici mon code Émetteur :

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <XBee.h>
#include <SoftwareSerial.h>

// --- Déclaration des constantes ---

const int APPUI=1; // constante état du BP 
const int PAS_APPUI=0; // constante état du BP 

// --- constantes des broches ---

const int BP=2; //declaration constante de broche 
const int LED=13; //declaration constante de broche 

// --- Déclaration des variables globales ---

int ETAT_BP; // variable d'état du bouton poussoir, soit le système de détection de la ruche
int VOL_RUCHE = LOW; // variable définissant si la ruche est volé (=0) ou non (=1)


// --- Initialisation des fonctionnalités utilisées ---

//**************** FONCTION SETUP = Code d'initialisation *****

// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()
 
Serial.begin(9600); //Definition de la vitesse de transmission Zigbee.

delay(800); //Attente de 2 seconde pour permettre au réseau de se configuer.

pinMode(LED, OUTPUT); //met la broche en sortie 
pinMode(BP, INPUT); //met la broche en entree 
digitalWrite(BP, HIGH) ; // activation du pullup de la broche en entrée

}

 // fin de la fonction setup()



//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************

// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal ---

ETAT_BP = digitalRead(BP); // lit l'état du BP et met la valeur 0/1 dans la variable
if (ETAT_BP==APPUI) // si l'état du BP est appuyé (càd si variable état BP = 1)
{

  VOL_RUCHE == 0; //Si le bouton est appuyé, ruche posé, il n'y a pas vol donc VOL_RUCHE = 0 
  digitalWrite(LED, VOL_RUCHE); // Eteint la LED
  
}
else { // sinon (càd si variable état BP=0 soit ETAT_PB==PAS_APPUI)

  VOL_RUCHE == 1; //Si le bouton n'est pas appuyé, ruche soulevé, il y a vol donc VOL_RUCHE = 1
  digitalWrite(LED, !VOL_RUCHE); // Allume la LED , ainsi on enverra l'information à l'autre carte arduino pour envoyer un sms pour Vol

}

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// --- Fin programme ---

Pour ce qui est de la transmission Xbee, je suis toujours dans le flou, j’ai essayé de m’inspirer de ce code ici mais je ne comprends pas les parties “void setDestination()” & void " blink(int thisPin, int howManyTimes) ". Y Aurait - il une âme charitable pour me l’expliquer et me dire ce que je dois rajouter à mon programme pour envoyer la variable VOL_RUCHE ?

J’ai de plus une question qui me trotte, j’aurais ensuite une autre valeur à envoyé, ce qui me fera donc deux variables qui transiteront entre les deux cartes, n’aurais-je pas besoin de configurer mes modules ?

Merci de vos réponses.

Si ton module XBee est branché sur les ports 0 et 1. Pour envoyer une variable, il n'y a rien de plus simple :
Serial.println(variable);

Comme je l'ai dit dans ma première réponse, d'après ton besoin, je pense que l'utilisation des modules XBee en tant que simple liaison série est largement suffisant.

Pour t'en sortir, je pense que tu devrais commencer en reliant tes 2 arduinos avec des fils entre les ports 0 et 1 de chaque arduino (attention, pense à croiser les fils). Tu fais fonctionner ton projet et ensuite, tu remplaces simplement les fils par tes modules XBee.

Bon alors, j’ai suivi tes instructions et j’arrive à éteindre la led d’une carte arduino quand j’appuie sur le bouton poussoir de l’autre carte. Cependant cette dernière ne se rallume lorsque je relâche la pression sur le bouton, je suis bloqué à ce point.

voici le Code “Emetteur” ('carte arduino + led + bouton):

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <XBee.h>
#include <SoftwareSerial.h>

// --- Déclaration des constantes ---

const int APPUI=1; // constante état du BP 
const int PAS_APPUI=0; // constante état du BP 

// --- constantes des broches ---

const int BP=2; //declaration constante de broche 
const int LED=13; //declaration constante de broche 

// --- Déclaration des variables globales ---

int ETAT_BP; // variable d'état du bouton poussoir, soit le système de détection de la ruche
int VOL_RUCHE = 0; // variable définissant si la ruche est volé (=1) ou non (=0)


// --- Initialisation des fonctionnalités utilisées ---

//**************** FONCTION SETUP = Code d'initialisation *****

// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup()   { // debut de la fonction setup()
 
Serial.begin(9600); //Definition de la vitesse de transmission.

delay(800); //Attente de 2 seconde pour permettre au réseau de se configuer.

pinMode(LED, OUTPUT); //met la broche en sortie 
pinMode(BP, INPUT); //met la broche en entree 
digitalWrite(BP, HIGH) ; // activation du pullup de la broche en entrée

} // fin de la fonction setup()



//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************

// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension
void loop(){ // debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal ---

ETAT_BP = digitalRead(BP); // lit l'état du BP et met la valeur 0/1 dans la variable
if (ETAT_BP==APPUI) // si l'état du BP est appuyé (càd si variable état BP = 1)
{
// Attention à bien utiliser == et non =
  VOL_RUCHE == 0; //Si le bouton est appuyé, ruche posé, il n'y a pas vol donc VOL_RUCHE = 0
  
  digitalWrite(LED, VOL_RUCHE); // Eteint la LED
  
}
else { // sinon (càd si variable état BP=0 soit ETAT_PB==PAS_APPUI)

  VOL_RUCHE == 1; //Si le bouton n'est pas appuyé, ruche soulevé, il y a vol donc VOL_RUCHE = 1

  digitalWrite(LED, !VOL_RUCHE); // Allume la LED , ainsi on enverra l'information à l'autre carte arduino pour envoyer un sms pour Vol
  Serial.println(VOL_RUCHE, DEC); //Envoie de la variable VOL_RUCHE
}

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// --- Fin programme ---

et le code “récepteur” (carte arduino+led) :

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <SoftwareSerial.h>
#include <XBee.h>

// --- Déclaration des constantes ---
// --- constantes des broches ---
const int LED = 13; //declaration constante de broche 

// --- Déclaration des variables globales ---
int VALEUR_RECU=0; // variable définissant si la ruche est volé (=1) ou non (=0), recu par l'autre carte

// --- Initialisation des fonctionnalités utilisées ---
//**************** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup(){ // debut de la fonction setup()
 
 Serial.begin(9600); //Definition de la vitesse de transmission.
 delay(800); //Attente de 2 seconde pour permettre au réseau de se configurer
 pinMode (LED, OUTPUT); //met la broche en sortie
    
} //fin de la fonction setup()

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ //debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal ---

  if (Serial.available() > 0){ //si des données entrantes sont présentes
    VALEUR_RECU = Serial.read(); //Stockage sur VALEUR_RECU de la donnée entrante 0 ou 1
    digitalWrite(LED, VALEUR_RECU); //Allumage ou Extinction de la led
  }

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// --- Fin programme ---

Dans ton programme "Emetteur" :
Tu n'envoies une information sur le port série que si l'état du bouton est différent d'appuyé. L'appuie sur le bouton ne provoque rien sur le second arduino

Dans ton programme "Récepteur" :
Ta variable VALEUR_RECU sera toujours égale à 1 puisque tu n'envoies VOLE_RUCHE que lorsqu'il vaut 1. Donc ta LED sera toujours allumée.

Pour ce qui est du programme emetteur, oui c'est normal que l'appui du bouton ne provoque rien puisque c'est un système qui servira à signal lors du soulèvement d'un objet, si ce dernier est posé, le bouton sera appuyé, et ne provoquera donc rien. En revanche si le bouton n'est plus appuyer on transmet l'information à l'autre carte arduino, ce qui au final entraînera l'envoi d'un sms. Pour le moment je voudrais juste synchroniser les deux leds, qu'elles s'allument et s'éteignent en même temps.

Cependant je cherche un moyen de pouvoir exécuter une fonction qu'une seule fois, est ce possible ? je souhaite obtenir quelques chose du style

Si BP=0 (non appuyé) -> VOL_RUCHE = 1 -> Transmission sur l'autre carte arduino VOL_RUCHE via Serial -> la variable VOL_RUCHE = VALEUR_RECU -> si VALEUR_RECU = 1 -> Envoi d'UN sms. une fois cette oppération terminé tout repasse à 0.

J'avais penser à faire une fonction "ENVOI_SMS()" et faire si VALEUR_RECU = 1 -> Exécuter UNE fois la fonction ENVOI_SMS() ?

Comment veux-tu provoquer 2 actions sur tes LED (allumer, éteindre) en envoyant qu'une seule commande ?

Je ne dispose pas du materiel sous la main, donc je ne pourrais faire aucun test avec. Mais j’ai edit les deux programmes :

Programme Émetteur :

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <SoftwareSerial.h>
#include <XBee.h>

// --- Déclaration des constantes ---

const int APPUI=1; // constante état du BP 
const int PAS_APPUI=0; // constante état du BP 

// --- constantes des broches ---

const int BP=2; //declaration constante de broche 
const int LED=13; //declaration constante de broche 

// --- Déclaration des variables globales ---

int ETAT_BP; // variable d'état du bouton poussoir, soit le système de détection de la ruche
int VOL_RUCHE = 0; // variable définissant si la ruche est volé (=1) ou non (=0)


// --- Initialisation des fonctionnalités utilisées ---
//**************** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme


void setup()   { // debut de la fonction setup()
 
Serial.begin(9600); //Definition de la vitesse de transmission pour le vol de ruche
Serial1.begin(9600); //Definition de la vitesse de transmission pour la migration d'essaim

delay(800); //Attente de 2 seconde pour permettre au réseau de se configuer.

pinMode(LED, OUTPUT); //met la broche en sortie 
pinMode(BP, INPUT); //met la broche en entree 
digitalWrite(BP, HIGH) ; // activation du pullup de la broche en entrée

} // fin de la fonction setup()



//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension



void loop(){ // debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal ---


//Partie détection de vol/Soulevement

ETAT_BP = digitalRead(BP); // lit l'état du BP et met la valeur 0/1 dans la variable

if (ETAT_BP==APPUI) // si l'état du BP est appuyé (càd si variable état BP = 1)
{
// Attention à bien utiliser == et non =
  VOL_RUCHE == 0; //Si le bouton est appuyé, ruche posé, il n'y a pas vol donc VOL_RUCHE = 0
  
  digitalWrite(LED, VOL_RUCHE); // Eteint la LED
  Serial.println(VOL_RUCHE, DEC); //Envoie de la variable VOL_RUCHE =0
  delay(400); //Attente de 1 seconde avant lecture de "Serial"
  VOL_RUCHE = Serial.read(); //stockage sur VOL_RUCHE de la donnée entrante sera =0
  // VOL_RUCHE = 0
}
else { // sinon (càd si variable état BP=0 soit ETAT_PB==PAS_APPUI)

  VOL_RUCHE == 1; //Si le bouton n'est pas appuyé, ruche soulevé, il y a vol donc VOL_RUCHE = 1

  digitalWrite(LED, !VOL_RUCHE); // Allume la LED , ainsi on enverra l'information à l'autre carte arduino pour envoyer un sms pour Vol
  Serial.println(VOL_RUCHE, DEC); //Envoie de la variable VOL_RUCHE =1
  delay(400); //Attente de 1 seconde avant lecture de "Serial"
  VOL_RUCHE = Serial.read(); //stockage sur VOL_RUCHE de la donnée entrante sera = 0
  // VOL_RUCHE repasse à 0
}

//Partie Migration d'essaim



} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// --- Fin programme ---

Programme Récepteur :

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <SoftwareSerial.h>
#include <XBee.h>

// --- Déclaration des constantes ---
// --- constantes des broches ---

const int LED = 13; //declaration constante de broche 

// --- Déclaration des variables globales ---

int VALEUR_RECU=0; // variable définissant si la ruche est volé (=1) ou non (=0), recu par l'autre carte

// --- Initialisation des fonctionnalités utilisées ---
//**************** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme


void setup(){ // debut de la fonction setup()
 
 Serial.begin(9600); //Definition de la vitesse de transmission pour le vol de ruche
 Serial1.begin(9600); //Definition de la vitesse de transmission pour la migration d'essaim
 
 delay(800); //Attente de 2 seconde pour permettre au réseau de se configurer
 
 pinMode(LED, OUTPUT); //met la broche en sortie
    
} //fin de la fonction setup()



//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ //debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal ---


//Partie détection de vol/Soulevement

if (Serial.available() == 0){ //si data entrante sur serial = 0
  VALEUR_RECU = Serial.read(); //sotacke sur VALEUR_RECU de la donnée entrante sera =0
  digitalWrite(LED, VALEUR_RECU); //Eteinte de la led
  Serial.println(VALEUR_RECU, DEC); //Envoie de VAL_RECU donc = 0
}

if (Serial.available() == 1){ //si data entrante sur serial =1
    VALEUR_RECU = Serial.read(); //Stockage sur VALEUR_RECU de la donnée entrante sera =1
    digitalWrite(LED, VALEUR_RECU); //Allumage de la led simulant l'envoi d'un seul SMS
    Serial.println(!VALEUR_RECU, DEC); //Envoie de l'inverse VAL_RECU donc =0    
}

//Partie Migration d'essaim


} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// --- Fin programme ---

Ne serait pas mieux comme ça ?
Comme tu peux le voir j’ai encore bcp bcp de travail pour maîtriser le langage et toutes les syntaxes & nomenclatures de la programmation arduino, j’apprécie ton aide, Merci Beaucoup.

Petit Up à mon retour de vacances.. Personne ne peut m'aider ?
Merci.

tu as modifiés tes programmes, c'est bien, mais les as-tu testé ?

Bonjour,

J'ai modifié mes programmes pendant que j'étais en vacances mais compte tenu que le matériel ne m'appartient pas (il est à l'école), je ne peux donc que faire mes tests que le jeudi et vendredi, je vais donc faire mes tests demain.

Théoriquement, pour moi du moin (c'est pas pareil x) ), la led devrait s'éteindre lorsque j'appuie sur le bouton et s'allumer lorsque je le relâche, non ? Je précise que l'état de la led simule l'envoi d'un sms.

J'ai une autre question concernant les moduls xbee, je n'arrive pour le moment pas à les faire fonctionner, n'est il pas question de librarie à intégrer ? Car syntaxement parlant, elle est écrite dans les deux programmes, mais est elle intégrer au soft arduino ?

Merci

Je me répète, vu ton besoin, tu n’as pas besoin de la librairie XBee ! Je fais communiquer 2 arduinos via des modules XBee sans utiliser de librairie depuis assez longtemps pour te garantir que c’est possible.

Donc enlève les #include <XBee.h> et dont d’ailleurs tu ne te sers pas dans ton code.

Oui, seulement je pensais que la library était nécessaire, je l'avais mis par précautions..

Je dis ça car, comme je l'ai dis de même, lorsque j'ai fais mes tests avec les moduls xbee cela ne fonctionnait pas, et c'est d'ailleurs pour ça que tu m'a orienter vers les fils Tx->Rx & Rx->Tx afin de pouvoir tester le programme sans les moduls, là ça fonctionnait.

Il doit donc y avoir un problème au niveau des moduls car si je n'ai absolument rien besoin de faire au niveau de la config cela doit marcher aussi bien qu'avec les fils, non ?

Si cela fonctionne avec les fils et plus avec les modules, c'est qu'il y a un problème avec les modules.

As-tu bien positionné l'interrupteur de sélection USB/XBee sur les shields ? Pourquoi déclares-tu 2 liaisons séries dans ton programme alors que tu n'en utilises qu'une ?

Oui les interrupteurs shield sont sur Usb, j'ai feuilleter pas mal de datasheet et de livre c'est pour ça que je suis un peu dans le flou.

concernant les liaisons séries, comme je l'ai dis, je dois faire transité plusieurs choses entre les deux cartes, une variable concernant le vol de la ruche, lorsque je soulève la ruche le bouton poussoir change d'état, changant l'état d'une variable (0à1) j'envoie cette variable à l'autre carte sur le SERIAL, l'autre carte lis un changement d'état de la valeur reçue sur serial et envoie un sms puis remise à zero de tout le procéder.

Pour ce qui est du SERIAL1, je l'ai réservé pour le même type de fonctionnement mais pour la migration de l'essaim à l'intérieur de la ruche par la suite une lecture analogique de la tension d'un micro à l'intérieur de la ruche. Donc en effet je ne m'en sers pas pour le moment, mais je l'ai donc mis juste par précaution et pour m'y retrouver pour la suite rajouter des morceaux de programme que je fais en parallèle.

Tu vas communiquer avec un autre module ?

Quoi qu'il en soit, il faut y aller par étape, ne met pas du code qui ne sert à rien, ça complexifie ton sketch pour rien.

Tu sembles coincer sur la transmission via XBee, mets donc ton code de coté et essaies simplement d'envoyer 1 caractères d'un arduino à l'autre en passant par les modules.

Fais donc le code pour l’émetteur le plus simple possible pour envoyer un 1 en boucle (toutes les 5 secondes par exemple) sur le port série et un code pour le récepteur pour lire le port série et afficher le résultat dans le terminal. Tu commences avec des fils sur le montage, une fois que le code est validé, tu remplaces les fils par les XBee.

En vérité, j'ai un modul placé sur la ruche :
Arduino mega 2560 + carte shield audio avec enregistrement et lecture ( possibilité de brancher des écouteurs/casque et mirco ) + shield xbee + modul xbee + interrupteur type bouton poussoir

et l'autre modul type central :
Arduino mega 2560 + carte shield gps + carte shield gsm + shield xbee + modul xbee

Voilà pour plus de précisions.

Concernant le terminal, c'est celui de arduino ou x ctu ? Comment afficher la donner lue sur Serial dans le terminal?

Si tu n’as que 2 modules, je ne comprends pas bien pourquoi tu as besoin de 2 liaisons series. Enfin passons.

Oui, je te parle du terminal sur ton PC qui te permet d’afficher ce que l’arduino envoie sur le port série (USB) via la commande Serial.println().

A mon avis avant de te lancer dans ton projet, tu devrais revoir les bases de l’arduino. La bonne compréhension de l’utilisation de la liaison série et du terminal est le minimum pour t’en sortir. Pour le moindre debug tu vas utiliser du Serial.println() pour afficher des messages dans le terminal. Donc si tu ne maitrises pas ces éléments, tu vas bosser en aveugle et tu n’avanceras pas.

D'accord, oui la liason série est quelque chose de complètement nouveau j'essaie donc de m'en sortir avec les ressources que j'ai en complément de precieuse aide comme la tienne.

Pour ce qui est de l'utilisation de deux liaisons séries, une me permet de transiter la variable correspondant au vol et l'autre serial, de transiter la variable correspondant à la migration. Les deux auront forcément des valeurs différentes dans le temps, ça evitera tout conflit. J'ai beaucoup de choses à essayer tout à l'heure lorsque j'aurais le matériel sous la main.

Concernant le projet, je suis contraint par des délais scolaire, j'avance donc pas à pas.