Tabla de contenido:
Video: LÁMPARA SOLAR INALÁMBRICA CON BRAZO FLEXIBLE MAGNÉTICO: 8 Pasos (con Imágenes)
2025 Autor: John Day | [email protected]. Última modificación: 2025-01-13 06:57
Este proyecto se hizo a partir de una lámpara rota y un nodeMCU. Esta lámpara decorativa puede ajustarse en cualquier dirección y colocarse sobre materiales magnéticos o colocarse sobre la mesa. Se puede controlar en dos modos de la siguiente manera:
- Modo de control inalámbrico, como enlace de YouTube a continuación:
- Modo de control interactivo, como enlace de YouTube a continuación:
Paso 1: LISTA DE MATERIALES
Lista B. O. M:
Para el modo interactivo, uso MPU6050 para obtener datos de giroscopio de NodeMCU para controlar el color de la lámpara.
Imagen de materiales para este proyecto:
Paso 2: CIRCUITO
Este es un circuito muy simple, como el esquema de Fritzing anterior, con 1 tipo de ánodo común LED RGB, tres resistencias de corriente límite R100 y MPU6050.
El reflector se usa de cualquier lámpara rota y se conecta a la base de nodeMCU con 2 pernos o se pega con pegamento fuerte.
Trabajo de instalación:
Esquema a continuación:
Paso 3: BASE MAGNÉTICA - BRAZO FLEXIBLE
El brazo flexible se puede reutilizar a partir de grifos de agua flexibles rotos. Algo como eso:
Con algunos consejos, intentamos conectarlos a la base del imán permanente en la parte inferior del brazo flexible. En la parte superior, hicimos un taladro para conectar a nuestra placa de circuito y cargador solar / batería. Con esta base, podemos colocar la lámpara en superficies como mesas, pisos….; o se puede unir a materiales magnéticos como pilar de acero, estructura de acero.
Paso 4: SOLAR - CARGADOR DE BATERÍA
Provino de una lámpara de carga dañada. Agregué un interruptor de encendido / apagado y un suministro de cables de alimentación a nodeMCU. También tiene una salida de puerto USB y un enchufe para cargador de batería.
Paso 5: CONECTAR TODOS JUNTOS
Conexión de todas las piezas: NodeMCU y reflector, células solares y de batería, brazo flexible juntos.
TERMINAR
MODO DE CARGA
Paso 6: PROGRAMA DE CONTROL INTERACTIVO
El color cambiará cuando ajustemos el brazo flexible o giremos la lámpara.
LAMPARA INTERACTIVA
| #incluir |
| // Dirección del dispositivo esclavo MPU6050 |
| const uint8_t MPU6050SlaveAddress = 0x68; |
| // Seleccione los pines SDA y SCL para la comunicación I2C - Pin predeterminado en WIRE LIBRARY: SCL - D1 & SDA - D2 en NODEMCU |
| // const uint8_t SCL = D1; |
| // const uint8_t SDA = D2; |
| const int R = 14; |
| const int G = 12; |
| const int B = 13; |
| // MPU6050 pocas direcciones de registro de configuración |
| const uint8_t MPU6050_REGISTER_SMPLRT_DIV = 0x19; |
| const uint8_t MPU6050_REGISTER_USER_CTRL = 0x6A; |
| const uint8_t MPU6050_REGISTER_PWR_MGMT_1 = 0x6B; |
| const uint8_t MPU6050_REGISTER_PWR_MGMT_2 = 0x6C; |
| const uint8_t MPU6050_REGISTER_CONFIG = 0x1A; |
| const uint8_t MPU6050_REGISTER_GYRO_CONFIG = 0x1B; |
| const uint8_t MPU6050_REGISTER_ACCEL_CONFIG = 0x1C; |
| const uint8_t MPU6050_REGISTER_FIFO_EN = 0x23; |
| const uint8_t MPU6050_REGISTER_INT_ENABLE = 0x38; |
| const uint8_t MPU6050_REGISTER_ACCEL_XOUT_H = 0x3B; |
| const uint8_t MPU6050_REGISTER_SIGNAL_PATH_RESET = 0x68; |
| int16_t AccelX, AccelY, AccelZ, Temperature, GyroX, GyroY, GyroZ; |
| configuración vacía () { |
| pinMode (R, SALIDA); |
| pinMode (G, SALIDA); |
| pinMode (B, SALIDA); |
| //Serial.begin(9600); |
| Wire.begin (SDA, SCL); |
| MPU6050_Init (); |
| } |
| bucle vacío () { |
| uint16_t Ax, Ay, Az, T, Gx, Gy, Gz; |
| uint16_t Rojo, verde, azul; |
| Read_RawValue (MPU6050SlaveAddress, MPU6050_REGISTER_ACCEL_XOUT_H); |
| // Toma valor absoluto |
| Ax = myAbs (AccelX); |
| Ay = myAbs (AccelY); |
| Az = myAbs (AccelZ); |
| // Escala en rango |
| Rojo = mapa (Ax, 0, 16384, 0, 1023); |
| Verde = mapa (Ay, 0, 16384, 0, 1023); |
| Azul = mapa (Az, 0, 16384, 0, 1023); |
| // Impresión en serie para comprobar |
| //Serial.print("Red: "); Serial.print (rojo); |
| //Serial.print("Green: "); Serial.print (verde); |
| //Serial.print("Blue: "); Serial.print (azul); |
| // Escribir analógico en LED |
| analogWrite (R, rojo); // R |
| analogWrite (G, verde); // G |
| analogWrite (B, azul); // B |
| retraso (200); |
| } |
| void I2C_Write (uint8_t deviceAddress, uint8_t regAddress, uint8_t datos) { |
| Wire.beginTransmission (deviceAddress); |
| Wire.write (regAddress); |
| Wire.write (datos); |
| Wire.endTransmission (); |
| } |
| // Leer los 14 registros |
| void Read_RawValue (uint8_t deviceAddress, uint8_t regAddress) { |
| Wire.beginTransmission (deviceAddress); |
| Wire.write (regAddress); |
| Wire.endTransmission (); |
| Wire.requestFrom (deviceAddress, (uint8_t) 14); |
| AccelX = (((int16_t) Wire.read () << 8) | Wire.read ()); |
| AccelY = (((int16_t) Wire.read () << 8) | Wire.read ()); |
| AccelZ = (((int16_t) Wire.read () << 8) | Wire.read ()); |
| Temperatura = (((int16_t) Wire.read () << 8) | Wire.read ()); |
| GyroX = (((int16_t) Wire.read () << 8) | Wire.read ()); |
| GyroY = (((int16_t) Wire.read () << 8) | Wire.read ()); |
| GyroZ = (((int16_t) Wire.read () << 8) | Wire.read ()); |
| } |
| // Configurar MPU6050 |
| void MPU6050_Init () { |
| retraso (150); |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_SMPLRT_DIV, 0x07); |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_PWR_MGMT_1, 0x01); |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_PWR_MGMT_2, 0x00); |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_CONFIG, 0x00); |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_GYRO_CONFIG, 0x00); // establecer +/- 250 grados / segundo escala completa |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_ACCEL_CONFIG, 0x00); // establecer +/- 2g de escala completa |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_FIFO_EN, 0x00); |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_INT_ENABLE, 0x01); |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_SIGNAL_PATH_RESET, 0x00); |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_USER_CTRL, 0x00); |
| } |
| // Valor absoluto |
| flotar myAbs (flotar en) { |
| return (in)> 0? (in):-(in); |
| } |
ver el PROGRAMA DE LÁMPARAS RAWINTERACTIVAS alojado con ❤ por GitHub
Paso 7: PROGRAMA DE CONTROL INALÁMBRICO Y APLICACIÓN DE ANDROID
De otra forma, podemos usar la aplicación de Android para controlar el LED RGB con Android en la red WiFi. Aplicación de enlace para Android: aplicación LED RGB de control NODEMCU
Para el programa Arduino, puede consultar:
microcontrollerkits.blogspot.com/2016/05/es…
Después de cargar el programa en NodeMCU, la primera ejecución nos dará la dirección IP de NodeMCU en la impresión en serie. En mi caso, es: 192.164.1.39 en el puerto 80.
Ahora, podemos controlar la lámpara inalámbrica con una computadora portátil / tableta / teléfono móvil ingresando la dirección arriba en Internet Explorer.
O usando la aplicación de Android:
