Inhaltsverzeichnis:
Video: DRAHTLOSE SOLARLAMPE MIT MAGNETISCHEM FLEXIBLE ARM - Gunook
2025 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2025-01-13 06:56
Dieses Projekt wurde aus einer defekten Lampe und einer KnotenMCU erstellt. Diese dekorative Lampe lässt sich in alle Richtungen ausrichten & auf magnetischen Materialien befestigen oder auf den Tisch stellen. Es kann in zwei Modi wie folgt gesteuert werden:
- Drahtloser Steuerungsmodus, als YouTube-Link unten:
- Interaktiver Steuerungsmodus, als YouTube-Link unten:
Schritt 1: STÜCKLISTE
Stückliste:
Für den interaktiven Modus verwende ich MPU6050, um Kreiseldaten von NodeMCU zu erhalten, um die Farbe der Lampe zu steuern.
Materialbild für dieses Projekt:
Schritt 2: SCHALTUNG
Dies ist eine sehr einfache Schaltung, wie Fritzing-Schema oben, mit 1 RGB-LED-Anodentyp, drei Grenzstromwiderständen R100 und MPU6050.
Der Reflektor wird von allen kaputten Lampen verwendet und mit 2 Schrauben mit der NodeMCU-Basis verbunden oder mit starkem Kleber verklebt.
Installationsarbeit:
Schema unten:
Schritt 3: MAGNETISCHE BASIS - FLEXIBLER ARM
Flexibler Arm kann von defekten flexiblen Wasserhähnen wiederverwendet werden. Sowas in der Art:
Mit einigen Tipps versuchen wir, sie mit der Permanentmagnetbasis unten am flexiblen Arm zu verbinden. Oben haben wir ein Bohrloch für den Anschluss an unsere Platine und das Solar- / Batterieladegerät gemacht. Mit diesem Sockel können wir die Lampe auf Oberflächen wie Tische, Böden usw. stellen. oder es kann auf magnetischen Materialien wie Stahlsäulen, Stahlkonstruktionen befestigt werden.
Schritt 4: SOLAR – BATTERIELADEGERÄT
Es kam von einer beschädigten Ladelampe. Ich habe der nodeMCU einen Ein-/Aus-Schalter und eine Stromkabelversorgung hinzugefügt. Es hat auch eine USB-Port-Steckdose und einen Stecker für das Batterieladegerät.
Schritt 5: VERBINDEN SIE ALLE ZUSAMMEN
Alle Teile verbinden: NodeMCU & Reflektor, Solar- & Batteriezellen, flexibler Arm zusammen.
BEENDEN
LADEMODUS
Schritt 6: INTERAKTIVES STEUERUNGSPROGRAMM
Die Farbe wird geändert, wenn wir den flexiblen Arm einstellen oder die Lampe drehen.
INTERAKTIVE LAMPE
| #enthalten |
| // MPU6050 Slave-Geräteadresse |
| const uint8_t MPU6050SlaveAddress = 0x68; |
| // SDA- und SCL-Pins für die I2C-Kommunikation auswählen - Pin-Standard in der WIRE LIBRARY: SCL - D1 & SDA - D2 auf NODEMCU |
| // const uint8_t SCL = D1; |
| // const uint8_t SDA = D2; |
| const int R = 14; |
| const int G = 12; |
| const int B = 13; |
| // MPU6050 wenige Konfigurationsregisteradressen |
| 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, Temperatur, GyroX, GyroY, GyroZ; |
| Leere Einrichtung () { |
| pinMode (R, AUSGANG); |
| pinMode (G, AUSGANG); |
| pinMode (B, AUSGANG); |
| //Seriell.begin(9600); |
| Wire.begin(SDA, SCL); |
| MPU6050_Init(); |
| } |
| Leere Schleife () { |
| uint16_t Ax, Ay, Az, T, Gx, Gy, Gz; |
| uint16_t Rot, Grün, Blau; |
| Read_RawValue(MPU6050SlaveAddress, MPU6050_REGISTER_ACCEL_XOUT_H); |
| // Absoluten Wert nehmen |
| Ax = myAbs(AccelX); |
| Ay = myAbs(AccelY); |
| Az = myAbs(AccelZ); |
| // Im Bereich skalieren |
| Rot = Karte(Ax, 0, 16384, 0, 1023); |
| Grün = Karte(Ay, 0, 16384, 0, 1023); |
| Blau = Karte(Az, 0, 16384, 0, 1023); |
| // Seriendruck zur Überprüfung |
| //Serial.print("Rot:"); Serial.print (Rot); |
| //Serial.print("Grün:"); Serial.print (Grün); |
| //Seriell.print("Blau:"); Serial.print (Blau); |
| // Schreiben analog zu LED |
| analogWrite (R, Rot); // R |
| analogWrite (G, Grün); // G |
| analogWrite (B, Blau); // B |
| Verzögerung (200); |
| } |
| void I2C_Write(uint8_t deviceAddress, uint8_t regAddress, uint8_t data){ |
| Wire.beginTransmission(deviceAddress); |
| Wire.write (regAddress); |
| Wire.write (Daten); |
| Wire.endTransmission(); |
| } |
| // Alle 14 Register lesen |
| 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()); |
| Temperatur = (((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()); |
| } |
| // MPU6050 konfigurieren |
| void MPU6050_Init(){ |
| Verzögerung (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); // setze +/-250 Grad/Sekunde Vollausschlag |
| I2C_Write (MPU6050SlaveAddress, MPU6050_REGISTER_ACCEL_CONFIG, 0x00); // setze +/- 2g Vollausschlag |
| 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); |
| } |
| // Absolutwert |
| float myAbs(hineinschwimmen){ |
| Rückgabe (in)>0?(in):-(in); |
| } |
rawINTERAKTIVES LAMPENPROGRAMM ansehen, gehostet mit ❤ von GitHub
Schritt 7: DRAHTLOSES STEUERUNGSPROGRAMM UND ANDROID-ANWENDUNG
Auf andere Weise können wir die Android-App verwenden, um RGB-LED mit Android im WiFi-Netzwerk zu steuern. Android-App verknüpfen: NODEMCU-Steuerung RGB-LED-APP
Für Arduino-Programm können Sie sich beziehen auf:
microcontrollerkits.blogspot.com/2016/05/es…
Nach dem Hochladen des Programms auf NodeMCU gibt uns der erste Lauf die IP-Adresse des NodeMCU im Seriendruck. In meinem Fall ist es: 192.164.1.39 an Port 80.
Jetzt können wir die drahtlose Lampe mit Laptop / Tablet / Mobiltelefon steuern, indem wir die Adresse oben in den Internet Explorer eingeben.
Oder über die Android-App:
