Kartenausrichtung über Webserver - Gunook

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

Das Internet der Dinge (IoT) ist derzeit eines der beliebtesten Themen auf dem Planeten. Und mit dem Internet wächst es von Tag zu Tag schnell. Das Internet der Dinge verwandelt das einfache Zuhause in ein intelligentes Zuhause, in dem alles von Ihren Lichtern bis zu Ihren Schlössern von Ihrem Smartphone oder Desktop aus gesteuert werden kann. Dies ist der Luxus, den jeder besitzen möchte.

Wir spielen immer mit den Tools, die wir haben, und arbeiten weiter daran, den nächsten Schritt unserer Grenzen zu gehen. Wir versuchen, unseren Kunden eine Vision der neuesten Technologien und Ideen zu geben. Damit Sie Ihr Zuhause ohne großen Aufwand in ein Smart Home verwandeln und den Geschmack von Luxus genießen können.

Heute denken wir daran, an einem der wichtigsten Themen im IoT zu arbeiten – Digital Map Orientation.

Wir bauen einen Webserver, über den wir die Bewegungen jedes Geräts oder Dings überwachen können (es liegt an Ihnen, wen Sie ausspionieren wollen;)). Sie können jederzeit darüber nachdenken, dieses Projekt mit einigen Modifikationen auf die nächste Stufe zu bringen, und vergessen Sie nicht, uns dies in den Kommentaren unten mitzuteilen.

Fangen wir an als.. !!

Schritt 1: Ausrüstung, die wir brauchen..

1. LSM9DS0-Sensor

Der von STMicroelectronics hergestellte 3-in-1-Sensor LSM9DS0 ist ein System-in-Package mit einem digitalen 3D-Linearbeschleunigungssensor, einem digitalen 3D-Winkelgeschwindigkeitssensor und einem digitalen 3D-Magnetsensor. Das LSM9DS0 hat eine lineare Beschleunigungsendskala von ±2g/±4g/±6g/±8g/±16g, eine Magnetfeldendskala von ±2/±4/±8/±12 Gauss und eine Winkelgeschwindigkeit von ±245 /±500/±2000 dps.

2. Adafruit Huzzah ESP8266

Der ESP8266-Prozessor von Espressif ist ein 80-MHz-Mikrocontroller mit vollem WiFi-Frontend (sowohl als Client als auch als Access Point) und TCP/IP-Stack mit DNS-Unterstützung. Der ESP8266 ist eine unglaubliche Plattform für die Entwicklung von IoT-Anwendungen. Der ESP8266 bietet eine ausgereifte Plattform für die Überwachung und Steuerung von Anwendungen mit der Arduino Wire Language und der Arduino IDE.

3. ESP8266 USB-Programmierer

Dieser ESP8266-Hostadapter wurde vom Dcube Store speziell für die Adafruit Huzzah-Version des ESP8266 entwickelt und ermöglicht die I²C-Schnittstelle.

4. I2C-Verbindungskabel

5. Mini-USB-Kabel

Das Mini-USB-Kabel Netzteil ist die ideale Wahl für die Stromversorgung des Adafruit Huzzah ESP8266.

Schritt 2: Hardwareverbindungen

Im Allgemeinen ist das Herstellen von Verbindungen der einfachste Teil in diesem Projekt. Befolgen Sie die Anweisungen und Bilder, und Sie sollten keine Probleme haben.

Nehmen Sie zunächst den Adafruit Huzzah ESP8266 und platzieren Sie den USB-Programmer (mit nach innen gerichtetem I²C-Port) darauf. Drücken Sie den USB-Programmer leicht und wir sind mit diesem Schritt kinderleicht fertig (siehe Bild oben).

Anschluss des Sensors und Adafruit Huzzah ESP8266Nehmen Sie den Sensor und verbinden Sie das I²C-Kabel damit. Bitte denken Sie für den ordnungsgemäßen Betrieb dieses Kabels daran, dass der I²C-Ausgang IMMER mit dem I²C-Eingang verbunden ist. Das gleiche musste für den Adafruit Huzzah ESP8266 mit dem darüber montierten USB-Programmer befolgt werden (siehe Bild oben).

Mit Hilfe des ESP8266 USB Programmers ist es sehr einfach ESP zu programmieren. Alles, was Sie tun müssen, ist den Sensor an den USB-Programmer anzuschließen und schon kann es losgehen. Wir bevorzugen diesen Adapter, da er das Anschließen der Hardware erheblich erleichtert. Sie müssen sich keine Sorgen machen, die Pins des ESP an den Sensor zu löten oder die Pin-Diagramme und das Datenblatt zu lesen. Wir können mehrere Sensoren gleichzeitig verwenden und bearbeiten, Sie müssen nur eine Kette erstellen. Ohne diesen Plug-and-Play-USB-Programmierer besteht ein hohes Risiko für eine falsche Verbindung. Eine schlechte Verkabelung kann sowohl Ihr WLAN als auch Ihren Sensor zerstören.

Hinweis: Das braune Kabel sollte immer der Masseverbindung (GND) zwischen dem Ausgang eines Geräts und dem Eingang eines anderen Geräts folgen.

Stromversorgung der Schaltung

Stecken Sie das Mini-USB-Kabel in die Strombuchse des Adafruit Huzzah ESP8266. Anzünden und voila, wir können loslegen!

Schritt 3: Code

Der ESP-Code für den Adafruit Huzzah ESP8266 und LSM9DS0 Sensor ist in unserem Github-Repository verfügbar.

Bevor Sie mit dem Code fortfahren, lesen Sie die Anweisungen in der Readme-Datei und richten Sie Ihren Adafruit Huzzah ESP8266 entsprechend ein. Die Einrichtung des ESP dauert nur 5 Minuten.

Der Code ist lang, aber in der einfachsten Form, die Sie sich vorstellen können, und Sie werden keine Schwierigkeiten haben, ihn zu verstehen.

Der Einfachheit halber können Sie den funktionierenden ESP-Code für diesen Sensor auch von hier aus kopieren:

// Verbreitung mit freier Lizenz.// Verwenden Sie es, wie Sie wollen, profitabel oder kostenlos, sofern es in die Lizenzen der zugehörigen Werke passt. // LSM9DSO // Dieser Code wurde entwickelt, um mit dem TCS3414_I2CS I2C Mini-Modul zu arbeiten, das bei dcubestore.com erhältlich ist.

#enthalten

#enthalten

#enthalten

#enthalten

// LSM9DSO Gyro I2C-Adresse ist 6A(106)

#define Addr_Gyro 0x6A // LSM9DSO Accl I2C-Adresse ist 1E(30) #define Addr_Accl 0x1E

const char* ssid = "Ihre ssid";

const char* password = "Ihr Passwort"; int xGyro, yGyro, zGyro, xAccl, yAccl, zAccl, xMag, yMag, zMag;

ESP8266WebServer-Server (80);

void handleroot()

