Bienvenidos en esta nueva clase, vamos a ver cómo calcular la velocidad angular en RPM.
Entonces para esto vamos a utilizar esta fórmula que tenemos acá, pues podemos ver aquí que tenemos
dene que es la velocidad de rotación en revoluciones por minuto o rpm.
Tenemos enem n viene a ser el número de conteo generado en un determinado tiempo t y t es el tiempo
de generación de los pulsos en segundos.
Y R vendría a ser la resolución del Incoder para la precisión cuádruple que habíamos revisado anteriormente.
Ahora vamos acá y vamos a ver cómo calcular esa velocidad angular en Arduino.
En Arduino vamos a ver que es necesario transformar ese tiempo que tenemos acá en segundos.
Este tiempo hay que cambiarlo y convertirlo acá, porque como sabemos, los microcontroladores trabajan
en microsegundos y en milisegundos.
Por eso que hacer esa conversión.
Entonces en Arduino vamos a trabajar con milisegundos, trabajando con milisegundos.
Tenemos la equivalencia en la parte de acá, que sería un segundo, es igual a 1000 milisegundos.
Por lo tanto hacemos el reemplazo y la conversión acá y ya tendríamos nuestra fórmula para poder utilizarlo
en Arduino o en cualquier otro microcontrolador.
Aquí en Arduino vamos a implementar el código que habíamos revisado para el cálculo de posición, pero
ahora vamos a tener la variable N que va a hacer las revoluciones por minuto.
Adicionalmente, también debemos ingresar ya voltaje a nuestro motor para que pueda moverse.
Entonces lo que vamos a hacer es ingresar aquí.
Una variable de tipo enterás llamada variable de control se ve en la vamos a inicializar con 0 y vamos
a la parte de acá de configuración y aquí ya va a ser la velocidad en rpm.
Velocidad en rpm.
Listo.
Ahora vamos a ver ya en la parte de cálculo, vamos a ver en la parte de acá tenemos el cálculo.
Ni lo que vamos a ser aquí es lo siguiente vamos a eliminar todo esto y vamos a ubicar aquí N. Entonces
vamos a aplicar la fórmula que teníamos acá.
Como ven es N por 60, por 1000 y dividido para T por la resolución.
Entonces vamos a aplicar esa fórmula N va a ser igual a n por sesenta por mil
y esto va a ser dividido para el tiempo.
Vamos a tener un tiempo t y esto por la resolución que en este caso era R listo.
Y ahora lo que debemos de hacer es determinar este tiempo temp.
Como saben, estamos ejecutando esta parte de código cada 100 milisegundos.
Es el tiempo de muestreo que habíamos colocado acá.
Entonces nosotros podremos ubicar en esta parte.
No podemos ubicar aquí 100 milisegundos directamente o poner la variable sample time.
Sin embargo, para una mayor precisión voy a trabajar de esta manera.
Voy a medir el tiempo usando la función milis.
Entonces voy a utilizar aquí milis.
Vamos a abrir aquí también paréntesis.
Listo, milis menos una variable que ya hemos revisado, que es la variable lástima, lástima que me
permite determinar el tiempo anterior de muestreo.
Entonces aquí lo que hago es lo siguiente y así tendría una mayor precisión en la lectura de tiempo
para aplicar a esto.
Sin embargo, acá debemos hacer un pequeño cambio.
Esto debemos trasladarlo luego, porque esto debe actualizarse luego que se ejecute esta fórmula.
Una vez que se ejecuta ahí actualizamos y también debemos encerrar o reiniciar nuestra variable n que
era el conteo.
Entonces vamos a reiniciarlo a cero.
Esto debido a que nosotros vamos a medir simplemente la cantidad de pulsos cada determinado tiempo como
lo habíamos revisado.
Entonces es por eso que debemos reiniciar cada instante que calcule las revoluciones por minuto.
Utilizar esto usualmente.
Aquí trabajan.
He visto que trabajan en un segundo.
Sin embargo, vamos a ver que en aplicaciones de robótica no se trabaja con ese tiempo de muestreo de
1000 milisegundos.
Entonces, como ven, si nosotros trabajamos ahí en un tiempo de un segundo o 1000 milisegundos, vamos
a perder diez muestras y no vamos a realizar un correcto control.
Es por eso que estamos ejecutando este código en 100 milisegundos.
Entonces, una vez aclarado esto, vamos a cambiar.
Esta función ya no es posición, ahora es de RPM.
También debemos cambiarlo acá, esto es r.p.m.
Y acá es velocidad, velocidad.
Y acá vamos a imprimir la letra M o las revoluciones por minuto.
Ahí ya tendríamos listo.
Pero lo que nos falta en esta parte es mandar una velocidad a nuestro motor.
Es por eso que debemos ubicar acá unas nuevas variables para la parte de control.
Entonces, como acá ya necesitamos nuestro driver, entonces debemos realizar la programación para el
uso de este driver.
Entonces debemos declarar los pines para este driver.
Tenemos el primer pin constant.
Este va a ser la entrada y uno va a estar en el pin número 7, el constant boy, el indos.
Esto va a estar en el pin número 8.
Estos dos pines que tenemos acá me van a permitir controlar el sentido de giro y adicionalmente tenemos
otro pin.
En este caso este pin debe tener una salida doble B.M.
Que es la que vamos a utilizar para controlar la velocidad.
En este caso utilizamos el pin número 6, que es una señal de Pepe doble B.M.
Que tiene el Arduino.
Ahora vamos a la parte de configuración, nos vamos acá y debemos declarar esos pines como salidas.
Vamos a usar ping mode y aquí vamos a ubicar in 1.
Y esto va a ser de salida out con mayúsculas.
Output.
Listo.
Y de la misma manera lo hacemos para el otro pin.
Listo, y también vamos a inicializar los.
Para que nuestro motor empiece apagado.
Esto lo hacemos con digital con minúscula digital, right, digital right.
Y a ese pin vamos ubicarlo en bajo o falso.
Listo.
De la misma manera lo hacemos acá.
Digital right?
Indos?
Falso.
Listo, entonces ahí nuestro motor va a iniciar apagado.
Ahora vamos a ver cómo aplicar la señal de control de PWM a nuestro motor y también ver cómo variar
el sentido de giro.
Entonces vamos a ver eso.
Vamos a poner en la parte de acá.
Vamos a dar un valor de control.
Recuerden que aquí vamos a variar el ciclo de trabajo de la señal P doble VEM.
Entonces esto en Arduino lo veríamos de 0 2 55.
Entonces vamos a empezar con un valor de 2 55.
Entonces aquí el motor va a girar a su máxima velocidad.
Y ahora debemos determinar si nuestro valor es positivo o vamos a indicar que gire en sentido antihorario
y si el valor es negativo, vamos a girarlo en sentido horario.
Entonces esto lo vamos a hacer mediante una función.
Entonces vamos a crear aquí una función.
Entonces IF Si la variable de control es mayor a cero, vamos a girar nuestro motor en sentido antihorario.
Vamos a crear esta función para que gire en sentido antihorario, y lo que vamos a enviar como parámetros
de aquí son los pines.
Vamos a enviar de la siguiente manera y aquí vamos a enviar todos los pines de los tres pines que necesitamos
para el control de nuestro motor y el valor de control.
Listo.
Ahora.
Caso contrario, en nuestro motor va a girar en el otro sentido.
Es decir, por ejemplo, si aquí ingresamos menos dos 55.
Va a girar en sentido horario a su velocidad máxima.
Entonces aquí ingresamos Clock Weisz listo y de igual manera enviamos esos pines, no el pin 2, el
pin 1 y el habilitador en Naval.
Ah, y también debemos enviar el valor de P doble B.M.
Pero en este caso vamos a enviar un valor absoluto debido a que este valor, como les había mencionado,
debe ser en el rango de 0 a 2 55.
Listo, entonces vamos a ver cómo crear estas funciones que tenemos acá.
Esto lo vamos a crear en la parte de abajo en donde teníamos las funciones.
Vamos a crear una función void y listo, que vamos a abrir llaves.
Listo.
Y acá vamos a ingresar ya nuestro código.
Recuerden que aquí también tenemos parámetros.
Entonces van a tener el pin 1.
Vamos a tener el pin 2.
Vamos a tener el pin analógico de salida analógico listo y la señal de doble B.M.
Listo.
Así tenemos nuestra función y acabamos de realizar la parte de inversión y control de velocidad.
Entonces, para controlar la velocidad y que en este caso mi motor gire en sentido antihorario o vamos
a hacer lo siguiente digital right?
En base a la tabla revisamos que si el pin 1 está en alto, es decir a 5 voltios y digital right, el
pin 2 está en bajo.
Va a girar en ese sentido que les acabo de mencionar y acabamos enviar mediante Analog Right.
Vamos a enviar al pin analógico análo pin el valor de P doble B.M.
Con eso controlamos la velocidad y de la misma manera vamos a tener la función para que gire en sentido
horario.
Entonces esta función la vamos a crear acá abajo y quitamos de esta parte de acá tenemos los mismos
parámetros y aquí simplemente vamos a invertir esto.
Vamos a poner que esto va a estar en bajo y esto va a estar en alto.
Y así invertimos el sentido de giro de nuestro motor.
Entonces ya tenemos listo, vamos a compilar, a ver si no tenemos ningún error.
Listo, no tenemos ningún error.
Vamos a cargar esto en Arduino y vamos a observar el resultado.
Bueno, ya he cargado el código y lo que debemos hacer es armar el siguiente circuito, como es el circuito
anterior que teníamos la parte del encoder y hemos aumentado como aquí.
Los pines para el control de velocidad lo tenemos acá y vamos a alimentar este driver con una batería
de 3 celdas.
Entonces acá ya tenemos las conexiones.
Como pueden observar, no se olviden que debemos puentear las tierras.
Como pueden ver, ahí tenemos las tierras.
Y también recuerden que esta parte de aquí también deben tomarlo en cuenta la parte de conexión física,
porque recuerden que si enviamos un valor positivo de control, debe girar en sentido antihorario y
caso contrario en sentido horario.
Si no pasa esto, vamos a tener que ya sea invertir esa conexión o cambiar acá en la parte de código.
Por eso vamos a hacer la prueba para observar el resultado.