aide sur casque vision tête haute

Parlez nous de vos projets et de vos idées, imaginez des applications

aide sur casque vision tête haute

Message non lude Foil10 » Jeu 7 Aoû 2014 11:10

Bonjour,
Je suis assez nouveau dans l'arduino du coup j'ai encore beaucoup de mal à réaliser mes projets...
Mon projet actuel est assez simple, j'ai un vélo de contre la montre et un casque de contre la montre avec une visière dans laquelle j'aimerais intégrer un système de vision tête haute comme dans les avions de chasse.
Le projet ce divise en deux parties, la première utilise une carte mega 2560 qui recois des infos de deux capteurs à effet hall situer sur le vélo (un pour la vitesse et l'autre pour la cadance de pédalage RPM) et qui doit en déduire la vitesse et la cadence et s'occuper de gérer l'affichage sur la visière,
L'autre partie est une carte uno avec un shield audio qui est sencé fonctionner comme un assistant vocale et m'indiquer certaine information utile ou non dans mes écouteurs.
Les deux étant censé communiquer l'un avec l'autre par le biais d'une liaison par fil en utilisant la librayrie "Wire.h".
Pour l'instant toute la partie mécanique est réalisé et fonctionnelle.

J'ai deux GROS problème avec ce projet.
Le premier c'est que je n'arrive pas à calculer correctement la vitesse et la cadence.... même en affinant les réglage j'ai de grosses incohérence dans les valeur donnée en plus des bonnes valeurs...
Donc si quelqu'un pouvait me montrer comment puis-je régler cela...

Mon deuxième problème est assez étrange car lorsque j'utilise la librayrie Wire dans mon programme utilisant le shield audio tout plante et la liaison série ne fait que m'afficher des symboles bizarre... aucune piste audio ne se lit alors que dès que je sort la ligne "#include "Wire.h"" le programme se remmer à marcher correctement...

please help me, je vais finir par sauter par ma fenêtre si ça continue !!! en plus je sais que j'y suis presque !!! :cry:

Code: Tout sélectionner
#include "Wire.h";


char dizaine = 0; // variable pour affichage des dizaines
char unite = 0;  // variable pour affichage des unité
int bidon = 500;
int cadens = 0; // valeur de la cadence
boolean x = 0; //
int vit = 0; //signal d'entré du capteur hall de la vitesse
int temps1_vit = 0; //temps pris au premier passage
int temps2_vit = 0; //temps pris au deuxième passage
int temps_vit = 0; //temps entre les deux passages
int vitesse_actuel = 0; //vitesse
int vitesse_precedente = 4;
unsigned int ecart = 0;

 
int cad = 0; //valeur signal capteur hall de la cadence
boolean y = 0;
int temps1_cad = 0; //premiers passage
int temps2_cad = 0; //deuxième passage
int temps_cad = 0; //entre les deux passages

boolean temps_vit_affichage = 0; //varialble de clignotement dans l'affichage
boolean temps_cad_affichage = 0; //varialble de clignotement dans l'affichage
boolean temps_bidon_affichage = 0; //varialble de clignotement dans l'affichage

int transmission = 0; //connexion filaire avec l'autre carte
int km = 0; //kilomètre parcourue



//////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////

void setup()
{
 // Wire.begin();
  Serial.begin(9600);
  pinMode(A1, INPUT); // entré capteur boisson
  pinMode(A2, INPUT); // entré compteur vitesse
  pinMode(A3, INPUT); // entré compteur cadence
  pinMode(A4, INPUT); // entré capteur pulse
 
 
  pinMode(6, OUTPUT);  // sortie 7 afficheur sept segments
  pinMode(7, OUTPUT);  // sortie 6 afficheur sept segments
  pinMode(9, OUTPUT);  // sortie 5 afficheur sept segments
  pinMode(10, OUTPUT); // sortie 4 afficheur sept segments
  pinMode(11, OUTPUT); // sortie 3 afficheur sept segments
  pinMode(12, OUTPUT); // sortie 2 afficheur sept segments
  pinMode(13, OUTPUT); // sortie 1 afficheur sept segments
 
  pinMode(49, OUTPUT); // sortie 1 cadence
  pinMode(51, OUTPUT); // sortie 2 cadence
  pinMode(27, OUTPUT); // sortie 3 cadence
  pinMode(29, OUTPUT); // sortie 4 cadence
  pinMode(31, OUTPUT); // sortie 1 vitesse
  pinMode(33, OUTPUT); // sortie 2 vitesse
  pinMode(35, OUTPUT); // sortie 3 vitesse
  pinMode(37, OUTPUT); // sortie 4 vitesse
  pinMode(39, OUTPUT); // sortie 1 bidon
  pinMode(41, OUTPUT); // sortie 2 bidon
  pinMode(43, OUTPUT); // sortie 3 bidon
  pinMode(45, OUTPUT); // sortie 4 bidon
 
  digitalWrite(1, LOW);   
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  digitalWrite(6, LOW);
  digitalWrite(7, LOW);
  digitalWrite(8, LOW);   
  digitalWrite(9, LOW);
  digitalWrite(10, LOW);
  digitalWrite(11, LOW);
  digitalWrite(12, LOW);
  digitalWrite(13, LOW);
  digitalWrite(49, LOW);   
  digitalWrite(51, LOW);
  digitalWrite(27, LOW);
  digitalWrite(29, LOW);
  digitalWrite(31, LOW);
  digitalWrite(33, LOW);
  digitalWrite(35, LOW);
  digitalWrite(37, LOW);   
  digitalWrite(39, LOW);
  digitalWrite(41, LOW);
  digitalWrite(43, LOW);
  digitalWrite(45, LOW);
 
 
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void loop()
{
 
 

 
  vitesse();
  cadence();
  affichage();
 
 
 Serial.println(vitesse_actuel);
 Serial.println();
// Serial.println(cadens);
 
 
 
 
}

///////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////

void vitesse()
{
 
 

  vit = analogRead(A2);



// si la valeur du capteur dépasse 1021
  if(vit > 1021)
  {
     x = 1 - x; // on change une fois sur deux x pour que prendre deux mesures de temps et ainsi avoir un temps entre deux passage de l'aimant
     km = km + 2.12;

     if(x == 1) // premier passage
     {
       temps1_vit = millis();
       delay(15); //delay pour ne pas mesurer deux fois le même passage
     }
 
    if(x == 0) //deuxième passage
    {
      temps2_vit = millis();
      delay(15);
    }
 
  }
  if((temps1_vit != 0) && (temps2_vit != 0))
    {
      temps_vit = (temps2_vit - temps1_vit);
      vitesse_actuel = ((2.12 * 3600) / temps_vit); //calcul de la vitesse
      temps1_vit = 0; // on remet à zéros
      temps2_vit = 0;
      //filtre();
      dizaine = vitesse_actuel / 10; // pour affichage
      unite = vitesse_actuel - (dizaine * 10);
    }
}

/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////

void cadence()
{
 
 
   cad = analogRead(A3);


  if(cad > 1000)
  {
      y = 1 - y; //même chose que pour la vitesse mais avec des delay plus long car l'aimant passe plus lentement devant le capteur

   
   
   if(y == 1)
   {
     temps1_cad = millis();
     delay(150);
     
 
   }
 
  if(y == 0)
    {
      temps2_cad = millis();
      delay(150);
    }
  }
  if((temps1_cad != 0) && (temps2_cad != 0))
    {
      temps_cad = (temps2_cad - temps1_cad);
      cadens = 60000 / temps_cad;
     
      if(cadens > 150) //filtre pour éliminer les valeurs incohérente...
      {
        cadens = 0;
      }
      temps1_cad = 0;
      temps2_cad = 0;

    }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////




 

Foil10
 
Messages: 7
Inscription: Jeu 7 Aoû 2014 10:37

Re: aide sur casque vision tête haute

Message non lude phil » Jeu 7 Aoû 2014 22:12

bonjour,

c'est toujours à la fin que c'est le plus dur :-)

Plusieurs question :

Quel afficheur est utilisé dans ce projet ?

Pourquoi est ce que tu as utilisé la lib wire.h (lib I2C si mes souvenir sont bons...) ?
La carte uno et la carte mega ont toutes les deux des UARTs qui permettent la communication série avec la gestion d'un buffer ce qui n'est pas possible en I2C.

Quelle shield audio est ce que tu utilises ? Peut etre qu'elle fonctionne aussi en I2C...

Pour le contage de la vitesse, il est conseillé d'utilisé les interruptions, tu as un exemple ici ==> http://playground.arduino.cc/Main/ReadingRPM

D'autre part, de combien de message différents as tu besoin entre la uno et la mega?
Avec juste 4 fils et sans protocole de communication il est possible de transmettre 16 états...
C'est un peu barbare mais ça marche très bien.
Est ce que tu as un schéma de ton montage ? est ce que tu peux également poster ton code ?

Quoi qu'il en soit, je pense que tout peut "rentrer" dans l'arduino mega, reste à optimiser tout ça :-)
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19

Re: aide sur casque vision tête haute

Message non lude EricDuino » Ven 8 Aoû 2014 10:37

Bonjour,

Je vois 2 trucs qui me choquent :shock: :

- utiliser des variables de type char pour dizaine et unité et faire des calculs dessus comme si c'était des nombres ce n'est pas cool car je pense que ça fait des calculs sur des valeurs ASCII...

- faire un délai après la lecture d'un capteur peut faire rater une lecture de l'autre capteur.

Je ne te donne pas de solution, mais je pense que (au minimum) ces 2 choses t'empêchent d'aboutir. ;)
Avatar de l’utilisateur
EricDuino
 
