- [ARDUINO] - Transposer un tableau en code ?

[johnmary]

Bonjour à tous,

Pour expérimenter un projet en cours, j'utilise actuellement une carte Arduino, qui est bien pratique pour faire pas mal de test à la sauvage à vrai dire

Cependant je suis face à un problème auquel je n'ai jamais été confronté, quel que soit le langage de programmation utilisé :

Dans ce projet, j'ai 30 variables de type boolean qui doivent être envoyée sur un bus de la façon suivante :

Je reçoit plusieurs paquets de variables, j'ajoute celles que j'ai, j'envoi la somme des variables.

Comme au final ce ne sont pas moins d'environ 200 Variables qui circulerons sur ce bus (la somme finale), j'ai décidé de les regrouper en paquet, selon leur fonction, pour limiter le nombre de valeur qui circulerons.

Les 30 premières variables par exemple, sont destinées à commander uniquement des relais, Les 30 suivantes des optocoupleurs, d'autres en revanche seront de type Integer et représenterons des valeurs de température, d'humidité etc..., elles ne pourrons donc pas faire l'objet du condensage que j'envisage ci dessous :

L'idée :

Le principe est simple : Utiliser l'algèbre de boole
En effet, ces 30 variables de type boolean ne peuvent prendre que deux états :
Ce sont donc (30)^2 Solutions qui sont possibles, soit 900.

J'ai donc réalisé un tableau sur excel qui ressemble à peu près à cela :

 Cliquez pour afficher

0 0 0 0 0 0 0 0 = 1
0 0 0 0 0 0 0 1 = 2
0 0 0 0 0 0 1 0 = 3
0 0 0 0 0 0 1 1 = 4
0 0 0 0 0 1 0 0 = 5
0 0 0 0 0 1 0 1 = 6
0 0 0 0 0 1 1 0 = 7
0 0 0 0 0 1 1 1 = 8
0 0 0 0 1 0 0 0 = 9
0 0 0 0 1 0 0 1 = 10
0 0 0 0 1 0 1 0 = 11
0 0 0 0 1 0 1 1 = 12
0 0 0 0 1 1 0 0 = 13
0 0 0 0 1 1 0 1 = 14
0 0 0 0 1 1 1 0 = 15
0 0 0 0 1 1 1 1 = 16
0 0 0 1 0 0 0 0 = 17
0 0 0 1 0 0 0 1 = 18
0 0 0 1 0 0 1 0 = 19
0 0 0 1 0 0 1 1 = 20
0 0 0 1 0 1 0 0 = 21
0 0 0 1 0 1 0 1 = 22
0 0 0 1 0 1 1 0 = 23
0 0 0 1 0 1 1 1 = 24
0 0 0 1 1 0 0 0 = 25
0 0 0 1 1 0 0 1 = 26
0 0 0 1 1 0 1 0 = 27
0 0 0 1 1 0 1 1 = 28
0 0 0 1 1 1 0 0 = 29
0 0 0 1 1 1 0 1 = 30
0 0 0 1 1 1 1 0 = 31
0 0 0 1 1 1 1 1 = 32
0 0 1 0 0 0 0 0 = 33

ETC....

Avec

• autant de colonne qu'il existe de variable boolean, plus une pour le codage qui en retourne.
• autant de ligne qu'il existe de solutions.

Mes questions sont les suivantes :

1. Comment puis-je réaliser ce tableau dans le code ? ou une structure similaire ?
2. Comment obtenir une instruction qui me renvoi le codage en fonction des variables ?

En fait j'aimerais pouvoir donner ce tableau, et avoir un fonction qui à partir de l'état de variable que je lui donne :

Lire Variable 1
Lire Variable 2
Lire Variable 3
etc...

Retourner Ligne correspondante.

Et que le programme aie chercher directement la ligne qui correspond à l'état de ces variables et qu'elle retourne le n° de la ligne correspondante : ligne 5.


Bien entendu, si cela n'est pas possible c'est toujours réalisable avec une boucle if / else... mais ça me ferait 900 boucles If à faire, juste pour un paquet


Je vous remercie d'avance pour toute l'aide dont vous saurez m'apporter
-----

[invitef86a6203]

Il y a quelque chose de pas claire...
Tu nous parle de fonctions booléennes et affiche un tableau de la fonction (n-1) en binaire.

Un octet ne peut avoir que 8 fonctions par exemple 8 relais On/Off
On fait donc une boucle de 8 pour actionner le bon relais et pour simplifier un switch case pour appeler les fonctions
https://www.arduino.cc/en/Reference/SwitchCase

unsigned char Octet;
unsigned char mask;
unsigned char i;

Octet= 0xAA; // juste pour tester 10101010
mask = 1;
for (i=0; i<8; i++)
   {
   if (Octet && mask) {
       switch(Octet && mask) {
            case 1;
                function1();
                break;
            case 2;
                function2();
                break;
            case 4;
                function3();
                break;
            case  8;
                function4();
                break;
            case 16;
                function5();
                break;
            case 32;
                function6();
                break;
            case 64;
                function7();
                break;
            case 128;
                function8();
                break;
             }
      }
      mask = mask << 1; // bit suivant
   }

