Luz nocturna que cambia de color con Ardruino 101: 4 pasos (con imágenes)

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

En este proyecto harás una lámpara de noche usando ardruino, Adafruit neo rgb Strips y una impresora 3D.

Tenga en cuenta que este intructable es puramente para mi proyecto escolar. El código de este proyecto se basa en otro proyecto. Dicho esto, no soy un experto en lo que respecta a Ardruino.

Paso 1: requisitos

Para este proyecto, necesitará el siguiente hardware y herramientas

Hardware:

1 - Un ardruino101 (en EE. UU.) O un Genuino101 (para fuera de EE. UU.).

2 - Tiras de led NeoPixel rgb de adafruit (5 voltios).

3 - Un conector usb ardruino (conector tipo B a A).

4 - Un software de Ardruino, Ardruino IDE En este tutorial usaremos la versión 1.8.5. Los requisitos de la biblioteca de software son: 101, Adafruit NeoPixel y Madgwick.

5 -Y un objeto para albergar tu hardware. En este caso, utilizaré una impresora 3D. El archivo para esta impresión 3D se encuentra en las descripciones llamadas "Cabezal de lámpara". Tenga en cuenta que este formato de archivo no está listo para imprimir en 3D. Dependiendo de sus impresoras 3D, primero debe ejecutar el software de impresión 3D designado en el objeto 3D de antemano. A veces, la escala de la impresión 3D se restablecerá. así que asegúrese de que el diámetro esté establecido en 11 cm por 11 cm.

6 - Kit de soldadura básico.

Paso 2: comprensión del hardware y el software

Ardruin / Genuino101

Solo para aclarar Ardruino101 y genuino101 son exactamente los mismos al lado de los nombres. Ambos tienen las mismas especificaciones y utilizan el mismo software.

Ardruino101 posee las especificaciones básicas como el ardruino UNO y más. La característica principal de ardruino101 es el acelerómetro y giroscopio que usaremos en nuestro proyecto. Además, este tipo de ardruino tiene su biblioteca de código única llamada CurrieIMU (Unidades de medida internas) que se incluye en la extensión de la biblioteca 101.

Dicho esto, hablemos del software.

Software y bibliotecas

Ardruino IDE usa Python como su código fuente principal. también es la plataforma de código principal donde se ejecuta la mayoría de ardruino. Hay muchos tutoriales en línea sobre cómo usar este software, por lo que le recomiendo que los investigue primero si es nuevo en este programa.

Dicho esto, las bibliotecas que usaremos son las siguientes:

En el menú Boceto,> Incluir biblioteca> Administrar bibliotecas … En el cuadro de entrada de texto, escriba

- 101 En estándar, el ardruino 101 no se incluye automáticamente en el IDE de ardruino. Necesitamos esta extensión de biblioteca para codificar nuestro tipo ardruino.

-Adafruit NeoPixel para codificar nuestras tiras de píxeles Neo.

-Madgwick Para leer los datos en bruto y calcular estos datos en bruto, cabeceo y balanceo.

Tiras Neo RGB

El tipo que usaré es un tipo de 5 voltios o 5v. Con este 5v no necesito una fuente de alimentación extendida para controlar mis tiras. En cambio, usaré mi ardruino como fuente de energía para controlar e iluminar las tiras.

A continuación, se incluyen algunos consejos que debe conocer antes de comenzar con estas tiras.

Primero necesitará unas tiras LED Neodigital RGB de adafruit. Este tipo de tiras es cotrolable mediante códigos. Lo siguiente que debe saber es que hay una parte trasera y una parte delantera en estas tiras. Esta parte trasera y delantera es importante para la soldadura. Asegúrese de soldar el lado frontal donde la tecla de flecha apunta en dirección opuesta a la punta.

Aquí hay una guía sobre cómo usarlos.

Hay 3 puntos de soldadura que debe tener en cuenta: conexión a tierra (GND), conexión de voltaje (V) y conexión de clavija (DIN).

Paso 3: configuración de los componentes

