Taco Metro
Taco Metro
Taco Metro
(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.
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);
}
void loop()
{
actual = debounce(anterior);
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.
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
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 {
38 int i;
39
42 lcd.scrollDisplayRight();
43 delay (1000);
44 }
45
48 lcd.scrollDisplayLeft();
49 delay (1000);
50 }
1 /**
2 GeekFactory - "INNOVATING TOGETHER"
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
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
36
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
47 lcd.setCursor(6, 1);
48 lcd.print(volts, 1);
49
51 delay (1000);
1 byte smile[8] = {
2 0b00000000,
3 0b00001010,
4 0b00001010,
5 0b00001010,
6 0b00000000,
7 0b00010001,
8 0b00001110,
9 0b00000000,
10 };
11 */
12
13 #include <LiquidCrystal.h>
14
18
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 {
102
111
113 lcd.clear();
118
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 {
// 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 /*
4 */
10 int valorPulsador = 0;
11
12 void setup() {
14 pinMode(pulsadorPin, INPUT);
15 pinMode(ledPin, OUTPUT);
16 }
17
18 void loop() {
20 valorPulsador = digitalRead(pulsadorPin);
21
23 if (valorPulsador == HIGH) {
24 digitalWrite(ledPin, HIGH);
25 }
26 else {
27 digitalWrite(ledPin, LOW);
28 }
29 }