hum... je suppose qu'il s agit ici encore d un truc très simple... et que je fais le tour des grands classiques du newbie ;D
mon souci est le suivant:
j ai des potentiomètres de 10kohms.
je fais un envoi de leur valeur depuis arduino vers le pc quand il y a un changement de valeur, en comparant la valeur précédemment envoyée et la valeur actuelle.
hors, celle ci fluctue tout le temps, saturant l envoi vers le port série sur usb.
j ai bien vu l exemple ici présent: http://www.arduino.cc/en/Tutorial/Smoothing
seulement il consomme beaucoup de ressources dès que généralisé à plus d'un analogue.
j ai un peu plus de stabilité en divisant les valeurs par 8 ( échelle 0-127), mais j aurais préféré rester sur une base 0-255 au minimum ( /4), à défaut de bénéficier du 0-1023 :(.
Y a t il un moyen de nettoyer ou filtrer ou atténuer électroniquement la sortie des valeurs des ces potentiomètres ?
bref, d'arrondir et lisser leur réponse électrique ?
Certaines positions sur les potentiomètres fluctuent tout le temps ( pb de contact ou de qualité ?)
oh grand gozaki, tout celà est très ésotérique: je suis une bille total en électronique ... un petit schéma ou un tuto quelque part ? un lien ? ;D
j ai bien rajouté des variables pour rafraichir l envoi uniquement au bout de X millisecondes, mais c est pas très glop. du coup oui, une solution électronique simple qui permette de garder la plage de valeurs en 0-1024 serait hachement bien
Slt,
le plus simple serait peut-être de mettre en place un paramètre x=10 par ex.
Si ta nouvelle valeur est supérieure à [ancienne valeur] +x ou inférieure à [ancienne valeur] - x alors tu la prends en compte et tu mets à jour [ancienne valeur],
sinon tu ne fais rien.
oui je suis d accord que ce n est pas tres normal.
sous d autres softs ces fluctuations arrivent mais c est généralement des problèmes quand on fait du tracking sur une image vidéo.
où les pixels fluctuent beaucoup.
mais avec un potentiometre !
voilà le code sous arduino.
Actuellement je demande la lecture de l entrée analo 0 uniquement.
Sa variation est de +1 à +2 parfois.
j ai retiré du code la partie hand-shaking avec le byte d ammorcage d une réponse. dans le moniteur le potentiomètre varie tout le temps.
coté montage c est vraiment ce qu il y a de plus simple: Le Gnd à la patte basse du potentiometre, le 5v à la patte haute et l analogue pour la lecture à la patte du milieu.
//definitions
const int BAUDRATE=9600;
const int NBR_ANALOG=6;
const int NBR_DIGITAL=13;//(les deux premieres pins associées au tx rx en serie)
//communication
int inByte=0;
//création d'un tableau de définition pour les I/O
bool digital_is_output[NBR_DIGITAL];
bool allow_analog_read[NBR_ANALOG];
//tableaux de stockage des valeurs reçues en input
int buffer_analog[NBR_ANALOG];
int old_buffer_analog[NBR_ANALOG];
bool buffer_digital[NBR_DIGITAL];
bool old_buffer_digital[NBR_DIGITAL];
/////////////////////////////////////////////////////////////////
void aquire_arduino()
{
//digitales///////////////////
for(int i=2;i<NBR_DIGITAL;i++)//on zappe les états de TX RX en pins 0 et 1
{
//si le digital est une entrée et pas les leds tx rx on lit et on stocke
if(digital_is_output[i]==0 )
{
old_buffer_digital[i]=buffer_digital[i];
buffer_digital[i]= digitalRead(i);
if(old_buffer_digital[i]!=buffer_digital[i])
{
Serial.print("DIG/");
Serial.print(i);
Serial.print("=");
Serial.print(buffer_digital[i]);
Serial.println("/");
}
}
}
//analogues////////////////////
for(int i=0;i<NBR_ANALOG;i++)//on zappe les états de TX RX en pins 0 et 1
{
if(allow_analog_read[i]==1)//si on autorise la lecture de cet analog
{
old_buffer_analog[i]=buffer_analog[i];
int temp_val=analogRead(i);
buffer_analog[i]= temp_val;
if(old_buffer_analog[i]!=buffer_analog[i])
{
Serial.print("ANG/");
Serial.print(i);
Serial.print("=");
Serial.print(buffer_analog[i]);
Serial.println("/");
}
}
}
}
/////////////////////////////////////////////////////////////////
void setup()
{
Serial.begin(BAUDRATE);
//votre définition des pins à mettre en OUTPUT
digital_is_output[9]=1;
digital_is_output[10]=1;
digital_is_output[11]=1;
//autorisation de lecture des analogues
allow_analog_read[0]=1;
//INITIALISATION DES ON/OFF
for(int i=2; i<NBR_DIGITAL; i++)//on zappe les états de TX RX en pins 0 et 1
{
if(digital_is_output[i]==1){pinMode(i,OUTPUT);}
else {pinMode(i,INPUT);}
}
}
/////////////////////////////////////////////////////////////////
void loop()
{
/* if (Serial.available() > 0)
{
inByte=Serial.read();
if(inByte==147)//valeur ordre depuis white cat
{*/
aquire_arduino();
// }
//}
}
je voulais dire : une resistance entre ton potentiometre et ton entrée analogique et un condensateur entre l'entrée analogique et la masse.
La résistance et le condensateur forment un filtre passe-bas qui couperont les hautes fréquences. Plus la valeur du condensateurs et/ou de la résistances est élevée plus tu atténues les fréquences supérieures à la fréquence de coupure. La fréquence de coupure vaut 1/(2PIR*C).
généralement on prend un condensateur de type céramique
merci gozaki de ces precisions.
generalement, on met quelle "puissance" de condensateur avec des potentiomètres en 10Kohms ?
sinon, la technique du >old_value+1 <old_value-1 fonctionne tres bien. plus de surcharge d envois sur le port serie!
j ai une question de TRES TRES newbie:
je viens de voir que arduino toournait à deux cadences ( 8 ou 16Mhz), fonction de l alim et sur batterie ou pas.
Si une config marche en 16, faut il diviser par deux la vitesse des Bauds pour avoir des reactions identiques en 8 ? ou bien ne s agit il que d une question de rapidité d execution de la boucle principale ?
coté montage c est vraiment ce qu il y a de plus simple: Le Gnd à la patte basse du potentiometre, le 5v à la patte haute et l analogue pour la lecture à la patte du milieu.
salut,
Je me trompe ou c'est une super facon de mettre l'alim en court-circuit quand le potar est en butée d'un coté???
Pour pinailler un peu : je commencerais plus bas avec un R série de 100k dans l'entrée analogique et 100nF... si c'est vraiment le 50 Hz qui met le bronx faudra monter en capa... Attention, quand même, car on introduit du déphasage... si la mesure intervient dans une boucle de régulation, on peut creer de l'instabilité...
je commencerais plus bas avec un R série de 100k dans l'entrée analogique
Attention une résistance trop élevée à une influence négative sur le temps de réponse de l'ADC. La tension à l'entrée de l'ADC n'a pas le temps de se stabiliser et la mesure est imprécise.
Préférer une valeur de résistance dans les 10K max et augmenter le condensateur si nécessaire.
Faire attention aussi au bruit capté par les connexions. Il ne faut pas perdre de vue que le LSB du convertisseur n'est que de 5mV.
hum grosso modo, quel set de differents condos faudrait il avoir pour ajuster celà correctement ( j ai rien sous la main, donc il faut que je commande, autant avoir tout en 1 fois) ?
deuxieme question: quelle est la distance max par rapport à la carte des capteurs analogues et digitaux pour avoir le signal ok ( 2 m / 5m / 10 m ?) ?
En fait si tu as l'intention de bricoler régulièrement le mieux c'est d'acheter un sachet (ou une boite) avec un assortiment de valeurs. C'est vrai aussi bien pour les condensateurs que pour les résistances. Il n'y a rien de plus agaçant que d'être arrêté plusieurs jours pour une valeur manquante.
Pour la longueur cela dépend beaucoup de l'environnement. C'est difficile de faire des prédictions.
Ce que l'on peut dire.
Si la source du signal (dans ton cas le potentiomètre) présente une résistance élevée elle sera plus facilement perturbée.
Si la liaison est longue elle sera plus facilement perturbée
Précautions à prendre
Utiliser une source de faible résistance interne. Par exemple si tu dois absolument placer ton potentiomètre loin de l'arduino préférer un potentiomètre de 1K plutôt qu'un de 10K.
Protéger la connexion en utilisant un fil blindé pour faire passer l'information.
Placer un filtrage sur l'entrée de l'arduino pour filtrer les perturbations.