En este tutorial aprendemos cómo hacer programación básica de Arduino a través de códigos de ejemplo y programas de muestra. Este tutorial puede ser un curso extremadamente valioso para todos los recién llegados que deseen comprender los conceptos básicos a través de un lenguaje fácil y comprensible.
Introducción
De acuerdo a wikipedia un microcontrolador es equivalente a una mini computadora construida dentro de un solo chip IC, que tiene su propio procesador central, entradas programables, memoria y periféricos de salida.
Un microcontrolador se vuelve muy útil para un usuario, ya que ofrece un procesador integrado, memoria y puertos de entrada / salida (también llamados GPIO o pines de entrada / salida de propósito general) que el usuario puede controlar según las especificaciones deseadas.
En este tutorial trabajaremos con una placa Arduino Uno para aprender y probar los programas. Para probar e integrar el ensamblaje del hardware usaremos una placa de pruebas.
Ahora movámonos rápidamente y aprendamos cómo comenzar con una programación Arduino.
1.2 Instalación del software (Windows)
Para ello, necesitará acceso a Internet, que obviamente tendría en su computadora. Vaya al siguiente enlace y descargue el software IDE:
Archivo ZIP de Windows para instalación no administrativa
Después de la descarga, encontrará el icono de configuración de Arduino en la carpeta de descarga, que se vería así:
Una vez que obtenga esto, simplemente puede hacer doble clic en él e instalar Arduino, el entorno de desarrollo integrado (IDE) en su computadora. El proceso completo se puede visualizar en el siguiente video:
https://youtu.be/x7AMn1paCeU1.4 Comenzando con nuestro primer circuito
Antes de comenzar a aprender las técnicas de programación reales, para cualquier novato sería útil comenzar con un componente básico como un LED y comprender cómo conectarlo con un Arduino.
Como sabemos, un LED es un diodo emisor de luz que tiene una polaridad y no se iluminará si no está conectado con los polos de alimentación correctos.
Otro aspecto de los LED es que estos dispositivos funcionan con baja corriente y pueden dañarse instantáneamente si no se incluye una resistencia calculada adecuadamente en serie con uno de sus pines.
Como regla general, un 1/4 de vatio de 330 ohmios es bastante ideal para cada aumento de 5 V en la entrada de suministro para limitar la corriente a un nivel seguro requerido. Por lo tanto, para 5 V puede ser de 330 ohmios, para 10 V puede ser de 680 ohmios y así sucesivamente.
Uso de la placa de pruebas para el montaje
Asegúrese de saber cómo utilizar un tablero de circuitos antes de probar el tutorial explicado en este capítulo, ya que estaríamos usando una placa para todos los experimentos aquí.
La configuración básica de la conexión LED se puede ver a continuación:
Puede ver 3 componentes básicos arriba:
- Un LED de 5 mm y 20 mA
- una resistencia de 330 ohmios y 1/4 vatios
- Un Placa Arduino
Simplemente monte el sistema según el diagrama.
Luego, conecte los 5V del USB de la computadora al Arduino. Tan pronto como haga esto, verá que el LED se ilumina.
Sé que eso es bastante básico, pero siempre es bueno empezar desde cero. Tenga la seguridad de que las cosas comenzarán a ponerse cada vez más interesantes a medida que avancemos.
1.5 Control de LED con Arduino
Ahora aprenderemos a controlar un LED con un programa Arduino.
Para escribir un programa debemos tener al menos 2 funciones en cada programa.
Una función puede entenderse como una serie de instrucciones de programación a las que se les puede asignar un nombre, como se indica a continuación:
- configuración() esto se llama o se ejecuta durante el inicio del programa.
- lazo() esto se llama o ejecuta repetidamente durante todo el período operativo del Arduino.
Por lo tanto, aunque puede que no tenga una funcionalidad práctica, técnicamente un programa Arduino legítimo más corto se puede escribir como:
Programa más simple
|_+_|
Es posible que haya notado que en muchos de los lenguajes de programación, el sistema comienza mostrando una letra simple, 'Hola, mundo' en la pantalla.
El equivalente electrónico de esta frase en la interpretación de microcontroladores es hacer parpadear un LED ENCENDIDO y APAGADO.
Este es el programa más básico que se puede escribir e implementar para indicar un correcto funcionamiento del sistema.
Intentaremos implementar y comprender el procedimiento a través del siguiente código:
Listado 1.2: led1 / led1.pde
|_+_|
Bien, ahora entendamos qué significa cada línea del código y cómo funciona para ejecutar la función:
|_+_|
Funciona como una constante que nos permite utilizarlo durante todo el curso de programación, sin necesidad de utilizar el valor real que se le asigna.
Según las reglas estándar, estas constantes se reconocen con la letra inicial a . Aunque esto no es obligatorio, hace que las cosas sean más claras y fáciles de entender cada vez que desee revisar los detalles del código.
|_+_|
Este código configura el pin específico al que está conectado nuestro LED. En otras palabras, el código le dice al Arduino que controle el aspecto de 'escritura' en este pin, en lugar de 'leerlo'.
|_+_|
Las líneas anteriores indican la ejecución real de la aplicación. El código comienza escribiendo y generando una salida ALTA en la conexión LED correspondiente, encendiendo el LED.
Aquí, el término ALTO simplemente significa obtener + 5V en el pin correspondiente del Arduino. El término complementario LOW simplemente indica un cero o 0V en el pin designado.
A continuación, llamamos void setup() cuya función es crear un retardo en milisegundos (1/1000 de segundo). Dado que se ingresa la cifra 500, el retardo implementado será de 1/2 segundo.
{
}
void loop()
{
}
Tan pronto como transcurre este 1/2 segundo, se ejecuta la siguiente línea que apaga el LED con el término LOW en el mismo pin.
La línea siguiente genera una vez más el retraso de 1/2 segundo, para permitir que el LED permanezca APAGADO durante 1/2 segundos.
Y el proceso continúa infinitamente mediante la ejecución de las líneas de código, siempre que el Arduino se mantenga encendido.
Antes de pasar al siguiente nivel, le recomiendo que programe el código anterior y compruebe si puede implementar la secuencia de LED ON / OFF correctamente o no.
Dado que el LED predeterminado en Arduino está conectado con el pin # 13, debería responder inmediatamente al programa anterior y comenzar a parpadear. Sin embargo, si encuentra que su LED externo no parpadea, entonces podría haber una falla de conexión con su LED, puede intentar invertir la polaridad de su LED y, con suerte, verlo parpadear también.
Puede jugar con el tiempo de retardo alterando la cifra '500' a algún otro valor y encontrar el LED 'escuchando' los comandos y haciendo que parpadee según los valores de retardo especificados.
Pero recuerde, si ve que el LED no parpadea con una frecuencia constante de 1 segundo, independientemente de la alteración del tiempo de retardo, eso puede indicar que el código no está funcionando debido a algún error. Porque, por defecto, el Arduino se programará con una frecuencia de parpadeo de 1 segundo. Por lo tanto, esta tasa debe variar según su código para confirmar que funciona correctamente.
1.7 Comentarios
Las líneas de códigos que entendimos anteriormente fueron escritas específicamente para el software de computadora.
Sin embargo, para asegurarse de que el usuario pueda referirse al significado de las líneas y comprenderlas, a menudo puede ser útil y sensato escribir la explicación junto a las líneas de códigos deseadas.
Estos se llaman comentarios que están escritos solo para referencia humana o de usuario, y están codificados para permitir que las computadoras lo ignoren de manera segura.
El idioma de estos comentarios está escrito con un par de formatos:
- El estilo de bloque de comentario, en el que la descripción del comentario se incluye debajo del símbolo de inicio / * y el símbolo de finalización * /
- Esto no tiene que restringirse en una línea, sino que podría extenderse a las siguientes líneas posteriores dependiendo de la longitud del comentario o la descripción, como se muestra en el siguiente ejemplo:
/ * Este es un comentario * /
/* Asi es esto */
/* Y
* esta
* como
* bien */
Para escribir una descripción rápida de una sola línea para un comentario, dos barras // símbolo al principio son suficientes. Esto le dice a la computadora que esta línea no tiene nada que ver con el código real y debe ignorarse. Por ejemplo:
// Este es un comentario que las computadoras ignorarán.
He aquí un ejemplo de referencia:
|_+_|
|_+_|
1.8 Solución de problemas
Si encuentra que su programa muestra un 'error' durante la compilación, o algún otro problema, los siguientes consejos probablemente lo ayudarán a volver a verificar su código y eliminar el obstáculo.
- El idioma de su programa distinguirá entre mayúsculas y minúsculas. Por ejemplo la expresión myVar no se puede escribir como MyVar.
- Todo tipo de espacios en blanco que pueden ser ejecutados por su teclado, finalmente se representan como un solo espacio, y es visible o entendido solo por usted, la computadora no lo tendrá en cuenta. En pocas palabras, los espacios libres de cualquier tipo no tendrán ningún efecto en los resultados del código.
- Cada bloque de código debe incluirse entre corchetes izquierda y derecha, '{' y '}'
- Los dígitos de los números no deben separarse con comas. Por ejemplo, es posible que 1000 no se escriba como 1000.
- Cada línea de código incluida entre corchetes debe terminar con un punto y coma
Creando una interesante secuencia de luces LED con Arduino
En nuestro capítulo anterior, aprendimos cómo hacer parpadear un LED ENCENDIDO / APAGADO continuamente con una tasa de retraso constante.
Ahora aprenderemos cómo se pueden ejecutar diferentes patrones de retardo en el mismo LED actualizando el código del programa.
No usaremos un LED externo, sino el LED predeterminado integrado en la placa Arduino en el pin # 13. Puede encontrar este pequeño LED SMD justo detrás del conector USB.
2.2 Comprensión de las declaraciones IF
En esta sección aprenderemos cómo las estructuras de control nos permiten ejecutar códigos individuales y, en ocasiones, incluso de forma repetitiva, según sea necesario.
La declaración si se convierte en la 1ª estructura de control. La siguiente implementación muestra cómo se usa:
|_+_|
Intentaremos comprender el código anterior paso a paso y aprender cómo se puede utilizar para otras ejecuciones similares.
Los códigos entre la 1ª y la 7ª línea son exactamente similares a nuestro programa inicial.
La primera modificación ocurre realmente en la octava línea.
|_+_|
Puede encontrar que esto es similar al código en la primera línea, salvo que falte el término const.
Esto se debe simplemente a que este código no es una constante. En cambio, esto se define como un variable , que tiene la propiedad de un valor variable en el transcurso de la programación.
En el ejemplo anterior, puede ver que a esta variable se le atribuye un valor de 1000. Recuerde, las variables que están encerradas entre corchetes deben escribirse estrictamente solo entre pares de corchetes y se denominan variables 'locales'.
Alternativamente, las variables que se supone que están fuera de las llaves, como la que estamos discutiendo ahora, se reconocen como 'globales' y podrían ejecutarse en cualquier lugar dentro del código de un programa.
Continuando, puede ver que los códigos entre la línea 9 y 11 también son similares al primer programa, sin embargo, las cosas comienzan a ponerse interesantes después de la línea 11. ¡Veamos cómo!
|_+_|
En este código vemos que el valor predeterminado de la tiempo de retardo se modifica restando 100 de él.
El significado 100 se deduce de su valor inicial de 1000, proporcionándole un nuevo valor de 900.
A través de la siguiente imagen, intentaremos comprender algunos de los operadores matemáticos utilizados en el lenguaje Arduino.
Ahora evaluemos los códigos entre la línea 13 y la 15.
|_+_|
El objetivo principal del código anterior es garantizar que el LED continúe parpadeando sin ninguna interrupción.
Debido al hecho de que se deducen 100 del original tiempo de retardo , evita que el parpadeo del LED llegue a cero y permite que el parpadeo continúe.
La siguiente imagen muestra algunos operadores de comparación que usaríamos en nuestros códigos:
En nuestro código anterior, podríamos haber probado que el código sea const int kPinLed = 13 .
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
Sin embargo, debido a que ser una figura negativa puede ser igualmente malo, no lo hicimos, y esta es una práctica recomendada.
Piense, ¿cuál podría haber sido el resultado si hubiéramos intentado deducir 300 en lugar de 100 de const int kPinLed = 13?
Así que ahora puede que se haya dado cuenta de que si el void setup() se escribe como menor o igual a cero, entonces el tiempo de retardo volvería a la cifra original 1000.
{
pinMode(kPinLed, OUTPUT)
}
|_+_|
Las últimas 4 líneas del código como se muestra arriba se vuelven responsables de encender / apagar, encender / apagar el LED continuamente.
Aquí se puede notar claramente que en lugar de usar un número de figura, hemos usado una variable para asignar el tiempo de retardo para que podamos ajustarlo como queramos durante el período operativo del código. Eso es genial, ¿verdad?
2.3 Declaraciones ELSE
Aquí aprenderemos por qué y cómo si el término puede tener una cláusula demás para que decida la situación en caso de si declaración es falsa.
Lo siento si eso suena demasiado confuso, no se preocupe, intentaremos entenderlo con el siguiente ejemplo:
|_+_|
En lo anterior, puede ver que en la décima línea el código solo se ejecuta cuando void loop() es menor o igual a 100, si no es así, se ejecuta el código de la línea 13, pero ambos juntos nunca pueden suceder, se implementará el código de la línea 10 o la línea 13, nunca ambos.
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
Es posible que haya notado que, a diferencia de lo que hicimos en nuestra sección 2.2 anterior, aquí no comparamos con 0, sino que comparamos con 100. Esto se debe a que en este ejemplo comparado ANTES restamos 100, por el contrario en la sección 2.2, comparamos DESPUÉS de restado. ¿Puedes decir qué podría haber pasado si hubiéramos comparado 0 en lugar de 100?
2.4 declaraciones WHILE
A mientras declaración es bastante similar a si declaración, excepto el hecho de que provoca la ejecución repetida de un bloque de código (que puede estar entre corchetes) durante el tiempo que las condiciones son aplicables, y esto funciona sin un demás declaración.
El siguiente ejemplo le ayudará a comprender esto mejor
|_+_|
¿Puedes adivinar para qué está programado el código anterior? Bueno, está diseñado para hacer parpadear el LED más rápido y luego más lento.
2.5 ¿Qué es verdadero y falso?
En lenguaje de programación, falso se refiere a cero (0). En realidad, no se usa 'verdadero', sino que se asume que cuando nada es falso, entonces todo lo que se incluye es verdadero.
Parece un poco extraño, sin embargo, hace el trabajo bastante bien.
Intentaremos comprender la situación a través del siguiente ejemplo.
A veces puede encontrar un código como se indica a continuación:
|_+_|
Esto está codificado, parece que la ejecución del LED seguirá funcionando para siempre, siempre que haya energía disponible.
Sin embargo, una desventaja de este tipo de código podría surgir cuando accidentalmente el usuario aplica un = en lugar de ==.
Estoy seguro de que ya sabe que = significa una asignación, lo que significa que se usa para designar un valor seleccionado para una variable, mientras que a == se usa para hacer cumplir una prueba si el valor era el mismo.
Por ejemplo, suponga que necesita que un LED parpadee con un patrón de velocidad secuencial y repetitivamente, pero usó incorrectamente un = en lugar de ==.
El código entonces aparecería así:
|_+_|
El error asignará 0 a delay() y conducirá al si declaración para comprobar si 0 era verdadero o no. Dado que 0 se refiere a falso, pensará que no es cierto y detendrá la aplicación de /* , sino la función
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*//* Pin Definitions */ se mantiene en 0 durante el transcurso del bucle ().
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
¡¡Esto parece muy indeseable !!
Por lo tanto, siempre revise su programa para asegurarse de que no ha cometido ningún error tan tonto.
2.6 Combinaciones
A veces, puede sentir la necesidad de probar varias cosas juntas. Por ejemplo, es posible que desee examinar si una variable estaba entre dos números. Si bien esto se puede implementar usando la instrucción if varias veces, puede ser más conveniente usar combinaciones lógicas para una lectura mejor y más fácil.
La implementación de combinaciones en términos lógicos se puede realizar con 3 métodos, como se muestra en la siguiente tabla:
Sería interesante saber que el operador NOT puede funcionar como un conmutador para una variable que se puede designar como cierto o falso (o BAJO o ALTO).
El siguiente ejemplo ilustra la condición:
|_+_|
Aquí el const int kPinLed = 13 será BAJA y, posteriormente, tan pronto como
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}int delayTime = 1000, se pondrá ALTA. El siguiente bucle provocará delayTime = delayTime - 100 ser ALTO cuando if(delayTime <= 0){ // If the delay time is zero or less, reset it. es bajo.
delayTime = 1000
}
2.7 declaraciones FOR
Ahora intentaremos comprender otra estructura de control que es una por lazo. Esto puede resultar muy útil cuando desee implementar algo varias veces.
Entendamos esto con el siguiente ejemplo:
|_+_|
Puedes encontrar algo único en la línea con por.
Es el codigo i ++? . Esto es útil para los programadores que son bastante vagos y quieren implementar la codificación a través de accesos directos convenientes.
El término anterior se conoce como operadores compuestos, ya que hacen el trabajo de combinar un operador de asignación con otro operador de asignación. Los más populares de estos se pueden visualizar en la siguiente tabla:
Encontrará que hay 3 subenunciados en un enunciado for. Está estructurado como se muestra a continuación:
|_+_|
La declaración # 1 ocurre justo al principio y solo una vez. La condición se prueba cada vez durante el curso del bucle. Siempre que sea cierto dentro de las llaves, se aplica la siguiente declaración n. ° 2. En caso de falso, el sistema salta al siguiente bloque de código.
Conexión de más LED
Bien, ahora veremos cómo podemos conectar más leds para obtener efectos más interesantes.
Conecte los LED y el Arduino como se muestra a continuación. El cable rojo en realidad no es necesario, pero como siempre es una buena idea tener ambos rieles de suministro incluidos en la placa de pruebas, la configuración tiene sentido.
Ahora arreglemos un programa que nos permitirá comprobar si nuestro hardware está configurado correctamente o no.
Siempre se recomienda codificar y ejecutar pequeños fragmentos de programas paso a paso para verificar si los respectivos hardwares están conectados correctamente o no.
Esto ayuda a solucionar un posible error rápidamente.
El siguiente ejemplo de código proporciona a los LED 2 a 5 un patrón específico al girarlos uno tras otro de forma cíclica.
|_+_|
Como puede notar, el código no tiene nada de malo, excepto el hecho de que parece largo y, por lo tanto, propenso a errores.
Por supuesto que hay mejores formas de escribir el código anterior, la siguiente sección lo revelará.
2.9 Introducción a las matrices
Las matrices pueden ser un grupo de variables que se pueden indexar con números de índice. El siguiente ejemplo nos ayudará a comprenderlo mejor.
|_+_|
Bien, ahora repasemos cada sección y entendamos cómo funcionan realmente.
|_+_|
El código anterior define cuántos elementos máximos se supone que tenemos en la matriz. Este código nos ayuda en las secciones siguientes a asegurarnos de que todo esté escrito dentro de una matriz y nada una vez que finalice la matriz.
|_+_|
En la siguiente línea configuramos la estructura de la matriz. Los números dentro del corchete indican el número de elementos en la matriz. Aunque la cantidad real podría haberse escrito, escribir como constantes funciona mejor. Los valores normalmente se pueden ver dentro del corchete con comas y designan los valores a la matriz.
Cuando encuentre una matriz indexada con el número 0, esto indica el primer elemento de la matriz, como se muestra en if(delayTime == 0).
De manera similar, el último elemento se mostrará como delayTime, ya que la cuenta de 0 a 3 es 4.
|_+_|
El código anterior muestra el uso de bucle para pasar por cada elemento de la matriz y para configurarlos como SALIDAS. Implementamos corchetes junto con el índice para llegar a cada uno de los elementos de la matriz.
Si se pregunta si es posible usar el pin # 2 al pin # 5 sin matrices, la respuesta es sí, es posible. Pero en este ejemplo no se hace porque no lo hicimos de esa manera. En las siguientes secciones, puede eliminar el enfoque de matriz si los pines de salida seleccionados no están en línea.
Continuando, veamos qué hace el siguiente bloque de código:
|_+_|
Aquí el código procede a través de cada uno de los LED para encenderlos secuencialmente con un intervalo o retraso de 100 milisegundos.
|_+_|
El uso del código anterior muestra cómo la aplicación de en bucle podría usarse para moverse por el bucle incluso en el orden inverso.
Comienza desde delayTime porque las matrices tienen un índice cero. No partimos de digitalWrite(kPinLed, HIGH) porque eso resultaría en cruzar el final de la matriz.
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
El código usa> = 0 para verificar que el primer elemento en el índice 0 no se pierda ni se ignore.
Capítulo 3
¿Qué es una entrada?
Entonces aprendimos a operar cosas usando Arduino. En este capítulo discutiremos cómo detectar el mundo real interconectando entradas de parámetros externos.
3.1 Uso de botones pulsadores
Todos sabemos qué es un pulsador y cómo funciona. Es una especie de interruptor o botón que conecta una señal de una etapa del circuito a otra momentáneamente mientras está en la condición presionada, y rompe la señal cuando se suelta.
3.1.1 Un botón y un LED
Conectaremos el Arduino con un botón con Arduino según los detalles mostrados arriba y aprenderemos el funcionamiento básico y la implementación de la configuración.
El pulsador indicado, que también se llama pulsador de microinterruptor, tiene 4 pines en total (2 pares en cada lado). Cuando se presiona, cada par de pines se unen internamente y permiten una conexión o conducción a través de ellos.
En este ejemplo, estamos usando solo un par de estos pines o contactos, el otro par es irrelevante y, por lo tanto, se ignora.
¡Procedamos aplicando el siguiente código y verifiquemos que funciona!
|_+_|
Puede encontrar algunas cosas que parecen inusuales aquí. Vamos a resolverlos paso a paso.
|_+_|
Lo primero que hacemos es arreglar el buttonPin como el APORTE. Bueno, eso es bastante básico, lo sé.
A continuación, asignamos ALTO hacia APORTE alfiler. Te preguntas, ¿cómo es posible escribir algo en la entrada? Seguro, esto puede ser interesante.
En realidad, la asignación de un ALTO a una entrada de Arduino activa una resistencia pull-up interna de 20k Ohmios (un BAJO en este pin lo desactiva).
Otra pregunta que puede hacer es qué es una resistencia pull-up. He cubierto una publicación completa sobre resistencias pull-up que aprendelo aquí .
OK, avanzando, ahora veamos el código del ciclo principal:
|_+_|
Cuando presiona el botón pulsador, el pin cableado se conecta a tierra, lo que genera un BAJO a ese alfiler. Y mientras está en la condición sin presionar, el mismo pasador se mantiene en ALTO o + 5V a través de la resistencia pull-up interna de 20K.
Aquí queremos que el Arduino encienda el LED cuando se presiona el botón pulsador (LOW), por lo tanto, escribimos HIGH para la salida de cada respuesta de un LOW desde el pulsador, mientras se presiona.
3.1.2 Dos botones y un LED
Bueno, puede que se pregunte que la acción mostrada anteriormente podría haberse realizado sin un Arduino también. Entiendo, sin embargo, esta es una piedra de remojo para aprender cómo se puede usar el botón pulsador con Arduno.
Hasta este punto, hemos estudiado la escritura de códigos para encender (ALTO) o APAGAR (BAJO) un LED.
Ahora veamos cómo se puede controlar el brillo del LED con un Arduino.
Se puede hacer usando dos métodos:
- Restringiendo la cantidad de corriente al LED
- Mediante el uso PWM o modulación de ancho de pulso, en la que el suministro al LED se enciende / apaga a una velocidad deseada muy rápidamente, produciendo una iluminación promedio cuya intensidad dependería del PWM.
En una placa Arduino, el soporte PWM está disponible en los pines marcados con una tilde (~), que son los pines 3, 4, 5, 9, 10 y 11) a 500Hz (500 veces por segundo). El usuario puede proporcionar cualquier valor entre 0 y 255, donde 0 se refiere a no ALTO o no + 5V, y 255 le dice a Arduino que obtenga un ALTO o + 5V todo el tiempo. Para iniciar estos comandos deberá acceder a analogWrite () con el valor deseado.
Puede asumir que PWM es x / 255 donde x es el valor deseado que desea enviar a través de const int kPinLed = 13 .
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
Configure el Arduino y otros parámetros como se muestra arriba.
|_+_|
Puede encontrar 3 líneas aquí que necesitan alguna explicación.
|_+_|
La línea: delayTime ilustra una función única dentro de Arduino conocida como restricción ().
Esta función interna comprende un código similar al siguiente:
int restricción (valor int, int min, int max)
|_+_|
Todos los códigos discutidos antes de esto comenzaron con vacío , lo que significaba no devolver nada (nulo). Considerando que el código anterior comienza con En t , que indica que devuelve un número entero. Hablaremos más en las secciones posteriores, por el momento solo recuerde que un número entero no tiene partes fraccionarias.
Correcto, esto implica el código: const int kPinLed = 13 asigna el
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}while (1){ .
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}
La siguiente línea emplea int delayTime = 1000 para ordena a Arduino que aplique PWM en el pin seleccionado con el valor deseado.
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
La siguiente línea crea un retraso de 20 milisegundos, esto es para asegurarnos de que no ajustamos el valor más rápido que 50 Hz o 50 veces por segundo. Esto se debe a que los humanos pueden ser mucho más lentos que un Arduino. Por lo tanto, si no se hace el retraso, el programa podría hacernos sentir que presionando el primer botón apaga el LED y presionando el segundo botón lo enciende (pruébelo usted mismo para confirmar).
3.2 Potenciómetros
Sigamos adelante y aprendamos a usar potenciómetros con Arduino.
Para saber cómo funciona un potenciómetro o una olla, puede leer este artículo .
Conecte los parámetros mostrados con su Arduino como se muestra arriba.
Una olla tendrá 3 terminales. La terminal del medio se conectará con ANALOG IN 0 en el Arduino. Los otros dos terminales exteriores pueden conectarse a rieles de suministro de + 5V y 0V.
Programemos y veamos los resultados:
|_+_|
Encontrará un par de cosas que pueden parecer completamente nuevas y no están incluidas en ninguno de nuestros códigos anteriores.
- La constante
delayTimese asigna como A0, donde A es el atajo para describir uno de los pines analógicos. Sin embargo, A0 también se refiere al pin # 14, A1 al pin # 15 y así sucesivamente, y estos le permiten ser utilizados como entradas / salidas digitales en caso de que se quede sin pines para un experimento. Pero recuerde que no puede usar pines digitales como pines analógicos. - La línea:
delayTime = 1000presenta una nueva función interna en Arduino conocida como mapa(). Esta característica se recalibra de un rango dado a otro, denominado como map (valor, fromLow, fromHigh, toLow, toHigh). Esto puede resultar crucial ya quedelayTimeda un valor dentro del rango de 0-1023, pero analogWrite puede aceptar un valor de 0-255.
Puede pensar que, dado que es posible controlar el brillo de un LED a través de una resistencia cambiante, simplemente una olla podría haber sido suficiente para el propósito, por qué el uso de Arduino. Bueno, nuevamente, es solo la base, para mostrar cómo se podría configurar una olla con un Arduino.
Sin problemas, ahora haremos algo que no se puede hacer sin un Arduino.
En este experimento veremos cómo se puede usar la resistencia variable de una olla para controlar la velocidad de parpadeo o la tasa de un LED.
Aquí está el programa:
|_+_|
3.2.3 Evitar retrasos ()
El código anterior se ve bien, pero el LED no puede verificar el valor de la olla hasta que pasa por cada ciclo completo. Para retrasos más largos, este proceso se alarga, el usuario debe esperar para ver la respuesta del bote mientras lo mueve. Este retraso se puede evitar con una programación inteligente, de modo que permite al usuario verificar el valor sin retrasos mínimos. Aquí está el código.
|_+_|
Entonces, ¿qué es tan diferente en el código anterior? Es la siguiente línea la que marca la diferencia.
|_+_|
Hasta esta sección, hemos discutido sobre la variable int. Sin embargo, puede haber muchos más tipos de variables a las que puede acceder. La lista se puede leer a continuación:
Actualmente, puede ser crucial saber que para almacenar números relativamente grandes para el En t variable, podría utilizar el término largo o un largo int.
Aquí puedes ver otra función interesante llamada millis ().
Esto produce el lapso de tiempo en milisegundos que Arduino trabajó en su curso de operación desde el principio (esto se restablecerá a 0 después de cada 50 días). Aqui vuelve un largo porque si volvio En t , puede que no sea posible contar durante períodos prolongados. ¿Podría responder exactamente cuánto tiempo? La respuesta es 32,767 segundos.
Por lo tanto, en lugar de usar delay (), verificamos milis (), y tan pronto como transcurra el número particular de milisegundos, cambiamos el LED. En consecuencia, almacenamos el tiempo que lo cambiamos por última vez en ultima vez variable, de modo que nos permita volver a comprobarlo cuando lo deseemos.
3.3 LED RGB
Hasta ahora hemos jugado con un LED de un solo color. Aunque el color del LED se puede cambiar reemplazando el LED con otro color, pero ¿qué tal si se usan LED RGB? para cambiar los colores del LED sin cambiar los LED?
Un LED RGB es básicamente un LED que tiene un LED rojo, verde y azul incrustado y combinado en un solo LED. Tiene un cable común que va al suelo o al riel de suministro de 0 V, mientras que los otros 3 cables se alimentan con señales positivas PWM diversificadas para implementar el mezcla de colores .
Puede cablear la configuración como se muestra a continuación:
Puede parecer un poco complejo, pero en realidad es una réplica de nuestro diseño de control LED anterior que usaba PWM.
Aquí hay un código de programa de práctica:
|_+_|
Después de cargar este código, solo vea cómo los ajustes del potenciómetro crean un efecto de luz interesante en el RGB, puede ser realmente divertido.
Verá que cuando las 3 macetas se mueven a las posiciones máximas, en lugar de un color blanco, verá rojo. Esto se debe a que el color rojo es el más prominente entre los 3 colores y, por lo tanto, domina en esta situación. Sin embargo, puedes experimentar con la función mapa() , antes de ejecutarlo en la parte roja del LED, para crear un equilibrio más sensible.
Audio con Arduino
En esta sección, aprenderemos cómo agregar sonido y música básicos a una configuración de Arduino.
Veremos cómo pasar una señal a un altavoz conectado con una frecuencia deseada.
Para ser más precisos, se probará una nota A media, que es una nota de frecuencia de 440 Hz.
Para hacer esto, simplemente tocaremos una nota A media y optimizaremos la señal de onda sinusoidal con onda cuadrada.
Además, calcularemos la cantidad de tiempo que un altavoz puede permanecer ENCENDIDO demandando la fórmula:
timeDelay = 1 segundo / 2 x toneFrequency.
timeDelay = 1 segundo / 2 x 440
timeDelay = 1136 microsegundos
4.1 Conectemos la placa Arduino
4.2 Agregar una nota simple
Ya hemos hablado de la función demora() donde la unidad está en milisegundos (segundo / 1000), sin embargo, encontrará otra función int ledState = LOW donde la unidad está en microsegundos, (milisegundos / 1000).
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}
Para la configuración actual, programamos un código para encender / apagar + 5V en el pin seleccionado vinculado con el altavoz, a una velocidad de 440 pulsos por segundo.
Recuerde, en la última discusión determinamos el valor de 1136 microsegundos para la nota de audio deseada.
Así que aquí está el programa para esto, que le permitirá escuchar una nota de audio de 440 Hz tan pronto como programe el arduino con un altavoz conectado.
|_+_|
Con la aplicación anterior es posible hacer una nota de audio, lo que también significa que podemos crear una música según nuestra propia elección.
Del código comprendemos que Arduino incluye un par de funciones integradas que, además, contribuyen a la creación de música.
El primero es tono() que trabaja con 2 elementos junto con un tercer elemento opcional, designado como tono (pin, frecuencia, duración). o tono (pin, frecuencia)
Ambos están designados para ejecutarse en función del período de tiempo asignado por usted.
En ausencia de un período de tiempo, la música continuará sonando hasta que la llamada tono() se ejecuta de nuevo, o hasta que ejecute ni uno ().
Esto deberá hacerse usando una función de retardo en caso de que la reproducción de música sea lo único fundamental que esté implementando.
La duración del tiempo puede ser crucial, ya que permite proporcionar un tiempo durante el que se reproduce la música, por lo que puede tener la libertad de hacer otras cosas. Tan pronto como transcurre la duración, la música se detiene.
La siguiente función ni uno () maneja un solo parámetro y detiene el tono seleccionado en un pin asignado en particular.
Una advertencia peculiar: en cualquier momento tono() La función está implementada, la función PWM en los pines 3 y 11 dejará de funcionar.
Por lo tanto, siempre que se utilice un accesorio de altavoz en el programa, asegúrese de no usar el pin mencionado para los altavoces, en su lugar pruebe con otros pines para el accesorio de altavoz.
Bien, aquí está el programa para implementar música en un altavoz, aunque no es una música real, sino una nota C de escala básica.
|_+_|
En el código anterior, es posible que haya notado algo nuevo y eso es #define .
Este término funciona como un comando de búsqueda y reemplazo para la computadora mientras se realiza la compilación.
Siempre que encuentra lo primero antes de un espacio, lo reemplaza con la parte restante de la línea (llamada macros).
Entonces, en este ejemplo, cuando la computadora ve NOTE_E4 lo reemplaza rápidamente con la cantidad 330.
Para obtener más notas y personalización, puede consultar un archivo en su memoria USB llamado parcelas.h , donde se pueden encontrar la mayoría de las frecuencias según sus preferencias.
4.4 Música con funciones
El código anterior se ve bien, pero parece tener muchas repeticiones, debería haber algún método para acortar estas repeticiones, ¿verdad?
Hasta ahora hemos trabajado con dos funciones esenciales incluidas con Arduino. Ahora puede ser el momento de que creemos nuestras propias funciones.
Cada función debe comenzar con el tipo de variable con la que puede estar asociada. Por ejemplo la función vacío se refiere al tipo que no devuelve nada, de ahí el nombre void. Tenga en cuenta que ya hemos discutido una lista de variables en nuestras secciones anteriores, es posible que desee consultarlas.
En consecuencia, el nombre de la función particular obtiene un paréntesis abierto '(' seguido de una lista de parámetros separados por comas.
Cada uno de los parámetros adquiere su tipo junto con un nombre, y finalmente un cierre ')' paréntesis.
Estos parámetros se pueden aplicar dentro de la función en forma de variables.
Veamos un ejemplo a continuación donde desarrollamos una función llamada ourTone () diseñado para fusionar el tono() con demora() líneas, de forma que la función deje de regresar hasta que la nota haya terminado de reproducir el tono.
Implementamos estas funciones en nuestro código anterior y obtenemos el programa a continuación, vea las últimas líneas:
|_+_|
Las funciones pueden resultar muy útiles para facilitar la comprensión de un programa.
El siguiente es un ejemplo en el que podemos especificar la elección del tono que queremos tocar utilizando dos matrices. Una matriz para retener las notas, la otra para retener los tiempos.
|_+_|
Puede ver claramente en la primera línea la introducción de #incluir declaración. El trabajo de esta declaración es recoger todo el archivo entre las comillas y colocarlo en la posición del #incluir declaración. De acuerdo con las reglas estándar, estas se colocan estrictamente al comienzo del programa.
Capítulo 5
Medir la temperatura
Solo para recordar, recuerde que en lugar de escribir programas grandes por completo, siempre es aconsejable escribir y analizar partes pequeñas de códigos, lo que ayuda a rastrear errores rápidamente.
5.1 Monitor en serie
Hasta ahora, los códigos que discutimos no parecen tan fáciles de permitir una rápida resolución de problemas. Aquí intentaremos facilitar el seguimiento y la resolución de un posible problema.
El Arduino tiene una función que le permite 'responder' con la computadora. Puede observar que el pin0 y el pin1 están marcados como RX y TX uno al lado del otro. Estos pines en realidad son rastreados por un IC separado dentro de Arduino que los actualiza para leer a través del cable USB mientras está conectado a la PC.
La siguiente sección muestra un programa completo, por favor revíselo, aprenderemos sobre las nuevas entradas en el código a partir de entonces. Este código es el mismo que el expresado en la sección 2.2 excepto en el hecho de que incluye algunos datos adicionales que nos permiten identificar para qué está codificado.
|_+_|
Puede identificar dos cosas nuevas aquí, una nueva línea en el configuración() función.
|_+_|
Esta línea simplemente expresa la necesidad de utilizar el Serial1 código para hacer cumplir con 9600 baudios. (aquí serial se refiere a bits enviado uno tras otro, y baudios significa la velocidad a la que se envía). Este valor en baudios y el que está dentro del monitor en serie (lo aprenderemos más adelante) deben ser iguales, de lo contrario los datos en el monitor en serie mostrarán basura. 9600 siendo el estándar se vuelve más conveniente de usar.
La segunda nueva entrada es la siguiente
|_+_|
Aquí, la segunda línea sugiere que lo siguiente que sale del puerto serie comenzará en la siguiente línea. Así es como la segunda línea es diferente de la primera línea.
Una cosa más que puede ver son las comillas ('). Esto se conoce como una cadena, que se usará solo como constantes aquí, porque una discusión adicional sobre este tema puede ser demasiado elaborada y fuera de alcance.
Bien, ahora podemos cargar el código anterior en Arduino y ver qué sucede.
Vaya, parece que no ha pasado nada, el LED del pin # 13 de Arduino parpadeó y se detuvo, mientras que el LED Tx permaneció parpadeando.
Bueno, eso es porque la ventana Serial Monitor aún no está arreglada.
Debe hacer clic en el cuadro Monitor de serie en su IDE como se muestra arriba. No olvide verificar la velocidad en baudios ubicada en la parte inferior derecha, por defecto debe ser 9600 y coincidirá con el código. Si no es así, asegúrese de seleccionar 9600.
El siguiente videoclip explica cómo se hace.
https://youtu.be/ENg8CUyXm10Ahora avancemos y aprendamos cómo la función de monitor en serie anterior puede ayudar a procesar el medición de temperatura usando Arduino
Usaremos el IC TMP36 como sensor de temperatura, con un rango de -40 a 150 grados Celsius.
La configuración se puede ver a continuación:
El siguiente código iniciará la medición de temperatura leyendo la salida del sensor TMP36 y enviándolos al monitor en serie de la ID.
|_+_|
Entendamos el código desde arriba.
|_+_|
Aquí puedes ver que hemos incluido el tipo de variable flotador.
Este es el único tipo de variable que permite almacenar todo excepto números enteros (números sin partes decimales o fraccionarias).
La precisión de una variable flotante puede ser de hasta 6 a 7 dígitos.
El código adjunto ledState es nuestra propia función que calcula matemáticamente y convierte la diferencia de voltaje detectada del sensor TMP36 en grados Celsius.
|_+_|
En la siguiente sección de los códigos, ya que el término ledState = !ledState se asigna para devolver una cifra entre 1 y 1023, nos es posible evaluar el voltaje del sensor multiplicando nuestra lectura por 5 y luego dividiéndola por 1024.
El sensor TMP36 está especificado para generar 0,5 V a 0 grados Celsius y, posteriormente, genera 10 mV por cada aumento de grados Celsius.
Aquí está la aproximación que podemos generar a través de los cálculos:
Puede considerar que es su primera función que devuelve algún valor (tenga en cuenta que todas las funciones restantes hasta ahora no devolvieron ningún valor ya que han sido del tipo vacío ).
Puede comprender que para obtener un valor de una función, simplemente necesita agregar regreso seguido del número deseado que desea devolver.
Cuando decimos regreso significa que la función devuelve una respuesta o una respuesta cada vez que se la llama, que podría aplicarse a una variable.
Cuando se envía al monitor en serie, la lectura se convierte a Fahrenheit a través de convertToF().
|_+_|
Esta función toma el rango Celsius y lo convierte a Fahrenheit.
Para convertir Fahrenheit a Celsius implementamos la fórmula Fahrenheit = 9/ 5 (grados Celsius) + 32.
5.3 Interfaz de una pantalla LCD
Ahora estudiemos cómo interconectar o conectar un pantalla LCD con Arduino para obtener una visualización visual de las salidas requeridas.
En nuestra aplicación vamos a emplear una pantalla LCD gráfica de 84x48, con 84 píxeles o puntos horizontalmente y una resolución vertical de 48 píxeles. Dado que un controlador dedicado se vuelve imperativo para todos los LCD, el presente dispositivo también incorpora uno en forma de controlador PCD8544.
En este tutorial, conectaremos el módulo LCD especificado anteriormente con Arduino y aplicaremos ciertas rutinas para crear mensajes de texto en la pantalla.
En la siguiente figura puede encontrar detalles sobre la interfaz de la pantalla LCD, junto con una pequeña Regulador de voltaje de 3.3V . Este regulador es necesario ya que la pantalla LCD está especificada para funcionar con un suministro de 3.3V.
También puede ver 8 pines del módulo LCD, las especificaciones de pines se pueden estudiar en la siguiente tabla:
Ahora veamos cómo podemos conectar la pantalla LCD y los parámetros relevantes con nuestro Arduino. Los detalles se pueden visualizar en la siguiente ilustración que se muestra:
5.4 Comunicación con la pantalla LCD
Aunque es posible escribir coeds elaborados para interactuar con LCD de Arduino, aprenderemos a hacer lo mismo usando bibliotecas.
Las bibliotecas comprenden una variedad de códigos que se pueden aplicar rápidamente para un programa Arduino seleccionado.
Esto permite al usuario llamar a una función sin esfuerzo sin tener que pasar por un trabajo de codificación complejo.
5.4.1 Cómo instalar la biblioteca
Para esto tendrás que crear un directorio llamado bibliotecas en tu computadora Arduino IDE, como se explica aquí
5.4.2 Implementación de las operaciones de LCD
Al igual que en nuestro enfoque anterior, primero revisaremos todo el código y luego trataremos de comprender los detalles de las líneas individuales.
|_+_|
La línea incluye el código ledState
El código #include indica a la PC que recoja el archivo mencionado y reemplace el elemento #include con el contenido del archivo durante el transcurso de la compilación del programa.
El elemento #include puede poseer corchetes angulares que indican la búsqueda en el directorio de la biblioteca, alternativamente también puede tener comillas que indican la búsqueda dentro del mismo directorio en el que se encuentra el programa.
Las siguientes líneas de código expresan los pines de la pantalla LCD, y luego escribimos una nueva forma de variable:
|_+_|
Aquí expresamos una variable con el nombre lcd que tiene el tipo PCD8544 y le indicamos a la PC que vuelva a clasificar sus pines asociados con el Arduino.
En este proceso, describimos la variable a la PC indicando cómo el pin clk, din, dc y reset se interconectan con el Arduino.
|_+_|
La línea ledState = !ledState inicializa el funcionamiento de la pantalla LCD. Una vez que esto se ejecuta, la siguiente línea impone un cursor en la parte superior izquierda de la pantalla. Y la siguiente línea siguiente hace un esfuerzo por imprimir el mensaje 'Hola, mundo'.
Esto parece bastante idéntico a la técnica en la que enviamos mensajes a través del monitor en serie. La única diferencia es el uso del código const int kPinLed = 13 en lugar de serial.print.
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}
En realidad, el siguiente bloque de código se llama repetidamente.
|_+_|
Usando esta línea for (statement1conditionstatement2){ colocamos el cursor en la columna 0 en el extremo izquierdo de la primera fila, sobre la pantalla LCD.
// statements
}
La siguiente línea emplea un atajo: const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}
Si recuerda que hemos trabajado con const int k_numLEDs = 4 en nuestros códigos anteriores, podríamos haber aplicado lo mismo aquí también a través de los códigos:
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i
}
}
void loop()
{
for(int i = 0 i
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}
|_+_|
Sin embargo, debido al hecho de que aquí no hay períodos de tiempo en milisegundos, lo logramos simplemente enviando const int k_numLEDs = 4 función directamente a const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5 .
5.5 Combinando todo
Bien, ahora combinemos todos los códigos que aprendimos anteriormente para hacer el circuito de temperatura LCD, y veamos cómo se ve:
|_+_|
Todo parece estándar en el programa anterior, excepto el uso de la función setCursor () . Esto se emplea para alinear el texto lo más posible alrededor del centro de la pantalla.
¡Genial! Y felicidades, acaba de programar su propio pequeño indicador de temperatura LCD usando Arduino.
Aplicaciones prácticas de Arduino
Dado que, en este punto, hemos cubierto exhaustivamente las diversas técnicas de programación en detalle, es hora de analizarlas aplicándolas para algunas implementaciones prácticas útiles.
Comenzaremos con los sensores y veremos cómo se pueden usar los dispositivos de sensor con Arduino ejecutando algunos códigos de muestra.
7.1 Introducción a los sensores
En este tutorial aprenderemos sobre la amplia variedad de sensores que se pueden usar con Arduino. Estos pueden incluir dispositivos como sensor de luz LDR, sensor de efecto Hall magnético, sensores de inclinación, sensor de vibración, sensor de presión, etc.
Comenzaremos con la interfaz de sensor de luz LDR con Arduino, como se muestra en el siguiente diagrama:
Como todos sabemos, el LDR es un dispositivo de resistencia dependiente de la luz cuya resistencia depende de la intensidad del incidente ambiental en su superficie.
La intensidad de la luz es inversamente proporcional a la lectura de resistencia del LDR.
Aquí aprenderemos cómo esta propiedad se puede integrar con Arduino para ejecutar una aplicación útil:
El código completo del programa se puede visualizar como se indica a continuación:
|_+_|
Todos los parámetros utilizados en el código ya se han discutido en nuestro curso que hemos aprendido hasta ahora. Puede comprobar las líneas consultando las secciones correspondientes.
Los valores se eligieron al azar, puede cambiar fácilmente según sus propias preferencias.
Sensor de inclinación
Un sensor de inclinación es un dispositivo simple que se puede utilizar para detectar una acción de inclinación en cualquier objeto donde esté instalado. El dispositivo tiene básicamente una bola metálica en su interior, que al inclinarse rueda sobre un par de contactos provocando una conducción a través de esos contactos. Estos contactos terminados como los cables del interruptor de inclinación, se utilizan con un circuito externo para detectar la conducción debido a una acción de inclinación y activar la aplicación de salida deseada.
Ahora veamos cómo Sensor de inclinación el dispositivo podría estar conectado. La siguiente imagen nos da una idea de la configuración completa:
|_+_|
En este ejemplo, el LED del pin # 13 predeterminado se utiliza como indicador de inclinación.
Puede ver claramente la inclusión de la resistencia pull-up aquí, bastante similar a lo que hicimos en la sección 3.1. Por lo tanto, el término BAJO indica que la función de inclinación no se activa.
7.4 Relé de interruptor de láminas (relé activado por imán en miniatura)
Ahora veamos cómo conectar un interruptor de relé o un sensor de campo magnético con Arduino. Un relé de lengüeta es un tipo de interruptor que se activa o conduce cuando se acerca un campo magnético o un imán. Básicamente, tiene un par de contactos ferromagnéticos dentro de un gabinete de vidrio en miniatura que se unen o hacen contacto debido a la tracción magnética siempre que un magnético esté cerca de él. Cuando esto sucede, los terminales de los contactos muestran conducción debido al cierre de los contactos.
Aquí también usamos el LED del pin # 13 para indicar la respuesta. Puede conectar un LED externo desde este pin si es necesario según nuestras explicaciones anteriores.
|_+_|
Los términos del código deben ser familiares y autoexplicativos.
7.5 Sensor de vibración con transductor piezoeléctrico
En el siguiente programa de muestra veremos cómo transductor piezoeléctrico se puede utilizar como sensor de vibración para iluminar un LED a través de Arduino.
Un elemento piezoeléctrico en realidad es un dispositivo que genera vibración u oscilación cuando se aplica una frecuencia a través de sus terminales. Sin embargo, el mismo piezo se podría utilizar en el proceso inverso para generando pulsos eléctricos en respuesta a la vibración aplicada en su cuerpo. Esta vibración puede tener la forma de un golpe o golpe en la superficie del piezo.
Configure el Arduino y un elemento piezoeléctrico como se muestra en la siguiente figura
|_+_|
El umbral 100 se introduce solo para asegurarse de que Arduino responda solo a las vibraciones genuinas a través de golpes, y no a otras vibraciones más pequeñas, como sonidos fuertes o bocinas.
La selección del pin A5 no es obligatoria, puede seleccionar cualquier otra entrada analógica según sus preferencias y haciéndola coincidir en el código del programa.
Usando servomotor con Arduino
Un servomotor es un tipo de motor de CC que se puede girar en ángulos precisos según la demanda de una aplicación en particular. Se puede hacer aplicando un comando calculado a las entradas relevantes del motor para producir un ángulo de giro o giro preciso dentro del rango de 180 grados en el motor.
Normalmente, un servomotor tiene 3 cables o entradas. Los cables positivos son normalmente de color rojo, el cable negativo o de tierra es negro, y el cable de comando o el cable de señalización son normalmente de color blanco o amarillo.
Arduino facilita el control del servomotor a través del lenguaje de soporte integrado que hace que el control sea muy conveniente e ideal para los servomotores.
El siguiente ejemplo nos mostrará el programa de configuración básico para implementar el control del servomotor a través de Arduino:
El código se proporciona a continuación:
|_+_|
Podemos ver un par de nuevas entradas aquí. Uno que le dice al cable adjunto del servo a qué pin está asignado. El otro es el código que proporciona al pin un valor entre 0 y 180, para determinar el ángulo de rotación del servo.
Conclusión
El tema de Arduino puede ser infinitamente largo y, por lo tanto, más allá del alcance de este artículo. Sin embargo, espero que el tutorial anterior sin duda le haya ayudado a aprender los conceptos básicos de Arduino y a comprender los parámetros importantes a través de los diversos códigos de aplicación de ejemplo.
Es de esperar que se pueda actualizar más información de vez en cuando aquí, siempre que esté disponible.
Mientras tanto, disfruta de tu curso de programación, ¡Feliz Arduinoing para ti!
Anterior: Circuito del medidor del detector de alcohol con módulo de sensor MQ-3 Siguiente artículo: Circuito alimentador de perros controlado por teléfono móvil
