Question technique

Bonjour,

Je suis un petit nouveau dans le domaine de l'arduino. Je m'y suis intéressé car j'organise souvent des quizz et j'aimerai faire des buzzers avec arbitrage sans fil dans ce genre : http://buzzers.fr/produits/buzzers-hf/cubes-score/

j'ai deux arduinos uno r3. Le premier fait "controller", il possède : - La liste des appareils connectés. - La liste des scores pour chaque joueurs. - Il donne l'information de mise en fonctionnement ou hors jeu de l'autre arduino. - Réceptionne les informations de tous les autres arduinos

Les autres arduinos contrôlent: - un afficheur 7 segments. - des leds. - un bouton poussoir. - Envoi l'information au controller

Ils communiquent actuellement avec des module 433mhz radio. Les soucis que je rencontre sont qu'il y a beaucoup de perte dans les informations transmissent et une latence de plusieurs secondes.

Mes modules de réception n'ont pas d’antenne, l'installation d'une antenne va-t-elle supprimer mes problèmes ? Ou alors je n'utilise peut être pas la bonne technologie ?

Merci d'avance pour vos conseils. MisterJJ.

Vous voulez mesurer un délai de réponse souvent hyper court entre plusieurs appareils émettants à la même fréquence... quand 2 buzzers sont appuyé quasi simultanément il y’a encombrement sur les ondes et donc pertes (sans parler potentiellement d'influence électromagnétique de votre buzz suivant comment le haut parleur est fichu )

Idéalement il faudrait émettre sur des canaux différents et le timing restera approximatif et dépendant de l’ordre dans lequel le récepteur va écouter

Avez vous vraiment besoin du sans fil?

Perso J’en ai fabriqué un avec fils sur la base de cet instructables qui donne une bonne bidouille pour récupérer des buzzers du commerce ((22 euros sur Amazon) avec mon propre code pour le jeu (et usage des PORT register pour lire les 4 buzzers d’un coup)

Mais bon si vous jouez avec 50 personnes c’est pas la même chose qu’à 4...

misterjj: Ils communiquent actuellement avec des module 433mhz radio. Les soucis que je rencontre sont qu'il y a beaucoup de perte dans les informations transmissent et une latence de plusieurs secondes.

Mes modules de réception n'ont pas d’antenne, l'installation d'une antenne va-t-elle supprimer mes problèmes ? Ou alors je n'utilise peut être pas la bonne technologie ?

Merci d'avance pour vos conseils. MisterJJ.

Bonjour Le 433 MHz en simplex n'est surement pas une bonne solution , surtout si tu utilise des modules "tres bas de gamme" Comme évoqué par J-M-L expose un peu mieux tes souhaits : - Nombre de participants max envisagés ? - Distance mini de transmission souhaitée ? - ... Autres contraintes

AMHA , il faut regarder du coté des "transceivers intelligents" genre NRF24L01 en 2.4 GHz qui ont l'avantage d’être peu onéreux et d'interfaçage tres simple avec le monde arduino. Il y a d'autres candidats dans d'autres bandes de frequence

Bonjour,

Merci de vos réponses.

Pour le nombre de joueurs, je suis partie sur 4 (+ un controller) La distance ne sera que d'un mettre ou deux.

En suivant vous conseils, je me suis renseigné sur le module NRF24L01, et je pense essayer avec ca : Les modules NRF24L01 x 5 des daptateurs Sockets x5 (j'ai vu des tuto qui les conseil, mais j'ai pas trop compris pourquoi)

Est-ce les bons composant ?

Oui les NRF24L01 supportent plusieurs canaux et les petits adapteurs rendent la vie facile pour la gestion de la puissance électrique nécessaire

Il y a au moins 3 tutos sur ces composants dans la partie tutoriel du forum (cherchez NRF)

Bonjour,

Merci de votre aide je suis passer sur des modules NRF24L01.
J’ai bien avancer sur mon projet.

Lorsque je fais mon dev et mes tests avec un controller et un buzzer, tout marche nickel.
Les temps de réponses et le taux de reception est très bon.

Mais lorsque j’ajoute un deuxième buzzer plus rien de fonctionne correctement :

  • Le taux de réceptions qui fonctionnent chute a moins de 50%

Ci-joint les branchements et le code utilisé :

Voyez-vous dans le code ce qui peut expliquer mon problème ?

Merci par avance.
Jonathan.

buzzer.ino (7.45 KB)

controller.ino (6 KB)

Peux pas lire des .ino sur mon smartphone (suis en vadrouille)… postez le code directement (avec les balises de code).

Idem, rajoutez les balises d’images…[img]...le lien de votre image attachée...[/img]

Voici vos 2 images:

buzzer.jpg

controller.jpg

Bonjours,

J'étais limité par le nombre de caractères dans un post, c'est pour ca que je suis passé par des fichier.

Je vais le découper en plusieurs post :

Pour le controller :

|500x387

#include 
#include 
#include 
#include 
#include 
#include 

struct message {
  unsigned long _micros;
  byte to;
  byte from;
  int value;
  int code;
} message;
bool isWaittingAnswer = false;
int wattingPalyer = 0;
int scores[] = {0, 0, 0, 0};
bool isStanby = false;
int changeScoreTo = 0;

//code
const int CODE_REGISTRATION = 0;
const int CODE_REGISTRATION_OK = 1;
const int CODE_REGISTRATION_INIT = 2;

const int CODE_PRESS_BUTTON = 10;
const int CODE_STANDBY = 11;
const int CODE_WAIT_ANSWER = 12;
const int CODE_ANSWER_WRONG = 13;
const int CODE_ANSWER_GOOD = 14;
const int CODE_NEXT = 15;
const int CODE_DISPLAY_SCORE = 16;
const int CODE_CHANGE_SCORE = 17;
const int CODE_CHANGE_SCORE_STOP = 18;

//pin
int PinIRreceiver = 6;

int PinRadioCE = 7;
int PinRadioCSN = 8;

// 0 is controller
int iAm = 0;
RF24 radio(PinRadioCE, PinRadioCSN);
byte addresses[][6] = {"00001", "00002", "00003", "00004", "00005"}; //controller, red, blue, yellow, green


// Module infra rouge
IRrecv irrecv(PinIRreceiver);
decode_results results;

void setup() {
  Serial.begin(9600);
  //init radio
  radio.begin();
  radio.setPALevel(RF24_PA_LOW);
  radio.setAutoAck(false);
  radio.openReadingPipe(1, addresses[iAm]);
  radio.startListening();
  //init IR
  irrecv.enableIRIn();
}

void loop() {
  if ( radio.available()) {
    while (radio.available()) {
      radio.read( &message, sizeof(message) );
    }
    receivedMessage(message.to , message.from, message.code);
  }
  if (irrecv.decode(&results)) // have we received an IR signal?
  {
    translateIR();
    irrecv.resume(); // receive the next value
  }
}

void receivedMessage(int to, int from, int code) {
  if (to != iAm) {
    return;
  }
  Serial.print("CONTROLLER :receive from "); Serial.print(from); Serial.print(" code "); Serial.println(code);

  switch (code) {
    case CODE_REGISTRATION:
      sendMessage(from, CODE_REGISTRATION_OK);
      break;
    case CODE_PRESS_BUTTON:
      if (!isWaittingAnswer) {
        isWaittingAnswer = true;
        wattingPalyer = from;
        sendMessage(from, CODE_WAIT_ANSWER);
        otherMessage(from, CODE_STANDBY);
        isStanby = true;
      }
      break;
  }
}

void sendMessage(int to, int code) {
  sendMessage(to, code, 0);
}
void sendMessage(int to, int code, int value) {
  Serial.print(F(" send to : "));
  Serial.print(to);
  Serial.print(F(" code : "));
  Serial.print(code);
  Serial.print(F(" value : "));
  Serial.println(message.value);

  radio.stopListening();
  radio.openWritingPipe(addresses[to]);
  unsigned long started_waiting_at = micros();
  boolean timeout = false;

  message._micros = micros();
  message.to = to;
  message.from = iAm;
  message.code = code;
  message.value = value;

  if (!radio.write( &message, sizeof(message) )) {
    Serial.println(F("failed"));
  }

  radio.startListening();
}

void broadcast(int code) {
  sendMessage(1, code);
  delay(100);
  sendMessage(2, code);
  delay(100);
  sendMessage(3, code);
  delay(100);
  sendMessage(4, code);
}

void otherMessage(int exlude, int code) {
  if (exlude != 1)
    sendMessage(1, code);
  if (exlude != 2)
    sendMessage(2, code);
  if (exlude != 3)
    sendMessage(3, code);
  if (exlude != 4)
    sendMessage(4, code);
}

void translateIR() {
  switch (results.value) {
    case 0xFFA25D: //power
      broadcast(CODE_REGISTRATION_INIT);
      isWaittingAnswer = false;
      wattingPalyer = 0;
      isStanby = false;
      scores[1] = 0;
      scores[2] = 0;
      scores[3] = 0;
      scores[4] = 0;
      break;
    case 0xFFE21D: Serial.println("FUNC/STOP"); break;
    case 0xFF629D: Serial.println("VOL+"); break;
    case 0xFF22DD: // fast backward
      if (isWaittingAnswer && wattingPalyer != 0) {
        sendMessage(wattingPalyer, CODE_ANSWER_WRONG);
        isWaittingAnswer = false;
        wattingPalyer = 0;
        changeScoreTo = 0;
      }
      break;
    case 0xFF02FD: //pause / play
      if (isStanby) {
        broadcast(CODE_NEXT);
        isWaittingAnswer = false;
        wattingPalyer = 0;
        changeScoreTo = 0;
        isStanby = false;
      } else {
        broadcast(CODE_STANDBY);
        isStanby = true;
      }
      break;
    case 0xFFC23D: // falst forward
      if (isWaittingAnswer && wattingPalyer != 0) {
        sendMessage(wattingPalyer, CODE_ANSWER_GOOD);
        scores[wattingPalyer]++;
        delay(1000);
        sendMessage(wattingPalyer, CODE_DISPLAY_SCORE, scores[wattingPalyer]);
        isWaittingAnswer = false;
        wattingPalyer = 0;
      }
      break;
    case 0xFFA857: // vol -
      if (isStanby) {
        changeScoreTo = (changeScoreTo + 1) % 5;
        if (changeScoreTo != 0) {
          broadcast(CODE_CHANGE_SCORE_STOP);
          sendMessage(changeScoreTo, CODE_DISPLAY_SCORE, scores[changeScoreTo]);
          sendMessage(changeScoreTo, CODE_CHANGE_SCORE);
        }
      }
    break;
    case 0xFFE01F: //down
          scores[changeScoreTo]--;
          sendMessage(changeScoreTo, CODE_DISPLAY_SCORE, scores[changeScoreTo]);
    break;
    case 0xFF906F: //up
          scores[changeScoreTo]++;
          sendMessage(changeScoreTo, CODE_DISPLAY_SCORE, scores[changeScoreTo]);
    break;
    case 0xFF9867: Serial.println("EQ");    break;
    case 0xFFB04F: Serial.println("ST/REPT");    break;
    case 0xFF6897: Serial.println("0");    break;
    case 0xFF30CF: Serial.println("1");    break;
    case 0xFF18E7: Serial.println("2");    break;
    case 0xFF7A85: Serial.println("3");    break;
    case 0xFF10EF: Serial.println("4");    break;
    case 0xFF38C7: Serial.println("5");    break;
    case 0xFF5AA5: Serial.println("6");    break;
    case 0xFF42BD: Serial.println("7");    break;
    case 0xFF4AB5: Serial.println("8");    break;
    case 0xFF52AD: Serial.println("9");    break;
    case 0xFFFFFFFF: Serial.println(" REPEAT"); break;
  }
}

Suite du message précédent :

Pour les buzzers :

|500x484

  #include 
  #include 
  #include 
  #include 
  #include 

  const int  LED_RED = 2;
  const int LED_WHITE = 3;
  const int LED_GREEN = 4;
  const int LED_OFF = 5;

  //code
  const int CODE_REGISTRATION = 0;
  const int CODE_REGISTRATION_OK = 1;
  const int CODE_REGISTRATION_INIT = 2;

  const int CODE_PRESS_BUTTON = 10;
  const int CODE_STANDBY = 11;
  const int CODE_WAIT_ANSWER = 12;
  const int CODE_ANSWER_WRONG = 13;
  const int CODE_ANSWER_GOOD = 14;
  const int CODE_NEXT = 15;
  const int CODE_DISPLAY_SCORE = 16;
  const int CODE_CHANGE_SCORE = 17;
  const int CODE_CHANGE_SCORE_STOP = 18;

  //variables
  struct message{
    unsigned long _micros;
    byte to;
    byte from;
    int value;
    int code;
  }message;
  bool isReady = false;
  bool isStandby = false;
  long nextRegistrationTime = 0;
  bool isWaittingAnswer = false;
  bool isWrongAnswer = false;
  long wrongAnswerTimer = false;
  bool isGoodAnswer = false;
  bool isPushedButton = false;
  int8_t TimeDisp[] = {0x00,0x00,0x00,0x00};   //Tableau des 4 chiffres
  int score = 0;
  bool isChangeScrore = false;
  bool isChangeScroreOn = true;
  


  //pin
  int PinButton = 2;
  int PinLedWhite = 3;
  int PinLedRed = 4;
  int PinLedGreen = 5;

  int PinRadioCE = 7;
  int PinRadioCSN = 8;

  int Pin4DigitCLK = 10;
  int Pin4DigitDIO = 9;

  // 1 is red
  int iAm = 1;
  RF24 radio(PinRadioCE,PinRadioCSN);
  byte addresses[][6] = {"00001","00002","00003","00004","00005"}; //controller, red, blue, yellow, green

  // 4 digit 7 segement
  TM1637 tm1637(Pin4DigitCLK,Pin4DigitDIO);
  int intensity = 7;

  void setup() {
    Serial.begin(9600);
    //init radio
    radio.begin();
    radio.setPALevel(RF24_PA_LOW);
    radio.setAutoAck(false);
    radio.openReadingPipe(1,addresses[iAm]);
    radio.startListening();

    // init displayer
    tm1637.set(intensity);   //0 éclairage faible réglable jusqu'à 7 le plus intense
    tm1637.init();
    displayScore(0);


    //init pin 
    pinMode(PinButton, INPUT_PULLUP); 
    pinMode(PinLedRed, OUTPUT);
    pinMode(PinLedWhite, OUTPUT);
    pinMode(PinLedGreen, OUTPUT);
  }

  void loop() {
    if( radio.available()){                                                    
      while (radio.available()) {                          
        radio.read( &message, sizeof(message) );             
      }
      receivedMessage(message);
    }

    if (!isPushedButton && digitalRead(PinButton) == LOW)
    {
      isPushedButton = true;
      if (isReady && !isWaittingAnswer && !isStandby && !isGoodAnswer && !isWrongAnswer)
        sendMessage(CODE_PRESS_BUTTON);
    } else if (isPushedButton && digitalRead(PinButton) == HIGH) {
      isPushedButton = false;
    }

    //clignotement score
    if (isChangeScrore) {
      if ((millis() % 1000) > 500 && !isChangeScroreOn) {
        isChangeScroreOn = true;
        displayScore(score);
      } else if((millis() % 1000) < 500 && isChangeScroreOn) {
        isChangeScroreOn = false;
        tm1637.display(0x00,0x7f);
        tm1637.display(0x01,0x7f);
        tm1637.display(0x02,0x7f);
        tm1637.display(0x03,0x7f);  
      }
    }

    if (isWaittingAnswer) {
      if ((millis() % 1000) > 500) {
        ledSwhitcher(LED_WHITE);
      } else {
        ledSwhitcher(LED_OFF);
      }
    }else if (isGoodAnswer) {
      ledSwhitcher(LED_GREEN);
    }else if (isWrongAnswer) {
      long delta = millis() - wrongAnswerTimer;
      if (delta > 5000) {
        isWrongAnswer = false;
      } else {
        if ((delta % 1000 < 100) && delta > 100) {
          ledSwhitcher(LED_OFF);
        } else {
          ledSwhitcher(LED_RED);
        }
      }
    }else if (isStandby) {
      ledSwhitcher(LED_OFF);
    }else if (!isReady) {
      ledSwhitcher(LED_RED);
    } else {
      ledSwhitcher(LED_WHITE);
    }

    if (!isReady && nextRegistrationTime<=millis()) {
      sendMessage(CODE_REGISTRATION);
      nextRegistrationTime = millis() + 5000;
    }
  }
  
  void receivedMessage(struct message msg) {
    byte to = msg.to;
    byte from = msg.from;
    byte code = msg.code;
    if (to != iAm) {
      return;
    }
    Serial.print("Buzzer :receive from ");Serial.print(from);
    Serial.print(" code ");Serial.print(code);
    Serial.print(" value ");Serial.println(msg.value);

    switch(code) {
      case CODE_REGISTRATION_OK:
        isReady = true;
        break;
      case CODE_REGISTRATION_INIT:
        isReady = false;
        isWaittingAnswer = false;
        isStandby = false;
        isGoodAnswer = false;
        isWrongAnswer = false;
        nextRegistrationTime = millis();
        displayScore(0);
        isChangeScrore = false;
        break;
      case CODE_WAIT_ANSWER:
        isWaittingAnswer = true;
        break;
      case CODE_STANDBY:
        isStandby = true;
        isWaittingAnswer = false;
        isGoodAnswer = false;
        break;
      case CODE_ANSWER_WRONG:
        wrongAnswerTimer = millis();
        isWaittingAnswer = false;
        isWrongAnswer = true;
        break;
      case CODE_ANSWER_GOOD:
        isWaittingAnswer = false;
        isGoodAnswer = true;
        break;
      case CODE_NEXT:
        isWaittingAnswer = false;
        isStandby = false;
        isGoodAnswer = false;
        isWrongAnswer = false;
        isChangeScrore = false;
        displayScore(score);
        break;
      case CODE_DISPLAY_SCORE:
        score = msg.value;
        displayScore(score);
        break;
      case CODE_CHANGE_SCORE:
        isChangeScrore = true;
        break;
      case CODE_CHANGE_SCORE_STOP:
        isChangeScrore = false;
        displayScore(score);
        break;
    }
  }

  void sendMessage(int code) {
      Serial.print(F(" send : "));
      Serial.println(code);
      
      radio.stopListening();  
      radio.openWritingPipe(addresses[0]);
      unsigned long started_waiting_at = micros();               
      boolean timeout = false; 
      
      message._micros = micros();
      message.to = 0;
      message.from = iAm;
      message.code = code;
      
      if (!radio.write( &message, sizeof(message) )){
         Serial.println(F("failed"));
      }
       
      radio.startListening(); 
  }


  void ledSwhitcher(int led) {
    switch(led) {
      case LED_RED :
        digitalWrite(PinLedWhite, LOW);
        digitalWrite(PinLedGreen, LOW);
        digitalWrite(PinLedRed, HIGH);
      break;
      case LED_GREEN :
        digitalWrite(PinLedWhite, LOW);
        digitalWrite(PinLedRed, LOW);
        digitalWrite(PinLedGreen, HIGH);
      break;
      case LED_WHITE :
        digitalWrite(PinLedRed, LOW);
        digitalWrite(PinLedGreen, LOW);
        digitalWrite(PinLedWhite, HIGH);
      break;
      case LED_OFF :
        digitalWrite(PinLedRed, LOW);
        digitalWrite(PinLedGreen, LOW);
        digitalWrite(PinLedWhite, LOW);
      break;
    }
  }
  
  void displayScore(int scrore) {
    int unit = scrore % 10;
    scrore -= unit;
    scrore /= 10;
    int decade = scrore % 10;
    scrore -= decade;
    scrore /= 10;
    int hundred = scrore % 10;
    scrore -= hundred;
    scrore /= 10;
    int thousand = scrore % 10;
    
    TimeDisp[3] = unit;
    TimeDisp[2] = decade;
    TimeDisp[1] = hundred;
    TimeDisp[0] = thousand;
    tm1637.display(TimeDisp);
  }

NB: pour chaque buzzers la variables "iAm" sera incrémenter :

  • 1er buzzer (iAm = 1 )
  • 2eme buzzer (iAm = 2 )
  • 3eme buzzer (iAm = 3 )
  • 4eme buzzer (iAm = 4 )
  if( radio.available()){                                                   
      while (radio.available()) {                         
        radio.read( &message, sizeof(message) );             
      }
      receivedMessage(message);
    }

Il me semble que si deux messages sont reçus l'un derrière l'autre, seul le deuxième sera traité. A essayer sans la boucle while.

@+