Taco Metro

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 25

CONTADOR DE PULSOS DE ENCODER CON ARDUINO

(Recomiendo conocer primero el funcionamiento de los encoders, pueden ver este link y/o buscar por
otras fuentes)

Los encoders tienen como principio generan señales digitales en respuesta al movimiento, sea de
un disco o cinta perforada.

Éstos se utilizan, en su mayoría de las aplicaciones, para el control de posición y/o velocidad de un
motor. Considerando básicamente el número de pulsos leído y la cantidad de ranuras que existen en
un disco o cinta para controlar una posición específica o una velocidad.

Sin embargo, este post se centrará en realizar el conteo de pulsos que genera un encoder. Para ello se
necesitará el sensor optoacoplador y el disco o cinta ranurada, resistencias que se especifican en el
circuito más adelante y la placa Arduino.

Recomendación: Si se desea fabricar uno disco recomiendo utilizar programas (como OPTICAL
ENCODER ó CODEWHEEL GENERATOR) que puedan diseñar éstos e imprimirlos en cartulinas,
tres o cuatro y pegarlas; ó pegar una hoja de cartulina impresa en un cartón. Pero no utilizar plástico
a no ser que se pegue una cartulina impresa a cada lado.

Bueno, el sensor optoacoplador generará pulsos de acuerdo a cuantas franjas blancas o transparentes
detectó. Estos pulsos serán contados por Arduino.

Como se sabe la sensibilidad de los sensores, es posible que en algunos casos no esté claro un pulso y
exista errores pequeños que con el tiempo se van haciendo muy notorios y eso afecta el objetivo
final. Razón suficiente para añadir un circuito extra ó un programa específico. En este caso expongo
el primero, añadiendo un disparador Schmitt (74LS14) previniendo dicho ruido.

Efecto del uso del schmitt trigger


(B) en vez de un comparador (A)

Como se conoce los pulsos tienen únicamente dos respuestas ALTO(1) y BAJO(0), que da lugar a
conectar a una entrada digital del Arduino, como se observa en la imagen.
Toma en cuenta el esquema del CI 74LS14. Para este caso únicamente se utiliza 4 pines de conexión,
puedes considerar cualquier par que te sea más cómodo (Ix y Qx) y los de alimentación (VCC y
GND).
Considerando al optoacoplador:

La configuración de estos sensores puede ser también de la siguiente manera (considerando que su
estructura interna es la misma).
El programa es de la siguiente manera:
boolean anterior = 0;
boolean actual = 0;
int contador = 0;

void setup()
{
Serial.begin(9600);
pinMode(2,INPUT);
}

boolean debounce(boolean dato_anterior)


{

boolean dato_actual = digitalRead(2);


if (dato_anterior != dato_actual)
{
delay(10);
dato_actual = digitalRead(2);
}
return dato_actual;
}

void loop()
{

actual = debounce(anterior);

if ( anterior == 0 && actual == 1)


{
contador++;

delay (100);
Serial.println(contador);
}

anterior = actual;
}

De esta manera acoplando un disco o cinta, como se mencionó anteriormente, ó sólo para hacer la
prueba podrían interrumpir con una cartulina o cartón interponiéndolo en el optoacoplador para
observar el conteo de pulsos generado.
Considere contar también con un módulo para Arduino que compone de este sensor y todo el circuito
adicional acondicionado. Éste tiene salidas digitales y analógicos, los digitales ayudarán a ejecutar la
tarea de contar los pulsos como se presentó en este post. Mientras los analógicos ayudarán a usar a
este sensor como retroalimentación en un lazo cerrado y así aplicar PID por ejemplo.
Pantalla alfanumérica LCD 16X2 con Arduino
by Admin | Oct 12, 2017 | Tutoriales Arduino | 7 comments
En este tutorial enseñaremos a utilizar la pantalla LCD 16X2 con Arduino. Abordaremos lo
más básico: desde la conexión de la pantalla con el arduino, mostrar cadenas de texto, enviar la
lectura de un sensor a la pantalla y finalmente llegaremos a generar caracteres personalizados en
la pantalla para hacer aún más vistosos nuestros proyectos. Estaremos utilizando la librería
LiquidCrystal que viene integrada en la instalación del IDE de arduino y nos permite controlar
toda clase de pantallas compatibles con el controlador HD44780 ya sean de 16×2, 20×4 u
otras configuraciones de caracteres.
Como adicional a este articulo recomendamos la lectura de nuestro otro artículo, donde
explicamos como realizar la conexión de la pantalla LCD 16X2 a través de un adaptador I2C,
esto permite la comunicación con pantallas de este tipo usando solamente dos pines.

