Instituto Tecnológico de Piedras Negras
Ingeniería Electrónica Microcontroladores Practica #6 Control de motor de Pasos. Ing. Ewald Fritsche R. Integrantes: Pablo Cárdenas Gallegos 15430067
Jonás Emmanuel Delgadillo Berrones 15430157
Piedras Negras, Coahuila 31 de Mayo del 2018
Contenido Índice ..................................................................................................................................................
1
1.- Introducción .................................................................................................................................. 2 2.- Objetivo .........................................................................................................................................
3
3.- Marco Teórico................................................................................................................................ 4 3.1.- Arduino .......................................................................................................................................
4
3.2.- Arduino Leonardo ...................................................................................................................... 5 3.3.- Arduino Mega 2560 .................................................................................................................... 5 3.4.- Arduino Yun ................................................................................................................................ 5 3.5.- Control de motores paso a paso ................................................................................................ 6 4.- Desarrollo ...................................................................................................................................... 7 4.1.- Material y equipo utilizado ........................................................................................................ 7 4.2.- Procedimiento ............................................................................................................................ 7 4.3.- Programación en arduino .......................................................................................................... 8 4.4.- Fotografía ................................................................................................................................... 9 5.- Fuentes Bibliográficas ................................................................................................................ 12 6.- Conclusiones y observaciones .................................................................................................... 13
Página 1
1.- Introducción El Arduino básicamente es una placa con un microcontrolador programable, barata y de fácil uso. Lo primero que tenemos que tener claro es, que es un microcontrolador y en qué se diferencia con el microprocesador. Todos alguna vez hemos entrado en contacto con ambos conceptos, es decir, todos en casa tenemos un ordenador, ya sea de sobremesa, portátil … Pues bien, el núcleo de nuestros ordenadores es un microprocesador, un chip encargado de realizar operaciones complejas a partir de unas instrucciones (que llamaremos programa) y unos datos de entrada obteniendo unos datos de salida. Para procesar y almacenar estos datos necesitamos conectar el microprocesador a la memoria RAM y demás dispositivos de E/S (Entrada/Salida), que se conectan a través de la placa base. Definido de forma escueta el microprocesador, y teniendo en cuenta que habíamos dicho que el microprocesador necesita que se conecte a la memoria a través de la placa base, en el microcontrolador tenemos tanto la memoria donde almacenamos el programa, como la memoria donde se almacena los datos, en el mismo ensamblado (en el mismo chip).
Página 2
2.- Objetivo Esta práctica muestra cómo controlar un motor paso a paso usando el microcontrolador Arduino al especificar un ángulo desde el monitor serie. Ingresando un cierto ángulo, el motor enciende el monitor serie y el motor girará en ese ángulo en relación a su posición anterior.
Página 3
3.-Marco teórico 3.1.-Arduino Hace unos años apareció un proyecto libre, llamado arduino, el cual facilitaba el acceso a esta clase de dispositivos a los estudiantes, dado que es una placa basada en openhardware (su diseño es libre y es posible reproducirlo por cualquier persona). La programación de arduino no se realizaba a bajo nivel con ensamblador como muchos Microcontroladores (a partir de ahora los llamaremos PICs), sino que se realiza con un lenguaje más comprensible por la mayoría de nosotros, C/C++ (la referencia básica al lenguaje la encontramos aquí y ejemplos en esta ruta). Con estos elementos, un programador que no sabe de PICs, sería capaz de programar el arduino en poco tiempo. La placa de la versión UNO se componía de 14 pines de E/S digitales, de los cuales, tenía 2 para conexión serie. Estos pines nos sirve para la mayoría de sensores básicos, o para relees, accionadores, etc. los cuales solo tienen 2 estados, encendido o apagado (o con las constantes de arduino HIGH y LOW). También tiene 6 pines analógicos, capaces de leer hasta 1024 niveles de tensión, llamados resolución del puerto analógico. Estos sirven para leer sensores que nos devuelven rangos de tensiones diferentes dependiendo de su estado, como pueda ser, una termoresistencia, una resistencia variable, etc. Básicamente, con la estructura del arduino UNO, cualquier persona puede adentrarse en el mundo de la programación de PICs. Pero, para proyectos más grandes, se necesita mayor potencia, con lo que los chicos de arduino fueron creando placas y versiones mejoradas del arduino UNO.
Página 4
3.2.- Arduino Leonardo Es la primera evolución del arduino Mega, de hecho, tiene los mismos puertos pero el PIC es diferente, con mayor capacidad y mayor frecuencia de trabajo. Otra diferencia es el puerto USB, que a la vez de ser usado para subir el programa, el Leonardo es capaz de usar dicho USB como host, es decir, podemos usarlo de teclado, etc. Otra inclusión son los puertos SDA y SCL, utilizados para dispositivos que se comunican a través del protocolo I2C.
3.3.- Arduino Mega 2560 Para los que se les queda corto el Leonardo diseñaron el arduino Mega 2560, con muchísima más velocidad en el microcontrolador y muchos más puertos digitales (54 pines) y analógicos (16 pines). Tenemos los pines para I2C como el Leonardo (aunque cambian de posición). De este diseño nace también el Arduino Mega ADK, que es una placa modificada del Mega 2560, pero se le añade un puerto USB host. Google ha diseñado varios proyectos con esta placa y su buque insignia. Otra evolución, es el Arduino DUE, con el mismo diseño que el Mega 2560 pero con microprocesador de 32 bits. Es muchísimo más rápido que el Mega 2560.
3.4.- Arduino YUN Básicamente, esta placa tiene las mismas características de pines y procesador que el Arduino Leonardo, pero se le ha incorporado un microordenador donde reside un pequeño Unix, el cual nos permite montar servidores web muy básicos. Esta placa, se usa mayoritariamente para proyectos en los que los sensores tienen que informar a través de una red Ethernet de una forma rápida y sencilla. Existen más desarrollos que vendrán en un futuro, fusionando la potencia de las placas arduino con placas madres de ordenador. Ofreciéndonos la posibilidad de crear multitud de proyectos, con potencia y escalabilidad sin límites.
Página 5
3.5.- Control de motores paso a paso. El motor paso a paso es el convertidor electromecánico que permite la conversión de una información en forma de energía eléctrica, en una energía mecánica y una información de posición. Está constituido por un estator cuyos devanados se llaman fases y un rotor de un elevado número de polos. Su funcionamiento es síncrono y la alimentación cíclica de sus fases debe originar en cambio de configuración un giro elemental del rotor, constante, llamado paso. El control de posición de motores paso a paso se puede efectuar en lazo abierto siempre que se tomen las precauciones necesarias para no perder ningún paso. Indicaremos que utilizando técnicas de PWM para el control de la corriente, asegurando de esta manera un aprovechamiento máximo de par y con la programación adecuada de aceleración y deceleración, se puede trabajar perfectamente en lazo abierto siempre que las variaciones que el par de carga sean conocidas de antemano. Es en estas aplicaciones de carga conocida donde el motor paso a paso tiene sus posibilidades industriales. En el caso de tener que accionar cargas desconocidas, su funcionamiento en lazo cerrado sería del todo perfecto, pero el coste del transductor de realimentación generalmente no justifica esta aplicación. El ángulo de paso real para el motor es 5.625 °, sin embargo, emplea engranajes con relación de transmisión de 1:64 para reducir aún más el ángulo a 5.625 / 64 = 0.0879 ° La resolución del motor (Paso por revolución) = 360 / paso de ángulo o 360 / 0.0879 = 4096 pasos / revolución. Switching sequence for Half Stepping (1 or 2 phase ON) 1
2
3
4
5
6
7
8
IN1
ON
ON
OFF
OFF
OFF
OFF
OFF
ON
IN2
OFF
ON
ON
ON
OFF
OFF
OFF
OFF
IN3
OFF
OFF
OFF
ON
ON
ON
OFF
OFF
IN4
OFF
OFF
OFF
OFF
ON
OFF
ON
ON
Página 6
4.- Desarrollo 4.1.- Material y equipo utilizado:
Arduino o Genuino Board
Pantalla LCD (compatible con el controlador Hitachi HD44780)
conectores de pin para soldar a los pines de la pantalla LCD
Motor paso a paso (28BYJ-48)
Conductor de motor paso a paso
cables de conexión (jumpers)
tablilla Protoboard
Software
Una computadora que ejecuta el software Arduino (IDE)
4.2.- Procedimiento del Circuito:
Antes de conectar la pantalla LCD a su placa Arduino o Genuino, le sugerimos soldar una tira de cabeza de alfiler al conector de conteo de 14 (o 16) pines de la pantalla LCD.
Para conectar su pantalla LCD a su tablero, conecte los siguientes pines:
Pin LCD RS a pin digital 12
LCD Habilitar pin a pin digital 11
Pin LCD D4 a pin digital 5
Pin LCD D5 a pin digital 4
Pin LCD D6 a pin digital 3
LCD D7 pin a digital pin 2
Además, cablee un pot de 10k a + 5V y GND, con su wiper (salida) a las pantallas LCD de pin VO (pin3). Una resistencia de 220 ohm se usa para alimentar la luz de fondo de la pantalla, generalmente en los pines 15 y 16 del conector LCD
Conecte IN1 - IN4 a arduino pin 8,9,10,11 .
Página 7
4.3.- Programación en arduino. #include const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2; LiquidCrystal lcd(rs, en, d4, d5, d6, d7); //define pin numbers #define IN1 8 #define IN2 9 #define IN3 10 #define IN4 6 int ang = 0; //for the delay int mils = 1; void setup() { lcd.begin(16, 2); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT); Serial.begin(9600);
}
void loop() { // Read input from serial Monitor if available if (Serial.available()) { ang = Serial.parseInt(); Serial.println("Read " + String(ang) + " degrees"); rotate(ang); lcd.setCursor(0,0);
Página 8
lcd.print("Gira:"); lcd.print(String(ang)); lcd.print(" grados"); } }
void rotate(int angle) {
int numberOfRounds = (int) angle * 1.42222; // angle*512/360 for (int i = 0; i < numberOfRounds; i++) { //1000 digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); digitalWrite(IN3, LOW); digitalWrite(IN4, LOW); delay(mils); //1100 digitalWrite(IN1, HIGH); digitalWrite(IN2, HIGH); digitalWrite(IN3, LOW); digitalWrite(IN4, LOW); delay(mils); //0100 digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH); digitalWrite(IN3, LOW); digitalWrite(IN4, LOW); delay(mils); //0110 digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH); digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW); delay(mils); //0011 digitalWrite(IN1, LOW); digitalWrite(IN2, LOW); digitalWrite(IN3, HIGH); digitalWrite(IN4, HIGH); delay(mils); //0010 digitalWrite(IN1, LOW); digitalWrite(IN2, LOW); digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW); delay(mils); //0001 digitalWrite(IN1, LOW); digitalWrite(IN2, LOW);
Página 9
digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH); delay(mils); //1001 digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH); delay(mils); }
// Switch off all phases digitalWrite(IN1, LOW); digitalWrite(IN2, LOW); digitalWrite(IN3, LOW); digitalWrite(IN4, LOW); }
Página 10
4.4.- Fotografía.
Evidencia fotográfica del armado de la práctica.
Evidencia fotográfica del armado de la práctica.
Página 11
5.- Conclusiones y observaciones De una manera ingeniosa, se puede controlar este motor en función de los ángulos. Lo relacionamos con una máquina de estados finitos. Nos parece interesante la conversión de pasos a ángulos que se realiza en el código.
Página 12
6.- Fuente de información. •
https://blog.mazitekgh.com/2017/10/controlling-stepper-motor-using-
arduino.html
Página 13
