next topic »

[on:]

Bonsoir,
Je reviens a nouveau vers vous parce que j'ai des soucis avec les type de variables.
Peut-être pourriez vous m'expliquer comment me débrouiller.

Voilà, Je voudrai ecrire un byte sous le format binaire dans l'EEPROM : en le faisant manuellement pas de soucis

par exemple :
byte trame=B010101;
EEPROM.write(0,trame);

cela fonctionne parfaitement, ensuite avec l'instruction bitread(x,n) je peut récuperer chaque bit et m'en servir pour positionner l'état d'une sortie.

Là ou cela se complique c'est quand je veux envoyer le byte par le port série car je ne sait pas comment envoyer le format :
si j'envoie une variable   String="B010101", lorsque je veux l'écrire dans l'EEPROM j'obtiens une erreur car il faut mettre un byte
et quand j'envoie une varaible Byte=B010101, je me retrouve avec des chiffres genre 245102235 et pas des bits !

Je ne sais plus comment m'en sortir, il faudrait pouvroi convertir une String="B010101" en Byte=B010101 mais ça je sais pas faire...

J'espère être assez explicite (j'avoue que c'est brouillon).

Merci
A bientôt

[Reply #1 on:]

Bonjour,

J'ai strictement rien compris à ce que tu voulais faire ...

Tu veut stocker un byte reçu depuis le port série sur l'eeprom ?

[Reply #2 on:]

oui,
si tu mets par exemple :

byte trame=B010101;
EEPROM.write(0,trame);

si tu fait ensuite
Serial.println(EEPROM.read(0),BIN);

tu auras : 010101 sur le moniteur (et donc dans ton programme tu peux lire chaque bit 1 par 1)

Ben je veux arriver au même résultat mais en l'envoyant par le port série.

[Reply #3 on:]

Pour résumer a l'extrême ,

Je voudrai mettre dans l'eeprom, le byte B010101 mais en envoyant le "B010101" par le port série.

Je suis désolé de ne pas savoir mieux expliquer 

[Reply #4 on:]

Yep!

Je vais essayer de comprendre également

DONNEE --> port série --> ARDUINO --> EEPROM ???

Si tu recois tes data de type char par le port serie par exemple, un simple byte(data) devrait suffire.

@+

Zoroastre.

[Reply #5 on:]

Tu veut envoyer B10101010 en tant que 9 caractéres ? Envoyé un seul octet serait plus rapide/simple ?

Edit : Ok j'ai compris

Un truc dans le genre devrait le faire (/!\ codé vite fait sans réel test) :

Code:

byte getBinary() {
  while(Serial.available() < 9);
  if(Serial.read() == 'B') {
    byte n = 0;
    for(byte i = 0, i < 8; i++) {
      bitWrite(n, i, (Serial.read() == '1') ? 1 : 0);  
    }
    return n;
  }
  return 0;
}

[Reply #6 on:]

Si vous collez ça dans l'arduino :

#include <EEPROM.h> // Librairie pour le stockage de données en mémoire Eeprom interne

void setup() {               
 Serial.begin(9600); // initialise connexion série à 115200 bauds
     
 byte test=B10101;
 EEPROM.write(0,test);
 Serial.println(EEPROM.read(0),BIN); 
}

void loop() {
 
}

Sur le moniteur on obtient 10101 on est d'accord.

Et bien je veux le même résultat mais en mettant le B10101 par le port série.

[Reply #7 on:]

Merci Skywoodd je vais tester, tu as été plus rapide que moi sur la réponse....

[Reply #8 on:]

Bon bah je vais laisser tomber je pense, pas moyen d'y arriver...
J'ai découvert le bitWrite que je ne connaissait pas (normal je débute)

Merci en tout cas de m'avoir répondu si rapidement.

A bientôt

[Reply #9 on:]

Bon bah je vais laisser tomber je pense, pas moyen d'y arriver...
J'ai découvert le bitWrite que je ne connaissait pas (normal je débute)

T'est du genre à abandonner aussi rapidement
Qu'est ce qui ne marche pas ?

[Reply #10 on:]

Lol je n'abandonne pas, mais je ne voulais pas vous déranger encore et encore.
Je vous mets le code ou j'en suis :

#include <EEPROM.h> // Librairie pour le stockage de données en mémoire Eeprom interne


byte inputString;

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

    Serial.begin(9600);

}


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

   
}

//-----------------------------------------------------------

//-----------------------------------------------------------
//    EVENEMENT
//-----------------------------------------------------------

/*
  Evénement qui se déclenche lorsque le port série reçoit
  des informations.
 */
void serialEvent() {
 char inChar;
 int compteur=0;
 
  while (Serial.available()) {
   
    inChar = (char)Serial.read();
    // Si le caractère "." arrive sur le port com 'caractere choisi au pif !'
    // on indique que la ligne de transmission est effectuée et Arduino peut traiter la commande
    if (inChar != '.') {
      if (inChar=='0'){
          bitWrite(inputString,compteur,0);
      }
      else {
          bitWrite(inputString,compteur,1);
      }
      compteur = compteur + 1;
    }
    else{
      //EEPROM.write(0,inputString);
      Serial.println(inputString,BIN);
    }

  }
}

Théoriquement si dans le moniteur on tappe 01010. (le point indique la fin de ma trame), il devrait marquer 01010 et ben non il marque rien !
il me reste 15 cheveux environ a m'arracher....

[Reply #11 on:]

CA MARCHE !

Code:

#include <EEPROM.h> // Librairie pour le stockage de données en mémoire Eeprom interne

byte inputString;
int compteur=0;

void setup()   { // debut de la fonction setup()
    Serial.begin(9600);
}

//    LOOP

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

//    EVENEMENT

/*
  Evénement qui se déclenche lorsque le port série reçoit
  des informations.
 */
void serialEvent() {
 char inChar;
 
  while (Serial.available()) {
   
    inChar = (char)Serial.read();
    // Si le caractère "." arrive sur le port com 'caractere choisi au pif !'
    // on indique que la ligne de transmission est effectuée et Arduino peut traiter la commande
    if (inChar != '.') {
      if (inChar=='0'){
          bitWrite(inputString,compteur,0);
      }
      else {
          bitWrite(inputString,compteur,1);
      }
      compteur = compteur + 1;
    }
    else{
     
      EEPROM.write(0,inputString);
      Serial.println(EEPROM.read(0),BIN);
      compteur=0;
    }
  }
}

Voila, a part que le sens s'inverse a cause du bitWrite qui démarre a droite.
C'est impeccable.

Il faudra quand même que je vous explique à quoi ça va servir.

[Reply #12 on:]

Dans un code en VB.net (que je maitrise beaucoup mieux heureusement !) j'ai fait une grille qui permet d'envoyer 10 ligne composée chacune de 10 cases.
Chaque case correspondent chacune a une sortie de l'Arduino (une led ou une lampe) soit 10 Led qui seront soit allumées soit éteintes et cela pendant 10 cycles.

donc :
Ligne 1 : 0110010110 : led1 éteinte, led2 allumée,..... (de gauche a droite)
Ligne 2 : 1111001111
....
Ligne 10 : 0011101101

Capture d'écran de mon prog.



Voila je récupére toutes les sélections sous forme d'une chaine de 100 caractères (10 Lignes x 10 leds )
ce qui donne par exemple : mavariable = "0001111011101010101101.....................0101" (100 caractères)

Et j'envoie le tout a l'Arduino par le port série.

Ensuite c'est l'arduino qui travaille :
Il lit ligne par ligne avec un delai entre chaque ligne et allume/eteind les led et je me retrouve avec un chenillard programmable par VB.

Le must étant de sauver dans l'Arduino la dernière config d'ou ma recherche pour ecrire des "bits" dans l'EEPROM
je pense faire des paquete de 5 bit ce qui me prendrai 20 adresses dans l'EEPROM

Voilà vous savez tout.
Comme je sauve chaque grille dans une base de donnée, je peut a tout moment rappeler un schéma de chenillard et l'envoyer a l'Arduino.

C'est pas beau la vie ?
Bon il me reste du taf.

Sans toi Skywood je n'y serai pas arrivé car je ne connaissais pas toutes les commande.

Merci une fois de plus.

+++

[Reply #13 on:]

Si tu envoyais les 100 0/1 sous la forme de 13 octet se serais plus rapide que d'envoyé 100 octets (et plus simple à gérer) 
Niveau prog vb.net il suffit de faire une fonction qui prend 8 boolean en arguments et qui sort un octet avec chrw() (+ calcul avec puissance de 2).

Voir un systéme tiptop, tu envoi chaque trame de 10 boolean sous forme d'un unsigned int (2 octets) :
1er octet : <bit 5 ~ 7 : adresse étape part1><bit 0 ~ 4 : valeurs D1 ~ D5>
2eme octet : <bit 5 ~ 7 : adresse étape part2><bit 0 ~ 4 : valeurs D6 & D10>
Et tu n'actualise que les lignes (adresses) qui ont était modifié dans ton prog, coté arduino il récupère les deux octets, calcul l'adresse, et met à jour l'adresse en EEPROM qui va bien

[Reply #14 on:]

En effet Skywodd,
Le problème est ma méconnaissance du système "Arduino" ce qui m'amène a des solutions basiques et donc souvent "lourdes".
Ton analyse est judicieuse, en effet avec ta méthode cela va rudement accélérer les mise a jour ainsi que les durées de transmission qui seront diminuées.

Merci donc d'avoir prit la peine de regarder mon projet.

Comme la partie gestion/création de la trame de transmission dans mon prog VB n'était pas encore faite, cela ne sera pas dur de l'orienter avec ta solution.

Merci
à bientôt

++