Go Down

Topic: [Résolue] Serial pour en contrôler un autre avec telle données  (Read 1 time) previous topic - next topic

200sx200

Pourquoi attendez vous alors de recevoir ça pour commencer ?
Bonne question, j'ai zappé le coté "les octets suivant ne sont pas lus"

Je vois aussi qu'il y a de l'hexadeximal et du décimal . Le 29 par exemple, c'est 29 ou 0x29?
Oui, j'ai pas pensé à les remplacés  :/
L'arduino prendrais des valeurs de plusieurs types ?

J-M-L

C'est le compilateur qui interprète ce que vous tapez en C++, ensuite c'est codé en binaire, des 1 et des 0 en mémoire

Si vous écrivez

A = 11;
B = 0x11;
C = 011;
D = 11B;

Et que vous imprimez ces valeurs vous verrez qu'elles sont toutes différentes

A est en décimal (base 10) ce que vous utilisez dans la vraie vie
B est en hexadécimal (base 16)
C est en octal (base 8 )
D est en binaire (base 2)

Donc dans le tableau si c'est important de tester l'ensemble de la communication il faut bien mettre toutes les bonnes valeurs dans la base que vous voulez mais il faut que ça corresponde. Si vous vous fichez d'avoir reçu toute la chaîne et que seul le dernier caractère compte (et n'arrive pas plusieurs fois dans la chaîne) alors ne mettez que le dernier caractère à écouter. Vous ne pouvez pas mettre 0 pour dire je me fiche de cette valeur (ou alors modifiez le test de validité) il faut que tout corresponde
Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous

200sx200

D'accord, mais s'il y avait des valeurs identiques ? je peux choisir le numéro de la valeurs comme dans le tableau byte ? ex: tableau[2] et tableau[11]

Ou il faudrait enregistrer les valeurs reçues dans un tableau pour ensuite choisir telle valeur ?

J-M-L

mon code attend une suite de valeurs - ce n'est pas grave s'il y en a 2 identiques, l'important c'est que la suite de valeurs soit dans le bon ordre. Si au lieu de magic vous mettez hello par exemple, les 2 l ne sont pas un soucis. tant que vous ne tapez pas hello la détection ne fonctionne pas.

si vous vouliez dire "je me fiche du caractère qui est à tel endroit" vous pourriez modifier le code. par exemple dire que le caractère '?' veut dire n'importe quel valeur de cet octet est OK et en tenir compte dans le code de test dans le buffer.

 par exemple en mettant comme phrase à détecter ma?ic alors magic va fonctionner mais aussi maRic ou maTic ou ce que vous voulez pour le troisième octet. c'est vous qui contrôlez ce qui est acceptable par votre code de test.

voici le code modifié pour tenir compte d'un point d'interrogation comme caractère générique
Code: [Select]

const uint8_t genericByte = '?';

const uint8_t magicPhrase[] = {'m', 'a', '?', 'i', 'c'}; // pas obligatoirement des caractères

const uint8_t localBufferSize = sizeof(magicPhrase); // attention faire -1 si vous utilisez une c-string pour initialiser la phrase magique
uint8_t localBuffer[localBufferSize]; // buffer circulaire de la bonne taille

boolean gotMagicPhrase()
{
  boolean magicFound = false;
  static byte index = 0; // là où on est en train d'écrire dans le buffer circulaire

  while (Serial.available() > 0) {
    localBuffer[index] = (uint8_t) Serial.read();

    // *******************************************************************
    // DEBUG SI VOUS VOULEZ VOIR LE BUFFER CIRCULAIRE QUI SE CONSTRUIT
    //            VOUS POUVEZ VIRER CE CODE QUI NE SERT A RIEN
    // *******************************************************************
    Serial.print("[");
    for (byte i = 0; i < localBufferSize; i++) {
      Serial.print((char) localBuffer[i]); // en ASCII
    }
    Serial.print("] --> ");

    Serial.print("{ ");
    for (byte i = 0; i < localBufferSize; i++) {
      Serial.print("0x"); Serial.print(localBuffer[i], HEX); Serial.print(" "); // en HEXA
    }
    Serial.println("}");
    // *******************************************************************


    magicFound = true;
    for (int i = 0; i < localBufferSize; i++) {
      if (magicPhrase[i] != genericByte) { // le genericByte correspond à n'importe quel octet donc on le saute
        if (localBuffer[(index + 1 + i) % localBufferSize] != magicPhrase[i]) {
          magicFound = false;
          break; // pas la peine de continuer, le buffer n'est pas bon
        }
      }
    }

    index++; // le prochain caractère ira dans cette case
    if (index == localBufferSize) index = 0; // on boucle dans le buffer circulaire

    if (magicFound) break;
  }

  return magicFound;
}


void setup() {
  Serial.begin(115200);

  // pas nécessaire pour une variable globale mais pour vous montrer comment faire
  // si vous aviez besoin de mettre le buffer à vide
  // memset(localBuffer, '\0', localBufferSize);

}

void loop() {
  static boolean foundMagicPhrase = false;
  if (!foundMagicPhrase) {
    foundMagicPhrase = gotMagicPhrase(); // on va voir si on a reçu la phrase
    if (foundMagicPhrase) {
      Serial.println("Bingo");
    } else {
      // *******************************************************************
      // ici vous faites ce que vous voulez, en attendant la phrase magique
      // *******************************************************************


      // *******************************************************************
    }
  } else {
    // *******************************************************************
    // ici vous faites ce que vous voulez, on a reçu la phrase magique
    // *******************************************************************


    // *******************************************************************

  }
}


on définit la phrase clé comme étant
Code: [Select]
const uint8_t magicPhrase[] = {'m', 'a', '?', 'i', 'c'}; // pas obligatoirement des caractères


et si je tape coucoumatic1234 la sortie me dit

[c] --> { 0x63 0x0 0x0 0x0 0x0 }
[co] --> { 0x63 0x6F 0x0 0x0 0x0 }
[cou] --> { 0x63 0x6F 0x75 0x0 0x0 }
[couc] --> { 0x63 0x6F 0x75 0x63 0x0 }
[couco] --> { 0x63 0x6F 0x75 0x63 0x6F }
[uouco] --> { 0x75 0x6F 0x75 0x63 0x6F }
[umuco] --> { 0x75 0x6D 0x75 0x63 0x6F }
[umaco] --> { 0x75 0x6D 0x61 0x63 0x6F }
[umato] --> { 0x75 0x6D 0x61 0x74 0x6F }
[umati] --> { 0x75 0x6D 0x61 0x74 0x69 }
[cmati] --> { 0x63 0x6D 0x61 0x74 0x69 }
Bingo


On voit donc bien que le '?' a bien été considéré comme générique et matic est une bonne entrée
OK ?
Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous

200sx200

oui oui d'accord mais si je souhaite pas exemple faire de "magic" l'octet 1,2,3 et 35 . (3er octet et dernier)

Avec un tableau c'est "octet[1]&&octet[2]&&octet[3]&&octet[35]"

Mais le sa voudrais dire que je dois faire "const uint8_t magicPhrase[] = {'1', '2', '3', '?xfois'(jusqu'à 34 ?), '35'}; ?

J-M-L

Oui ou si les premiers octets son insignifiants écouter juste la fin
Hello - Please do not PM me for help,  others will benefit as well if you post your question publicly on the forums.
Bonjour Pas de messages privés SVP, postez dans le forum directement pour que ça profite à tous


Go Up