Home

Willkommen bei HD Robotics

Erleben Sie die Zukunft der Robotik

Über uns

HD Robotics ist ein führender Innovator im Bereich der Robotik. Unser Ziel ist es, die Welt mit fortschrittlichen, zuverlässigen und effizienten Robotiklösungen zu verändern. Mit einem Team von hochqualifizierten Ingenieuren und Entwicklern sind wir bestrebt, die Grenzen des Möglichen zu erweitern und Technologien zu schaffen, die das tägliche Leben und die industrielle Produktion revolutionieren.

Unsere Produkte

  • Industrieroboter: Effizienz und Präzision für Ihre Fertigungsprozesse.
  • Serviceroboter: Intelligente Lösungen für den Alltag und professionelle Dienstleistungen.
  • Bildverarbeitungssysteme: Moderne Technologien für Inspektion, Qualitätskontrolle und Automatisierung.

 

Innovation und Qualität

Bei HD Robotics legen wir großen Wert auf Innovation und Qualität. Unsere Produkte werden unter den höchsten Standards entwickelt und getestet, um den Anforderungen unserer Kunden gerecht zu werden. Wir glauben an kontinuierliche Verbesserung und arbeiten ständig daran, unsere Technologien und Dienstleistungen zu optimieren.

Kundensupport

Ihre Zufriedenheit ist unser Erfolg. Unser engagiertes Support-Team steht Ihnen jederzeit zur Verfügung, um Ihre Fragen zu beantworten und Ihnen bei allen Anliegen zu helfen. Egal ob Sie technische Unterstützung benötigen oder eine maßgeschneiderte Lösung suchen, wir sind für Sie da.

Kontakt

Wir freuen uns, von Ihnen zu hören. Kontaktieren Sie uns noch heute, um mehr über unsere Produkte und Dienstleistungen zu erfahren.

Bleiben Sie verbunden

Folgen Sie uns auf unseren Social-Media-Kanälen und bleiben Sie auf dem Laufenden über die neuesten Entwicklungen und Innovationen in der Robotik.

HD Robotics - Ihr Partner für fortschrittliche Robotiklösungen

Erleben Sie, wie Technologie Ihre Welt verändern kann.

Ich hoffe, dieser Vorschlag entspricht Ihren Erwartungen. Lassen Sie mich wissen, ob Sie noch Anpassungen oder Ergänzungen wünschen!

Willkommen auf meiner Website! In diesem Projekt zeige ich dir, wie du ein automatisches Parkhaustür-System mit einem Servo-Motor und einem Ultraschall-Sensor baust, das mithilfe des ESP8266 gesteuert wird. Mit diesem System kannst du eine Tür öffnen und schließen lassen, sobald ein Auto in der Nähe ist. Alles wird auf einem OLED-Display angezeigt, sodass du die Entfernung und den Status des Systems in Echtzeit überwachen kannst. Lass uns also loslegen!

Watch Now!

 

Benötigte Komponenten:

  • ESP8266 (z.B. NodeMCU)
  • Servo-Motor
  • Ultraschall-Sensor (HC-SR04)
  • OLED-Display (128x64)
  • 2 LEDs (Grün und Rot)
  • Jumper Kabel
  • Breadboard
  • Widerstände (für LEDs)

Schaltplan und Verdrahtung:

  1. Ultraschall-Sensor (HC-SR04):

    • VCC → 3V (vom ESP8266)
    • GND → GND
    • Trig → GPIO5 (D1)
    • Echo → GPIO4 (D2)

  2. Servo-Motor:

    • VCC → 5V (vom ESP8266)
    • GND → GND
    • Signal → GPIO13 (D7)

  3. OLED-Display (I2C):

    • VCC → 3V (vom ESP8266)
    • GND → GND
    • SCL → GPIO14 (D5)
    • SDA → GPIO12 (D6)

  4. LEDs (Grün und Rot):

    • Grüne LED → GPIO2 (D4)
    • Rote LED → GPIO16 (D0)

Schritt 1: Code und Bibliotheken

Der Code, den du für dieses Projekt benötigst, steuert den Servo-Motor, liest die Entfernung vom Ultraschall-Sensor und zeigt alle Daten auf dem OLED-Display an. Außerdem steuert der Code die grünen und roten LEDs, je nachdem, ob die Tür geöffnet oder geschlossen ist.

Wichtige Bibliotheken:

  • Servo.h: Zum Steuern des Servo-Motors.
  • NewPing.h: Für die Kommunikation mit dem Ultraschall-Sensor.
  • Wire.h und U8g2lib.h: Für das OLED-Display.

     

     

     

     

     

     

     

    Code-Erklärung:

     

    #include <Wire.h>
    #include <NewPing.h>
    #include <Servo.h>
    #include <U8g2lib.h>

    // Pin-Zuweisung
    #define TRIG_PIN 5
    #define ECHO_PIN 4
    #define MAX_DISTANCE 200
    #define SERVO_PIN 13
    #define GREEN_LED_PIN 2
    #define RED_LED_PIN 16

    NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE); // Ultraschall-Sensor initialisieren
    Servo servo; // Servo-Motor initialisieren
    U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, 14, 12, U8X8_PIN_NONE); // OLED-Display initialisieren

    void setup() {
      pinMode(GREEN_LED_PIN, OUTPUT);
      pinMode(RED_LED_PIN, OUTPUT);
      servo.attach(SERVO_PIN); // Servo an GPIO 13 anschließen
      servo.write(0); // Tür geschlossen (0 Grad)
      
      u8g2.begin(); // OLED starten
    }

    void loop() {
      int distance = sonar.ping_cm(); // Entfernung messen
      if (distance > 0 && distance <= 13) { // Wenn das Auto näher als 13 cm ist
        digitalWrite(GREEN_LED_PIN, HIGH); // Grüne LED an (Tür öffnet)
        digitalWrite(RED_LED_PIN, LOW); // Rote LED aus
        servo.write(150); // Tür öffnet sich auf 150 Grad
        countdown(); // 5 Sekunden Countdown starten
      } else {
        digitalWrite(GREEN_LED_PIN, LOW); // Grüne LED aus
        digitalWrite(RED_LED_PIN, HIGH); // Rote LED an (Tür geschlossen)
        servo.write(0); // Tür bleibt geschlossen (0 Grad)
      }
      
      showDistance(distance); // Entfernung auf OLED anzeigen
    }

    void countdown() {
      for (int i = 5; i >= 0; i--) {
        u8g2.clearBuffer();
        u8g2.setFont(u8g2_font_ncenB08_tr);
        u8g2.drawStr(0, 10, "Countdown:");
        u8g2.setCursor(0, 30);
        u8g2.print(i);
        u8g2.sendBuffer();
        delay(1000);
      }
      servo.write(0); // Tür nach 5 Sekunden schließen
    }

    void showDistance(int distance) {
      u8g2.clearBuffer();
      u8g2.setFont(u8g2_font_ncenB08_tr);
      u8g2.drawStr(0, 10, "Entfernung:");
      u8g2.setCursor(0, 25);
      u8g2.print(distance);
      u8g2.print(" cm");
      u8g2.sendBuffer();
    }

     

    Code-Erklärung:

    1. Ultraschall-Sensor (HC-SR04): Der Sensor misst kontinuierlich die Entfernung zum Auto. Wenn die Entfernung unter 13 cm liegt, öffnet sich die Tür. Der Wert für die maximale Entfernung ist auf 200 cm gesetzt.

    2. Servo-Motor: Wenn der Sensor ein Auto erkennt (Entfernung < 13 cm), dreht sich der Servo-Motor auf 150 Grad und öffnet die Tür. Nach 5 Sekunden wird die Tür wieder auf 0 Grad geschlossen.

    3. LEDs: Die grüne LED leuchtet, wenn die Tür geöffnet wird, und blinkt während des Countdowns. Die rote LED leuchtet, wenn die Tür geschlossen ist.

    4. OLED-Display: Zeigt die Entfernung des Autos in Echtzeit an. Während des Countdowns wird die verbleibende Zeit angezeigt.

    Fazit und Download:

    Das Projekt kombiniert einfache Hardware und Software, um eine smarte Parkhaustür zu erstellen, die sich automatisch öffnet, wenn ein Auto in der Nähe ist, und sich nach 5 Sekunden wieder schließt. Du kannst den vollständigen Code direkt von meiner Website hier herunterladen.

    Falls du Fragen hast oder Hilfe benötigst, hinterlasse einen Kommentar oder kontaktiere mich über das Kontaktformular.

 

 

 

