Jak wysłać wideo do obrazu RawImage Unity z kamery ESP32

Bezproblemowe wyświetlanie strumieni wideo ESP32 w jedności

Czy kiedykolwiek chciałeś zintegrować strumień wideo w czasie rzeczywistym ze swoim projektem Unity? Jeśli eksperymentujesz z kamerą ESP32, możesz zdziwić się, gdy obraz wideo nie będzie renderowany zgodnie z oczekiwaniami. Elastyczność Unity sprawia, że ​​jest to doskonały wybór do takich zadań, ale wypełnienie luki pomiędzy Unity i strumieniowaniem MJPEG może wymagać pewnego wysiłku. 🖥️

Wielu programistów, szczególnie tych, którzy dopiero zaczynają przygodę z Unity, napotyka wyzwania podczas próby połączenia obrazu na żywo z kamery ESP32 z komponentem RawImage. Problemy takie jak puste tło, brak błędów konsoli lub nieprawidłowe renderowanie strumieni MJPEG mogą być dość frustrujące. Jednak przy odrobinie wskazówek i finezji pisania scenariuszy można całkowicie pokonać te przeszkody. 🚀

Załóżmy na przykład, że skonfigurowałeś transmisję wideo z kamery ESP32 pod adresem `http://192.1.1.1:81/stream`. Dodajesz RawImage do obszaru roboczego Unity, stosujesz skrypt i oczekujesz, że strumień się pojawi, ale wszystko, co otrzymasz, to pusty ekran. Debugowanie takiego scenariusza wymaga zwrócenia uwagi na szczegóły w skrypcie, protokołach przesyłania strumieniowego i ustawieniach aparatu Unity.

Ten przewodnik pomoże Ci rozwiązać problemy i wdrożyć rozwiązanie do renderowania strumieni MJPEG w Unity. Dowiesz się, jak napisać skrypt, który przechwytuje klatki wideo, przetwarza je i wyświetla na kanwie Unity. Na koniec obraz z kamery ESP32 ożyje w Unity, dzięki czemu Twój projekt będzie interaktywny i dynamiczny wizualnie. Zanurzmy się! 💡

Zrozumienie integracji strumieniowego przesyłania wideo ESP32 w Unity

Pierwszy skrypt wykorzystuje Unity Obraz surowy komponent do renderowania klatek wideo przesyłanych strumieniowo z kamery ESP32. Ustanawiając połączenie HTTP z adresem URL przesyłania strumieniowego ESP32, skrypt pobiera dane MJPEG, przetwarza każdą klatkę i wyświetla ją jako teksturę na płótnie. Klucz do osiągnięcia tego leży w Tekstura2D.LoadImage() metoda, która dekoduje surowe bajty ze strumienia MJPEG do formatu, który może wyświetlić Unity. Takie podejście zapewnia wydajne renderowanie wideo w czasie rzeczywistym, nawet dla początkujących programistów próbujących integracji IoT w Unity. 🖼️

Użycie współprogramów, takich jak in IEnumerator StartStream(), jest niezbędne dla tej implementacji. Współprogramy umożliwiają asynchroniczne pobieranie danych bez blokowania głównego wątku Unity. Zapewnia to płynną aktualizację obrazu wideo klatka po klatce, zachowując responsywność gry lub aplikacji. Na przykład, podczas gdy współprogram odczytuje ramki MJPEG, inne komponenty gry nadal działają płynnie. Jest to szczególnie przydatne w zastosowaniach takich jak monitorowanie bezpieczeństwa lub kioski interaktywne, gdzie krytyczny jest obraz wideo w czasie rzeczywistym.

Drugi skrypt ulepsza pierwszy, używając Żądanie UnityWeb, nowoczesna i zoptymalizowana metoda obsługi żądań internetowych. Inaczej Żądanie HttpWeb, co wymaga bardziej ręcznej obsługi strumieni, UnityWebRequestTexture.GetTexture() bezpośrednio pobiera i przetwarza tekstury z adresu URL strumienia wideo ESP32. Usprawnia to proces programowania, szczególnie w przypadku programistów Unity, dla których priorytetem jest wydajność i łatwość obsługi. Praktycznym przykładem może być programista integrujący obraz z kamery drona z symulacją VR opartą na Unity w celu nawigacji w czasie rzeczywistym. 🚁

Obydwa skrypty podkreślają znaczenie kodu modułowego i wielokrotnego użytku. Klasy zaprojektowano tak, aby można je było łatwo dołączyć do obiektu Unity, a właściwości takie jak adres URL i RawImage można dostosowywać za pomocą Inspektora Unity. Ta modułowość zapewnia programistom szybkie dostosowywanie skryptu do różnych zastosowań, niezależnie od tego, czy dotyczy robotyki, urządzeń IoT, czy niestandardowych aplikacji multimedialnych. Przykłady te stanowią solidną podstawę do renderowania wideo w czasie rzeczywistym w Unity, umożliwiając rozkwit kreatywności w projektach wymagających dynamicznego wkładu wizualnego. 🌟

