Registrador de datos Arduino: 8 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

En este tutorial, crearemos un registrador de datos simple usando Arduino. El punto es aprender los conceptos básicos del uso de Arduino para capturar información e imprimir en la terminal. Podemos usar esta configuración básica para completar una variedad de tareas.

Para empezar:

Necesitará una cuenta de Tinkercad (www.tinkercad.com). Dirígete y regístrate con tu correo electrónico o cuenta de redes sociales.

Iniciar sesión te lleva al panel de Tinkercad. Haga clic en "Circuitos" a la izquierda y seleccione "Crear nuevo circuito". ¡Empecemos!

Puede encontrar el archivo completo en TInkercad Circuits - ¡Gracias por revisarlo!

Paso 1: agregue algunos componentes

Necesitará algunos componentes básicos. Éstos incluyen:

• Placa arduino
• Tablero de circuitos

Añádalos buscándolos y haciendo clic y arrastrándolos al área central.

Coloque la placa de pruebas sobre el Arduino. Hace que sea más fácil ver las conexiones más tarde.

Paso 2: una nota sobre las placas de prueba

Una placa de pruebas es un dispositivo muy útil para la creación rápida de prototipos. Lo usamos para conectar componentes. Algunas cosas a tener en cuenta.

1. Los puntos están conectados verticalmente, pero la línea del medio separa esta conexión de las columnas superior e inferior.
2. Las columnas no están conectadas de izquierda a derecha, como en toda la fila. Esto significa que todos los componentes deben estar conectados a través de las columnas en lugar de bajarlas verticalmente.
3. Si necesita usar botones o interruptores, conéctelos a través de la rotura en el medio. Visitaremos esto en un tutorial posterior.

Paso 3: agregue dos sensores

Los dos sensores que estamos usando son un sensor fotosensible y un sensor de temperatura.

Estos sensores evalúan la luz y la temperatura. Usamos Arduino para leer el valor y mostrarlo en el monitor serial en el Arduino.

Busque y agregue los dos sensores. Asegúrese de que estén colocados a lo largo de las columnas de la placa de pruebas. Deje suficiente espacio entre ellos para que sea más fácil verlos.

Paso 4: Sensor fotosensible

1. Para el sensor fotosensible, agregue un cable desde el pin de 5V en el Arduino a la misma columna que la pata derecha en la parte de la placa de pruebas. Cambie el color del cable a rojo.
2. Conecte la pierna izquierda a través del pin en la misma columna al pin A0 (A-zero) en el Arduino. Este es el pin analógico, que usaremos para leer el valor del sensor. Colorea este cable de amarillo o de algo que no sea rojo o negro.

3. Coloque una resistencia (busque y haga clic y arrastre) en el tablero. Esto completa el circuito y protege el sensor y el pin.

   • Déle la vuelta para que cruce las columnas.
   • Conecte una pierna a la columna de la pierna derecha en la placa de pruebas

   • Coloque un cable desde el otro extremo de la resistencia al suelo

     Cambie el color del cable a negro

4. Verifique todas las conexiones. Si algo no está en el lugar correcto, esto no funcionará correctamente.

Paso 5: inicie el código

Veamos el código de este componente.

Primero, mire la tercera imagen en este paso. Contiene un código con dos funciones:

configuración vacía ()

bucle vacío ()

En C ++, todas las funciones proporcionan su tipo de retorno, luego el nombre, luego las dos llaves redondas que se pueden usar para pasar argumentos, generalmente como variables. En este caso, el tipo de retorno es nulo o nada. El nombre está configurado y la función no acepta argumentos.

La función de configuración se ejecuta una vez cuando Arduino arranca (cuando lo enchufa o coloca las baterías).

La función de bucle se ejecuta en un bucle constante desde el milisegundo que se completa la función de configuración.

Todo lo que ponga en la función de bucle se ejecutará cuando se ejecute Arduino. Todo lo externo que solo se ejecutará cuando se llame. Como si definiéramos y llamamos a otra función fuera del ciclo.

Tarea

Abra el panel Código con el botón en Tinkercad. Cambie el menú desplegable Bloques a Texto. Acepte el cuadro de advertencia que aparece. Ahora, elimine todo lo que ve excepto el texto en la tercera imagen en este paso.