HD Robotics 3D LED Cube mit ESP32

Einleitung

Der HD Robotics 3D LED Cube ist ein innovatives Projekt, das mit einem ESP32 Mikrocontroller betrieben wird und eine beeindruckende LED-Beleuchtung in drei Dimensionen ermöglicht. Dieses System nutzt WS2812-LEDs, die über die FastLED-Bibliothek gesteuert werden, und bietet eine benutzerfreundliche Steuerung über eine Web-Oberfläche.

Technische Spezifikationen

  • Mikrocontroller: ESP32
  • WLAN-Netzwerk: Eigenständiger Access Point
  • LED-Typ: WS2812 RGB-LEDs
  • Panels: 6 verbundene Panels mit jeweils 64 LEDs (insgesamt 384 LEDs)
    • 1 Panel oben
    • 1 Panel unten
    • 4 Seitenpanels, definiert als „Panel 3“ im Code
  • Signalverteiler: Ein externer Signalverteiler verbindet die Panels (kann auf AliExpress erworben werden)
  • Steuerung: Webinterface zur Effekt- und Helligkeitskontrolle

Aufbau des Codes

1. WLAN-Access Point Einrichtung

Der ESP32 wird als Access Point (AP) konfiguriert, sodass sich Benutzer direkt mit dem Netzwerk „ESP32_LED_Controller“ verbinden können. Anschließend kann über den Browser die Steuerung erfolgen:

const char* ssid = "ESP32_LED_Controller";
const char* password = "12345678";
WiFi.softAP(ssid, password);
server.begin();

2. LED-Panels und FastLED-Bibliothek

Die LEDs sind in sechs Panels aufgeteilt, wobei jedes Panel aus 64 LEDs besteht. Ein externer Signalverteiler verbindet alle Panels, sodass nur ein einzelnes Signal vom ESP32 benötigt wird.

#define NUM_LEDS_PER_PANEL 64
#define PANEL1_PIN 2  // Oben
#define PANEL2_PIN 3  // Unten
#define PANEL3_PIN 4  // Seitenpanels
CRGB panel1[NUM_LEDS_PER_PANEL];
CRGB panel2[NUM_LEDS_PER_PANEL];
CRGB panel3[NUM_LEDS_PER_PANEL * 4]; // 4 Seitenpanels als eine Einheit

3. Verbindung der WS2812 LED-Panels

Die sechs Panels werden in einer 3D-Würfelanordnung mit einem einzigen Datenstrom verbunden. Hierzu wird ein Signalverteiler verwendet, der das Signal vom ESP32 an alle sechs Panels verteilt. Dieser Verteiler kann z. B. auf AliExpress gekauft werden. Die Verkabelung erfolgt folgendermaßen:

  • Datenleitung vom ESP32 an den Signalverteiler
  • Vom Verteiler führen separate Datenleitungen zu den sechs Panels
  • Gemeinsame Stromversorgung für alle LEDs über eine 5V-Quelle mit ausreichender Leistung

4. Webinterface zur Steuerung

Das Webinterface ermöglicht es Benutzern, verschiedene Farben und Effekte für jedes Panel einzustellen. Der HTML-Code definiert verschiedene Buttons für Effekte und Helligkeitskontrolle:

<button class="button red" onclick="sendEffect('panel1=1')">Rot</button>
<button class="button green" onclick="sendEffect('panel1=2')">Grün</button>
<button class="button blue" onclick="sendEffect('panel1=3')">Blau</button>

Die JavaScript-Funktion sendet eine HTTP-Anfrage an den ESP32:

function sendEffect(effect) {
    fetch('/?' + effect).then(response => console.log(response));
}

5. Effektsteuerung

Die Effekte für die LED-Panels werden über eine Switch-Case-Struktur verwaltet. Hier sind einige Beispiele:

  • Einfarbige Beleuchtung:
case 1: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Red); break;
case 2: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Green); break;
  • Rainbow-Effekt:
case 4: {
    static uint8_t hue = 0;
    fill_rainbow(leds, NUM_LEDS_PER_PANEL, hue++, 7);
    break;
}
  • Regen-Effekt: LEDs leuchten nacheinander auf, um den Eindruck von fallendem Regen zu erzeugen.
case 8: {
    static int rainPosition = 0;
    fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Black);
    leds[rainPosition] = CRGB::Blue;
    rainPosition = (rainPosition + 1) % NUM_LEDS_PER_PANEL;
    break;
}

6. Client-Anfragen verarbeiten

Der ESP32 verarbeitet HTTP-Anfragen und setzt entsprechend die LED-Effekte.

WiFiClient client = server.available();
if (client) {
    String request = client.readStringUntil('\r');
    if (request.indexOf("panel1=1") > -1) effectPanel1 = 1;
    client.print(htmlPage());
    client.stop();
}

Fazit

Dieses Projekt demonstriert die leistungsfähige Kombination aus ESP32, FastLED und einer Websteuerung. Der HD Robotics 3D LED Cube bietet eine faszinierende Möglichkeit, dynamische Lichteffekte über WLAN zu steuern und ist ideal für kreative Lichtinstallationen, interaktive Kunstprojekte und Smart-Home-Anwendungen. Durch den Einsatz eines Signalverteilers können alle sechs Panels effizient angesteuert werden, was eine gleichmäßige und synchrone Beleuchtung des gesamten Würfels ermöglicht.

 

mein Code :

#include <WiFi.h>
#include <FastLED.h>

// WLAN Access Point Konfiguration
const char* ssid = "ESP32_LED_Controller";
const char* password = "12345678";

// HD Robotics 3D Cube-Einstellungen
#define NUM_LEDS_PER_PANEL 64 // Anzahl LEDs pro Panel (für 3D Cube)
#define PANEL1_PIN 2          // Datenpin für Panel 1 (unten)
#define PANEL2_PIN 3          // Datenpin für Panel 2 (oben)
#define PANEL3_PIN 4          // Datenpin für Panel 3

// LED-Arrays
CRGB panel1[NUM_LEDS_PER_PANEL];  // Panel 1 (unten)
CRGB panel2[NUM_LEDS_PER_PANEL];  // Panel 2 (oben)
CRGB panel3[NUM_LEDS_PER_PANEL];  // Panel 3

// HTTP-Server
WiFiServer server(80);

// Variablen zur Steuerung der LEDs
int effectPanel1 = 0;
int effectPanel2 = 0;
int effectPanel3 = 0;
int brightness = 128;  // Standardhelligkeit

// HTML-Seite
String htmlPage() {
  String html = R"rawliteral(
  <!DOCTYPE html>
  <html lang="de">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>LED Controller</title>
    <style>
      body {
        font-family: 'Arial', sans-serif;
        background-color: #2c3e50;
        color: #ecf0f1;
        text-align: center;
        margin: 0;
        padding: 0;
      }
      h1 {
        margin-top: 10px;
        font-size: 32px;
        color: #3498db;
      }
      h2 {
        margin: 15px 0;
        font-size: 20px;
        color: #ecf0f1;
      }
      .button {
        padding: 8px 16px;
        margin: 3px;
        font-size: 14px;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        transition: background-color 0.3s;
      }
      .button:hover {
        background-color: #2980b9;
      }
      .red { background-color: #e74c3c; }
      .green { background-color: #2ecc71; }
      .blue { background-color: #3498db; }
      .rainbow { background-color: #9b59b6; }
      .slider {
        width: 90%;
        margin: 10px 0;
        padding: 8px;
        background-color: #34495e;
        border-radius: 5px;
        border: none;
      }
      .slider-label {
        font-size: 16px;
        color: #ecf0f1;
      }
      .slider-value {
        font-size: 18px;
        color: #ecf0f1;
        font-weight: bold;
      }
      .button-container {
        display: flex;
        flex-wrap: wrap;
        justify-content: center;
        gap: 5px;
        margin: 5px 0;
      }
    </style>
  </head>
  <body>
    <h1>HD Robotics 3D Cube</h1>
    
    <!-- Panel 1 (Unten) -->
    <h2>Panel 1 (Unten)</h2>
    <div class="button-container">
      <button class="button red" onclick="sendEffect('panel1=1')">Red</button>
      <button class="button green" onclick="sendEffect('panel1=2')">Green</button>
      <button class="button blue" onclick="sendEffect('panel1=3')">Blue</button>
      <button class="button rainbow" onclick="sendEffect('panel1=4')">Rainbow</button>
      <button class="button" onclick="sendEffect('panel1=rain')">Rain Demo</button>
      <button class="button" onclick="sendEffect('panel1=blink')">Blink Demo</button>
    </div>

    <!-- Panel 2 (Oben) -->
    <h2>Panel 2 (Oben)</h2>
    <div class="button-container">
      <button class="button red" onclick="sendEffect('panel2=1')">Red</button>
      <button class="button green" onclick="sendEffect('panel2=2')">Green</button>
      <button class="button blue" onclick="sendEffect('panel2=3')">Blue</button>
      <button class="button rainbow" onclick="sendEffect('panel2=4')">Rainbow</button>
      <button class="button" onclick="sendEffect('panel2=rain')">Rain Demo</button>
      <button class="button" onclick="sendEffect('panel2=blink')">Blink Demo</button>
    </div>

    <!-- Panel 3 -->
    <h2>Panel 3</h2>
    <div class="button-container">
      <button class="button red" onclick="sendEffect('panel3=1')">Red</button>
      <button class="button green" onclick="sendEffect('panel3=2')">Green</button>
      <button class="button blue" onclick="sendEffect('panel3=3')">Blue</button>
      <button class="button rainbow" onclick="sendEffect('panel3=4')">Rainbow</button>
      <button class="button" onclick="sendEffect('panel3=rain')">Rain Demo</button>
      <button class="button" onclick="sendEffect('panel3=blink')">Blink Demo</button>
    </div>

    <!-- Helligkeitseinstellung -->
    <h2>Brightness</h2>
    <div>
      <input type="range" class="slider" min="0" max="255" value="128" id="brightnessSlider" onchange="updateBrightness()">
      <p class="slider-label">Brightness: <span class="slider-value" id="brightnessValue">128</span></p>
    </div>

    <!-- Turn Off All -->
    <h2>Turn Off All</h2>
    <div>
      <button class="button" onclick="sendEffect('turnOffAll=1')">Turn Off All</button>
    </div>

    <script>
      function sendEffect(effect) {
        fetch('/?' + effect).then(response => console.log(response));
      }
      
      function updateBrightness() {
        var brightness = document.getElementById("brightnessSlider").value;
        document.getElementById("brightnessValue").innerText = brightness;
        fetch('/?brightness=' + brightness);
      }
    </script>
  </body>
  </html>
  )rawliteral";
  return html;
}

// Effekte für die Panels
void setEffect(CRGB* leds, int effect) {
  switch (effect) {
    case 1: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Red); break;
    case 2: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Green); break;
    case 3: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Blue); break;
    case 4: {
      static uint8_t hue = 0;
      fill_rainbow(leds, NUM_LEDS_PER_PANEL, hue++, 7);
      break;
    }
    case 5: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Yellow); break;
    case 6: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Cyan); break;
    case 7: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::White); break;
    case 8: {
      // Rain Demo Effekt
      static int rainPosition = 0;
      CRGB colors[] = {CRGB::Red, CRGB::Green, CRGB::Blue, CRGB::Yellow, CRGB::Magenta, CRGB::Cyan};

      // Alle LEDs ausschalten
      fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Black);

      // Regen-Effekt (von oben nach unten)
      for (int i = 0; i < NUM_LEDS_PER_PANEL; i++) {
        if (i == rainPosition) {
          leds[i] = colors[random(0, 6)];  // Zufällige Farbe
        }
      }

      rainPosition = (rainPosition + 1) % NUM_LEDS_PER_PANEL;  // Position für nächsten Regen
      break;
    }
    case 9: {
      // Blink Demo Effekt
      static unsigned long lastBlinkTime = 0;
      static bool blinkState = false;
      if (millis() - lastBlinkTime > 500) {  // Blink alle 500ms
        lastBlinkTime = millis();
        blinkState = !blinkState;
        if (blinkState) {
          fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::White);  // Blink in Weiß
        } else {
          fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Black);  // Blink aus
        }
      }
      break;
    }
    case 10: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Black); break; // Turn Off All
    default: fill_solid(leds, NUM_LEDS_PER_PANEL, CRGB::Black); break;
  }
}

// Funktion zum Setzen der Helligkeit
void setBrightness(int brightness) {
  FastLED.setBrightness(brightness);
}

void setup() {
  // LEDs initialisieren
  FastLED.addLeds<WS2812, PANEL1_PIN, GRB>(panel1, NUM_LEDS_PER_PANEL);  // Panel 1 (unten)
  FastLED.addLeds<WS2812, PANEL2_PIN, GRB>(panel2, NUM_LEDS_PER_PANEL);  // Panel 2 (oben)
  FastLED.addLeds<WS2812, PANEL3_PIN, GRB>(panel3, NUM_LEDS_PER_PANEL);  // Panel 3

  // WLAN-Access Point starten
  WiFi.softAP(ssid, password);
  server.begin();

  Serial.begin(115200);
  Serial.println("Access Point gestartet!");
  Serial.print("Verbinde dich mit dem Netzwerk: ");
  Serial.println(ssid);
  Serial.println("Öffne die IP-Adresse 192.168.4.1 im Browser.");
}

void loop() {
  // Client-Verbindung bearbeiten
  WiFiClient client = server.available();
  if (client) {
    String request = client.readStringUntil('\r');
    client.flush();

    // Anfrage verarbeiten
    if (request.indexOf("panel1=1") > -1) effectPanel1 = 1;
    if (request.indexOf("panel1=2") > -1) effectPanel1 = 2;
    if (request.indexOf("panel1=3") > -1) effectPanel1 = 3;
    if (request.indexOf("panel1=4") > -1) effectPanel1 = 4;
    if (request.indexOf("panel1=rain") > -1) effectPanel1 = 8;
    if (request.indexOf("panel1=blink") > -1) effectPanel1 = 9;

    if (request.indexOf("panel2=1") > -1) effectPanel2 = 1;
    if (request.indexOf("panel2=2") > -1) effectPanel2 = 2;
    if (request.indexOf("panel2=3") > -1) effectPanel2 = 3;
    if (request.indexOf("panel2=4") > -1) effectPanel2 = 4;
    if (request.indexOf("panel2=rain") > -1) effectPanel2 = 8;
    if (request.indexOf("panel2=blink") > -1) effectPanel2 = 9;

    if (request.indexOf("panel3=1") > -1) effectPanel3 = 1;
    if (request.indexOf("panel3=2") > -1) effectPanel3 = 2;
    if (request.indexOf("panel3=3") > -1) effectPanel3 = 3;
    if (request.indexOf("panel3=4") > -1) effectPanel3 = 4;
    if (request.indexOf("panel3=rain") > -1) effectPanel3 = 8;
    if (request.indexOf("panel3=blink") > -1) effectPanel3 = 9;

    // Turn Off All
    if (request.indexOf("turnOffAll=1") > -1) {
      effectPanel1 = 10;
      effectPanel2 = 10;
      effectPanel3 = 10;
    }

    // Helligkeit einstellen
    if (request.indexOf("brightness=") > -1) {
      int value = request.substring(request.indexOf("brightness=") + 11).toInt();
      setBrightness(value);
    }

    // HTML-Seite zurückgeben
    client.print(htmlPage());
    delay(1);
    client.stop();
  }

  // Effekte auf Panels anwenden
  setEffect(panel1, effectPanel1);
  setEffect(panel2, effectPanel2);
  setEffect(panel3, effectPanel3);

  // LEDs aktualisieren
  FastLED.show();
}

 

das hier ist nicht final code ich teile mein final code nur mit Tiktok Live Abo Members.

My Blog

Older Posts