using UnityEngine;
using UnityEngine.UI;
using System.IO;
using System.Net;
using System.Collections;
public class ESP32Stream : MonoBehaviour
{
    public string url = "http://192.1.1.1:81/stream";
    public RawImage rawImage;
    private Texture2D texture;
    void Start()
    {
        if (rawImage == null)
        {
            Debug.LogError("RawImage is not assigned.");
            return;
        }
        texture = new Texture2D(2, 2);
        rawImage.texture = texture;
        StartCoroutine(StreamVideo());
    }
    IEnumerator StreamVideo()
    {
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
        WebResponse response = request.GetResponse();
        Stream stream = response.GetResponseStream();
        while (true)
        {
            MemoryStream ms = new MemoryStream();
            byte[] buffer = new byte[1024];
            int bytesRead = 0;
            while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0)
            {
                ms.Write(buffer, 0, bytesRead);
                texture.LoadImage(ms.ToArray());
                rawImage.texture = texture;
                yield return null;
            }
        }
    }
}

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Networking;
using System.Collections;
public class UnityWebRequestStream : MonoBehaviour
{
    public string streamURL = "http://192.1.1.1:81/stream";
    public RawImage videoDisplay;
    private Texture2D videoTexture;
    void Start()
    {
        videoTexture = new Texture2D(2, 2);
        videoDisplay.texture = videoTexture;
        StartCoroutine(StreamVideo());
    }
    IEnumerator StreamVideo()
    {
        while (true)
        {
            UnityWebRequest request = UnityWebRequestTexture.GetTexture(streamURL);
            yield return request.SendWebRequest();
            if (request.result != UnityWebRequest.Result.Success)
            {
                Debug.LogError("Stream failed: " + request.error);
            }
            else
            {
                videoTexture = ((DownloadHandlerTexture)request.downloadHandler).texture;
                videoDisplay.texture = videoTexture;
            }
            yield return new WaitForSeconds(0.1f);
        }
    }
}

Ulepszanie projektów Unity za pomocą strumieni wideo ESP32 w czasie rzeczywistym

Jednym z aspektów często pomijanych podczas integrowania strumieni wideo ESP32 w Unity jest obsługa wydajności w przypadku dłuższych sesji wykonawczych. Podczas pracy ze strumieniem MJPEG ramki są dostarczane jako ciągła sekwencja, co wymaga od Unity dekodowania i renderowania każdej z nich. Bez odpowiedniej optymalizacji może to prowadzić do wycieków pamięci lub opóźnień w aplikacji. Korzystanie z narzędzi takich jak Profiler w Unity pozwala programistom monitorować wykorzystanie pamięci i identyfikować potencjalne wąskie gardła w potoku renderowania wideo. Dobrze dopracowana gra zapewnia płynną grafikę, szczególnie w zastosowaniach interaktywnych, takich jak monitorowanie dronów czy interfejsy robotów. 🚁

Kolejnym ważnym tematem jest bezpieczeństwo, zwłaszcza podczas obsługi urządzeń IoT, takich jak ESP32. Adres URL przesyłania strumieniowego, często zakodowany na stałe w skryptach, naraża kamerę na nieautoryzowany dostęp. Lepszym podejściem jest użycie bezpiecznych adresów URL z zaszyfrowanymi tokenami i ograniczenie dostępu do określonych adresów IP. Programiści mogą również przechowywać adres przesyłania strumieniowego w zaszyfrowanym pliku konfiguracyjnym, zamiast ujawniać go w skrypcie Unity. Dzięki temu aplikacje oparte na Unity staną się bezpieczniejsze i bardziej odporne na potencjalne zagrożenia. 🔒

Na koniec rozważ dodanie funkcji umożliwiającej dynamiczne wstrzymywanie lub zatrzymywanie strumienia wideo. Podczas gdy wiele projektów koncentruje się na prostym renderowaniu wideo, rzeczywiste scenariusze często wymagają większej interaktywności. Na przykład system monitorowania bezpieczeństwa może wymagać wstrzymania transmisji w celu konserwacji lub przełączenia między wieloma kamerami. Implementacja poleceń takich jak „Wstrzymaj strumień” lub „Przełącz kamerę” za pomocą przycisków interfejsu użytkownika może znacznie zwiększyć użyteczność, dzięki czemu aplikację można dostosować do różnych przypadków użycia. 🌟