Las interrupciones de hardware

Es bastante fcil de escribir un programa que simplemente cuenta el

nmero de garrapatas. Pero si, por alguna razn, usted quiere que su
programa para hacer otra cosa que realizar un seguimiento de los
codificadores necesarios para utilizar las interrupciones de hardware.
Con el hardware interrumpe su programa principal se ejecuta hasta que
el estado de uno de los pernos cambios de interrupcin de la Arduino. A
continuacin, se detiene el programa principal, se ejecuta un mtodo de
interrupcin especial, entonces el programa principal se reanuda. Por
ejemplo, una rutina de evasin de obstculos puede ejecutarse en
segundo plano, pero si uno de los pines de interrupcin cambia de baja a
alta velocidad o la posicin del motor puede ser actualizado en el
mtodo de interrupcin.
Debido a que el programa principal se detiene cuando se activa el
mtodo de interrupcin, la longitud del mtodo de interrupcin debe ser
lo ms corto posible. Si el mtodo de interrupcin es demasiado largo,
entonces el Arduino se pasan todo su tiempo de funcionamiento del
mtodo de interrupcin y que en realidad nunca se ejecute el programa
principal.
Para ms detalles sobre el hardware interrumpe echa un vistazo a
esta pgina en el patio de Arduino.

ejemplo Esbozo
El siguiente esquema simplemente imprime los valores de las dos
variables de recuento.Cuando los motores se mueven, la salida del
codificador desencadena el mtodo de evento codificador adecuado. El
codificador mtodos de evento para aumentar o reducir las variables de
recuento, no perder de vista el nmero de garrapatas de cada
codificador. Si el motor se gira hacia adelante, el recuento se incrementa
y se decrementa si el motor se gira hacia atrs.
Los motores necesitan ser movidos manualmente para este boceto. No
se movern a s mismos. Vamos a ampliar esto a hacer un simple control
de velocidad del motor en un tutorial posterior.
Vamos a definir la direccin del motor de manera algo arbitraria: Si
RH_ENCODER_A es alto y RH_ENCODER_B es bajo, el motor est girando
hacia adelante. Si RH_ENCODER_A es alto y RH_ENCODER_B tambin es
alta, entonces el motor est girando hacia atrs. Puede intercambiar los
cables para ENCODER_A y ENCODER_B para cambiar la direccin si es
necesario.

1
2
3
4
5
6
7

/*
* Encoder example sketch
* by Andrew Kramer
* 1/1/2016
*
* Records encoder ticks for each wheel
* and prints the number of ticks for

8
9
1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1

* each encoder every 500ms

*
*/
// pins for the encoder inputs
#define RH_ENCODER_A 3
#define RH_ENCODER_B 5
#define LH_ENCODER_A 2
#define LH_ENCODER_B 4
// variables para almacenar el nmero de impulsos del encoder
volatile unsigned long leftCount = 0;
volatile unsigned long rightCount = 0;
void setup() {
pinMode(LH_ENCODER_A, INPUT);
pinMode(LH_ENCODER_B, INPUT);
pinMode(RH_ENCODER_A, INPUT);
pinMode(RH_ENCODER_B, INPUT);
// inicializar las interrupciones de hardware
attachInterrupt(0, leftEncoderEvent, CHANGE);
attachInterrupt(1, rightEncoderEvent, CHANGE);
Serial.begin(9600);
}
void loop() {
Serial.print("Right Count: ");
Serial.println(rightCount);
Serial.print("Left Count: ");
Serial.println(leftCount);
Serial.println();
delay(500);
}
// evento codificador para la llamada de interrupcin
void leftEncoderEvent() {
if (digitalRead(LH_ENCODER_A) == HIGH) {
if (digitalRead(LH_ENCODER_B) == LOW) {
leftCount++;
} else {
leftCount--;
}
} else {
if (digitalRead(LH_ENCODER_B) == LOW) {
leftCount--;
} else {
leftCount++;
}
}
}
// evento codificador para la llamada de interrupcin
void rightEncoderEvent() {
if (digitalRead(RH_ENCODER_A) == HIGH) {
if (digitalRead(RH_ENCODER_B) == LOW) {
rightCount++;
} else {
rightCount--;
}
} else {
if (digitalRead(RH_ENCODER_B) == LOW) {

4
rightCount--;
2
} else {
4
rightCount++;
3
}
4 }
4 }
4
5
4
6
4
7
4
8
4
9
5
0
5
1
5
2
5
3
5
4
5
5
5
6
5
7
5
8
5
9
6
0
6
1
6
2
6
3
6
4
6
5
6
6
6
7
6
8
6
9
7
0
7
1
7
2
7
3
7
4

7
5
7
6
7
7

Eso es todo por hoy. En mi prximo post voy a tomar lo que hemos
aprendido sobre el uso de codificadores con interrupciones de hardware
e incorporar eso en una sencilla rutina de control de velocidad. Despus
de que podemos bucear en el control PID de verdad!