Variables

Para comenzar, necesitamos asignar algunas variables para que nuestro código sea realmente eficiente.

Las variables son como cubos que solo pueden contener un objeto (C ++ es lo que llamamos orientado a objetos). Sí, tenemos matrices, pero estas son variables especiales y hablaremos de ellas más adelante. Cuando asignamos una variable, necesitamos decirle qué tipo es y luego darle un valor. Se parece a esto:

int someVar = A0;

Entonces, asignamos una variable y le dimos el tipo int. Un int es un entero o un número entero.

"¡Pero no usaste un número entero!", Te escucho decir. Eso es cierto.

Arduino hace algo especial para nosotros para que podamos usar A0 como un número entero, porque en otro archivo define A0 como un número entero, por lo que podemos usar la constante A0 para referirnos a este número entero sin tener que saber cuál es. Si escribiéramos 0, nos referiríamos al pin digital en la posición 0, lo que no funcionaría.

Entonces, para nuestro código escribiremos una variable para el sensor que hemos adjuntado. Si bien recomiendo darle un nombre simple, eso depende de usted.

Tu código debería verse así:

int lightSensor = A0;

configuración vacía () {} bucle vacío () {}

Ahora, digamos a Arduino cómo manejar el sensor en ese pin. Ejecutaremos una función dentro de la configuración para configurar el modo pin y decirle a Arduino dónde buscarlo.

int lightSensor = A0;

configuración vacía () {pinMode (sensor de luz, ENTRADA); } bucle vacío () {}

la función pinMode le dice a Arduino que el pin (A0) se utilizará como pin INPUT. Tenga en cuenta el camelCaseUsed (ver cada primera letra es una mayúscula, ya que tiene jorobas, por lo tanto … camel …!) Para las variables y los nombres de las funciones. Esta es una convención y es bueno acostumbrarse.

Finalmente, usemos la función analogRead para obtener algunos datos.

int lightSensor = A0;

configuración vacía () {pinMode (sensor de luz, ENTRADA); } bucle vacío () {lectura int = analogRead (sensor de luz); }

Verá que almacenamos la lectura en una variable. Esto es importante ya que necesitamos imprimirlo. Usemos la biblioteca serial (una biblioteca es un código que podemos agregar a nuestro código para hacer las cosas más rápidas de escribir, simplemente llamándola por su definición) para imprimir esto en el monitor serial.

int lightSensor = A0;