Primero necesitará imprimir en 3D el componente que puede encontrar en los requisitos. En este caso, usaré PLA. Asegúrese de que el diámetro del objeto general sea de 11 cm por 11 cm. Esto asegurará que el ardruino y las tiras encajen en el barco. Tenga en cuenta que cada impresora 3D utiliza diferentes softwares para calcular su proceso de impresión. Dicho esto, el archivo que use podría tener una escala diferente, así que téngalo en cuenta.

En segundo lugar, después de la impresión, asegúrese de que los componentes se puedan cerrar. Las impresiones 3D juntas forman una esfera. Deberían encajar bien. Si el compuesto se va a perder, coloque un poco de cinta en el lado interior para que se llene la tapa. Y si es demasiado grueso utiliza papel de lija.

En tercer lugar, los skematichs para el ardruino y las tiras son bastante fáciles. Usarás 3 cables para conectar las tiras al ardruino. Tenga en cuenta que los únicos lugares que sueldo son las tiras. no en el propio Ardruino.

GND va a GND

DIN va a un Pin (en nuestro caso pin6 en el ardruino)

5V pasa a 5V

Asegúrese de que la cantidad de tiras de LED que utiliza sea de 30 como máximo. Si se supera esa cantidad, no se ejecutará correctamente el código. Simplemente puede cortar las tiras sin usar que se muestren con un letrero de tijera.

Cuarto Todo debería encajar bien en la esfera. Podría gustarme que hice una intersección entre 1 de la impresión 3D para ver el canal y colocar un plástico transparente en la parte superior.

Paso 4: codificación

Entonces, a estas alturas ya debería tener todos los componentes necesarios en su biblioteca.

Aquí está el código que necesitará para ejecutar el proyecto. El resultado debería parecerse al enlace del video que envío en esta página.

La fuente de este código se puede encontrar aquí. Este proyecto también incluye los pasos necesarios para comprender mejor el código y el algaritmo detrás de los usos.

#incluir #incluir #incluir #incluir

#define PIN 6 // 11 píxeles NeoPixel Strip

#define PIN1 7 // 1 pixel NeoPixel Strip #define NUMPIXELS 30 // Numer of píxels #define SAMPLE_RATE 25 // Tasa de muestreo para acelerómetro y giroscopio

// Configuración de Madgwick

Filtro Madgwick; microsPerReading largo sin firmar, microsPrevious; flotar accelScale, gyroScale;

// Configuración de NeoPixel

Adafruit_NeoPixel píxeles = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); Adafruit_NeoPixel pixelsStatus = Adafruit_NeoPixel (1, 7, NEO_GRB + NEO_KHZ800);

// Espacios de color

RGBConverter rgbConverter; doble h = 1; doble s = 1; doble v = 1; byte rgb [3];

// Lámpara de movimiento de estado

// Estado 0 -> Seleccionar tono - Paso // Estado 1 -> Seleccionar saturación - Desplazamiento // Estado 2 -> Seleccionar valor - Guiñada // Estado 3 -> Fijar color volátil int statusLamp = 0;

configuración vacía () {

Serial.begin (9600);

// inicia la IMU y filtra

CurieIMU.begin (); CurieIMU.setGyroRate (SAMPLE_RATE); CurieIMU.setAccelerometerRate (SAMPLE_RATE); filter.begin (SAMPLE_RATE);

// Establece el rango del acelerómetro en 2G

CurieIMU.setAccelerometerRange (2); // Establece el rango del giroscopio en 250 grados / segundo CurieIMU.setGyroRange (250);

CurieIMU.autoCalibrateAccelerometerOffset (X_AXIS, 0);

CurieIMU.autoCalibrateAccelerometerOffset (Y_AXIS, 0); CurieIMU.autoCalibrateAccelerometerOffset (Z_AXIS, 1); CurieIMU.autoCalibrateGyroOffset ();

CurieIMU.attachInterrupt (eventCallback);

CurieIMU.setDetectionThreshold (CURIE_IMU_TAP, 950); CurieIMU.interrupts (CURIE_IMU_TAP);

// inicializar las variables para ajustar el ritmo de las actualizaciones a la velocidad correcta

microsPerReading = 1000000 / SAMPLE_RATE; microsPrevious = micros ();

// Iniciar NeoPixel 11

pixels.begin (); pixels.show ();

// Iniciar NeoPixel 1

pixelsStatus.begin (); pixels.show ();

// Mostrar estado en px

setStatusPixel (statusLamp); }