Materiales necesarios para las prácticas


Para realizar las prácticas que se mencionan a continuación requerimos los siguientes materiales:
 Arduino UNO R3
 Protoboard de 830 puntos
 Cables para conexión
 Potenciómetro de 10K
 Pantalla LCD 16×2 compatible con HD4470

¿Como utilizar una pantalla LCD 16×2 con Arduino?


Usar una pantalla LCD 16×2 con Arduino puede ser algo complicado por la cantidad de lineas de
conexión que se requieren, por lo tanto dividiremos el proceso en varias fases para facilitarlo:
 Conectar la pantalla LCD 16×2 a la alimentación de 5 volts, incluyendo la alimentación de la iluminación
led
 Colocar un potenciómetro para el ajuste de contraste
 Conectar los pines de datos a la pantalla (modo de 4 bits o modo de 8 bits)
 Conectar los pines de control RS y EN (de manera opcional el pin RW).
A continuación se muestran los diagramas de cada parte de este proceso de conexión; El primer
paso consiste en la conexión de la alimentación, hay que fijarnos en la polaridad para evitar
dañar la pantalla. En este caso utilizaremos los pines VSS(-), VDD(+), A(+) y K(-) para
brindar la alimentación.
El siguiente paso es conexión de un potenciómetro de 10K que permite el ajuste del contraste,
los extremos del potenciómetro van al positivo y negativo de la alimentación, mientras que el
cursor (centro) va al pin VO del módulo LCD.
A continuación conectamos los pines de datos D4, D5, D6, D7. Utilizaremos solamente estos 4
pines ya que operaremos la pantalla en Modo de 4 bits.
Finalmente realizamos la conexión de los pines de control RS y E. El pin RW es opcional y en
este caso no lo usamos para ahorrar un pin y mantener todo más simple.
Programación de la pantalla LCD 16×2 con Arduino
El siguiente programa es un ejemplo básico para comenzar a utilizar nuestra pantalla y probar
que las conexiones se encuentran correctas. Al cargarlo debemos ver letras en pantalla y además
una animación del texto moviéndose en la pantalla. Hemos comentado lo más posible el código
de manera que sea fácil de entender.
Si no se visualiza nada en la pantalla cuando se carga este programa, recomendamos mover
el potenciómetro del contraste y/o revisar las conexiones.
1 /**

2 GeekFactory - "INNOVATING TOGETHER"

3 Distribucion de materiales para el desarrollo e innovacion tecnologica

4 www.geekfactory.mx

6 EJEMPLO BASICO PARA EL USO DEL LCD 16X2 CON ARDUINO. MUESTRA UN TEXTO QUE
RECORRE
7
LA PANTALLA DE UN LADO A OTRO. ESTE PROGRAMA SIRVE COMO PRUEBA DEL CORRECTO
8
FUNCIONAMIENTO DE NUESTRO CONEXIONADO Y TAMBIEN ILUSTRA COMO REALIZAR
9 OPERACIONES
10 CON EL CURSOR, BORRAR LA PANTALLA Y MOSTRAR CADENAS DE TEXTO.
11 */
12 #include <LiquidCrystal.h>
13

14 // CONSTRUCTOR PARA LA PANTALLA LCD 16X2


15 // AQUI SE CONFIGURAN LOS PINES PARA LA COMUNICACION CON LA PANTALLA
16 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
17

18 void setup()
19 {
20 // INDICAMOS QUE TENEMOS CONECTADA UNA PANTALLA DE 16X2
21 lcd.begin(16, 2);
22 // MOVER EL CURSOR A LA PRIMERA POSICION DE LA PANTALLA (0, 0)
23 lcd.home();
24 // IMPRIMIR "Hola Mundo" EN LA PRIMERA LINEA
25 lcd.print("Hola Mundo");
26 // MOVER EL CURSOR A LA SEGUNDA LINEA (1) PRIMERA COLUMNA (0)
27 lcd.setCursor ( 0, 1 );
28 // IMPRIMIR OTRA CADENA EN ESTA POSICION
29 lcd.print("GEEKFACTORY");
30 // ESPERAR UN SEGUNDO
31 delay(1000);
32 }
33

34 void loop()

35 {

36 // EN EL CICLO PRINCIPAL SOLAMENTE RECORREMOS EL MENSAJE DE UN LADO A OTRO

37 // VARIABLE PARA CONTROL DE CICLOS

38 int i;

39

40 // DESPLAZAR LA PANTALLA A LA DERECHA 2 VECES

41 for ( int i = 0; i < 5; i++ ) {

42 lcd.scrollDisplayRight();

43 delay (1000);

44 }

45

46 // DESPLAZAR LA PANTALLA A LA IZQUIERDA 2 VECES

47 for ( int i = 0; i < 5; i++ ) {

48 lcd.scrollDisplayLeft();

49 delay (1000);

50 }

Mostrar el valor de un sensor en la pantalla LCD 16X2


con Arduino
Otro de los usos comunes de la pantalla LCD de 16×2 es mostrar valores medidos por sensores.
El siguiente programa esta diseñado para ser un ejemplo de como desplegar el valor medido por
un sensor en la pantalla, en este ejemplo estaremos utilizando un potenciómetro para simular la
entrada del sensor. De nueva cuenta, hemos comentado el código para que se facilite su
comprensión:

1 /**
2 GeekFactory - "INNOVATING TOGETHER"

3 Distribucion de materiales para el desarrollo e innovacion tecnologica

4 www.geekfactory.mx

6 EJEMPLO BASICO PARA EL USO DEL LCD 16X2 CON ARDUINO. MUESTRA UN TEXTO QUE
RECORRE
7
LA PANTALLA DE UN LADO A OTRO. ESTE PROGRAMA SIRVE COMO PRUEBA DEL CORRECTO
8
FUNCIONAMIENTO DE NUESTRO CONEXIONADO Y TAMBIEN ILUSTRA COMO REALIZAR
9 OPERACIONES
10 CON EL CURSOR, BORRAR LA PANTALLA Y MOSTRAR CADENAS DE TEXTO.
11 */
12 #include <LiquidCrystal.h>
13

14 // CONSTRUCTOR PARA LA PANTALLA LCD 16X2


15 // AQUI SE CONFIGURAN LOS PINES PARA LA COMUNICACION CON LA PANTALLA
16 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
17

18 void setup()
19 {
20 // INDICAMOS QUE TENEMOS CONECTADA UNA PANTALLA DE 16X2
21 lcd.begin(16, 2);
22 // MOVER EL CURSOR A LA PRIMERA POSICION DE LA PANTALLA Y BORRAR (0, 0)
23 lcd.clear();
24 // IMPRIMIR CADENA EN LA PRIMERA POSICION
25 lcd.print(" GEEKFACTORY.MX ");
26 // ESPERAR UN SEGUNDO
27 delay(1000);
28 }
29

30 void loop()
31 {
32 // BORRAMOS TODA LA PANTALLA PARA ACTUALIZARLA CADA SEGUNDO
33 lcd.clear();
34 // IMPRIMIR UN ENCABEZADO

35 lcd.print(" POTENCIOMETRO ");

36

37 // REALIZAR LECTURA ANALOGICA EN PIN A0

38 unsigned int val = analogRead(A0);

39 // CONVERTIR ESE VALOR A VOLTAJE (ASUMIENDO QUE EL ARDUINO SE ALIMENTA A 5 VOLTS)

40 float volts = (val * 5.0) / 1024.0;

41

42 // IMPRIMIR VALORES EN LA SEGUNDA LINEA, COMENZANDO POR EL VALOR DIRECTO DEL ADC

43 lcd.setCursor(0, 1);

44 lcd.print(val);

45

46 // IMPRIMIR EL VALOR EN VOLTAJE, DESPUES DE LA LECTURA DEL ADC

47 lcd.setCursor(6, 1);

48 lcd.print(volts, 1);

49

50 // ESPERAR UN SEGUNDO ANTES DE CONTUNUAR

51 delay (1000);

Crear y enviar caracteres personalizados a la pantalla


LCD 16X2
Otro de los usos de la pantalla LCD de 16×2 con arduino es mostrar información gráfica. En este
ejemplo, mostramos como definir caracteres personalizados que pueden enviarse al
controlador de pantalla. Con esta funcionalidad del controlador HD44780 se pueden obtener
resultados bastante vistosos, como puede verse en los siguientes ejemplos que hemos encontrado
navegando por internet:
Cada carácter se define como un grupo de 8 bytes que se envían a la memoria CGRAM. Por
ejemplo, podemos crear un icono con una carita feliz de la siguiente forma:

Traducido a código en C quedaría de la siguiente forma:

1 byte smile[8] = {

2 0b00000000,

3 0b00001010,

4 0b00001010,

5 0b00001010,

6 0b00000000,

7 0b00010001,

8 0b00001110,

9 0b00000000,

10 };

A continuación mostramos el programa completo que define los caracteres personalizados y


luego los muestra en la pantalla:
1 /**
2 GeekFactory - "INNOVATING TOGETHER"
3 Distribucion de materiales para el desarrollo e innovacion tecnologica
4 www.geekfactory.mx
5

6 EN ESTE EJEMPLO MOSTRAMOS COMO DEFINIR CARACTERES PERSONALIZADOS EN UNA


7 PANTALLA LCD 16X2 CON ARDUINO. EL CODIGO MUESTRA COMO DEFINIR LOS MAPAS
8 DE BITS Y COMO INDICARLE AL CONTROLADOR DE PANTALLA QUE MUESTRE LOS
9 CARACTERES

10 PERSONALIZADOS EN POSICIONES ESPECIFICAS DE LA PANTALLA.

11 */

12

13 #include <LiquidCrystal.h>

14

15 // CONSTRUCTOR PARA LA PANTALLA LCD 16X2

16 // AQUI SE CONFIGURAN LOS PINES PARA LA COMUNICACION CON LA PANTALLA

17 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

18

19 // DEFINICION DE CARACTERES PERSONALIZADOS

20 byte smile[8] = {

21 0b00000000,

22 0b00001010,

23 0b00001010,

24 0b00001010,

25 0b00000000,

26 0b00010001,

27 0b00001110,

28 0b00000000,

29 };

30

31 byte sad[8] = {

32 0b00000000,
33 0b00001010,

34 0b00001010,

35 0b00001010,

36 0b00000000,

37 0b00001110,

38 0b00010001,

39 0b00000000,

40 };

41

42 byte body[8] = {

43 0b00001110,

44 0b00001110,

45 0b00000100,

46 0b00011111,

47 0b00000100,

48 0b00001010,

49 0b00010001,

50 0b00000000,

51 };

52

53 byte arrowr[8] = {

54 0b00001000,

55 0b00000100,

56 0b00000010,

57 0b00011111,

58 0b00000010,

59 0b00000100,

60 0b00001000,

61 0b00000000,

62 };

63

64 byte arrowu[8] = {
65 0b00000100,

66 0b00001110,

67 0b00010101,

68 0b00000100,

69 0b00000100,

70 0b00000100,

71 0b00000100,

72 0b00000000,

73 };

74

75 byte arrowd[8] = {

76 0b00000100,

77 0b00000100,

78 0b00000100,

79 0b00000100,

80 0b00010101,

81 0b00001110,

82 0b00000100,

83 0b00000000,

84 };

85

86 byte arrowl[8] = {

87 0b00000010,

88 0b00000100,

89 0b00001000,

90 0b00011111,

91 0b00001000,

92 0b00000100,

93 0b00000010,

94 0b00000000,

95 };

96
97

98 void setup()

99 {

100 // INDICAMOS QUE TENEMOS CONECTADA UNA PANTALLA DE 16X2

101 lcd.begin(16, 2);

102

103 // ENVIAR LOS MAPAS DE BITS AL CONTROLADOR DE PANTALLA

104 lcd.createChar (0, smile);

105 lcd.createChar (1, sad);

106 lcd.createChar (2, body);

107 lcd.createChar (3, arrowr);

108 lcd.createChar (4, arrowu);

109 lcd.createChar (5, arrowd);

110 lcd.createChar (6, arrowl);

111

112 // LIMPIAR LA PANTALLA Y MOVER EL CURSOR A LA PRIMERA POSICION

113 lcd.clear();

114 // IMPRIMIR TITULO EN LA PRIMERA LINEA

115 lcd.print(" GEEKFACTORY.MX ");

116 // MOVER EL CURSOR A LA SEGUNDA LINEA

117 lcd.setCursor(0, 1);

118

119 // AHORA ESCRIBIMOS (MOSTRAMOS) LOS CARACTERES A LA PANTALLA

120 lcd.write((byte)0);

121 lcd.write((byte)1);

122 lcd.write((byte)2);

123 lcd.write((byte)3);

124 lcd.write((byte)4);

125 lcd.write((byte)5);

126 lcd.write((byte)6);

127 }

128
129 void loop()

130 {

131 // NO HACEMOS NADA EN EL LOOP

Código del botón

// Práctica encender LED con botón pulsador y luego apagar LED con el
mismo
//boton pulsador
const int LED =13;
const int BOTON = 7;
int val = 0; //val se emplea para almacenar el estado del boton
int state = 0; // 0 LED apagado, mientras que 1 encendido
int old_val = 0; // almacena el antiguo valor de val
void setup(){ // definir si la variable es de entrada // o salida.
pinMode(LED,OUTPUT); // establecer que el pin digital es una señal de
salida
pinMode(BOTON,INPUT); // y BOTON como señal de entrada
}
void loop() { // loop = realice un lazo continuamente
val= digitalRead(BOTON); // lee el estado del Boton
if ((val == HIGH) && (old_val == LOW)){
state=1-state;
delay(10);
}
old_val = val; // valor del antiguo estado
if (state==1){
digitalWrite(LED, HIGH); // enciende el LED
}
else{
digitalWrite(LED,LOW); // apagar el LED
}
}
Programando pulsadores con Arduino
El código que debes cargar en la placa es el siguiente.

C++

1 /*

2 Creado: Luis del Valle (ldelvalleh@programarfacil.com)


3 https://programarfacil.com

4 */

6 // Constantes para definir los pines

7 const int pulsadorPin = 2;

8 const int ledPin = 13;

10 int valorPulsador = 0;

11

12 void setup() {

13 // Activamos los pines de entrada y salida

14 pinMode(pulsadorPin, INPUT);

15 pinMode(ledPin, OUTPUT);

16 }

17

18 void loop() {

19 // Leemos el valor del pin

20 valorPulsador = digitalRead(pulsadorPin);

21

22 // Encendemos o apagamos el pin del LED según convenga

23 if (valorPulsador == HIGH) {

24 digitalWrite(ledPin, HIGH);
25 }

26 else {

27 digitalWrite(ledPin, LOW);

28 }

29 }

También podría gustarte