Terminé Incrémenter valeur négative arduino

[usitour]

Bonjour

Possédant 2 règles acurite, sortie TTL en quadrature, je voulais faire un programme pour
les exploiter. Pour les essais, j(utilise un codeur rotatif (provient d'une VHF, je pense).

Mon programme incrémente bien les valeur positive, mais en sens inverse le signe "-" s'affiche,
mais les valeurs s'arrêtent à -1.
Dans le programme j'ai cette condition:

if(valeur < -999999 || valeur > 999999)
return;
if (valeur < 0) {
negative=true;
valeur = valeur * -1;
//print character '-' in the leftmost column
lc.setChar(0,6,'-',false);
}
else {
//print a blank in the sign column
lc.setChar(0,6,' ',false);
La ligne qui me chagrine c'est: valeur = valeur * -1;
en effet, si on multiplie une valeur négative par une autre valeur négative, le résultat devient positif,
et donc pour l'instant cela affiche 0 puis -1, puis 0, etc...
Je sèche lamentablement depuis quelques jours, étant il y a quelques années habitué aux
microcontroleur Pic et ATmel, je suis un peu dérouté par cet IDE arduino et ces 2 fonctions Setup et Loop.
Merci d'avance pour m'éclairer

Cdlt

 

[MegaHertz]

Bonjour,

Comment as tu défini valeur ?

D'ou vient ce prog ?

Les valeurs -999999 et +999999 n'ont pas de sens, en programmation tu finis souvent par des limites en puissance de 2 et si valeur est un entier 16 bits tu ne peux même pas les atteindre puisqu'il ira de -32768 à 32767.

Là tu n'as pas de logique MVC (Modèle, Vue, Contrôle), puisque pour modifier l'affichage tu décides de modifier la valeur.

A mon avis ton code est beaucoup trop compliqué, tu devrais remplacer tout ce bazard par :

lc.setChar(0,6,(valeur < 0)?'-':' ',false);
return;

et c'est tout

 

[jpbbricole]

Bonjour usitour

Possédant 2 règles acurite, sortie TTL en quadrature,

Je pense qu'il faut voire le problème à la lecture du codeur, s'il est en quadrature, tu peux, à la lecture, définir si l'incrément est négatif ou positif et après ajouter cette valeur au compteur.

Autrement pour décrémenter de 1 une variable c'est x--
Pour décrémenter de n une variable c'est x -= n

Montre l'entier du programme, surtout la partie lisant les entrées A et B de l'encodeur.

étant il y a quelques années habitué aux
microcontroleur Pic et ATmel, je suis un peu dérouté par cet IDE arduino et ces 2 fonctions Setup et Loop.

Moi c'était les PIC Microchip et je peux dire que le concept Arduino m'a bien simplifié la vie, j'étais réfractaire au C+++ et je m'y suis mis.

Cordialement
jpbbricole

 

[usitour]

Merci pour les réponses

Comment as tu défini valeur ?
Long valeur;

D'ou vient ce prog ?

un exemple fourni par la librairie
Ledcontrol pour l'utilisation de 8 digits 7 segments avec un max 7219

Les valeurs -999999 et +999999 n'ont pas de sens,

C'est la limite fixé pour les règles 999,999mm.

Là tu n'as pas de logique MVC (Modèle, Vue, Contrôle),

Houla, tu vas fort, le programme me paraissait simple.

Montre l'entier du programme,

#include <LedControl.h>

/**********************************************************
7 segments 8 digits mas 7219
Codeur rotatif et Arduino.
http://electroniqueamateur.blogspot.com/2014/08/codeur-rotatif-et-arduino.html
*********************************************************/
#include "LedControl.h"

// MAX72XX connections
int DIN = 12;
int CS = 11;
int CLK = 10;
int NO = 1; // number of MAX72XX devices connected

LedControl lc=LedControl(DIN,CLK,CS,NO);

//codeur
#define PinA 2 // 1ere sortie du codeur
#define PinB 3 // 2e sortie du codeur

volatile boolean mouvement;
volatile boolean up;

long valeur;

// routine déclanchée quand le signal A passe de haut a bas
void routineInterruption () {
if (digitalRead(PinA))
up = digitalRead(PinB);
else
up = !digitalRead(PinB);
mouvement = true;
}

void setup () {

pinMode(PinA,INPUT);
pinMode(PinB,INPUT);

// activation des pullups internes de l'Arduino, si on n'utilise pas de pullups externes.
// digitalWrite (PinA, HIGH);
// digitalWrite (PinB, HIGH);
lc.shutdown(0,false); // The MAX72XX is in power-saving mode on startup
lc.setIntensity(0,4); // set the brightness origine 8

attachInterrupt (0,routineInterruption,FALLING); // interruption sur front descendant
}

void loop () {

if (mouvement) { // on a détecté une rotation du bouton
if (up)
valeur++;
else
valeur--;
mouvement= false;

display ();
}
}

void display() {
// the first parameter is the address of the MAX72XX chip in the daisy chain
int micron = 0;
int centieme = 0;
int dixieme = 0;
int mm = 0;
int cm = 0;
int dm = 0;
boolean negative;

if(valeur < -999999 || valeur > 999999)
return;
if (valeur < 0) {
negative=true;
valeur = valeur * -1;
//print character '-' in the leftmost column
lc.setChar(0,6,'-',false);
}
else {
//print a blank in the sign column
lc.setChar(0,6,' ',false);
}

micron = (valeur % 10);
lc.setDigit(0,0,micron,false);
centieme = (valeur / 10) % 10;
lc.setDigit(0,1,centieme,false);
dixieme = (valeur / 100) % 10;
lc.setDigit(0,2,dixieme,false);
mm = (valeur / 1000) % 10;
lc.setDigit(0,3,mm,true);
cm = (valeur / 10000) % 10;
lc.setDigit(0,4,cm,false);
dm = valeur / 100000;
lc.setDigit(0,5,dm,false);
lc.setDigit(0,7,0,false);

delayMicroseconds(100);
}

ça fait de la longueur sur la page,
Cdlt

 

[Charly 57]

Bonjour
la réponse m'intéresse aussi.

 

[cr-_-]

Voici une version corrigée rapidement

2 petites choses: digitalRead est une fonction très lente, il existe des librairies plus rapides (fastio de mémoire) et même une librairie qui fait le décodage en quadrature (mais j'ai oublié son nom) en l'état actuel tu ne pourras pas faire des rotations trop rapides tu vas perdre des pas

valeur est un long et sur arduino c'est un 32 bits donc la plage de valeurs possible est de -2 147 483 648 à 2 147 483 647 donc ça passe par contre il faut que tu spécifies que 999999 est un long donc il faut écrire 999999L

Vous devez être connecté pour voir ce contenu.

 

[usitour]

Bonsoir

2 petites choses: digitalRead est une fonction très lente,

je pense que c'est une fonction plutôt réservé à l'utilisation de bouton rotatif, genre potentiomètre continu.
L'utilisation des règles sera pour une machine conventionnelle.

tu spécifies que 999999 est un long donc il faut écrire 999999L

Et oui, je l'ai lu pourtant sur le site Arduino référence, mais j'ai lu tellement que j'ai zappé, il n'y
avait pas ce soucis en language C microcontrôleur pic ou sous avr-gcc.

// il ne faut pas modifier valeur car c'est cette variable qui compte // donc on la met dans une variable locale

Là, j'avoue être un peu paumé dans la déclaration des variables sous Arduino, suivant l'endroit ou
je la déclarais, cela me donnait des erreurs de compilation.
Rien ne m'empêche de programmer directement l'atmega 328, mais je voulais découvrir cet IDE Arduino.

Je vais essayer tes modifs,.
Merci

Cdlt

.

 

[usitour]

C'est tout bon, juste une modif
micron = (valeur % 10); à remplacer par micron=(valeur_disp % 10)
J'ai appris beaucoup de choses, mais surtout que j'ai encore beaucoup à apprendre.
Plus qu'à faire un adaptateur pour la règle acurite et essayer tout ça.
Je considère ce problème comme résolu, merci.
Cdlt

 

[cr-_-]

Pour la déclaration des variables on parle de portée, en anglais scope.
Pour que ça compile il faut que les variables soient à la portée de tes méthodes. (globales pour les interruptions, ou locale comme valeur_disp que j'ai rajouté car elle n'est utilisée que par la fonction dans laquelle elle est déclarée)

l'ide arduino n'est qu'une surchouche à plein d'outils (et entre autre avr-gcc) qui se veut simplifiante (et qu'il l'est quand même pour la plupart des gens) mais derrière c'est du C (ou du C++ )
pour le L le compilateur est souvent intelligent et met ça en mémoire avec la bonne taille mais si par exemple tu fais une comparaison entre un long et un int tu peux avoir des surprises

Edit: Tant mieux si ça fonctionne et bon courage pour la suite de l'apprentissage, (ça fait plus de 15ans que je développe sur systèmes embarqués et j'en apprend encore tout les jours )

 

[usitour]

l'ide arduino n'est qu'une surchouche à plein d'outils

Les librairies, c'est bien, mais parfois on aimerait la modifier, mais comme le compilateur
garde tout ça en fichiers cachés, c'est un peu galère