void setup () {// Establecer modos de pin pinMode (lightSensor, INPUT); // Agrega la biblioteca serial Serial.begin (9600); } void loop () {// Leer el sensor int reading = analogRead (lightSensor); // Imprime el valor en el monitor Serial.print ("Light:"); Serial.println (lectura); // retrasar el siguiente ciclo por 3 segundos de retraso (3000); }

¡Algunas cosas nuevas! Primero, verá estos:

// Este es un comentario

Usamos comentarios para decirle a otras personas lo que está haciendo nuestro código. Deberías usarlos a menudo. El compilador no los leerá ni los convertirá en código.

Ahora, también agregamos la biblioteca Serial con la línea

Serial.begin (9600)

Este es un ejemplo de una función que toma un argumento. Usted llamó a la biblioteca Serial, luego ejecutó una función (sabemos que es una función debido a las llaves redondas) y pasó un número entero como argumento, configurando la función Serial para que opere a 9600 baudios. No se preocupe por qué, solo sepa que funciona, por ahora.

Lo siguiente que hicimos fue imprimir en el monitor de serie. Usamos dos funciones:

// Este se imprime en la serie sin salto de línea (una entrada al final)

Serial.print ("Light:"); // Este pone el salto de línea para que cada vez que leemos y escribimos, pasa a una nueva línea Serial.println (lectura);

Lo que es importante ver es que cada uno tiene un propósito diferente. Asegúrese de que sus cadenas utilicen comillas dobles y de dejar el espacio después de los dos puntos. Eso ayuda a la legibilidad para el usuario.

Finalmente, usamos la función de retardo, para ralentizar nuestro bucle y hacer que solo se lea una vez cada tres segundos. Esto está escrito en miles de segundos. Cámbielo para leer solo una vez cada 5 segundos.

¡Excelente! ¡Vamos!

Paso 6: simulación

Siempre verifique que todo funcione ejecutando la simulación. Para este circuito, también deberá abrir el simulador para verificar que funcione y verificar sus valores.

Inicie la simulación y compruebe el monitor de serie. Cambie el valor del sensor de luz haciendo clic en él y cambiando el valor con el control deslizante. También debería ver el cambio de valor en el monitor de serie. Si no es así, o si cuando presiona el botón Iniciar simulación obtiene errores, regrese con cuidado y verifique todo su código.

• Concéntrese en las líneas indicadas en la ventana de depuración roja que se le presentará.
• Si su código es correcto y la simulación aún no funciona, verifique su cableado.
• Vuelva a cargar la página; es posible que tenga un error de sistema / servidor no relacionado.
• Mueve el puño hacia la computadora y vuelve a comprobarlo. Todos los programadores hacen esto. Todos. Los. Tiempo.

Paso 7: Conecte el sensor de temperatura

Voy a asumir que ahora estás en el camino correcto. Continúe y conecte el sensor de temperatura como sugiere la imagen. Tenga en cuenta la ubicación de los cables de 5V y GND en el mismo espacio que los de la luz. Esto esta bien. Es como un circuito paralelo y no causará problemas en el simulador. En un circuito real, debe usar una placa de conexión o un blindaje para proporcionar una mejor administración de energía y conexiones.

Ahora, actualice el código.

El código del sensor de temperatura

Esto es un poco más complicado, pero solo porque tenemos que hacer algunas matemáticas para convertir la lectura. No es tan malo.

int lightSensor = A0;

int tempSensor = A1; void setup () {// Establecer modos de pin pinMode (lightSensor, INPUT); // Agrega la biblioteca serial Serial.begin (9600); } void loop () {// El sensor de temperatura // Creando dos variables en una línea - ¡oh eficiencia! // Float var para almacenar un voltaje flotante decimal, gradosC; // Leer el valor del pin y convertirlo en una lectura de 0 a 5 // Esencialmente voltaje = (5/1023 = 0.004882814); voltaje = (analogRead (tempSensor) * 0.004882814); // Convertir a grados C grados C = (voltaje - 0.5) * 100; // Imprimir en el monitor de serie Serial.print ("Temp:"); Serial.print (grados C); Serial.println ("oC"); // Leer el sensor int reading = analogRead (lightSensor); // Imprime el valor en el monitor Serial.print ("Light:"); Serial.println (lectura); // retrasar el siguiente bucle por 3 segundos de retraso (3000); }

He realizado algunas actualizaciones al código. Analicémoslos individualmente.

Primero, agregué la línea

int tempSensor = A1;

Al igual que el sensor de luz, necesito almacenar el valor en una variable para que sea más fácil más adelante. Si tuviera que cambiar la ubicación de este sensor (como volver a cablear la placa), entonces solo tengo que cambiar una línea de código, no buscar en toda la base de código para cambiar el A0 o A1, etc.

Luego, agregamos una línea para almacenar la lectura y la temperatura en un flotador. Tenga en cuenta dos variables en una línea.

voltaje de flotación, grados C;

Esto es realmente útil porque reduce la cantidad de líneas que tengo que escribir y acelera el código. Sin embargo, puede ser más difícil encontrar errores.

Ahora, haremos la lectura y la almacenaremos, luego la convertiremos a nuestro valor de salida.

voltaje = (analogRead (tempSensor) * 0.004882814);

grados C = (voltaje - 0.5) * 100;

Esas dos líneas parecen difíciles, pero en la primera tomamos la lectura y la multiplicamos por 0.004… porque convierte 1023 (la lectura analógica devuelve este valor) en una lectura de 5.

La segunda línea multiplica esa lectura por 100 para mover el punto decimal. Eso nos da la temperatura. ¡Limpio!

Paso 8: prueba y verificación

Si todo va según lo planeado, debe tener un circuito que funcione. Pruebe ejecutando la simulación y utilizando el monitor en serie. Si tiene errores, verifique, vuelva a verificar y agite el puño.

¿Tú lo hiciste? ¡Comparte y cuéntanos tu historia!

Este es el circuito final integrado para que pueda jugar / probar la creación final. ¡Gracias por completar el tutorial!