Messages: 225
Inscription: Sam 5 Mai 2012 10:10
Localisation: Toulouse

Re: aide sur casque vision tête haute

Message non lude phil » Ven 8 Aoû 2014 11:56

EricDuino a écrit:- utiliser des variables de type char pour dizaine et unité et faire des calculs dessus comme si c'était des nombres ce n'est pas cool car je pense que ça fait des calculs sur des valeurs ASCII...


Pour l'affichage , en effet c'est mieux de faire avec de l'ascii, mais les calcul c'est beaucoup mieux en int ou autre type de nombre :D
Y a la lib c itoa (integer to ascii) qui permet de faire ça
http://playground.arduino.cc/Code/PrintingNumbers
du coup tout les calcul sont fait sur des integer et on utilise itoa juste pour l'affichage

ensuite la fonction millis() retourne un unsigned long [0 - 4,294,967,295 ] et le résultat de millis et stocké dans un int [-32,768 - 32,767] du coup toutes les 32 et 64 secondes, il va y avoir un truc étrange :? ;)

Du coup il faut selon moi, faire tout en unsigned long et la différences par contre peut être stocké dans un int

Enfin au niveau des delay, ça peut tout de même aider pour le debouce mais je suis pas sur que ce soit vraiment nécessaire avec un capteur a effet hall
encore une fois, avec des interruptions en mode falling au rising, ça devrait bien se passer....
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19

Re: aide sur casque vision tête haute

Message non lude Foil10 » Sam 9 Aoû 2014 16:47

bonjour,
ben je voulais une façon simple de communication et j'ai trouvé cette librayrie. je ne connais pas ce que tu appel UARTs, ca utilise les broches tx et rx non ???
Pour l'affichage j'utilise un afficheur sept segment pour les unités et des leds pour les dizaines donc très simple.

A quoi sert un buffer exactement et le I2C ???

Pour le shield, c'est le Wave shield de chez adafruit : http://snootlab.com/adafruit/92-adafrui ... duino.html

Je doit envoyer quatre variables, la vitesse, la cadence, la flotte qui reste dans le bidon et les kilomètres restant. Mais je peut encoder pour envoyer un simple int sauf que qu'avec la façon "barbare" j'ai peur que les données soit reçue qu'as moitié...

En ce qui concerne les char, je ne savait pas que c'était pour les caractères et depuis vue que ça marche je l'ai laisser tel quelle :D

Pour le delay c'est parce que sinon la carte compte deux passage sur le même parce qu'elle va trop vite...
en ce qui concerne le code de Jade(oui je l'ai appeler Jade :D )
Code: Tout sélectionner

#include <FatReader.h>
#include <SdReader.h>
#include <avr/pgmspace.h>
#include "WaveUtil.h"
#include "WaveHC.h"
 
SdReader card;    // This object holds the information for the card
FatVolume vol;    // This holds the information for the partition on the card
FatReader root;   // This holds the information for the filesystem on the card
FatReader f;      // This holds the information for the file we're play
 
WaveHC wave;      // This is the only wave (audio) object, since we will only play one at a time
 
#define DEBOUNCE 100  // button debouncer
 
// this handy function will return the number of bytes currently free in RAM, great for debugging!   
int freeRam(void)
{
  extern int  __bss_end;
  extern int  *__brkval;
  int free_memory;
  if((int)__brkval == 0) {
    free_memory = ((int)&free_memory) - ((int)&__bss_end);
  }
  else {
    free_memory = ((int)&free_memory) - ((int)__brkval);
  }
  return free_memory;
}
 
void sdErrorCheck(void)
{
  if (!card.errorCode()) return;
  putstring("\n\rSD I/O error: ");
  Serial.print(card.errorCode(), HEX);
  putstring(", ");
  Serial.println(card.errorData(), HEX);
  while(1);
}

void setup() {
 
  //Wire.begin(4); // Rejoindre le bus à l'adresse #4
 // Wire.onReceive(receiveEvent);
  // set up serial port
  Serial.begin(9600);
  putstring_nl("WaveHC with 6 buttons");
 
   putstring("Free RAM: ");       // This can help with debugging, running out of RAM is bad
  Serial.println(freeRam());      // if this is under 150 bytes it may spell trouble!
 
  // Set the output pins for the DAC control. This pins are defined in the library
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
 
  // pin13 LED
  pinMode(13, OUTPUT);
 
  // enable pull-up resistors on switch pins (analog inputs)
  digitalWrite(14, HIGH);
  digitalWrite(15, HIGH);
  digitalWrite(16, HIGH);
  digitalWrite(17, HIGH);
  digitalWrite(18, HIGH);
  digitalWrite(19, HIGH);
 
  //  if (!card.init(true)) { //play with 4 MHz spi if 8MHz isn't working for you
  if (!card.init()) {         //play with 8 MHz spi (default faster!) 
    putstring_nl("Card init. failed!");  // Something went wrong, lets print out why
    sdErrorCheck();
    while(1);                            // then 'halt' - do nothing!
  }
 
  // enable optimize read - some cards may timeout. Disable if you're having problems
  card.partialBlockRead(true);
 
// Now we will look for a FAT partition!
  uint8_t part;
  for (part = 0; part < 5; part++) {     // we have up to 5 slots to look in
    if (vol.init(card, part))
      break;                             // we found one, lets bail
  }
  if (part == 5) {                       // if we ended up not finding one  :(
    putstring_nl("No valid FAT partition!");
    sdErrorCheck();      // Something went wrong, lets print out why
    while(1);                            // then 'halt' - do nothing!
  }
 
  // Lets tell the user about what we found
  putstring("Using partition ");
  Serial.print(part, DEC);
  putstring(", type is FAT");
  Serial.println(vol.fatType(),DEC);     // FAT16 or FAT32?
 
  // Try to open the root directory
  if (!root.openRoot(vol)) {
    putstring_nl("Can't open root dir!"); // Something went wrong,
    while(1);                             // then 'halt' - do nothing!
  }
 
  // Whew! We got past the tough parts.
  putstring_nl("Ready!");
}

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////

int x = 0;
boolean start = 0;
boolean effort_intense = 0;
boolean t = 1;

char bidon = Serial.read();
char cadens = Serial.read();
int vitesse = 0;
int km_restant = 0;

const int ledPin =  13;     
int ledState = LOW;           
long previousMillis = 0;
int km_a_faire = 60;

void loop()
{
   
   
   
///////////////START///////////////////////////////////////////////////////   
    if(start == 0)
      {
       playcomplete("hello.wav");
        start = 1;
      }
     
///////FONCTIONS////////////////////////////////////////////////////////   
    KmRestant();
    effort_int();   
   
 
///////////////BOIRE////////////////////////////////////////////////////     
    unsigned long currentMillis = millis();
    if(currentMillis - previousMillis > 3000)
      {
        previousMillis = currentMillis; 
        playcomplete("boire.wav");
      }
/////////////////////////////////////////////////////////////////////////     
 

   
   
     
       
     
}

/////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

byte check_switches()
{
  static byte previous[6];
  static long time[6];
  byte reading;
  byte pressed;
  byte index;
  pressed = 0;
 
  for (byte index = 0; index < 6; ++index) {
    reading = digitalRead(14 + index);
    if (reading == LOW && previous[index] == HIGH && millis() - time[index] > DEBOUNCE)
    {
      // switch pressed
      time[index] = millis();
      pressed = index + 1;
      break;
    }
    previous[index] = reading;
  }
  // return switch number (1 - 6)
  return (pressed);
}
 
 
// Plays a full file from beginning to end with no pause.
void playcomplete(char *name) {
  // call our helper to find and play this name
  playfile(name);
  while (wave.isplaying) {
  // do nothing while its playing
  }
  // now its done playing
}
 
void playfile(char *name) {
  // see if the wave object is currently doing something
  if (wave.isplaying) {// already playing something, so stop it!
    wave.stop(); // stop it
  }
  // look in the root directory and open the file
  if (!f.open(root, name)) {
    putstring("Couldn't open file "); Serial.print(name); return;
  }
  // OK read the file and turn it into a wave object
  if (!wave.create(f)) {
    putstring_nl("Not a valid WAV"); return;
  }
 
  // ok time to play! start playback
  wave.play();
}

fonction effort intense
Code: Tout sélectionner
void effort_int()
{
  if((vitesse >= 45) && (cadens >= 100))
      {
        effort_intense = 1;
        playcomplete("eff_int.wav");
      }
    x = random(0, 13);
    if((x == 0) && (effort_intense == 1))
        {
          playcomplete("MUS_1.wav");
        }
       
     if((x == 1) && (effort_intense == 1))
        {
          playcomplete("MUS_2.wav");
        }
       
      if((x == 2) && (effort_intense == 1))
        {
          playcomplete("MUS_3.wav");
        }
       
      if((x == 3) && (effort_intense == 1))
        {
          playcomplete("MUS_4.wav");
        }
       
      if((x == 4) && (effort_intense == 1))
        {
          playcomplete("MUS_5.wav");
        }
       
      if((x == 5) && (effort_intense == 1))
        {
          playcomplete("MUS_6.wav");
        }
       
      if((x == 6) && (effort_intense == 1))
        {
          playcomplete("MUS_7.wav");
        }
       
      if((x == 7) && (effort_intense == 1))
        {
          playcomplete("MUS_8.wav");
        }
       
      if((x == 8) && (effort_intense == 1))
        {
          playcomplete("MUS_9.wav");
        }
       
      if((x == 9) && (effort_intense == 1))
        {
          playcomplete("MUS_10.wav");
        }
       
      if((x == 10) && (effort_intense == 1))
        {
          playcomplete("MUS_11.wav");
        }
       
      if((x == 11) && (effort_intense == 1))
        {
          playcomplete("MUS_12.wav");
        }
       
      if((x == 12) && (effort_intense == 1))
        {
          playcomplete("MUS_13.wav");
        }
}

fonction km restant
Code: Tout sélectionner
void KmRestant()
{
  if(km_restant == 50)
    {
      playcomplete("50km.wav");
    }
   
   if(km_restant == 40)
    {
      playcomplete("40km.wav");
    }
   
    if(km_restant == 30)
    {
      playcomplete("30km.wav");
    }
   
    if(km_restant == 20)
    {
      playcomplete("20km.wav");
    }
   
    if(km_restant == 15)
    {
      playcomplete("15km.wav");
    }
   
    if(km_restant == 10)
    {
      playcomplete("10km.wav");
    }
   
    if(km_restant == 5)
    {
      playcomplete("5km.wav");
    }
   
    if(km_restant == 2.5)
    {
      playcomplete("2_5km.wav");
    }
   
    if(km_restant == 2)
    {
      playcomplete("2km.wav");
    }
   
    if(km_restant == 1.5)
    {
      playcomplete("1_5km.wav");
      playcomplete("come_on.wav");
      playcomplete("F1.wav");
    }
   
    if(km_restant == 1)
    {
      playcomplete("1km.wav");
    }
   
    if(km_restant == 0.5)
    {
      playcomplete("0_5km.wav");
    }
   
    if(km_restant == 0.2)
    {
      playcomplete("0_2km.wav");
    }
   
    if(km_restant == 0)
    {
      playcomplete("finish.wav");
      donnee();
    }
}


Merci pour l'aide, je vais essayer de bosser ça un peut plus...
Foil10
 
Messages: 7
Inscription: Jeu 7 Aoû 2014 10:37

Re: aide sur casque vision tête haute

Message non lude Foil10 » Sam 9 Aoû 2014 18:09

Je ne sais pour quel raison mais je n'arrive pas à faire fonctionner ma fonction interrupt que se soit sur la broche 2 ou 3... c'est bien les pins digital qu'il faut utiliser ???
Foil10
 
Messages: 7
Inscription: Jeu 7 Aoû 2014 10:37

Re: aide sur casque vision tête haute

Message non lude phil » Dim 10 Aoû 2014 10:37

Foil10 a écrit:ben je voulais une façon simple de communication et j'ai trouvé cette librayrie. je ne connais pas ce que tu appel UARTs, ca utilise les broches tx et rx non ???

Oui tout a fait, est on utilise ça avec des serial.begin, serial.read et serial.write


Foil10 a écrit:A quoi sert un buffer exactement et le I2C ???


IC2 est un standard de communication [url]http://arduino.cc/en/reference/wire[/url ]
Un buffer permet de stocker des caractères reçu alors que le micro-contrôleur fait autre chose.


Foil10 a écrit:Je doit envoyer quatre variables, la vitesse, la cadence, la flotte qui reste dans le bidon et les kilomètres restant. Mais je peut encoder pour envoyer un simple int sauf que qu'avec la façon "barbare" j'ai peur que les données soit reçue qu'as moitié...


OK comme tu veux, par contre, pourquoi tu utilise deux arduinos (uno et mega )?
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19

Re: aide sur casque vision tête haute

Message non lude Foil10 » Dim 10 Aoû 2014 11:21

ben quand mon uno lit un fichier audio, il ne peut pas continuer à calculer la vitesse enfin je crois...
en plus à la base je n'avais que ma uno et j'ai dut acheter ma mega pour avoir plus de broche et c'est là que je suis partie sur le fait d'utiliser les deux séparement et de les faire communiquer... je pensais pas que se serai l'une des partie les plus difficile ^^

J'ai enfin réussi à utiliser les interruption et j'ai du coup essayer d'utiliser le code des rpm mais j'ai l'impression que l'arduino a le temps de faire deux interruptions sur un même passage car j'ai des chiffres completement incohérent...
Par exemple j'ai fait un programme très simple juste pour voir ce que récupère comme information ma mega lors de l'interruption
Code: Tout sélectionner
void setup()
{
  Serial.begin(9600);
   digitalWrite(2, HIGH);

  attachInterrupt(0, x, RISING);
}
int z = 0;
void loop()
{
  Serial.println(z);
  delay(1000);
}

void x(){
  z++;
  delay(10);
}


un compte tour tout bête en apparence sauf que à chaque passage j'obtient ces résultat là:
0
0
2
2
2
5
5
...

j'ai l'impression que il fait +3 quand je tourne lentement et +2 quand je tourne rapidement...

Une idée peut être pour corriger cette erreur peut être ???
Foil10
 
Messages: 7
Inscription: Jeu 7 Aoû 2014 10:37

Re: aide sur casque vision tête haute

Message non lude phil » Lun 11 Aoû 2014 21:59

essaye avec ça pour voir :


Code: Tout sélectionner
    void setup()
    {
      Serial.begin(9600);
       digitalWrite(2, HIGH);

      attachInterrupt(0, x, RISING);
    }
    int z = 0;
    void loop()
    {
      Serial.println(z);
      delay(1000);
    }

    void x(){
detachInterrupt(0);
      z++;
      delay(10);
      attachInterrupt(0, x, RISING);

    }


detachInterrupt
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19

Re: aide sur casque vision tête haute

Message non lude Foil10 » Lun 18 Aoû 2014 11:13

toujours la même chose... je commence à me dire que j'obtenais de meilleur résultat sans l'interuption... quand j'utilise le programme des rpm même en faisant la modif avec le delay, à chaque interruption il me fait +3... en changeant le type d'interruption et en mettant un FALLING à la place d'un RISING j'obtient des +2 ce qui commence à être mieu... du coup je me dit que ca vient peut être de mon capteur, j'ai vue sur des vidéos que les mecs mettent des résistances mais je ne sais pas de combien de ohm elles sont parce que moi, même en mettant 7 resistance de 150ohms , je n'obtient aucune différence... faut-il peut être en mettre de plusieurs kilo-ohm ???
cordialement
Foil10
 
Messages: 7
Inscription: Jeu 7 Aoû 2014 10:37

Re: aide sur casque vision tête haute

Message non lude phil » Lun 18 Aoû 2014 15:31

est ce que tu peux poster un schéma ?
Est ce que tu peux rappeler la ref de ton capteur à effet hall ?

Si on regarde ça ==> http://bildr.org/2011/04/various-hall-effect-sensors/
suivant le type de capteur il faut une 750 ou une 10 k...
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19

Re: aide sur casque vision tête haute

Message non lude Foil10 » Mer 20 Aoû 2014 14:05

euh pour le schéma je ne sais pas comment faire ^^ de toute façon c'est tout simple, j'ai branché une patte du capteur au GND et l'autre sur le pin 2.
mon capteur c'est http://snootlab.com/sparkfun/315-interr ... ed-fr.html
Foil10
 
Messages: 7
Inscription: Jeu 7 Aoû 2014 10:37

Re: aide sur casque vision tête haute

Message non lude phil » Mer 20 Aoû 2014 15:08

ok !!!
C'est pas tout à fait un capteur a effet hall mais un ILS (interrupteur à lame souple).
C'est a considérer comme un interrupteur ou bouton poussoir de base. Il convient donc d'y adjoindre une résistance de pullup ou de pulldown.
En général on utilise des 10 k (mais ça va marché aussi avec des 20, 30 100k ....)
pour câbler cela ==> http://fr.wikipedia.org/wiki/R%C3%A9sistance_de_rappel#Utilisation_avec_un_interrupteur_manuel

Il y a aussi une astuce pour utiliser les pullup interne de l'arduino ==> http://arduino.cc/en/Tutorial/InputPullupSerial
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19

Re: aide sur casque vision tête haute

Message non lude EricDuino » Mer 20 Aoû 2014 15:25

Bien Phil !

va aussi falloir gerer le rebond ?
Avatar de l’utilisateur
EricDuino
 
Messages: 225
Inscription: Sam 5 Mai 2012 10:10
Localisation: Toulouse

Re: aide sur casque vision tête haute

Message non lude phil » Jeu 21 Aoû 2014 20:56

EricDuino a écrit:va aussi falloir gerer le rebond ?


Et oui :-)
Un exemple de comment faire ça en software ici http://www.instructables.com/id/Arduino-Software-debouncing-in-interrupt-function/
all your shields are belong to us...
Avatar de l’utilisateur
phil
 
Messages: 192
Inscription: Mer 7 Sep 2011 11:19


Retourner vers Vos projets, vos idées

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 1 invité