Show Posts
Pages: [1] 2 3 ... 228
1  International / Français / Re: faire du "multitâches" ? on: July 21, 2014, 02:46:53 pm
Regarde le programme blinkWithoutDelay qui fait parti des programme installés avec l'IDE.
millis() permet de gérer plusieurs temporisations en parallèle car elle permet de faire des délais non bloquants. Donc l'ordre dans lequel ces temporisations arrivent est sans importance.
Il y a cette librairie http://forum.arduino.cc/index.php?topic=101814.0 qui pourrait t'intéresser.
2  International / Français / Re: Lecture eeprom 24LC256 on: July 21, 2014, 11:53:33 am
La différence entre un fichier texte et un fichier binaire.
Les 2 fichiers contiennent les nombres allant de 0 à 32.
3  International / Français / Re: Lecture eeprom 24LC256 on: July 21, 2014, 11:12:11 am
Le fichier .txt que je lis ? Pour l'instant j'ai seulement mis des nombres dedans
Dans le fichier texte se trouvera l'ensemble des données de l'eeprom orginal (qui est un programme, peut être en binaire, peut être en texte) que j'aurais enregistré octet par octet sur mon fichier .txt ce seront donc des octets enregistré à l'aide de dataFile.println(readEEPROM(disk1, address+i)); dans le fichier texte.
Tu n'as définitivement pas compris la différence entre un fichier texte et un fichier binaire.
Une EEPROM contient des octets. Chaque octet contient une valeur comprise entre 0 et 255. Lorsque tu utilises print il n'ajoute pas les zéros devant les nombres qui ne contiennent qu'un ou 2 chiffres. Lorsque tu vas lire dans ton EEPROM les valeurs suivantes:
100,2,45,23,234
la fonction print va mettre dans le fichier
 10024523234
Je serais curieux de savoir comment tu vas retrouver tes petits là-dedans.

Dans un fichier binaire, un octet de donnée écrite égale un octet dans le fichier
Dans un fichier texte, un octet de donnée écrite égale un, deux ou trois caractères dans le fichier.

Ce que je constate c'est que lorsque je copie des nombre supérieurs à 255 ils ne sont pas enregistrés dans les cases mémoires donc ça veut dire que mon programme est bon non ?

Plus on avance et plus j'ai l'impression que tu ne comprends vraiment rien aux données que tu manipules.
Comme je le dis au-dessus, un octet, (quel que soit le type de la variable byte, char, ...) c'est une valeur comprise entre 0 et 255. Donc c'est normal que lorsque tu mets une valeur supérieure à 255 une partie se perde dans la nature.

Lorsque je copie le contenue de l'EEPROM original vers la carte SD dois-je utiliser dataFile.write() ou dataFile.print(); ?

On a déjà discuté la différence entre write et print alors je ne vais pas me répéter tu reprends mes réponses précédentes et tu essayes de les comprendre.
4  International / Français / Re: Lecture eeprom 24LC256 on: July 21, 2014, 09:35:11 am
On ne parle pas de la mémoire mais du fichier que tu lis.
5  International / Français / Re: Lecture eeprom 24LC256 on: July 21, 2014, 08:49:09 am
Plus ça va et moins on comprends ton histoire.
Le fichier que tu essayes de programmer dans une EEPROM c'est du texte ou c'est du binaire.
Si tu fais val = myFile.parseInt(); c'est que les données à écrire sont en texte dans le fichier et non en binaire.
6  International / Français / Re: lcd on: July 21, 2014, 08:44:51 am
Il y a un problème dans le calcul de ta moyenne. La variable compteur est un int donc au bout de 32767 itération elle devient négative. Au bout de 65536 itération elle repasse par 0.
Pour régler les problèmes de bruit de mesure, il est plus simple de faire :
  - soit une moyenne glissante sur un certain nombre de mesures successives. On place les mesures dans un tableau et on calcul une moyenne sur ses éléments. A chaque itération on remplace la plus ancienne valeur
  - soit un filtre passe-bas simple de type tempFiltre = k * tempFiltre + (1-k) * temp. temp mesure courante, tempFiltre valeur précédente. k supérieur à 0 et toujours inférieur à 1. k de l'ordre de 0,75 pour un filtrage pas trop énergique. Plus k est élevé plus l'historique est prépondérant sur la mesure actuelle.
7  International / Français / Re: Lecture eeprom 24LC256 on: July 21, 2014, 08:00:25 am
Pourquoi ces 2 boucles imbriquées?
Code:
    while (i<=32767) {
    for(i=0; i<32767; i++){
      val = myFile.read();
     Serial.write(val);
     writeEEPROM(disk1, address+i, val);
     //Serial.println(val);
     delay(500);
    }
    }

Pourquoi ce test
Code:
for(i=0; i<32767; i++){
    if (i<=32767) {
i ne peut pas dépasser 32767 donc le if est inutile.

Quote
Pourquoi est-ce que mes valeurs s'affichent de cette façon :
1
0
2
Quelle partie du programme sort ces valeurs?
8  International / Français / Re: Lecture eeprom 24LC256 on: July 21, 2014, 05:25:46 am
Cela n'a rien à voir avec le fait d'utiliser un ficher texte. C'est ton programme qui est codé avec les pieds et tu n'as pas du faire le moindre organigramme.
Petite explication de texte.
Code:
 // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  for(int i=0;i<32767; i++){
 myFile = SD.open("datalog.txt", FILE_WRITE); // <-- là tu ouvres le fichier en écriture pourquoi ???

 /*
 // re-open the file for reading:
 myFile = SD.open("datalog.txt");  // là tu le rouvres, pourquoi puisque c'est déjà fait la ligne au-dessus??
 if (myFile) {
Serial.println("datalog.txt:");

// read from the file until there's nothing else in it:
while (myFile.available()) { // tu vas rester dans cette boucle tant qu'il y a des données dans le fichier ouvert
 val = myFile.read();   // tu lis un octet du fichier
 writeEEPROM(disk1, address+i, val); // tu l'écris à adresse + i (i = 0 à la première itération de la boucle for)
 Serial.write(val); // écho sur la console
} // cette boucle s'exécute pour le nombre d'octets contenu dans le fichier mais i est constant
// donc tous les octets sont écrit à la même adresse
// close the file:
myFile.close();
 } else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
 }*/
 val = readEEPROM(disk1,address+i);  //utilise pour tester la valeur écrite sur EEPROM
 Serial.write(val);
}

Pour chaque itération de la boucle for tu écris l'intégralité du fichier à la même adresse. Ce qui fait qu'à la fin toute la mémoire est remplie avec le même octet (le dernier du fichier). Au passage tu fais donc "32768 * la taille du fichier" cycles d'écriture à chaque fois. Cela doit être long et va certainement finir par tuer la mémoire. Si ton fichier fait 32768 octets (ce que je suppose vu que tu lis toute la mémoire) tu fais 32768 * 32768 = 1073741824 cycles d'écriture à chaque fois que tu fais tourner ton code.
Il va falloir monter ta mémoire sur un support car tu vas la changer souvent.
9  International / Français / Re: Controler led à partir du terminal serie on: July 21, 2014, 02:48:41 am
Faut un peu chercher pourquoi il ne fonctionne pas.
Si par exemple tu mettais des Serial.print dans la partie construction de la chaîne comme ça
Code:
        else {
           caractereReception=char(octetReception);
           Serial.println(caractereReception,HEX);
           chaineReception=chaineReception+String(caractereReception);
           Serial.println(chaineReception);}
Tu comprendrais peut être ce qui ne va pas.
Tu verrais que tu ne reçois jamais le caractère nouvelle ligne (10) qui est attendu pour marquer la fin de ligne par ce que le terminal et configuré par défaut pour envoyer le retour chariot (13).
Ce qui amène à la correction suivante
Code:
        if ((octetReception==10)||(octetReception==13)) {
Maintenant on interprète le message qu'il se termine par 10 ou par 13.

Ensuite pour le premier message qui n'est pas reconnu c'est par ce qu'il à un espace en trop au début. Conséquence de la création de la variable chaineReception avec un espace dedans.
Le programme corrigé
Code:
int octetReception=0;
char caractereReception=0;
String chaineReception="";

const int LED=13;

void setup(){
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
}

void loop(){

  while (Serial.available()>0) {
    octetReception=Serial.read();

    if ((octetReception==10)||(octetReception==13)) {
      Serial.print('\n');
      Serial.print("message : ");
      Serial.println(chaineReception);
      if (chaineReception=="LED=ON"){
        digitalWrite(LED, HIGH);
        Serial.println("La led s'allume !");
      }

      if (chaineReception=="LED=OFF"){
        digitalWrite(LED, LOW);
        Serial.println("La led s'eteint !");
      }

      chaineReception="";
      break;
    }


    else {
      caractereReception=char(octetReception);
      //Serial.println(caractereReception,HEX);
      chaineReception=chaineReception+String(caractereReception);
      //Serial.println(chaineReception);
    }
  }
}
10  International / Français / Re: Lecture eeprom 24LC256 on: July 20, 2014, 10:11:26 pm
C'est pas très surprenant que ça ne fonctionne pas!
Tu relis ton code avant de l'exécuter??
Dans la boucle formée par le while (myFile.available()) l'adresse ne change pas.
Tu as autour de tout ça une boucle for qui rouvre le fichier à chaque itération et repart donc du début du fichier à chaque tour.
11  International / Français / Re: Problème de classe et d'interruption : comment mixer les 2 on: July 20, 2014, 02:54:53 pm
Tu devrais regarder comment fonctionne la librairie softwareSerial. C'est une classe et elle fonctionne sous interruption.
12  International / Français / Re: controler 8x8 DOT matrix on: July 20, 2014, 02:45:10 pm
http://playground.arduino.cc/Main/DirectDriveLEDMatrix
13  International / Français / Re: Controler led à partir du terminal serie on: July 20, 2014, 02:33:02 pm
Si tu as recopié la code sans essayer de le comprendre c'est pas trop étonnant qu'il ne fonctionne pas. Toutes les lignes concernant la LED sont en commentaire.
Et il attend la commande en majuscule.
14  International / Français / Re: YUN ecriture SD et transfert Wifi au Cloud ou FTP on: July 20, 2014, 02:24:03 pm
Je pense que tu devrais trouver ta réponse de ce coté http://arduino.cc/en/Reference/YunBridgeLibrary
15  International / Français / Re: Lecture eeprom 24LC256 on: July 20, 2014, 02:18:02 pm
Pour la faire courte.
  - Pour lire en EEPROM tu utilises read()
  - Tu stockes la valeur dans un byte ou un tableau de byte
  - Tu écris dans la seconde EEPROM en utilisant un write()
Ces opérations ne changent pas les données manipulées.

Après ce que tu fais pour afficher les données pour contrôle c'est ta cuisine.
Pages: [1] 2 3 ... 228