{ unsigned int data[6];

// I2C-Übertragung starten

Wire.beginTransmission(Addr_Gyro); // Steuerregister 1 auswählen Wire.write (0x20); // Datenrate = 95Hz, X, Y, Z-Achse aktiviert, Einschalten Wire.write (0x0F); // I2C-Übertragung stoppen Wire.endTransmission();

// I2C-Übertragung starten

Wire.beginTransmission(Addr_Gyro); // Steuerregister 4 auswählen Wire.write (0x23); // Full-Scale 2000 dps, kontinuierliche Aktualisierung Wire.write (0x30); // I2C-Übertragung stoppen Wire.endTransmission();

// I2C-Übertragung starten

Wire.beginTransmission(Addr_Accl); // Steuerregister 1 auswählen Wire.write (0x20); // Beschleunigungsdatenrate = 100Hz, X, Y, Z-Achse aktiviert, Einschalten Wire.write (0x67); // I2C-Übertragung auf dem Gerät stoppen Wire.endTransmission();

// I2C-Übertragung starten

Wire.beginTransmission(Addr_Accl); // Steuerregister 2 auswählen Wire.write (0x21); // Auswahl der vollen Skala +/- 16g Wire.write (0x20); // I2C-Übertragung stoppen Wire.endTransmission();

// I2C-Übertragung starten

Wire.beginTransmission(Addr_Accl); // Steuerregister 5 auswählen Wire.write (0x24); // Magnetisch hohe Auflösung, Ausgangsdatenrate = 50Hz Wire.write (0x70); // I2C-Übertragung stoppen Wire.endTransmission();

// I2C-Übertragung starten

Wire.beginTransmission(Addr_Accl); // Steuerregister 6 auswählen Wire.write (0x25); // Magnetischer Vollausschlag +/- 12 Gauss Wire.write (0x60); // I2C-Übertragung stoppen Wire.endTransmission();

// I2C-Übertragung starten

Wire.beginTransmission(Addr_Accl); // Steuerregister 7 auswählen Wire.write (0x26); // Normaler Modus, magnetischer kontinuierlicher Konvertierungsmodus Wire.write (0x00); // I2C-Übertragung stoppen Wire.endTransmission(); Verzögerung (300);

for (int i = 0; i < 6; i++) {// I2C-Übertragung starten Wire.beginTransmission(Addr_Gyro); // Datenregister auswählen Wire.write ((40 + i)); // I2C-Übertragung stoppen Wire.endTransmission();

// 1 Byte Daten anfordern

Wire.requestFrom(Addr_Gyro, 1);

// 6 Byte Daten lesen

// xGyro lsb, xGyro msb, yGyro lsb, yGyro msb, zGyro lsb, zGyro msb if (Wire.available() == 1) { data = Wire.read(); } }

// Konvertieren Sie die Daten

int xGyro = ((Daten[1] * 256) + Daten[0]); int yGyro = ((Daten[3] * 256) + Daten[2]); int zGyro = ((Daten[5] * 256) + Daten[4]);

for (int i = 0; i < 6; i++) {// I2C-Übertragung starten Wire.beginTransmission(Addr_Accl); // Datenregister auswählen Wire.write ((40 + i)); // I2C-Übertragung stoppen Wire.endTransmission();

// 1 Byte Daten anfordern

Wire.requestFrom(Addr_Accl, 1);

// 6 Byte Daten lesen

// xAccl lsb, xAccl msb, yAccl lsb, yAccl msb // zAccl lsb, zAccl msb if (Wire.available() == 1) { data = Wire.read(); } }

// Konvertieren Sie die Daten

int xAccl = ((Daten[1] * 256) + Daten[0]); int yAccl = ((Daten[3] * 256) + Daten[2]); int zAccl = ((Daten[5] * 256) + Daten[4]);

for (int i = 0; i < 6; i++) {// I2C-Übertragung starten Wire.beginTransmission(Addr_Accl); // Datenregister auswählen Wire.write ((8 + i)); // I2C-Übertragung stoppen Wire.endTransmission();

// 1 Byte Daten anfordern

Wire.requestFrom(Addr_Accl, 1);

// 6 Byte Daten lesen

// xMag lsb, xMag msb, yMag lsb, yMag msb // zMag lsb, zMag msb if (Wire.available() == 1) { data = Wire.read(); } }

// Konvertieren Sie die Daten

int xMag = ((Daten[1] * 256) + Daten[0]); int yMag = ((Daten[3] * 256) + Daten[2]); int zMag = ((Daten[5] * 256) + Daten[4]);

// Daten an seriellen Monitor ausgeben

Serial.print ("X-Rotationsachse: "); Serial.println (xGyro); Serial.print ("Y-Rotationsachse: "); Serial.println (yGyro); Serial.print ("Z-Rotationsachse: "); Serial.println (zGyro); Serial.print ("Beschleunigung in der X-Achse: "); Serial.println (xAccl); Serial.print ("Beschleunigung in der Y-Achse: "); Serial.println (yAccl); Serial.print ("Beschleunigung in der Z-Achse: "); Serial.println (zAccl); Serial.print ("Magnetfeld in der X-Achse: "); Serial.println (xMag); Serial.print ("Magnetfeld in der Y-Achse: "); Serial.println (yMag); Serial.print ("Magnetisch in der Z-Achse abgelegt: "); Serial.println (zMag);

// Daten an Webserver ausgeben

server.sendContent ("

DCUBE STORE

www.dcubestore.com

"" LSM9DS0 Sensor I2C Mini Modul

);

server.sendContent ("

X-Rotationsachse = " + String(xGyro)); server.sendContent ("

Y-Rotationsachse = " + String(yGyro)); server.sendContent ("

Z-Rotationsachse = " + String(zGyro)); server.sendContent ("

Beschleunigung in X-Achse = " + String(xAccl)); server.sendContent ("

Beschleunigung in Y-Achse = " + String(yAccl)); server.sendContent ("

Beschleunigung in Z-Achse = " + String(zAccl)); server.sendContent ("

Magnetisch abgelegt in X-Achse = " + String(xMag)); server.sendContent ("

Magnetisch abgelegt in Y-Achse = " + String(yMag)); server.sendContent ("

Magnetisches Feld in Z-Achse = " + String(zMag)); delay(1000); }

Void-Setup ()

{ // I2C-Kommunikation als MASTER Wire.begin (2, 14) initialisieren; // Serielle Kommunikation initialisieren, Baudrate = 115200 einstellen Serial.begin(115200);

// Mit WiFi-Netzwerk verbinden

WiFi.begin(ssid, Passwort);

// Auf Verbindung warten

Während (WiFi.status () != WL_CONNECTED) { Verzögerung (500); Serial.print("."); } Serial.println(""); Serial.print ("Verbunden mit"); Serial.println (ssid);

// Holen Sie sich die IP-Adresse von ESP8266

Serial.print ("IP-Adresse: "); Serial.println (WiFi.localIP());

// Server starten

server.on("/", handleroot); server.begin(); Serial.println("HTTP-Server gestartet"); }

Leere Schleife ()

{ server.handleClient(); }

Schritt 4: Code bearbeiten

Laden Sie nun den Code herunter (oder git pull) und öffnen Sie ihn in der Arduino IDE.

Kompilieren und laden Sie den Code hoch und sehen Sie sich die Ausgabe auf Serial Monitor an.

Hinweis: Stellen Sie vor dem Hochladen sicher, dass Sie Ihr SSID-Netzwerk und Ihr Passwort in den Code eingeben.

Kopieren Sie die IP-Adresse des ESP8266 vom Serial Monitor und fügen Sie sie in Ihren Webbrowser ein. Sie sehen eine Webseite mit Drehachse, Beschleunigung und Magnetfeldmessung in der 3-Achse.

Die Ausgabe des Sensors auf Serial Monitor und Web Server wird im Bild oben gezeigt.

Schritt 5: Anwendungen und Funktionen

Das LSM9DS0 ist ein System-in-Package mit einem digitalen 3D-Linearbeschleunigungssensor, einem digitalen 3D-Winkelgeschwindigkeitssensor und einem digitalen 3D-Magnetsensor. Durch die Messung dieser drei Eigenschaften können Sie viel Wissen über die Bewegung eines Objekts gewinnen. Wenn Sie die Kraft und Richtung des Erdmagnetfelds mit einem Magnetometer messen, können Sie Ihren Kurs annähern. Ein Beschleunigungsmesser in Ihrem Telefon kann die Richtung der Schwerkraft messen und die Ausrichtung (Hochformat, Landschaft, flach usw.) schätzen. Quadcopter mit eingebauten Gyroskopen können nach plötzlichen Rollen oder Nicken Ausschau halten. Wir können dies im Global Positioning System (GPS) verwenden.

Einige weitere Anwendungen umfassen Indoor-Navigation, intelligente Benutzeroberflächen, erweiterte Gestenerkennung, Gaming- und Virtual-Reality-Eingabegeräte usw.

Mit Hilfe von ESP8266 können wir seine Kapazität auf eine größere Länge erhöhen. Wir können unsere Geräte steuern und ihre Leistung von unseren Desktops und mobilen Geräten aus überwachen. Wir können die Daten online speichern und verwalten und sie jederzeit auf Änderungen untersuchen. Weitere Anwendungen sind Hausautomation, Mesh-Netzwerk, industrielle drahtlose Steuerung, Babyphone, Sensornetzwerke, tragbare Elektronik, standortabhängige WLAN-Geräte, WLAN-Positionssystem-Beacons.

Schritt 6: Ressourcen für weitere Schritte

Weitere Informationen zu LSM9DS0 und ESP8266 finden Sie unter den folgenden Links:

• LSM9DS0 Sensordatenblatt
• LSM9DS0-Schaltplan
• ESP8266 Datenblatt