DRAHTLOSE SOLARLAMPE MIT MAGNETISCHEM FLEXIBLE ARM - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

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:

Schritt 8: EINIGE BILDER