Le if (Octet && mask) est facultatif si la fonction gère les 2 états.

[johnmary]

Bonjour Pat !

C'est bon, tu à je pense solutionner mon problème !

Effectivement recevoir un octet permet de commander 8 relais ! J'en ai 30 ça me fait 4 Octets à envoyer sur le bus.
Chaque octet gère ses 8 relais, mais surtout Switch / Case permet de faciliter AMPLEMENT le code !

J'aurais donc 4 octets pour les relais, 4 octets pour les opto, 4 Relais pour d'autres récepteurs tout ou rien, et enfin 1 Octet par capteur de température

[johnmary]

Bonjour,

Finalement, chaque paquet sera envoyé de la sorte (voir PJ)

Un octet de groupe correspondant à une lettre,
et quatre octet de données, dont chaque bit viendra mettre à jour une variable boolean.


Quelle structure serait appropriée ?

1. Lire les octets qui entrent sur le bus série,
2. Lire le premier Octet et enregistrer sa valeur,
3. Lire les quatre octet suivants en lisant chaque bit, un à un, puis mettre à jour les variables (qui seront choisies en fonction de la lettre issue du premier octet)

Par exemple si c'est la lettre A, ce seront les variables L1 à L32 qui seront mises à jour à partir des 4 Octets de données
Sinon si c'est la lettre B, ce seront les variables P1 à P32 qui seront mises à jour, etc...

Je sèche sur les structures à utiliser

[A voir en vidéo sur Futura]

[invitef86a6203]

Généralement la transmission série se fait d'un seul tenant , si la vitesse est élevée , ça va être risqué de décoder en temps réel.
Le mieux est de mémoriser le message , peut être avec l'interruption , une fois complet un flag indique un message reçu.
Alors le programme principal va le traiter, puis effacer le flag pour autoriser un nouveau message.

Il manque tout de même un CRC pour valider la transmission , mais ça signifie qu'on va acquitter le message, peut être est ce trop compliqué.
On met généralement un octet de start au début de message , ça évite de démarrer une séquence n'importe ou.

[johnmary]

si la vitesse est élevée

Je n'ai pas vraiment besoin que la vitesse soit élevée, en fait même si elle est inférieur à 9600 Bauds, cela ne me dérange pas tellement, le rafraichissement des données ne se fera que lors qu'un appui sur une touche sera effectué, donc vraiment aléatoire ! Si c’est utilisé par un nerveux ou un petit vieux

Le mieux est de mémoriser le message

Ce n'est pas le rôle de l'instruction Serial.available() ? Je pensais qu'elle mémorisait en tampon l'intégralité du message dès sa réception et jusqu'à ré-écriture ?

ça va être risqué de décoder en temps réel.

Je pensais justement recevoir le message en intégralité dans une variable et seulement après décortiquer le message, car je pense que je ne suis pas assez doué pour le faire en direct ^.^
Et puis de toutes manières ce n’est pas ce que je recherche.

une fois complet un flag indique un message reçu.

C'est à dire faire passer une variable à 1 lorsque les 5 Octets ont été reçus ?

Il manque tout de même un CRC pour valider la transmission , mais ça signifie qu'on va acquitter le message, peut être est ce trop compliqué.

Pour le moment je n'ai pas besoin d'acquitter, le programme reçoit et exécute sans rendre de compte à son envoyeur.

On met généralement un octet de start au début de message , ça évite de démarrer une séquence n'importe ou.

Je pensais qu'il été automatiquement géré par Arduino celui-ci ? Octet de Start et octet de Stop généré par la fonction " Serial.write" ?
C'est pour cette raison que je ne l'ai pas représenté sur l'image :/

[invitef86a6203]

J
Ce n'est pas le rôle de l'instruction Serial.available() ? Je pensais qu'elle mémorisait en tampon l'intégralité du message dès sa réception et jusqu'à ré-écriture ?

ça indique qu'i y a quelque chose , mais ça ne dit pas si le message est complet

C'est à dire faire passer une variable à 1 lorsque les 5 Octets ont été reçus ?

oui ou un booleen

Je pensais qu'il été automatiquement géré par Arduino celui-ci ? Octet de Start et octet de Stop généré par la fonction " Serial.write" ?
C'est pour cette raison que je ne l'ai pas représenté sur l'image :/

Non , il envoie ce que tu met dans ta variable rien de plus ou de moins
C est a toi de vérifier si le message est cohérent ou complet ou autre...

[johnmary]

ça indique qu'i y a quelque chose , mais ça ne dit pas si le message est complet

Comment stocker plusieurs octets dès que quelque chose est présent sur le bus série alors ?

Quelque chose du genre ?

if (Serial.available())
{char tampon = Serial.read();} ?

Non , il envoie ce que tu met dans ta variable rien de plus ou de moins
C est a toi de vérifier si le message est cohérent ou complet ou autre...