bucle vacío () {

int aix, aiy, aiz; // acelerómetro int gix, giy, giz; hacha flotante, ay, az; flotar gx, gy, gz; balanceo flotante, cabeceo, guiñada; microsNow largo estático sin firmar;

// verifica si es hora de leer datos y actualizar el filtro

microsNow = micros (); if (microsNow - microsPrevious> = microsPerReading) {

// leer datos sin procesar de CurieIMU

CurieIMU.readMotionSensor (aix, aiy, aiz, gix, giy, giz);

// convertir de datos brutos a unidades de gravedad y grados / segundo

ax = convertRawAcceleration (aix); ay = convertRawAcceleration (aiy); az = convertRawAcceleration (aiz); gx = convertRawGyro (gix); gy = convertRawGyro (giy); gz = convertRawGyro (giz);

// actualiza el filtro, que calcula la orientación

filter.updateIMU (gx, gy, gz, ax, ay, az);

// imprime el encabezado, cabeceo y balanceo

roll = filter.getRoll (); tono = filter.getPitch (); guiñada = filter.getYaw ();

// Incrementamos el tiempo anterior, por lo que mantenemos el ritmo adecuado

microsPrevious = microsPrevious + microsPerReading;

// Solo si cambia el tono, la saturación o el valor

if (statusLamp select Hue if (pitch> = -90 && pitch <= 90 && statusLamp == 0) {// Transformar ángulo pitch = pitch + 90; // Obtiene coordenadas de color de los ángulos h = pitch / 180.0;}

// Restricciones de ángulos

// rodar solo -90º a 90º = 180º // Estado 1 -> seleccionar Saturación if (roll> = -90 && roll <= 90 && statusLamp == 1) {// Transformar ángulo roll = roll + 90; // Obtiene coordenadas de color de los ángulos s = roll / 180.0; }

// Estado 2 -> seleccionar Valor

if (statusLamp == 2) {// guiñada de 0º a 360º v = guiñada / 360.0; }

// Convertir a rgb

rgbConverter.hsvToRgb (h, s, v, rgb); / * Serial.print ("Color:"); Serial.print (h); Serial.print ("-"); Serial.print (s); Serial.print ("-"); Serial.print (v); Serial.println ("");

Serial.print ("Orientación:");

Serial.print (guiñada); Serial.print (""); Serial.print (paso); Serial.print (""); Serial.println (rollo); * /

// Cambiar el color de los píxeles

para (int px = 0; px <NUMPIXELS; px ++) {pixels.setPixelColor (px, pixels. Color (rgb [0], rgb [1], rgb [2])); pixels.show (); }}

// Mostrar estado en px

setStatusPixel (statusLamp); }}

float convertRawAcceleration (int aRaw) {

// dado que estamos usando el rango 2G // -2g se asigna a un valor bruto de -32768 // + 2g se asigna a un valor bruto de 32767

flotar a = (aRaw * 2.0) / 32768.0;

return a; }

float convertRawGyro (int gRaw) {

// dado que estamos usando un rango de 250 grados / segundos // -250 se asigna a un valor bruto de -32768 // +250 se asigna a un valor bruto de 32767

flotar g = (gRaw * 250.0) / 32768.0;

return g; }

evento vacío estáticoCallback ()

{// Detectar tap en todos los ejes if (CurieIMU.getInterruptStatus (CURIE_IMU_TAP)) {Serial.print ("Tap detectado statusLamp:"); Serial.println (statusLamp);

// Cambian de estado

statusLamp ++;

// Estado inicial

if (statusLamp> 3) {statusLamp = 0; }}}

void setStatusPixel (int statusPx)

{switch (statusPx) {caso 0: pixelsStatus.setPixelColor (0, pixelsStatus. Color (150, 0, 0)); pixelsStatus.show (); rotura; caso 1: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 150, 0)); pixelsStatus.show (); rotura; caso 2: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 0, 150)); pixelsStatus.show (); rotura; caso 3: pixelsStatus.setPixelColor (0, pixelsStatus. Color (0, 0, 0)); pixelsStatus.show (); rotura;

}

}