Ok, je l'ignorais ! J'immaginais que Arduino était un peu plus malin que ça sur le port Série
Donc c'est dans mon intérêt de mettre un octet de Start effectivement !

[invitef86a6203]

un exemple trouvé avec google;
http://stackoverflow.com/questions/5...-using-arduino

[johnmary]

ça, OK :

 while (Serial.available() > 0) // Don't read unless
                                   // there you know there is data
    {
        if(index < 19) // One less than the size of the array
        {
            inChar = Serial.read(); // Read a character
            inData[index] = inChar; // Store it
            index++; // Increment where to write next
            inData[index] = '\0'; // Null terminate the string
        }
    }

Mais ça ?

if (strcmp(inData,This) == 0) {
for (int i=0;i<19;i++) {
inData[i]=0;
}
index=0;
return(0);
}
else {
return(1);
}

Le principe me semble simple : On viens stocker dans un tableau chaque octet lu sur le bus ?

Ensuite si je veux les réutiliser je n'ai qu'à faire appel à la case correspondante puis à l'examiner ?

[invitef86a6203]

le gars à un buffer de 19 char donc il met une limite pour ne pas dépasser cette taille

Le strcmp compare une chaine de char avec une autre il l'appelle this donc mettre quelque chose dedans
Si la comparaison est bonne strcmp renvoie 0 , dans ce cas il efface la chaine.

Après il faut interpréter ce qu'on reçoit
admettons que pour commencer un message avec "MESxx" après xxune valeur en hexa ascii.
Il faudra faire un strcomp de MES puis transformer les 2 ASCCII en binaire.

[johnmary]

Avec une fonction :

if (Comp("MES")==0)
{
  ...
}

Mais en fait si on regarde bien, ça permet de convertir déjà en alphanumérique ce qui est lu sur le bus, et ensuite de l'interpréter ?

Je ne sais pas si c'est applicable avec cela :

1) Lire le premier octet, le stocker (Chaque message comporte 4 Octet, donc à faire 4 fois dans 4 emplacement différents)

2) Décomposer le premier octet en bit, et affecter à une variable boolean chaque bit correspondant.

Donc 1 Octet = 8bits = 8Variables boolean.


Lire et stocker, ça, c'est OK, l'idée du :

 Cliquez pour afficher

 while (Serial.available() > 0) // Don't read unless
                                   // there you know there is data
    {
        if(index < 19) // One less than the size of the array
        {
            inChar = Serial.read(); // Read a character
            inData[index] = inChar; // Store it
            index++; // Increment where to write next
            inData[index] = '\0'; // Null terminate the string
        }
    }

me plaît bien

Mais maintenant il faut que j'arrive à

> Faire en sorte que Arduino lise bien du binaire et ne convertisse pas automatiquement ce qu'il lit sur le bus série
> Décomposer un octet reçu et l'exploser en 8 ?

[johnmary]

Bonjour à tous !

Le morceaux de code que m'a indiqué freepicbasic me semble correct, je l'ai modifié un peu à ma sauce et il roule parfaitement.

Finalement, avec mon code modifié ou même avec le code d'origine, lorsqu'un message est envoyé sur le bus mais qu'il ne correspond à aucune condition :

if (Comp("VALEUR")==0)

La variable Comp se bloque, et les messages suivants ne sont plus pris en compte du tout.

Pour info j'utilise cette instruction pour commander des relais :

if (Comp("L10")==0)

L pour Lumière
1 pour Relais 1
0 pour état bas.

Les messages possibles commencent donc pour le moment tous par L, le deuxième caractère va de 0 à 10 et le dernier caractère vaut 0 ou 1.

Si par mégarde j'écris L13, Plus rien n'est ensuite pris en compte.

J'aimerais ajouter une ligne de code à la fin des If / else if / else if , qui effacerait le contenu de la variable Comp pour que dans le cas où la valeur de la variable Comp n'est pas exploitée par un If, qu'une valeur lui soit automatiquement affectée.

J'espère que cela pourrait permettre d'éviter ce genre de bug, et qu'on puisse également détecter une anomalie pour éventuellement la faire remonter ?


Malheureusement j'ai essayer plusieurs combinaisons mais comme il s'agit de pointeur, j'ai beaucoup de mal avec ces derniers, pourriez vous m'aider ?
Merci d'avance !

[invitef86a6203]

dans ton prog la variable s'appelle "indata"
ça sort d'ou COMP ?

pour tester une chaine il y a 2 fonctions strcmp et strncmp
if (strcmp(inData,"L13") == 0) {
Teste la totalité de la chaine si inData est plus longue c est faux !

ou

if (stnrcmp(inData,"L13",3) == 0 ) {

3 indique le nombre de caractères à tester
Si la chaine n'est pas terminer par un '\0' on test que n caractères même si la chaine est plus longue.


Dans ton prog index remet le compteur à zéro et on finit la chaine avec un '\0' il suffit de mettre index=0;